diff --git a/drivers/media/platform/msm/cvp/Makefile b/drivers/media/platform/msm/cvp/Makefile
index cde02b04b71f..c135359250cf 100644
--- a/drivers/media/platform/msm/cvp/Makefile
+++ b/drivers/media/platform/msm/cvp/Makefile
@@ -16,6 +16,7 @@ msm-cvp-objs := cvp.o \
 				hfi_packetization.o \
 				cvp_core_hfi.o \
 				msm_cvp_clocks.o \
-				msm_cvp_dsp.o
+				msm_cvp_dsp.o \
+				msm_cvp_buf.o
 
 obj-$(CONFIG_MSM_CVP) := msm-cvp.o
diff --git a/drivers/media/platform/msm/cvp/cvp_hfi_helper.h b/drivers/media/platform/msm/cvp/cvp_hfi_helper.h
index bc79f7bffc13..c9662ef9ab12 100644
--- a/drivers/media/platform/msm/cvp/cvp_hfi_helper.h
+++ b/drivers/media/platform/msm/cvp/cvp_hfi_helper.h
@@ -442,20 +442,6 @@ struct cvp_hfi_cmd_sys_test_ssr_packet {
 	u32 trigger_type;
 };
 
-struct cvp_buf_type {
-	s32 fd;
-	u32 size;
-	u32 offset;
-	u32 flags;
-	union {
-		struct dma_buf *dbuf;
-		struct {
-			u32 reserved1;
-			u32 reserved2;
-		};
-	};
-};
-
 struct cvp_hfi_msg_sys_session_flush_done_packet {
 	u32 size;
 	u32 packet_type;
diff --git a/drivers/media/platform/msm/cvp/msm_cvp.c b/drivers/media/platform/msm/cvp/msm_cvp.c
index 876c8cad424b..983c93921695 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp.c
@@ -6,6 +6,7 @@
 #include "msm_cvp.h"
 #include "cvp_hfi.h"
 #include "cvp_core_hfi.h"
+#include "msm_cvp_buf.h"
 
 struct cvp_power_level {
 	unsigned long core_sum;
@@ -13,39 +14,6 @@ struct cvp_power_level {
 	unsigned long bw_sum;
 };
 
-static void print_internal_buffer(u32 tag, const char *str,
-		struct msm_cvp_inst *inst, struct cvp_internal_buf *cbuf)
-{
-	if (!(tag & msm_cvp_debug) || !inst || !cbuf)
-		return;
-
-	if (cbuf->smem->dma_buf) {
-		dprintk(tag,
-		"%s: %x : fd %d off %d %s size %d iova %#x",
-		str, hash32_ptr(inst->session), cbuf->fd,
-		cbuf->offset, cbuf->smem->dma_buf->name, cbuf->size,
-		cbuf->smem->device_addr);
-	} else {
-		dprintk(tag,
-		"%s: %x : idx %2d fd %d off %d size %d iova %#x",
-		str, hash32_ptr(inst->session), cbuf->fd,
-		cbuf->offset, cbuf->size, cbuf->smem->device_addr);
-	}
-}
-
-void print_smem(u32 tag, const char *str, struct msm_cvp_inst *inst,
-		struct msm_cvp_smem *smem)
-{
-	if (!(tag & msm_cvp_debug) || !inst || !smem)
-		return;
-
-	if (smem->dma_buf) {
-		dprintk(tag, "%s: %x : %s size %d flags %#x iova %#x", str,
-			hash32_ptr(inst->session), smem->dma_buf->name,
-			smem->size, smem->flags, smem->device_addr);
-	}
-}
-
 static int msm_cvp_get_session_info(struct msm_cvp_inst *inst,
 		struct cvp_kmd_session_info *session)
 {
@@ -70,444 +38,7 @@ static int msm_cvp_get_session_info(struct msm_cvp_inst *inst,
 	return rc;
 }
 
-static int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst,
-					struct cvp_kmd_buffer *buf)
-{
-	int rc = 0;
-	bool found = false;
-	struct cvp_internal_buf *cbuf;
-	struct msm_cvp_smem *smem = NULL;
-	struct cvp_hal_session *session;
-	struct dma_buf *dma_buf = NULL;
 
-	if (!inst || !inst->core || !buf) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return -EINVAL;
-	}
-
-	if (buf->fd < 0) {
-		dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
-		return 0;
-	}
-
-	if (buf->offset) {
-		dprintk(CVP_ERR,
-			"%s: offset is deprecated, set to 0.\n",
-			__func__);
-		return -EINVAL;
-	}
-
-	session = (struct cvp_hal_session *)inst->session;
-
-	mutex_lock(&inst->cvpdspbufs.lock);
-	list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
-		if (cbuf->fd == buf->fd) {
-			if (cbuf->size != buf->size) {
-				dprintk(CVP_ERR, "%s: buf size mismatch\n",
-					__func__);
-				mutex_unlock(&inst->cvpdspbufs.lock);
-				return -EINVAL;
-			}
-			found = true;
-			break;
-		}
-	}
-	mutex_unlock(&inst->cvpdspbufs.lock);
-	if (found) {
-		print_internal_buffer(CVP_ERR, "duplicate", inst, cbuf);
-		return -EINVAL;
-	}
-
-	dma_buf = msm_cvp_smem_get_dma_buf(buf->fd);
-	if (!dma_buf) {
-		dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
-		return 0;
-	}
-
-	cbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
-	if (!cbuf)
-		return -ENOMEM;
-
-	smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
-	if (!smem) {
-		kmem_cache_free(cvp_driver->buf_cache, cbuf);
-		return -ENOMEM;
-	}
-
-	smem->dma_buf = dma_buf;
-	dprintk(CVP_ERR, "%s: dma_buf = %llx\n", __func__, dma_buf);
-	rc = msm_cvp_map_smem(inst, smem);
-	if (rc) {
-		print_client_buffer(CVP_ERR, "map failed", inst, buf);
-		goto exit;
-	}
-
-	if (buf->index) {
-		rc = cvp_dsp_register_buffer(hash32_ptr(session), buf->fd,
-			smem->dma_buf->size, buf->size, buf->offset,
-			buf->index, (uint32_t)smem->device_addr);
-		if (rc) {
-			dprintk(CVP_ERR,
-				"%s: failed dsp registration for fd=%d rc=%d",
-				__func__, buf->fd, rc);
-			goto exit;
-		}
-	} else {
-		dprintk(CVP_ERR, "%s: buf index is 0 fd=%d", __func__, buf->fd);
-		rc = -EINVAL;
-		goto exit;
-	}
-
-	cbuf->smem = smem;
-	cbuf->fd = buf->fd;
-	cbuf->size = buf->size;
-	cbuf->offset = buf->offset;
-	cbuf->ownership = CLIENT;
-	cbuf->index = buf->index;
-
-	mutex_lock(&inst->cvpdspbufs.lock);
-	list_add_tail(&cbuf->list, &inst->cvpdspbufs.list);
-	mutex_unlock(&inst->cvpdspbufs.lock);
-
-	return rc;
-
-exit:
-	if (smem->device_addr)
-		msm_cvp_unmap_smem(smem);
-	kmem_cache_free(cvp_driver->buf_cache, cbuf);
-	cbuf = NULL;
-	kmem_cache_free(cvp_driver->smem_cache, smem);
-	smem = NULL;
-	return rc;
-}
-
-static int msm_cvp_unmap_buf_dsp(struct msm_cvp_inst *inst,
-	struct cvp_kmd_buffer *buf)
-{
-	int rc = 0;
-	bool found;
-	struct cvp_internal_buf *cbuf;
-	struct cvp_hal_session *session;
-
-	if (!inst || !inst->core || !buf) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return -EINVAL;
-	}
-
-	session = (struct cvp_hal_session *)inst->session;
-	if (!session) {
-		dprintk(CVP_ERR, "%s: invalid session\n", __func__);
-		return -EINVAL;
-	}
-
-	mutex_lock(&inst->cvpdspbufs.lock);
-	found = false;
-	list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
-		if (cbuf->fd == buf->fd) {
-			found = true;
-			break;
-		}
-	}
-	mutex_unlock(&inst->cvpdspbufs.lock);
-	if (!found) {
-		print_client_buffer(CVP_ERR, "invalid", inst, buf);
-		return -EINVAL;
-	}
-
-	if (buf->index) {
-		rc = cvp_dsp_deregister_buffer(hash32_ptr(session), buf->fd,
-			cbuf->smem->dma_buf->size, buf->size, buf->offset,
-			buf->index, (uint32_t)cbuf->smem->device_addr);
-		if (rc) {
-			dprintk(CVP_ERR,
-				"%s: failed dsp deregistration fd=%d rc=%d",
-				__func__, buf->fd, rc);
-			return rc;
-		}
-	}
-
-	if (cbuf->smem->device_addr)
-		msm_cvp_unmap_smem(cbuf->smem);
-
-	mutex_lock(&inst->cvpdspbufs.lock);
-	list_del(&cbuf->list);
-	mutex_unlock(&inst->cvpdspbufs.lock);
-
-	kmem_cache_free(cvp_driver->smem_cache, cbuf->smem);
-	kmem_cache_free(cvp_driver->buf_cache, cbuf);
-	return rc;
-}
-
-static void msm_cvp_cache_operations(struct msm_cvp_smem *smem, u32 type,
-					u32 offset, u32 size)
-{
-	enum smem_cache_ops cache_op;
-
-	if (!smem) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return;
-	}
-
-	switch (type) {
-	case CVP_KMD_BUFTYPE_INPUT:
-		cache_op = SMEM_CACHE_CLEAN;
-		break;
-	case CVP_KMD_BUFTYPE_OUTPUT:
-		cache_op = SMEM_CACHE_INVALIDATE;
-		break;
-	default:
-		cache_op = SMEM_CACHE_CLEAN_INVALIDATE;
-	}
-
-	msm_cvp_smem_cache_operations(smem->dma_buf, cache_op, offset, size);
-}
-
-static struct msm_cvp_smem *msm_cvp_session_find_smem(
-	struct msm_cvp_inst *inst,
-	struct dma_buf *dma_buf)
-{
-	struct msm_cvp_smem *smem;
-
-	mutex_lock(&inst->cpusmems.lock);
-	list_for_each_entry(smem, &inst->cpusmems.list, list) {
-		if (smem->dma_buf == dma_buf) {
-			atomic_inc(&smem->refcount);
-			/*
-			 * If we find it, it means we already increased
-			 * refcount before, so we put it to avoid double
-			 * incremental.
-			 */
-			msm_cvp_smem_put_dma_buf(smem->dma_buf);
-			mutex_unlock(&inst->cpusmems.lock);
-			print_smem(CVP_DBG, "found", inst, smem);
-			return smem;
-		}
-	}
-	mutex_unlock(&inst->cpusmems.lock);
-
-	return NULL;
-}
-
-static int msm_cvp_session_add_smem(struct msm_cvp_inst *inst,
-				struct msm_cvp_smem *smem)
-{
-	struct msm_cvp_smem *smem2, *d;
-	int found = false;
-
-	mutex_lock(&inst->cpusmems.lock);
-	if (inst->cpusmems.nr == inst->cpusmems.maxnr) {
-		list_for_each_entry_safe(smem2, d, &inst->cpusmems.list, list) {
-			if (atomic_read(&smem2->refcount) == 0) {
-				found = true;
-				list_del(&smem2->list);
-
-				msm_cvp_unmap_smem(smem2);
-				msm_cvp_smem_put_dma_buf(smem2->dma_buf);
-				kmem_cache_free(cvp_driver->smem_cache, smem2);
-				smem2 = NULL;
-
-				break;
-			}
-		}
-
-		if (!found) {
-			dprintk(CVP_ERR, "%s: not enough memory\n", __func__);
-			mutex_unlock(&inst->cpusmems.lock);
-			return -ENOMEM;
-		}
-		inst->cpusmems.nr--;
-	}
-
-	atomic_inc(&smem->refcount);
-	list_add_tail(&smem->list, &inst->cpusmems.list);
-	inst->cpusmems.nr++;
-	mutex_unlock(&inst->cpusmems.lock);
-
-	return 0;
-}
-
-static struct msm_cvp_smem *msm_cvp_session_get_smem(
-	struct msm_cvp_inst *inst,
-	struct cvp_buf_type *buf)
-{
-	int rc = 0;
-	struct msm_cvp_smem *smem = NULL;
-	struct dma_buf *dma_buf = NULL;
-
-	if (buf->fd < 0) {
-		dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
-		return NULL;
-	}
-
-	dma_buf = msm_cvp_smem_get_dma_buf(buf->fd);
-	if (!dma_buf) {
-		dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
-		return NULL;
-	}
-
-	smem = msm_cvp_session_find_smem(inst, dma_buf);
-	if (!smem) {
-		smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
-		if (!smem)
-			return NULL;
-
-		smem->dma_buf = dma_buf;
-		rc = msm_cvp_map_smem(inst, smem);
-		if (rc)
-			goto exit;
-
-		rc = msm_cvp_session_add_smem(inst, smem);
-		if (rc)
-			goto exit2;
-	}
-
-	if (buf->size > smem->size || buf->size > smem->size - buf->offset) {
-		dprintk(CVP_ERR, "%s: invalid offset %d or size %d\n",
-			__func__, buf->offset, buf->size);
-		goto exit2;
-	}
-
-	return smem;
-
-exit2:
-	msm_cvp_unmap_smem(smem);
-exit:
-	msm_cvp_smem_put_dma_buf(dma_buf);
-	kmem_cache_free(cvp_driver->smem_cache, smem);
-	smem = NULL;
-	return smem;
-}
-
-static u32 msm_cvp_map_user_persist_buf(struct msm_cvp_inst *inst,
-					struct cvp_buf_type *buf)
-{
-	u32 iova = 0;
-	struct msm_cvp_smem *smem = NULL;
-	struct cvp_internal_buf *pbuf;
-
-	if (!inst) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return -EINVAL;
-	}
-
-	pbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
-	if (!pbuf)
-		return 0;
-
-	smem = msm_cvp_session_get_smem(inst, buf);
-	if (!smem)
-		goto exit;
-
-	pbuf->smem = smem;
-	pbuf->fd = buf->fd;
-	pbuf->size = buf->size;
-	pbuf->offset = buf->offset;
-	pbuf->ownership = CLIENT;
-
-	mutex_lock(&inst->persistbufs.lock);
-	list_add_tail(&pbuf->list, &inst->persistbufs.list);
-	mutex_unlock(&inst->persistbufs.lock);
-
-	print_internal_buffer(CVP_DBG, "map persist", inst, pbuf);
-
-	iova = smem->device_addr + buf->offset;
-
-	return iova;
-
-exit:
-	kmem_cache_free(cvp_driver->buf_cache, pbuf);
-	return 0;
-}
-
-static u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
-			struct cvp_buf_type *buf,
-			struct msm_cvp_frame *frame)
-{
-	u32 iova = 0;
-	struct msm_cvp_smem *smem = NULL;
-	u32 nr;
-	u32 type;
-
-	if (!inst || !frame) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return 0;
-	}
-
-	nr = frame->nr;
-	if (nr == MAX_FRAME_BUFFER_NUMS) {
-		dprintk(CVP_ERR, "%s: max frame buffer reached\n", __func__);
-		return 0;
-	}
-
-	smem = msm_cvp_session_get_smem(inst, buf);
-	if (!smem)
-		return 0;
-
-	frame->bufs[nr].fd = buf->fd;
-	frame->bufs[nr].smem = smem;
-	frame->bufs[nr].size = buf->size;
-	frame->bufs[nr].offset = buf->offset;
-
-	print_internal_buffer(CVP_DBG, "map cpu", inst, &frame->bufs[nr]);
-
-	frame->nr++;
-
-	type = CVP_KMD_BUFTYPE_INPUT | CVP_KMD_BUFTYPE_OUTPUT;
-	msm_cvp_cache_operations(smem, type, buf->size, buf->offset);
-
-	iova = smem->device_addr + buf->offset;
-
-	return iova;
-}
-
-static void msm_cvp_unmap_frame_buf(struct msm_cvp_frame *frame)
-{
-	u32 i;
-	u32 type;
-	struct msm_cvp_smem *smem = NULL;
-	struct cvp_internal_buf *buf;
-
-	type = CVP_KMD_BUFTYPE_OUTPUT;
-
-	for (i = 0; i < frame->nr; ++i) {
-		buf = &frame->bufs[i];
-		smem = buf->smem;
-		msm_cvp_cache_operations(smem, type, buf->size, buf->offset);
-		atomic_dec(&smem->refcount);
-	}
-
-	kmem_cache_free(cvp_driver->frame_cache, frame);
-}
-
-static void msm_cvp_unmap_frame(struct msm_cvp_inst *inst, u64 ktid)
-{
-	struct msm_cvp_frame *frame, *dummy1;
-	bool found;
-
-	if (!inst) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return;
-	}
-
-	ktid &= (FENCE_BIT - 1);
-	dprintk(CVP_DBG, "%s: unmap frame %llu\n", __func__, ktid);
-
-	found = false;
-	mutex_lock(&inst->frames.lock);
-	list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
-		if (frame->ktid == ktid) {
-			found = true;
-			list_del(&frame->list);
-			break;
-		}
-	}
-	mutex_unlock(&inst->frames.lock);
-
-	if (found)
-		msm_cvp_unmap_frame_buf(frame);
-	else
-		dprintk(CVP_WARN, "%s frame %llu not found!\n", __func__, ktid);
-}
 
 static bool cvp_msg_pending(struct cvp_session_queue *sq,
 				struct cvp_session_msg **msg, u64 *ktid)
@@ -619,178 +150,6 @@ static int msm_cvp_session_receive_hfi(struct msm_cvp_inst *inst,
 	return rc;
 }
 
-static int msm_cvp_unmap_user_persist(struct msm_cvp_inst *inst,
-	struct cvp_kmd_hfi_packet *in_pkt,
-	unsigned int offset, unsigned int buf_num)
-{
-	struct cvp_buf_type *buf;
-	struct cvp_hfi_cmd_session_hdr *cmd_hdr;
-	struct cvp_internal_buf *pbuf, *dummy;
-	u64 ktid;
-	int i, rc = 0;
-	struct msm_cvp_smem *smem = NULL;
-
-	if (!offset || !buf_num)
-		return 0;
-
-	cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
-	ktid = cmd_hdr->client_data.kdata & (FENCE_BIT - 1);
-
-	for (i = 0; i < buf_num; i++) {
-		buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
-		offset += sizeof(*buf) >> 2;
-		mutex_lock(&inst->persistbufs.lock);
-		list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list,
-				list) {
-			if (pbuf->ktid == ktid) {
-				list_del(&pbuf->list);
-				smem = pbuf->smem;
-				atomic_dec(&smem->refcount);
-
-				dprintk(CVP_DBG, "unmap persist: %x %d %d %#x",
-					hash32_ptr(inst->session), pbuf->fd,
-					pbuf->size, smem->device_addr);
-				kmem_cache_free(cvp_driver->buf_cache, pbuf);
-				break;
-			}
-		}
-		mutex_unlock(&inst->persistbufs.lock);
-	}
-	return rc;
-}
-
-static int msm_cvp_mark_user_persist(struct msm_cvp_inst *inst,
-	struct cvp_kmd_hfi_packet *in_pkt,
-	unsigned int offset, unsigned int buf_num)
-{
-	struct cvp_hfi_cmd_session_hdr *cmd_hdr;
-	struct cvp_internal_buf *pbuf, *dummy;
-	u64 ktid;
-	struct cvp_buf_type *buf;
-	int i, rc = 0;
-
-	if (!offset || !buf_num)
-		return 0;
-
-	cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
-	ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
-	ktid &= (FENCE_BIT - 1);
-	cmd_hdr->client_data.kdata = ktid;
-
-	for (i = 0; i < buf_num; i++) {
-		buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
-		offset += sizeof(*buf) >> 2;
-
-		if (buf->fd < 0 || !buf->size)
-			continue;
-
-		mutex_lock(&inst->persistbufs.lock);
-		list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list,
-				list) {
-			if (pbuf->fd == buf->fd && pbuf->size == buf->size &&
-					pbuf->ownership == CLIENT) {
-				rc = 1;
-				break;
-			}
-		}
-		mutex_unlock(&inst->persistbufs.lock);
-		if (!rc) {
-			dprintk(CVP_ERR, "%s No persist buf %d found\n",
-				__func__, buf->fd);
-			rc = -EFAULT;
-			break;
-		}
-		buf->fd = pbuf->smem->device_addr;
-		pbuf->ktid = ktid;
-		rc = 0;
-	}
-	return rc;
-}
-
-static int msm_cvp_map_user_persist(struct msm_cvp_inst *inst,
-	struct cvp_kmd_hfi_packet *in_pkt,
-	unsigned int offset, unsigned int buf_num)
-{
-	struct cvp_buf_type *buf;
-	int i;
-	u32 iova;
-
-	if (!offset || !buf_num)
-		return 0;
-
-	for (i = 0; i < buf_num; i++) {
-		buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
-		offset += sizeof(*buf) >> 2;
-
-		if (buf->fd < 0 || !buf->size)
-			continue;
-
-		iova = msm_cvp_map_user_persist_buf(inst, buf);
-		if (!iova) {
-			dprintk(CVP_ERR,
-				"%s: buf %d register failed.\n",
-				__func__, i);
-
-			return -EINVAL;
-		}
-		buf->fd = iova;
-	}
-	return 0;
-}
-
-static int msm_cvp_map_frame(struct msm_cvp_inst *inst,
-	struct cvp_kmd_hfi_packet *in_pkt,
-	unsigned int offset, unsigned int buf_num)
-{
-	struct cvp_buf_type *buf;
-	int i;
-	u32 iova;
-	u64 ktid;
-	struct msm_cvp_frame *frame;
-	struct cvp_hfi_cmd_session_hdr *cmd_hdr;
-
-	if (!offset || !buf_num)
-		return 0;
-
-	cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
-	ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
-	ktid &= (FENCE_BIT - 1);
-	cmd_hdr->client_data.kdata = ktid;
-
-	frame = kmem_cache_zalloc(cvp_driver->frame_cache, GFP_KERNEL);
-	if (!frame)
-		return -ENOMEM;
-
-	frame->ktid = ktid;
-	frame->nr = 0;
-
-	for (i = 0; i < buf_num; i++) {
-		buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
-		offset += sizeof(*buf) >> 2;
-
-		if (buf->fd < 0 || !buf->size)
-			continue;
-
-		iova = msm_cvp_map_frame_buf(inst, buf, frame);
-		if (!iova) {
-			dprintk(CVP_ERR,
-				"%s: buf %d register failed.\n",
-				__func__, i);
-
-			msm_cvp_unmap_frame_buf(frame);
-			return -EINVAL;
-		}
-		buf->fd = iova;
-	}
-
-	mutex_lock(&inst->frames.lock);
-	list_add_tail(&frame->list, &inst->frames.list);
-	mutex_unlock(&inst->frames.lock);
-	dprintk(CVP_DBG, "%s: map frame %llu\n", __func__, ktid);
-
-	return 0;
-}
-
 static int msm_cvp_session_process_hfi(
 	struct msm_cvp_inst *inst,
 	struct cvp_kmd_hfi_packet *in_pkt,
@@ -2678,9 +2037,6 @@ int msm_cvp_session_deinit(struct msm_cvp_inst *inst)
 {
 	int rc = 0;
 	struct cvp_hal_session *session;
-	struct cvp_internal_buf *cbuf, *dummy;
-	struct msm_cvp_frame *frame, *dummy1;
-	struct msm_cvp_smem *smem, *dummy3;
 
 	if (!inst || !inst->core) {
 		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
@@ -2697,48 +2053,7 @@ int msm_cvp_session_deinit(struct msm_cvp_inst *inst)
 	if (rc)
 		dprintk(CVP_ERR, "%s: close failed\n", __func__);
 
-	mutex_lock(&inst->frames.lock);
-	list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
-		list_del(&frame->list);
-		msm_cvp_unmap_frame_buf(frame);
-	}
-	mutex_unlock(&inst->frames.lock);
-
-	mutex_lock(&inst->cpusmems.lock);
-	list_for_each_entry_safe(smem, dummy3, &inst->cpusmems.list, list) {
-		if (atomic_read(&smem->refcount) == 0) {
-			list_del(&smem->list);
-			print_smem(CVP_DBG, "free", inst, smem);
-			msm_cvp_unmap_smem(smem);
-			msm_cvp_smem_put_dma_buf(smem->dma_buf);
-			kmem_cache_free(cvp_driver->smem_cache, smem);
-			smem = NULL;
-		} else {
-			print_smem(CVP_WARN, "in use", inst, smem);
-		}
-	}
-	mutex_unlock(&inst->cpusmems.lock);
-
-	mutex_lock(&inst->cvpdspbufs.lock);
-	list_for_each_entry_safe(cbuf, dummy, &inst->cvpdspbufs.list,
-			list) {
-		print_internal_buffer(CVP_DBG, "remove dspbufs", inst, cbuf);
-		rc = cvp_dsp_deregister_buffer(hash32_ptr(session),
-			cbuf->fd, cbuf->smem->dma_buf->size, cbuf->size,
-			cbuf->offset, cbuf->index,
-			(uint32_t)cbuf->smem->device_addr);
-		if (rc)
-			dprintk(CVP_ERR,
-				"%s: failed dsp deregistration fd=%d rc=%d",
-				__func__, cbuf->fd, rc);
-
-		msm_cvp_unmap_smem(cbuf->smem);
-		msm_cvp_smem_put_dma_buf(cbuf->smem->dma_buf);
-		list_del(&cbuf->list);
-		kmem_cache_free(cvp_driver->buf_cache, cbuf);
-	}
-	mutex_unlock(&inst->cvpdspbufs.lock);
-
+	rc = msm_cvp_session_deinit_buffers(inst);
 	return rc;
 }
 
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_buf.c b/drivers/media/platform/msm/cvp/msm_cvp_buf.c
new file mode 100644
index 000000000000..7497fe09e599
--- /dev/null
+++ b/drivers/media/platform/msm/cvp/msm_cvp_buf.c
@@ -0,0 +1,922 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2020, The Linux Foundation. All rights reserved.
+ */
+
+#include "msm_cvp_common.h"
+#include "cvp_hfi_api.h"
+#include "msm_cvp_debug.h"
+#include "msm_cvp_core.h"
+#include "msm_cvp_dsp.h"
+
+void print_smem(u32 tag, const char *str, struct msm_cvp_inst *inst,
+		struct msm_cvp_smem *smem)
+{
+	if (!(tag & msm_cvp_debug) || !inst || !smem)
+		return;
+
+	if (smem->dma_buf) {
+		dprintk(tag, "%s: %x : %s size %d flags %#x iova %#x", str,
+			hash32_ptr(inst->session), smem->dma_buf->name,
+			smem->size, smem->flags, smem->device_addr);
+	}
+}
+
+static void print_internal_buffer(u32 tag, const char *str,
+		struct msm_cvp_inst *inst, struct cvp_internal_buf *cbuf)
+{
+	if (!(tag & msm_cvp_debug) || !inst || !cbuf)
+		return;
+
+	if (cbuf->smem->dma_buf) {
+		dprintk(tag,
+		"%s: %x : fd %d off %d %s size %d iova %#x",
+		str, hash32_ptr(inst->session), cbuf->fd,
+		cbuf->offset, cbuf->smem->dma_buf->name, cbuf->size,
+		cbuf->smem->device_addr);
+	} else {
+		dprintk(tag,
+		"%s: %x : idx %2d fd %d off %d size %d iova %#x",
+		str, hash32_ptr(inst->session), cbuf->fd,
+		cbuf->offset, cbuf->size, cbuf->smem->device_addr);
+	}
+}
+
+void print_cvp_buffer(u32 tag, const char *str, struct msm_cvp_inst *inst,
+		struct cvp_internal_buf *cbuf)
+{
+	dprintk(tag, "%s addr: %x size %u\n", str,
+			cbuf->smem->device_addr, cbuf->size);
+}
+
+void print_client_buffer(u32 tag, const char *str,
+		struct msm_cvp_inst *inst, struct cvp_kmd_buffer *cbuf)
+{
+	if (!(tag & msm_cvp_debug) || !inst || !cbuf)
+		return;
+
+	dprintk(tag,
+		"%s: %x : idx %2d fd %d off %d size %d type %d flags 0x%x\n",
+		str, hash32_ptr(inst->session), cbuf->index, cbuf->fd,
+		cbuf->offset, cbuf->size, cbuf->type, cbuf->flags);
+}
+
+int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst, struct cvp_kmd_buffer *buf)
+{
+	int rc = 0;
+	bool found = false;
+	struct cvp_internal_buf *cbuf;
+	struct msm_cvp_smem *smem = NULL;
+	struct cvp_hal_session *session;
+	struct dma_buf *dma_buf = NULL;
+
+	if (!inst || !inst->core || !buf) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+
+	if (buf->fd < 0) {
+		dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
+		return 0;
+	}
+
+	if (buf->offset) {
+		dprintk(CVP_ERR,
+			"%s: offset is deprecated, set to 0.\n",
+			__func__);
+		return -EINVAL;
+	}
+
+	session = (struct cvp_hal_session *)inst->session;
+
+	mutex_lock(&inst->cvpdspbufs.lock);
+	list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
+		if (cbuf->fd == buf->fd) {
+			if (cbuf->size != buf->size) {
+				dprintk(CVP_ERR, "%s: buf size mismatch\n",
+					__func__);
+				mutex_unlock(&inst->cvpdspbufs.lock);
+				return -EINVAL;
+			}
+			found = true;
+			break;
+		}
+	}
+	mutex_unlock(&inst->cvpdspbufs.lock);
+	if (found) {
+		print_internal_buffer(CVP_ERR, "duplicate", inst, cbuf);
+		return -EINVAL;
+	}
+
+	dma_buf = msm_cvp_smem_get_dma_buf(buf->fd);
+	if (!dma_buf) {
+		dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
+		return 0;
+	}
+
+	cbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
+	if (!cbuf)
+		return -ENOMEM;
+
+	smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
+	if (!smem) {
+		kmem_cache_free(cvp_driver->buf_cache, cbuf);
+		return -ENOMEM;
+	}
+
+	smem->dma_buf = dma_buf;
+	dprintk(CVP_ERR, "%s: dma_buf = %llx\n", __func__, dma_buf);
+	rc = msm_cvp_map_smem(inst, smem);
+	if (rc) {
+		print_client_buffer(CVP_ERR, "map failed", inst, buf);
+		goto exit;
+	}
+
+	if (buf->index) {
+		rc = cvp_dsp_register_buffer(hash32_ptr(session), buf->fd,
+			smem->dma_buf->size, buf->size, buf->offset,
+			buf->index, (uint32_t)smem->device_addr);
+		if (rc) {
+			dprintk(CVP_ERR,
+				"%s: failed dsp registration for fd=%d rc=%d",
+				__func__, buf->fd, rc);
+			goto exit;
+		}
+	} else {
+		dprintk(CVP_ERR, "%s: buf index is 0 fd=%d", __func__, buf->fd);
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	cbuf->smem = smem;
+	cbuf->fd = buf->fd;
+	cbuf->size = buf->size;
+	cbuf->offset = buf->offset;
+	cbuf->ownership = CLIENT;
+	cbuf->index = buf->index;
+
+	mutex_lock(&inst->cvpdspbufs.lock);
+	list_add_tail(&cbuf->list, &inst->cvpdspbufs.list);
+	mutex_unlock(&inst->cvpdspbufs.lock);
+
+	return rc;
+
+exit:
+	if (smem->device_addr)
+		msm_cvp_unmap_smem(smem);
+	kmem_cache_free(cvp_driver->buf_cache, cbuf);
+	cbuf = NULL;
+	kmem_cache_free(cvp_driver->smem_cache, smem);
+	smem = NULL;
+	return rc;
+}
+
+int msm_cvp_unmap_buf_dsp(struct msm_cvp_inst *inst, struct cvp_kmd_buffer *buf)
+{
+	int rc = 0;
+	bool found;
+	struct cvp_internal_buf *cbuf;
+	struct cvp_hal_session *session;
+
+	if (!inst || !inst->core || !buf) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+
+	session = (struct cvp_hal_session *)inst->session;
+	if (!session) {
+		dprintk(CVP_ERR, "%s: invalid session\n", __func__);
+		return -EINVAL;
+	}
+
+	mutex_lock(&inst->cvpdspbufs.lock);
+	found = false;
+	list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
+		if (cbuf->fd == buf->fd) {
+			found = true;
+			break;
+		}
+	}
+	mutex_unlock(&inst->cvpdspbufs.lock);
+	if (!found) {
+		print_client_buffer(CVP_ERR, "invalid", inst, buf);
+		return -EINVAL;
+	}
+
+	if (buf->index) {
+		rc = cvp_dsp_deregister_buffer(hash32_ptr(session), buf->fd,
+			cbuf->smem->dma_buf->size, buf->size, buf->offset,
+			buf->index, (uint32_t)cbuf->smem->device_addr);
+		if (rc) {
+			dprintk(CVP_ERR,
+				"%s: failed dsp deregistration fd=%d rc=%d",
+				__func__, buf->fd, rc);
+			return rc;
+		}
+	}
+
+	if (cbuf->smem->device_addr)
+		msm_cvp_unmap_smem(cbuf->smem);
+
+	mutex_lock(&inst->cvpdspbufs.lock);
+	list_del(&cbuf->list);
+	mutex_unlock(&inst->cvpdspbufs.lock);
+
+	kmem_cache_free(cvp_driver->smem_cache, cbuf->smem);
+	kmem_cache_free(cvp_driver->buf_cache, cbuf);
+	return rc;
+}
+
+void msm_cvp_cache_operations(struct msm_cvp_smem *smem, u32 type,
+				u32 offset, u32 size)
+{
+	enum smem_cache_ops cache_op;
+
+	if (!smem) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return;
+	}
+
+	switch (type) {
+	case CVP_KMD_BUFTYPE_INPUT:
+		cache_op = SMEM_CACHE_CLEAN;
+		break;
+	case CVP_KMD_BUFTYPE_OUTPUT:
+		cache_op = SMEM_CACHE_INVALIDATE;
+		break;
+	default:
+		cache_op = SMEM_CACHE_CLEAN_INVALIDATE;
+	}
+
+	msm_cvp_smem_cache_operations(smem->dma_buf, cache_op, offset, size);
+}
+
+static struct msm_cvp_smem *msm_cvp_session_find_smem(struct msm_cvp_inst *inst,
+				struct dma_buf *dma_buf)
+{
+	struct msm_cvp_smem *smem;
+
+	mutex_lock(&inst->dma_cache.lock);
+	list_for_each_entry(smem, &inst->dma_cache.list, list) {
+		if (smem->dma_buf == dma_buf) {
+			atomic_inc(&smem->refcount);
+			/*
+			 * If we find it, it means we already increased
+			 * refcount before, so we put it to avoid double
+			 * incremental.
+			 */
+			msm_cvp_smem_put_dma_buf(smem->dma_buf);
+			mutex_unlock(&inst->dma_cache.lock);
+			print_smem(CVP_DBG, "found", inst, smem);
+			return smem;
+		}
+	}
+	mutex_unlock(&inst->dma_cache.lock);
+
+	return NULL;
+}
+
+static int msm_cvp_session_add_smem(struct msm_cvp_inst *inst,
+				struct msm_cvp_smem *smem)
+{
+	struct msm_cvp_smem *smem2, *d;
+	int found = false;
+
+	mutex_lock(&inst->dma_cache.lock);
+	if (inst->dma_cache.nr == inst->dma_cache.maxnr) {
+		list_for_each_entry_safe(smem2, d,
+					&inst->dma_cache.list, list) {
+			if (atomic_read(&smem2->refcount) == 0) {
+				found = true;
+				list_del(&smem2->list);
+
+				msm_cvp_unmap_smem(smem2);
+				msm_cvp_smem_put_dma_buf(smem2->dma_buf);
+				kmem_cache_free(cvp_driver->smem_cache, smem2);
+				smem2 = NULL;
+
+				break;
+			}
+		}
+
+		if (!found) {
+			dprintk(CVP_WARN, "%s: not enough memory\n", __func__);
+			mutex_unlock(&inst->dma_cache.lock);
+			return -ENOMEM;
+		}
+		inst->dma_cache.nr--;
+	}
+
+	atomic_inc(&smem->refcount);
+	list_add_tail(&smem->list, &inst->dma_cache.list);
+	inst->dma_cache.nr++;
+	mutex_unlock(&inst->dma_cache.lock);
+
+	return 0;
+}
+
+static struct msm_cvp_smem *msm_cvp_session_get_smem(struct msm_cvp_inst *inst,
+						struct cvp_buf_type *buf)
+{
+	int rc = 0;
+	struct msm_cvp_smem *smem = NULL;
+	struct dma_buf *dma_buf = NULL;
+
+	if (buf->fd < 0) {
+		dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
+		return NULL;
+	}
+
+	dma_buf = msm_cvp_smem_get_dma_buf(buf->fd);
+	if (!dma_buf) {
+		dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
+		return NULL;
+	}
+
+	smem = msm_cvp_session_find_smem(inst, dma_buf);
+	if (!smem) {
+		smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
+		if (!smem)
+			return NULL;
+
+		smem->dma_buf = dma_buf;
+		rc = msm_cvp_map_smem(inst, smem);
+		if (rc)
+			goto exit;
+
+		rc = msm_cvp_session_add_smem(inst, smem);
+		if (rc && rc != -ENOMEM)
+			goto exit2;
+	}
+
+	if (buf->size > smem->size || buf->size > smem->size - buf->offset) {
+		dprintk(CVP_ERR, "%s: invalid offset %d or size %d\n",
+			__func__, buf->offset, buf->size);
+		goto exit2;
+	}
+
+	return smem;
+
+exit2:
+	msm_cvp_unmap_smem(smem);
+exit:
+	msm_cvp_smem_put_dma_buf(dma_buf);
+	kmem_cache_free(cvp_driver->smem_cache, smem);
+	smem = NULL;
+	return smem;
+}
+
+static u32 msm_cvp_map_user_persist_buf(struct msm_cvp_inst *inst,
+				struct cvp_buf_type *buf)
+{
+	u32 iova = 0;
+	struct msm_cvp_smem *smem = NULL;
+	struct cvp_internal_buf *pbuf;
+
+	if (!inst) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+
+	pbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
+	if (!pbuf)
+		return 0;
+
+	smem = msm_cvp_session_get_smem(inst, buf);
+	if (!smem)
+		goto exit;
+
+	pbuf->smem = smem;
+	pbuf->fd = buf->fd;
+	pbuf->size = buf->size;
+	pbuf->offset = buf->offset;
+	pbuf->ownership = CLIENT;
+
+	mutex_lock(&inst->persistbufs.lock);
+	list_add_tail(&pbuf->list, &inst->persistbufs.list);
+	mutex_unlock(&inst->persistbufs.lock);
+
+	print_internal_buffer(CVP_DBG, "map persist", inst, pbuf);
+
+	iova = smem->device_addr + buf->offset;
+
+	return iova;
+
+exit:
+	kmem_cache_free(cvp_driver->buf_cache, pbuf);
+	return 0;
+}
+
+u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
+			struct cvp_buf_type *buf,
+			struct msm_cvp_frame *frame)
+{
+	u32 iova = 0;
+	struct msm_cvp_smem *smem = NULL;
+	u32 nr;
+	u32 type;
+
+	if (!inst || !frame) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return 0;
+	}
+
+	nr = frame->nr;
+	if (nr == MAX_FRAME_BUFFER_NUMS) {
+		dprintk(CVP_ERR, "%s: max frame buffer reached\n", __func__);
+		return 0;
+	}
+
+	smem = msm_cvp_session_get_smem(inst, buf);
+	if (!smem)
+		return 0;
+
+	frame->bufs[nr].fd = buf->fd;
+	frame->bufs[nr].smem = smem;
+	frame->bufs[nr].size = buf->size;
+	frame->bufs[nr].offset = buf->offset;
+
+	print_internal_buffer(CVP_DBG, "map cpu", inst, &frame->bufs[nr]);
+
+	frame->nr++;
+
+	type = CVP_KMD_BUFTYPE_INPUT | CVP_KMD_BUFTYPE_OUTPUT;
+	msm_cvp_cache_operations(smem, type, buf->size, buf->offset);
+
+	iova = smem->device_addr + buf->offset;
+
+	return iova;
+}
+
+void msm_cvp_unmap_frame_buf(struct msm_cvp_frame *frame)
+{
+	u32 i;
+	u32 type;
+	struct msm_cvp_smem *smem = NULL;
+	struct cvp_internal_buf *buf;
+
+	type = CVP_KMD_BUFTYPE_OUTPUT;
+
+	for (i = 0; i < frame->nr; ++i) {
+		buf = &frame->bufs[i];
+		smem = buf->smem;
+		msm_cvp_cache_operations(smem, type, buf->size, buf->offset);
+		if (atomic_read(&smem->refcount) > 0) {
+			atomic_dec(&smem->refcount);
+		} else {
+			msm_cvp_unmap_smem(smem);
+			dma_buf_put(smem->dma_buf);
+			kfree(smem);
+			buf->smem = NULL;
+		}
+	}
+
+	kmem_cache_free(cvp_driver->frame_cache, frame);
+}
+
+void msm_cvp_unmap_frame(struct msm_cvp_inst *inst, u64 ktid)
+{
+	struct msm_cvp_frame *frame, *dummy1;
+	bool found;
+
+	if (!inst) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return;
+	}
+
+	ktid &= (FENCE_BIT - 1);
+	dprintk(CVP_DBG, "%s: unmap frame %llu\n", __func__, ktid);
+
+	found = false;
+	mutex_lock(&inst->frames.lock);
+	list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
+		if (frame->ktid == ktid) {
+			found = true;
+			list_del(&frame->list);
+			break;
+		}
+	}
+	mutex_unlock(&inst->frames.lock);
+
+	if (found)
+		msm_cvp_unmap_frame_buf(frame);
+	else
+		dprintk(CVP_WARN, "%s frame %llu not found!\n", __func__, ktid);
+}
+
+int msm_cvp_unmap_user_persist(struct msm_cvp_inst *inst,
+				struct cvp_kmd_hfi_packet *in_pkt,
+				unsigned int offset, unsigned int buf_num)
+{
+	struct cvp_buf_type *buf;
+	struct cvp_hfi_cmd_session_hdr *cmd_hdr;
+	struct cvp_internal_buf *pbuf, *dummy;
+	u64 ktid;
+	int i, rc = 0;
+	struct msm_cvp_smem *smem = NULL;
+
+	if (!offset || !buf_num)
+		return 0;
+
+	cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
+	ktid = cmd_hdr->client_data.kdata & (FENCE_BIT - 1);
+
+	for (i = 0; i < buf_num; i++) {
+		buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
+		offset += sizeof(*buf) >> 2;
+		mutex_lock(&inst->persistbufs.lock);
+		list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list,
+				list) {
+			if (pbuf->ktid == ktid) {
+				list_del(&pbuf->list);
+				smem = pbuf->smem;
+
+				dprintk(CVP_DBG, "unmap persist: %x %d %d %#x",
+					hash32_ptr(inst->session), pbuf->fd,
+					pbuf->size, smem->device_addr);
+
+				if (atomic_read(&smem->refcount) > 0) {
+					atomic_dec(&smem->refcount);
+				} else {
+					msm_cvp_unmap_smem(smem);
+					dma_buf_put(smem->dma_buf);
+					kfree(smem);
+					pbuf->smem = NULL;
+				}
+
+				kmem_cache_free(cvp_driver->buf_cache, pbuf);
+				break;
+			}
+		}
+		mutex_unlock(&inst->persistbufs.lock);
+	}
+	return rc;
+}
+
+int msm_cvp_mark_user_persist(struct msm_cvp_inst *inst,
+			struct cvp_kmd_hfi_packet *in_pkt,
+			unsigned int offset, unsigned int buf_num)
+{
+	struct cvp_hfi_cmd_session_hdr *cmd_hdr;
+	struct cvp_internal_buf *pbuf, *dummy;
+	u64 ktid;
+	struct cvp_buf_type *buf;
+	int i, rc = 0;
+
+	if (!offset || !buf_num)
+		return 0;
+
+	cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
+	ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
+	ktid &= (FENCE_BIT - 1);
+	cmd_hdr->client_data.kdata = ktid;
+
+	for (i = 0; i < buf_num; i++) {
+		buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
+		offset += sizeof(*buf) >> 2;
+
+		if (buf->fd < 0 || !buf->size)
+			continue;
+
+		mutex_lock(&inst->persistbufs.lock);
+		list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list,
+				list) {
+			if (pbuf->fd == buf->fd && pbuf->size == buf->size &&
+					pbuf->ownership == CLIENT) {
+				rc = 1;
+				break;
+			}
+		}
+		mutex_unlock(&inst->persistbufs.lock);
+		if (!rc) {
+			dprintk(CVP_ERR, "%s No persist buf %d found\n",
+				__func__, buf->fd);
+			rc = -EFAULT;
+			break;
+		}
+		buf->fd = pbuf->smem->device_addr;
+		pbuf->ktid = ktid;
+		rc = 0;
+	}
+	return rc;
+}
+
+int msm_cvp_map_user_persist(struct msm_cvp_inst *inst,
+			struct cvp_kmd_hfi_packet *in_pkt,
+			unsigned int offset, unsigned int buf_num)
+{
+	struct cvp_buf_type *buf;
+	int i;
+	u32 iova;
+
+	if (!offset || !buf_num)
+		return 0;
+
+	for (i = 0; i < buf_num; i++) {
+		buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
+		offset += sizeof(*buf) >> 2;
+
+		if (buf->fd < 0 || !buf->size)
+			continue;
+
+		iova = msm_cvp_map_user_persist_buf(inst, buf);
+		if (!iova) {
+			dprintk(CVP_ERR,
+				"%s: buf %d register failed.\n",
+				__func__, i);
+
+			return -EINVAL;
+		}
+		buf->fd = iova;
+	}
+	return 0;
+}
+
+int msm_cvp_map_frame(struct msm_cvp_inst *inst,
+		struct cvp_kmd_hfi_packet *in_pkt,
+		unsigned int offset, unsigned int buf_num)
+{
+	struct cvp_buf_type *buf;
+	int i;
+	u32 iova;
+	u64 ktid;
+	struct msm_cvp_frame *frame;
+	struct cvp_hfi_cmd_session_hdr *cmd_hdr;
+
+	if (!offset || !buf_num)
+		return 0;
+
+	cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
+	ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
+	ktid &= (FENCE_BIT - 1);
+	cmd_hdr->client_data.kdata = ktid;
+
+	frame = kmem_cache_zalloc(cvp_driver->frame_cache, GFP_KERNEL);
+	if (!frame)
+		return -ENOMEM;
+
+	frame->ktid = ktid;
+	frame->nr = 0;
+
+	for (i = 0; i < buf_num; i++) {
+		buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
+		offset += sizeof(*buf) >> 2;
+
+		if (buf->fd < 0 || !buf->size)
+			continue;
+
+		iova = msm_cvp_map_frame_buf(inst, buf, frame);
+		if (!iova) {
+			dprintk(CVP_ERR,
+				"%s: buf %d register failed.\n",
+				__func__, i);
+
+			msm_cvp_unmap_frame_buf(frame);
+			return -EINVAL;
+		}
+		buf->fd = iova;
+	}
+
+	mutex_lock(&inst->frames.lock);
+	list_add_tail(&frame->list, &inst->frames.list);
+	mutex_unlock(&inst->frames.lock);
+	dprintk(CVP_DBG, "%s: map frame %llu\n", __func__, ktid);
+
+	return 0;
+}
+
+int msm_cvp_session_deinit_buffers(struct msm_cvp_inst *inst)
+{
+	int rc = 0;
+	struct cvp_internal_buf *cbuf, *dummy;
+	struct msm_cvp_frame *frame, *dummy1;
+	struct msm_cvp_smem *smem, *dummy3;
+	struct cvp_hal_session *session;
+
+	session = (struct cvp_hal_session *)inst->session;
+
+	mutex_lock(&inst->frames.lock);
+	list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
+		list_del(&frame->list);
+		msm_cvp_unmap_frame_buf(frame);
+	}
+	mutex_unlock(&inst->frames.lock);
+
+	mutex_lock(&inst->dma_cache.lock);
+	list_for_each_entry_safe(smem, dummy3, &inst->dma_cache.list, list) {
+		if (atomic_read(&smem->refcount) == 0) {
+			list_del(&smem->list);
+			print_smem(CVP_DBG, "free", inst, smem);
+			msm_cvp_unmap_smem(smem);
+			msm_cvp_smem_put_dma_buf(smem->dma_buf);
+			kmem_cache_free(cvp_driver->smem_cache, smem);
+			smem = NULL;
+		} else {
+			print_smem(CVP_WARN, "in use", inst, smem);
+		}
+	}
+	mutex_unlock(&inst->dma_cache.lock);
+
+	mutex_lock(&inst->cvpdspbufs.lock);
+	list_for_each_entry_safe(cbuf, dummy, &inst->cvpdspbufs.list,
+			list) {
+		print_internal_buffer(CVP_DBG, "remove dspbufs", inst, cbuf);
+		rc = cvp_dsp_deregister_buffer(hash32_ptr(session),
+			cbuf->fd, cbuf->smem->dma_buf->size, cbuf->size,
+			cbuf->offset, cbuf->index,
+			(uint32_t)cbuf->smem->device_addr);
+		if (rc)
+			dprintk(CVP_ERR,
+				"%s: failed dsp deregistration fd=%d rc=%d",
+				__func__, cbuf->fd, rc);
+
+		msm_cvp_unmap_smem(cbuf->smem);
+		msm_cvp_smem_put_dma_buf(cbuf->smem->dma_buf);
+		list_del(&cbuf->list);
+		kmem_cache_free(cvp_driver->buf_cache, cbuf);
+	}
+	mutex_unlock(&inst->cvpdspbufs.lock);
+
+	return rc;
+}
+
+void msm_cvp_print_inst_bufs(struct msm_cvp_inst *inst)
+{
+	struct cvp_internal_buf *buf;
+	struct msm_cvp_smem *smem;
+
+	if (!inst) {
+		dprintk(CVP_ERR, "%s - invalid param %pK\n",
+			__func__, inst);
+		return;
+	}
+
+	dprintk(CVP_ERR, "active session cmd %d\n", inst->cur_cmd_type);
+	dprintk(CVP_ERR,
+			"---Buffer details for inst: %pK of type: %d---\n",
+			inst, inst->session_type);
+	mutex_lock(&inst->dma_cache.lock);
+	dprintk(CVP_ERR, "dma cache:\n");
+	list_for_each_entry(smem, &inst->dma_cache.list, list)
+		print_smem(CVP_ERR, "bufdump", inst, smem);
+	mutex_unlock(&inst->dma_cache.lock);
+
+	mutex_lock(&inst->cvpdspbufs.lock);
+	dprintk(CVP_ERR, "dsp buffer list:\n");
+	list_for_each_entry(buf, &inst->cvpdspbufs.list, list)
+		print_cvp_buffer(CVP_ERR, "bufdump", inst, buf);
+	mutex_unlock(&inst->cvpdspbufs.lock);
+
+	mutex_lock(&inst->persistbufs.lock);
+	dprintk(CVP_ERR, "persist buffer list:\n");
+	list_for_each_entry(buf, &inst->persistbufs.list, list)
+		print_cvp_buffer(CVP_ERR, "bufdump", inst, buf);
+	mutex_unlock(&inst->persistbufs.lock);
+}
+
+struct cvp_internal_buf *cvp_allocate_arp_bufs(struct msm_cvp_inst *inst,
+			u32 buffer_size)
+{
+	struct cvp_internal_buf *buf;
+	struct msm_cvp_list *buf_list;
+	u32 smem_flags = SMEM_UNCACHED;
+	int rc = 0;
+
+	if (!inst) {
+		dprintk(CVP_ERR, "%s Invalid input\n", __func__);
+		return NULL;
+	}
+
+	buf_list = &inst->persistbufs;
+
+	if (!buffer_size)
+		return NULL;
+
+	/* PERSIST buffer requires secure mapping */
+	smem_flags |= SMEM_SECURE | SMEM_NON_PIXEL;
+
+	buf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
+	if (!buf) {
+		dprintk(CVP_ERR, "%s Out of memory\n", __func__);
+		goto fail_kzalloc;
+	}
+
+	buf->smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
+	if (!buf->smem) {
+		dprintk(CVP_ERR, "%s Out of memory\n", __func__);
+		goto fail_kzalloc;
+	}
+
+	rc = msm_cvp_smem_alloc(buffer_size, 1, smem_flags, 0,
+			&(inst->core->resources), buf->smem);
+	if (rc) {
+		dprintk(CVP_ERR, "Failed to allocate ARP memory\n");
+		goto err_no_mem;
+	}
+
+	buf->size = buf->smem->size;
+	buf->type = HFI_BUFFER_INTERNAL_PERSIST_1;
+	buf->ownership = DRIVER;
+
+	mutex_lock(&buf_list->lock);
+	list_add_tail(&buf->list, &buf_list->list);
+	mutex_unlock(&buf_list->lock);
+	return buf;
+
+err_no_mem:
+	kmem_cache_free(cvp_driver->buf_cache, buf);
+fail_kzalloc:
+	return NULL;
+}
+
+int cvp_release_arp_buffers(struct msm_cvp_inst *inst)
+{
+	struct msm_cvp_smem *smem;
+	struct list_head *ptr, *next;
+	struct cvp_internal_buf *buf;
+	int rc = 0;
+	struct msm_cvp_core *core;
+	struct cvp_hfi_device *hdev;
+	int all_released;
+
+	if (!inst) {
+		dprintk(CVP_ERR, "Invalid instance pointer = %pK\n", inst);
+		return -EINVAL;
+	}
+
+	core = inst->core;
+	if (!core) {
+		dprintk(CVP_ERR, "Invalid core pointer = %pK\n", core);
+		return -EINVAL;
+	}
+	hdev = core->device;
+	if (!hdev) {
+		dprintk(CVP_ERR, "Invalid device pointer = %pK\n", hdev);
+		return -EINVAL;
+	}
+
+	dprintk(CVP_DBG, "release persist buffer!\n");
+	all_released = 0;
+
+	mutex_lock(&inst->persistbufs.lock);
+	list_for_each_safe(ptr, next, &inst->persistbufs.list) {
+		buf = list_entry(ptr, struct cvp_internal_buf, list);
+		smem = buf->smem;
+		if (!smem) {
+			dprintk(CVP_ERR, "%s invalid smem\n", __func__);
+			mutex_unlock(&inst->persistbufs.lock);
+			return -EINVAL;
+		}
+
+		/* Workaround for FW: release buffer means release all */
+		if (inst->state <= MSM_CVP_CLOSE_DONE && !all_released) {
+			rc = call_hfi_op(hdev, session_release_buffers,
+					(void *)inst->session);
+			if (!rc) {
+				mutex_unlock(&inst->persistbufs.lock);
+				rc = wait_for_sess_signal_receipt(inst,
+					HAL_SESSION_RELEASE_BUFFER_DONE);
+				if (rc)
+					dprintk(CVP_WARN,
+					"%s: wait for signal failed, rc %d\n",
+					__func__, rc);
+				mutex_lock(&inst->persistbufs.lock);
+			} else {
+				dprintk(CVP_WARN,
+						"Rel prst buf fail:%x, %d\n",
+						smem->device_addr,
+						smem->size);
+			}
+			all_released = 1;
+		}
+		list_del(&buf->list);
+
+		if (buf->ownership == DRIVER) {
+			dprintk(CVP_DBG,
+			"%s: %x : fd %d %s size %d",
+			"free arp", hash32_ptr(inst->session), buf->fd,
+			smem->dma_buf->name, buf->size);
+			msm_cvp_smem_free(smem);
+			kmem_cache_free(cvp_driver->smem_cache, smem);
+		} else if (buf->ownership == CLIENT) {
+			dprintk(CVP_DBG,
+			"%s: %x : fd %d %s size %d",
+			"unmap persist", hash32_ptr(inst->session),
+			buf->fd, smem->dma_buf->name, buf->size);
+
+			mutex_lock(&inst->dma_cache.lock);
+			if (atomic_read(&smem->refcount) == 0) {
+				list_del(&smem->list);
+				msm_cvp_unmap_smem(smem);
+				dma_buf_put(smem->dma_buf);
+				kfree(smem);
+				buf->smem = NULL;
+			}
+			mutex_unlock(&inst->dma_cache.lock);
+		}
+		kmem_cache_free(cvp_driver->buf_cache, buf);
+	}
+	mutex_unlock(&inst->persistbufs.lock);
+	return rc;
+}
+
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_buf.h b/drivers/media/platform/msm/cvp/msm_cvp_buf.h
new file mode 100644
index 000000000000..7ca40f725082
--- /dev/null
+++ b/drivers/media/platform/msm/cvp/msm_cvp_buf.h
@@ -0,0 +1,160 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2020, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _MSM_CVP_BUF_H_
+#define _MSM_CVP_BUF_H_
+
+#include <linux/poll.h>
+#include <linux/types.h>
+#include <linux/dma-buf.h>
+#include <linux/ion.h>
+#include <linux/msm_ion.h>
+#include <linux/refcount.h>
+#include <media/msm_cvp_private.h>
+#include <media/msm_cvp_vidc.h>
+
+#define MAX_FRAME_BUFFER_NUMS 30
+#define MAX_DMABUF_NUMS 64
+
+struct msm_cvp_inst;
+struct msm_cvp_platform_resources;
+struct msm_cvp_list;
+
+enum smem_cache_ops {
+	SMEM_CACHE_CLEAN,
+	SMEM_CACHE_INVALIDATE,
+	SMEM_CACHE_CLEAN_INVALIDATE,
+};
+
+enum smem_prop {
+	SMEM_UNCACHED = 0x1,
+	SMEM_CACHED = 0x2,
+	SMEM_SECURE = 0x4,
+	SMEM_ADSP = 0x8,
+	SMEM_NON_PIXEL = 0x10
+};
+
+struct cvp_dma_mapping_info {
+	struct device *dev;
+	struct iommu_domain *domain;
+	struct sg_table *table;
+	struct dma_buf_attachment *attach;
+	struct dma_buf *buf;
+	void *cb_info;
+};
+
+struct msm_cvp_smem {
+	struct list_head list;
+	atomic_t refcount;
+	struct dma_buf *dma_buf;
+	void *kvaddr;
+	u32 device_addr;
+	dma_addr_t dma_handle;
+	u32 size;
+	u32 flags;
+	u32 ion_flags;
+	struct cvp_dma_mapping_info mapping_info;
+};
+
+struct cvp_buf_type {
+	s32 fd;
+	u32 size;
+	u32 offset;
+	u32 flags;
+	union {
+		struct dma_buf *dbuf;
+		struct {
+			u32 reserved1;
+			u32 reserved2;
+		};
+	};
+};
+
+enum buffer_owner {
+	DRIVER,
+	FIRMWARE,
+	CLIENT,
+	MAX_OWNER
+};
+
+struct cvp_internal_buf {
+	struct list_head list;
+	s32 fd;
+	u32 size;
+	u32 offset;
+	u32 type;
+	u32 index;
+	u64 ktid;
+	enum buffer_owner ownership;
+	struct msm_cvp_smem *smem;
+};
+
+struct msm_cvp_frame {
+	struct list_head list;
+	struct cvp_internal_buf bufs[MAX_FRAME_BUFFER_NUMS];
+	u32 nr;
+	u64 ktid;
+};
+
+void print_cvp_buffer(u32 tag, const char *str,
+		struct msm_cvp_inst *inst,
+		struct cvp_internal_buf *cbuf);
+void print_cvp_buffer(u32 tag, const char *str,
+		struct msm_cvp_inst *inst,
+		struct cvp_internal_buf *cbuf);
+void print_client_buffer(u32 tag, const char *str,
+		struct msm_cvp_inst *inst,
+		struct cvp_kmd_buffer *cbuf);
+void print_smem(u32 tag, const char *str,
+		struct msm_cvp_inst *inst,
+		struct msm_cvp_smem *smem);
+
+/*Kernel DMA buffer and IOMMU mapping functions*/
+int msm_cvp_smem_alloc(size_t size, u32 align, u32 flags, int map_kernel,
+			void  *res, struct msm_cvp_smem *smem);
+int msm_cvp_smem_free(struct msm_cvp_smem *smem);
+struct context_bank_info *msm_cvp_smem_get_context_bank(bool is_secure,
+				struct msm_cvp_platform_resources *res,
+				unsigned long ion_flags);
+int msm_cvp_map_smem(struct msm_cvp_inst *inst,
+			struct msm_cvp_smem *smem);
+int msm_cvp_unmap_smem(struct msm_cvp_smem *smem);
+struct dma_buf *msm_cvp_smem_get_dma_buf(int fd);
+void msm_cvp_smem_put_dma_buf(void *dma_buf);
+int msm_cvp_smem_cache_operations(struct dma_buf *dbuf,
+				enum smem_cache_ops cache_op,
+				unsigned long offset,
+				unsigned long size);
+
+/* CVP driver internal buffer management functions*/
+struct cvp_internal_buf *cvp_allocate_arp_bufs(struct msm_cvp_inst *inst,
+					u32 buffer_size);
+int cvp_release_arp_buffers(struct msm_cvp_inst *inst);
+int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst,
+			struct cvp_kmd_buffer *buf);
+int msm_cvp_unmap_buf_dsp(struct msm_cvp_inst *inst,
+			struct cvp_kmd_buffer *buf);
+void msm_cvp_cache_operations(struct msm_cvp_smem *smem,
+			u32 type, u32 offset, u32 size);
+u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
+			struct cvp_buf_type *buf,
+			struct msm_cvp_frame *frame);
+void msm_cvp_unmap_frame_buf(struct msm_cvp_frame *frame);
+int msm_cvp_mark_user_persist(struct msm_cvp_inst *inst,
+			struct cvp_kmd_hfi_packet *in_pkt,
+			unsigned int offset, unsigned int buf_num);
+int msm_cvp_map_user_persist(struct msm_cvp_inst *inst,
+			struct cvp_kmd_hfi_packet *in_pkt,
+			unsigned int offset, unsigned int buf_num);
+int msm_cvp_unmap_user_persist(struct msm_cvp_inst *inst,
+			struct cvp_kmd_hfi_packet *in_pkt,
+			unsigned int offset, unsigned int buf_num);
+int msm_cvp_map_frame(struct msm_cvp_inst *inst,
+		struct cvp_kmd_hfi_packet *in_pkt,
+		unsigned int offset, unsigned int buf_num);
+void msm_cvp_unmap_frame(struct msm_cvp_inst *inst, u64 ktid);
+int msm_cvp_session_deinit_buffers(struct msm_cvp_inst *inst);
+void msm_cvp_print_inst_bufs(struct msm_cvp_inst *inst);
+#endif
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_common.c b/drivers/media/platform/msm/cvp/msm_cvp_common.c
index b659f2aa9026..5a72e9ae1724 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_common.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_common.c
@@ -671,7 +671,7 @@ static void handle_sys_error(enum hal_command_response cmd, void *data)
 		}
 
 		if (!core->trigger_ssr)
-			msm_cvp_comm_print_inst_info(inst);
+			msm_cvp_print_inst_bufs(inst);
 	}
 
 	/* handle the hw error before core released to get full debug info */
@@ -1534,47 +1534,6 @@ void msm_cvp_fw_unload_handler(struct work_struct *work)
 	mutex_unlock(&core->lock);
 }
 
-void print_cvp_buffer(u32 tag, const char *str, struct msm_cvp_inst *inst,
-		struct cvp_internal_buf *cbuf)
-{
-	dprintk(tag, "%s addr: %x size %u\n", str,
-		cbuf->smem->device_addr, cbuf->size);
-}
-
-void msm_cvp_comm_print_inst_info(struct msm_cvp_inst *inst)
-{
-	struct cvp_internal_buf *buf;
-	struct msm_cvp_smem *smem;
-
-	if (!inst) {
-		dprintk(CVP_ERR, "%s - invalid param %pK\n",
-			__func__, inst);
-		return;
-	}
-
-	dprintk(CVP_ERR, "active session cmd %d\n", inst->cur_cmd_type);
-	dprintk(CVP_ERR,
-			"---Buffer details for inst: %pK of type: %d---\n",
-			inst, inst->session_type);
-	mutex_lock(&inst->cpusmems.lock);
-	dprintk(CVP_ERR, "smem list:\n");
-	list_for_each_entry(smem, &inst->cpusmems.list, list)
-		print_smem(CVP_ERR, "bufdump", inst, smem);
-	mutex_unlock(&inst->cpusmems.lock);
-
-	mutex_lock(&inst->cvpdspbufs.lock);
-	dprintk(CVP_ERR, "dsp buffer list:\n");
-	list_for_each_entry(buf, &inst->cvpdspbufs.list, list)
-		print_cvp_buffer(CVP_ERR, "bufdump", inst, buf);
-	mutex_unlock(&inst->cvpdspbufs.lock);
-
-	mutex_lock(&inst->persistbufs.lock);
-	dprintk(CVP_ERR, "persist buffer list:\n");
-	list_for_each_entry(buf, &inst->persistbufs.list, list)
-		print_cvp_buffer(CVP_ERR, "bufdump", inst, buf);
-	mutex_unlock(&inst->persistbufs.lock);
-}
-
 static int set_internal_buf_on_fw(struct msm_cvp_inst *inst,
 				struct msm_cvp_smem *handle)
 {
@@ -1604,80 +1563,24 @@ static int set_internal_buf_on_fw(struct msm_cvp_inst *inst,
 	return 0;
 }
 
-static int allocate_and_set_internal_bufs(struct msm_cvp_inst *inst,
-			u32 buffer_size, struct msm_cvp_list *buf_list)
-{
-	struct cvp_internal_buf *buf;
-	u32 smem_flags = SMEM_UNCACHED;
-	int rc = 0;
-
-	if (!inst || !buf_list) {
-		dprintk(CVP_ERR, "%s Invalid input\n", __func__);
-		return -EINVAL;
-	}
-
-	if (!buffer_size)
-		return 0;
-
-	/* PERSIST buffer requires secure mapping */
-	smem_flags |= SMEM_SECURE | SMEM_NON_PIXEL;
-
-	buf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
-	if (!buf) {
-		dprintk(CVP_ERR, "%s Out of memory\n", __func__);
-		rc = -ENOMEM;
-		goto fail_kzalloc;
-	}
-
-	buf->smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
-	if (!buf->smem) {
-		dprintk(CVP_ERR, "%s Out of memory\n", __func__);
-		rc = -ENOMEM;
-		goto fail_kzalloc;
-	}
-
-	rc = msm_cvp_smem_alloc(buffer_size, 1, smem_flags, 0,
-			&(inst->core->resources), buf->smem);
-	if (rc) {
-		dprintk(CVP_ERR, "Failed to allocate ARP memory\n");
-		goto err_no_mem;
-	}
-
-	buf->size = buf->smem->size;
-	buf->type = HFI_BUFFER_INTERNAL_PERSIST_1;
-	buf->ownership = DRIVER;
-
-	rc = set_internal_buf_on_fw(inst, buf->smem);
-	if (rc)
-		goto fail_set_buffers;
-
-	mutex_lock(&buf_list->lock);
-	list_add_tail(&buf->list, &buf_list->list);
-	mutex_unlock(&buf_list->lock);
-	return rc;
-
-fail_set_buffers:
-	msm_cvp_smem_free(buf->smem);
-	kmem_cache_free(cvp_driver->smem_cache, buf->smem);
-err_no_mem:
-	kmem_cache_free(cvp_driver->buf_cache, buf);
-fail_kzalloc:
-	return rc;
-}
-
-
 /* Set ARP buffer for CVP firmware to handle concurrency */
 int cvp_comm_set_arp_buffers(struct msm_cvp_inst *inst)
 {
 	int rc = 0;
+	struct cvp_internal_buf *buf;
 
 	if (!inst || !inst->core || !inst->core->device) {
 		dprintk(CVP_ERR, "%s invalid parameters\n", __func__);
 		return -EINVAL;
 	}
 
-	rc = allocate_and_set_internal_bufs(inst, ARP_BUF_SIZE,
-						&inst->persistbufs);
+	buf = cvp_allocate_arp_bufs(inst, ARP_BUF_SIZE);
+	if (!buf) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	rc = set_internal_buf_on_fw(inst, buf->smem);
 	if (rc)
 		goto error;
 
@@ -1690,109 +1593,10 @@ int cvp_comm_set_arp_buffers(struct msm_cvp_inst *inst)
 	return rc;
 
 error:
-	cvp_comm_release_persist_buffers(inst);
+	cvp_release_arp_buffers(inst);
 	return rc;
 }
 
-int cvp_comm_release_persist_buffers(struct msm_cvp_inst *inst)
-{
-	struct msm_cvp_smem *smem;
-	struct list_head *ptr, *next;
-	struct cvp_internal_buf *buf;
-	int rc = 0;
-	struct msm_cvp_core *core;
-	struct cvp_hfi_device *hdev;
-	int all_released;
 
-	if (!inst) {
-		dprintk(CVP_ERR, "Invalid instance pointer = %pK\n", inst);
-		return -EINVAL;
-	}
 
-	core = inst->core;
-	if (!core) {
-		dprintk(CVP_ERR, "Invalid core pointer = %pK\n", core);
-		return -EINVAL;
-	}
-	hdev = core->device;
-	if (!hdev) {
-		dprintk(CVP_ERR, "Invalid device pointer = %pK\n", hdev);
-		return -EINVAL;
-	}
 
-	dprintk(CVP_DBG, "release persist buffer!\n");
-	all_released = 0;
-
-	mutex_lock(&inst->persistbufs.lock);
-	list_for_each_safe(ptr, next, &inst->persistbufs.list) {
-		buf = list_entry(ptr, struct cvp_internal_buf, list);
-		smem = buf->smem;
-		if (!smem) {
-			dprintk(CVP_ERR, "%s invalid smem\n", __func__);
-			mutex_unlock(&inst->persistbufs.lock);
-			return -EINVAL;
-		}
-
-		/* Workaround for FW: release buffer means release all */
-		if (inst->state <= MSM_CVP_CLOSE_DONE && !all_released) {
-			rc = call_hfi_op(hdev, session_release_buffers,
-					(void *)inst->session);
-			if (!rc) {
-				mutex_unlock(&inst->persistbufs.lock);
-				rc = wait_for_sess_signal_receipt(inst,
-					HAL_SESSION_RELEASE_BUFFER_DONE);
-				if (rc)
-					dprintk(CVP_WARN,
-					"%s: wait for signal failed, rc %d\n",
-					__func__, rc);
-				mutex_lock(&inst->persistbufs.lock);
-			} else {
-				dprintk(CVP_WARN,
-						"Rel prst buf fail:%x, %d\n",
-						smem->device_addr,
-						smem->size);
-			}
-			all_released = 1;
-		}
-		list_del(&buf->list);
-
-		if (buf->ownership == DRIVER) {
-			dprintk(CVP_DBG,
-			"%s: %x : fd %d %s size %d",
-			"free arp", hash32_ptr(inst->session), buf->fd,
-			smem->dma_buf->name, buf->size);
-			msm_cvp_smem_free(smem);
-			kmem_cache_free(cvp_driver->smem_cache, smem);
-		} else if (buf->ownership == CLIENT) {
-			dprintk(CVP_DBG,
-			"%s: %x : fd %d %s size %d",
-			"unmap persist", hash32_ptr(inst->session),
-			buf->fd, smem->dma_buf->name, buf->size);
-
-			mutex_lock(&inst->cpusmems.lock);
-			if (atomic_read(&smem->refcount) == 0) {
-				list_del(&smem->list);
-				msm_cvp_unmap_smem(smem);
-				dma_buf_put(smem->dma_buf);
-				kfree(smem);
-				buf->smem = NULL;
-			}
-			mutex_unlock(&inst->cpusmems.lock);
-		}
-		kmem_cache_free(cvp_driver->buf_cache, buf);
-	}
-	mutex_unlock(&inst->persistbufs.lock);
-	return rc;
-}
-
-void print_client_buffer(u32 tag, const char *str,
-		struct msm_cvp_inst *inst, struct cvp_kmd_buffer *cbuf)
-{
-	if (!(tag & msm_cvp_debug) || !inst || !cbuf)
-		return;
-
-	dprintk(tag,
-		"%s: %x : idx %2d fd %d off %d size %d type %d flags 0x%x\n",
-		str, hash32_ptr(inst->session), cbuf->index, cbuf->fd,
-		cbuf->offset, cbuf->size, cbuf->type, cbuf->flags);
-}
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_common.h b/drivers/media/platform/msm/cvp/msm_cvp_common.h
index 8e586f7003c7..bfef327fc9a6 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_common.h
+++ b/drivers/media/platform/msm/cvp/msm_cvp_common.h
@@ -26,17 +26,9 @@ void msm_cvp_comm_generate_sys_error(struct msm_cvp_inst *inst);
 int msm_cvp_comm_smem_cache_operations(struct msm_cvp_inst *inst,
 		struct msm_cvp_smem *mem, enum smem_cache_ops cache_ops);
 int msm_cvp_comm_check_core_init(struct msm_cvp_core *core);
-void msm_cvp_comm_print_inst_info(struct msm_cvp_inst *inst);
-void print_cvp_buffer(u32 tag, const char *str,
-		struct msm_cvp_inst *inst,
-		struct cvp_internal_buf *cbuf);
 int wait_for_sess_signal_receipt(struct msm_cvp_inst *inst,
 	enum hal_command_response cmd);
 int cvp_comm_set_arp_buffers(struct msm_cvp_inst *inst);
 int cvp_comm_release_persist_buffers(struct msm_cvp_inst *inst);
-void print_client_buffer(u32 tag, const char *str,
-		struct msm_cvp_inst *inst, struct cvp_kmd_buffer *cbuf);
-void print_smem(u32 tag, const char *str, struct msm_cvp_inst *inst,
-					struct msm_cvp_smem *smem);
 int msm_cvp_noc_error_info(struct msm_cvp_core *core);
 #endif
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_core.c b/drivers/media/platform/msm/cvp/msm_cvp_core.c
index 6a6b96675869..edc68c9c587b 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_core.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_core.c
@@ -321,7 +321,7 @@ void *msm_cvp_open(int core_id, int session_type)
 	spin_lock_init(&inst->event_handler.lock);
 
 	INIT_MSM_CVP_LIST(&inst->persistbufs);
-	INIT_MSM_CVP_LIST(&inst->cpusmems);
+	INIT_MSM_CVP_LIST(&inst->dma_cache);
 	INIT_MSM_CVP_LIST(&inst->cvpdspbufs);
 	INIT_MSM_CVP_LIST(&inst->frames);
 
@@ -338,7 +338,7 @@ void *msm_cvp_open(int core_id, int session_type)
 	inst->clk_data.sys_cache_bw = 0;
 	inst->clk_data.bitrate = 0;
 	inst->clk_data.core_id = 0;
-	inst->cpusmems.maxnr = MAX_DMABUF_NUMS;
+	inst->dma_cache.maxnr = MAX_DMABUF_NUMS;
 
 	for (i = SESSION_MSG_INDEX(SESSION_MSG_START);
 		i <= SESSION_MSG_INDEX(SESSION_MSG_END); i++) {
@@ -377,7 +377,7 @@ fail_init:
 	mutex_destroy(&inst->lock);
 
 	DEINIT_MSM_CVP_LIST(&inst->persistbufs);
-	DEINIT_MSM_CVP_LIST(&inst->cpusmems);
+	DEINIT_MSM_CVP_LIST(&inst->dma_cache);
 	DEINIT_MSM_CVP_LIST(&inst->cvpdspbufs);
 	DEINIT_MSM_CVP_LIST(&inst->frames);
 
@@ -395,7 +395,7 @@ static void msm_cvp_cleanup_instance(struct msm_cvp_inst *inst)
 		return;
 	}
 
-	if (cvp_comm_release_persist_buffers(inst))
+	if (cvp_release_arp_buffers(inst))
 		dprintk(CVP_ERR,
 			"Failed to release persist buffers\n");
 }
@@ -417,7 +417,7 @@ int msm_cvp_destroy(struct msm_cvp_inst *inst)
 	mutex_unlock(&core->lock);
 
 	DEINIT_MSM_CVP_LIST(&inst->persistbufs);
-	DEINIT_MSM_CVP_LIST(&inst->cpusmems);
+	DEINIT_MSM_CVP_LIST(&inst->dma_cache);
 	DEINIT_MSM_CVP_LIST(&inst->cvpdspbufs);
 	DEINIT_MSM_CVP_LIST(&inst->frames);
 
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_core.h b/drivers/media/platform/msm/cvp/msm_cvp_core.h
index ff74f64fb1e5..be1730963b92 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_core.h
+++ b/drivers/media/platform/msm/cvp/msm_cvp_core.h
@@ -14,42 +14,7 @@
 #include <linux/refcount.h>
 #include <media/msm_cvp_private.h>
 #include <media/msm_cvp_vidc.h>
-
-enum smem_prop {
-	SMEM_UNCACHED = 0x1,
-	SMEM_CACHED = 0x2,
-	SMEM_SECURE = 0x4,
-	SMEM_ADSP = 0x8,
-	SMEM_NON_PIXEL = 0x10
-};
-
-struct cvp_dma_mapping_info {
-	struct device *dev;
-	struct iommu_domain *domain;
-	struct sg_table *table;
-	struct dma_buf_attachment *attach;
-	struct dma_buf *buf;
-	void *cb_info;
-};
-
-struct msm_cvp_smem {
-	struct list_head list;
-	atomic_t refcount;
-	struct dma_buf *dma_buf;
-	void *kvaddr;
-	u32 device_addr;
-	dma_addr_t dma_handle;
-	u32 size;
-	u32 flags;
-	u32 ion_flags;
-	struct cvp_dma_mapping_info mapping_info;
-};
-
-enum smem_cache_ops {
-	SMEM_CACHE_CLEAN,
-	SMEM_CACHE_INVALIDATE,
-	SMEM_CACHE_CLEAN_INVALIDATE,
-};
+#include "msm_cvp_buf.h"
 
 enum core_id {
 	MSM_CORE_CVP = 0,
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_internal.h b/drivers/media/platform/msm/cvp/msm_cvp_internal.h
index 3801d7497999..cd33df4c0815 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_internal.h
+++ b/drivers/media/platform/msm/cvp/msm_cvp_internal.h
@@ -37,9 +37,6 @@
 #define FENCE_DME_DS_IDX 1
 #define FENCE_DME_OUTPUT_IDX 7
 
-#define MAX_FRAME_BUFFER_NUMS 10
-#define MAX_DMABUF_NUMS 30
-
 #define SYS_MSG_START HAL_SYS_INIT_DONE
 #define SYS_MSG_END HAL_SYS_ERROR
 #define SESSION_MSG_START HAL_SESSION_EVENT_CHANGE
@@ -102,25 +99,6 @@ static inline void DEINIT_MSM_CVP_LIST(struct msm_cvp_list *mlist)
 	mutex_destroy(&mlist->lock);
 }
 
-enum buffer_owner {
-	DRIVER,
-	FIRMWARE,
-	CLIENT,
-	MAX_OWNER
-};
-
-struct cvp_internal_buf {
-	struct list_head list;
-	s32 fd;
-	u32 size;
-	u32 offset;
-	u32 type;
-	u32 index;
-	u64 ktid;
-	enum buffer_owner ownership;
-	struct msm_cvp_smem *smem;
-};
-
 struct msm_cvp_common_data {
 	char key[128];
 	int value;
@@ -343,7 +321,7 @@ struct msm_cvp_inst {
 	enum instance_state state;
 	struct msm_cvp_list freqs;
 	struct msm_cvp_list persistbufs;
-	struct msm_cvp_list cpusmems;
+	struct msm_cvp_list dma_cache;
 	struct msm_cvp_list cvpdspbufs;
 	struct msm_cvp_list frames;
 	struct completion completions[SESSION_MSG_END - SESSION_MSG_START + 1];
@@ -374,13 +352,6 @@ struct cvp_fence_command {
 	struct cvp_hfi_cmd_session_hdr *pkt;
 };
 
-struct msm_cvp_frame {
-	struct list_head list;
-	struct cvp_internal_buf bufs[MAX_FRAME_BUFFER_NUMS];
-	u32 nr;
-	u64 ktid;
-};
-
 extern struct msm_cvp_drv *cvp_driver;
 
 void cvp_handle_cmd_response(enum hal_command_response cmd, void *data);
@@ -388,19 +359,7 @@ int msm_cvp_trigger_ssr(struct msm_cvp_core *core,
 	enum hal_ssr_trigger_type type);
 int msm_cvp_noc_error_info(struct msm_cvp_core *core);
 void msm_cvp_comm_handle_thermal_event(void);
-int msm_cvp_smem_alloc(size_t size, u32 align, u32 flags, int map_kernel,
-	void  *res, struct msm_cvp_smem *smem);
-int msm_cvp_smem_free(struct msm_cvp_smem *smem);
 
-struct context_bank_info *msm_cvp_smem_get_context_bank(bool is_secure,
-	struct msm_cvp_platform_resources *res, unsigned long ion_flags);
-int msm_cvp_map_smem(struct msm_cvp_inst *inst,
-				struct msm_cvp_smem *smem);
-int msm_cvp_unmap_smem(struct msm_cvp_smem *smem);
-struct dma_buf *msm_cvp_smem_get_dma_buf(int fd);
-void msm_cvp_smem_put_dma_buf(void *dma_buf);
-int msm_cvp_smem_cache_operations(struct dma_buf *dbuf,
-	enum smem_cache_ops cache_op, unsigned long offset, unsigned long size);
 void msm_cvp_fw_unload_handler(struct work_struct *work);
 void msm_cvp_ssr_handler(struct work_struct *work);
 /*
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 e39f6b78b30e..3558c9692643 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
@@ -904,7 +904,7 @@ int msm_cvp_smmu_fault_handler(struct iommu_domain *domain,
 
 	mutex_lock(&core->lock);
 	list_for_each_entry(inst, &core->instances, list) {
-		msm_cvp_comm_print_inst_info(inst);
+		msm_cvp_print_inst_bufs(inst);
 	}
 	core->smmu_fault_handled = true;
 	msm_cvp_noc_error_info(core);