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

Commit 30bb4347 authored by George Shen's avatar George Shen
Browse files

msm: cvp: Restructure CVP buffer management 



It fixes an issue that CVP session creation may fail if session runs
out of buffer cache.

Change-Id: I06f2db2132c16aef51b19a9ac0c7bed917390a7b
Signed-off-by: default avatarGeorge Shen <sqiao@codeaurora.org>
parent 04c6aea0

drivers/media/platform/msm/cvp/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -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

drivers/media/platform/msm/cvp/cvp_hfi_helper.h

+0 −14
Original line number Diff line number Diff line
@@ -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;

drivers/media/platform/msm/cvp/msm_cvp.c

+2 −687
Original line number Diff line number Diff line
@@ -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;

}

drivers/media/platform/msm/cvp/msm_cvp_buf.c

0 → 100644
+922 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/media/platform/msm/cvp/msm_cvp_buf.h

0 → 100644
+160 −0
Original line number Diff line number Diff line 
/* 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