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

Commit 2d5a347b authored by Ruofei Ma's avatar Ruofei Ma
Browse files

msm: cvp: Remove V4L2 framework from driver 



Remove V4L2 framework from CVP driver since it is
not needed.

Change-Id: I24688a3b42bca13d8cd45a6c5372d52c34740ac1
Signed-off-by: default avatarRuofei Ma <ruofeim@codeaurora.org>
parent be4e22c9

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

+0 −2
Original line number Diff line number Diff line
@@ -279,7 +279,5 @@ void cvp_venus_hfi_delete_device(void *device); 
int cvp_venus_hfi_initialize(struct hfi_device *hdev, u32 device_id,

		struct msm_cvp_platform_resources *res,

		hfi_cmd_response_callback callback);

bool cvp_venus_hfi_is_session_supported(unsigned long sessions_supported,

		enum cvp_vote_data_session session_type);



#endif

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

+0 −33
Original line number Diff line number Diff line
@@ -1399,32 +1399,6 @@ enum msm_cvp_thermal_level { 
	CVP_THERMAL_CRITICAL

};



enum cvp_vote_data_session {

	CVP_BUS_VOTE_DATA_SESSION_INVALID = 0,

	/*

	 * No declarations exist. Values generated by CVP_VOTE_DATA_SESSION_VAL

	 * describe the enumerations e.g.:

	 *

	 * enum cvp_bus_vote_data_session_type h264_decoder_session =

	 *        CVP_VOTE_DATA_SESSION_VAL(HAL_VIDEO_CODEC_H264,

	 *                 HAL_VIDEO_DOMAIN_DECODER);

	 */

};



/*

 * Careful modifying CVP_VOTE_DATA_SESSION_VAL().

 *

 * This macro assigns two bits to each codec: the lower bit denoting the codec

 * type, and the higher bit denoting session type.

 */

static inline enum cvp_vote_data_session CVP_VOTE_DATA_SESSION_VAL(

		enum hal_video_codec c, enum hal_domain d) {

	if (d != HAL_VIDEO_DOMAIN_ENCODER && d != HAL_VIDEO_DOMAIN_DECODER)

		return CVP_BUS_VOTE_DATA_SESSION_INVALID;



	return (1 << ilog2(c) * 2) | ((d - 1) << (ilog2(c) * 2 + 1));

}



struct msm_cvp_gov_data {

	struct cvp_bus_vote_data *data;

	u32 data_count;
@@ -1456,13 +1430,6 @@ struct cvp_bus_vote_data { 
	bool b_frames_enabled;

};



struct cvp_clk_scale_data {

	enum cvp_vote_data_session session[CVP_MAX_SESSIONS];

	enum msm_cvp_power_mode power_mode[CVP_MAX_SESSIONS];

	u32 load[CVP_MAX_SESSIONS];

	int num_sessions;

};



struct hal_cmd_sys_get_property_packet {

	u32 size;

	u32 packet_type;

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

+8 −108
Original line number Diff line number Diff line
@@ -114,27 +114,9 @@ int msm_cvp_comm_vote_bus(struct msm_cvp_core *core) 
	mutex_lock(&core->lock);

	list_for_each_entry(inst, &core->instances, list) {

		int codec = 0;

		struct msm_video_buffer *temp, *next;

		u32 filled_len = 0;

		u32 device_addr = 0;



		mutex_lock(&inst->registeredbufs.lock);

		list_for_each_entry_safe(temp, next,

				&inst->registeredbufs.list, list) {

			if (temp->vvb.vb2_buf.type ==

				V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {

				filled_len = max(filled_len,

					temp->vvb.vb2_buf.planes[0].bytesused);

				device_addr = temp->smem[0].device_addr;

			}

			if (inst->session_type == MSM_CVP_ENCODER &&

				(temp->vvb.flags &

				V4L2_BUF_FLAG_PERF_MODE)) {

				is_turbo = true;

			}

		}

		mutex_unlock(&inst->registeredbufs.lock);



		if ((!filled_len || !device_addr) &&

			(inst->session_type != MSM_CVP_CORE)) {

			dprintk(CVP_DBG, "%s: no input for session %x\n",
@@ -144,11 +126,7 @@ int msm_cvp_comm_vote_bus(struct msm_cvp_core *core) 


		++vote_data_count;



		switch (inst->session_type) {

		case MSM_CVP_CORE:

			codec = V4L2_PIX_FMT_CVP;

			break;

		default:

		if (inst->session_type != MSM_CVP_CORE) {

			dprintk(CVP_ERR, "%s: invalid session_type %#x\n",

				__func__, inst->session_type);

			break;
@@ -156,8 +134,8 @@ int msm_cvp_comm_vote_bus(struct msm_cvp_core *core) 


		memset(&(vote_data[i]), 0x0, sizeof(struct cvp_bus_vote_data));



		vote_data[i].domain = get_cvp_hal_domain(inst->session_type);

		vote_data[i].codec = get_cvp_hal_codec(codec);

		vote_data[i].domain = HAL_VIDEO_DOMAIN_CVP;

		vote_data[i].codec = HAL_VIDEO_CODEC_CVP;

		vote_data[i].input_width =  max(inst->prop.width[OUTPUT_PORT],

				inst->prop.width[OUTPUT_PORT]);

		vote_data[i].input_height = max(inst->prop.height[OUTPUT_PORT],
@@ -204,8 +182,7 @@ int msm_cvp_comm_vote_bus(struct msm_cvp_core *core) 
			vote_data[i].use_sys_cache = true;



		if (inst->session_type == MSM_CVP_CORE) {

			vote_data[i].domain =

				get_cvp_hal_domain(inst->session_type);

			vote_data[i].domain = HAL_VIDEO_DOMAIN_CVP;

			vote_data[i].ddr_bw = inst->clk_data.ddr_bw;

			vote_data[i].sys_cache_bw =

				inst->clk_data.sys_cache_bw;
@@ -239,22 +216,15 @@ static int msm_dcvs_scale_clocks(struct msm_cvp_inst *inst, 
	/* assume no increment or decrement is required initially */

	inst->clk_data.dcvs_flags = 0;



	if (!inst->clk_data.dcvs_mode || inst->batch.enable) {

		dprintk(CVP_DBG, "Skip DCVS (dcvs %d, batching %d)\n",

			inst->clk_data.dcvs_mode, inst->batch.enable);

	if (!inst->clk_data.dcvs_mode) {

		dprintk(CVP_DBG, "Skip DCVS (dcvs %d)\n",

			inst->clk_data.dcvs_mode);

		/* update load (freq) with normal value */

		inst->clk_data.load = inst->clk_data.load_norm;

		return 0;

	}



	dcvs = &inst->clk_data;



	if (is_decode_session(inst))

		bufs_with_fw = msm_cvp_comm_num_queued_bufs(inst,

			V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);

	else

		bufs_with_fw = msm_cvp_comm_num_queued_bufs(inst,

			V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);

	/* +1 as one buffer is going to be queued after the function */

	bufs_with_fw += 1;
@@ -493,7 +463,6 @@ int msm_cvp_set_clocks(struct msm_cvp_core *core) 


int msm_cvp_comm_scale_clocks(struct msm_cvp_inst *inst)

{

	struct msm_video_buffer *temp, *next;

	unsigned long freq = 0;

	u32 filled_len = 0;

	u32 device_addr = 0;
@@ -510,22 +479,6 @@ int msm_cvp_comm_scale_clocks(struct msm_cvp_inst *inst) 
		return 0;

	}



	mutex_lock(&inst->registeredbufs.lock);

	list_for_each_entry_safe(temp, next, &inst->registeredbufs.list, list) {

		if (temp->vvb.vb2_buf.type ==

				V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {

			filled_len = max(filled_len,

				temp->vvb.vb2_buf.planes[0].bytesused);

			if (inst->session_type == MSM_CVP_ENCODER &&

				(temp->vvb.flags &

				 V4L2_BUF_FLAG_PERF_MODE)) {

				is_turbo = true;

			}

			device_addr = temp->smem[0].device_addr;

		}

	}

	mutex_unlock(&inst->registeredbufs.lock);



	if (!filled_len || !device_addr) {

		dprintk(CVP_DBG, "%s no input for session %x\n",

			__func__, hash32_ptr(inst->session));
@@ -583,8 +536,7 @@ int msm_cvp_dcvs_try_enable(struct msm_cvp_inst *inst) 


	if (msm_cvp_clock_voting ||

			inst->flags & CVP_THUMBNAIL ||

			inst->clk_data.low_latency_mode ||

			inst->batch.enable) {

			inst->clk_data.low_latency_mode) {

		dprintk(CVP_PROF, "DCVS disabled: %pK\n", inst);

		inst->clk_data.dcvs_mode = false;

		return false;
@@ -611,58 +563,6 @@ int msm_cvp_comm_init_clocks_and_bus_data(struct msm_cvp_inst *inst) 
	return 0;

}



static bool is_output_buffer(struct msm_cvp_inst *inst,

	enum hal_buffer buffer_type)

{

	if (msm_cvp_comm_get_stream_output_mode(inst) ==

			HAL_VIDEO_DECODER_SECONDARY) {

		return buffer_type == HAL_BUFFER_OUTPUT2;

	} else {

		return buffer_type == HAL_BUFFER_OUTPUT;

	}

}



int msm_cvp_get_extra_buff_count(struct msm_cvp_inst *inst,

	enum hal_buffer buffer_type)

{

	int count = 0;



	if (!inst || !inst->core) {

		dprintk(CVP_ERR, "%s Invalid args\n", __func__);

		return 0;

	}

	/*

	 * no extra buffers for thumbnail session because

	 * neither dcvs nor batching will be enabled

	 */

	if (is_thumbnail_session(inst))

		return 0;



	/* Add DCVS extra buffer count */

	if (inst->core->resources.dcvs) {

		if (is_decode_session(inst) &&

			is_output_buffer(inst, buffer_type)) {

			count += DCVS_DEC_EXTRA_OUTPUT_BUFFERS;

		} else if ((is_encode_session(inst) &&

			buffer_type == HAL_BUFFER_INPUT)) {

			count += DCVS_ENC_EXTRA_INPUT_BUFFERS;

		}

	}



	/*

	 * if platform supports decode batching ensure minimum

	 * batch size count of extra buffers added on output port

	 */

	if (is_output_buffer(inst, buffer_type)) {

		if (inst->core->resources.decode_batching &&

			is_decode_session(inst) &&

			count < inst->batch.size)

			count = inst->batch.size;

	}



	return count;

}



int msm_cvp_decide_work_route(struct msm_cvp_inst *inst)

{

	return -EINVAL;

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

+0 −8
Original line number Diff line number Diff line
@@ -8,14 +8,6 @@ 
#define _MSM_CVP_CLOCKS_H_

#include "msm_cvp_internal.h"



/* extra o/p buffers in case of encoder dcvs */

#define DCVS_ENC_EXTRA_INPUT_BUFFERS 4



/* extra o/p buffers in case of decoder dcvs */

#define DCVS_DEC_EXTRA_OUTPUT_BUFFERS 4



int msm_cvp_get_extra_buff_count(struct msm_cvp_inst *inst,

	enum hal_buffer buffer_type);

int msm_cvp_set_clocks(struct msm_cvp_core *core);

int msm_cvp_comm_vote_bus(struct msm_cvp_core *core);

int msm_cvp_dcvs_try_enable(struct msm_cvp_inst *inst);

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

+23 −256
Original line number Diff line number Diff line
@@ -22,23 +22,6 @@ 


static void handle_session_error(enum hal_command_response cmd, void *data);



enum multi_stream msm_cvp_comm_get_stream_output_mode(struct msm_cvp_inst *inst)

{

	if (!inst) {

		dprintk(CVP_ERR, "%s: invalid params, return default mode\n",

			__func__);

		return HAL_VIDEO_DECODER_PRIMARY;

	}



	if (!is_decode_session(inst))

		return HAL_VIDEO_DECODER_PRIMARY;



	if (inst->stream_output_mode == HAL_VIDEO_DECODER_SECONDARY)

		return HAL_VIDEO_DECODER_SECONDARY;

	else

		return HAL_VIDEO_DECODER_PRIMARY;

}



int msm_cvp_comm_get_inst_load(struct msm_cvp_inst *inst,

		enum load_calc_quirks quirks)

{
@@ -56,40 +39,6 @@ int msm_cvp_comm_get_inst_load_per_core(struct msm_cvp_inst *inst, 
	return load;

}



enum hal_domain get_cvp_hal_domain(int session_type)

{

	enum hal_domain domain;



	switch (session_type) {

	case MSM_CVP_CORE:

		domain = HAL_VIDEO_DOMAIN_CVP;

		break;

	default:

		dprintk(CVP_ERR, "Wrong domain %d\n", session_type);

		domain = HAL_UNUSED_DOMAIN;

		break;

	}



	return domain;

}



enum hal_video_codec get_cvp_hal_codec(int fourcc)

{

	enum hal_video_codec codec;



	switch (fourcc) {

	case V4L2_PIX_FMT_CVP:

		codec = HAL_VIDEO_CODEC_CVP;

		break;

	default:

		dprintk(CVP_ERR, "Wrong codec: %#x\n", fourcc);

		codec = HAL_UNUSED_CODEC;

		break;

	}



	return codec;

}



struct msm_cvp_core *get_cvp_core(int core_id)

{

	struct msm_cvp_core *core;
@@ -113,16 +62,6 @@ struct msm_cvp_core *get_cvp_core(int core_id) 
	return NULL;

}



struct buf_queue *msm_cvp_comm_get_vb2q(

		struct msm_cvp_inst *inst, enum v4l2_buf_type type)

{

	if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)

		return &inst->bufq[CAPTURE_PORT];

	if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)

		return &inst->bufq[OUTPUT_PORT];

	return NULL;

}



static void handle_sys_init_done(enum hal_command_response cmd, void *data)

{

	struct msm_cvp_cb_cmd_done *response = data;
@@ -153,9 +92,6 @@ static void handle_sys_init_done(enum hal_command_response cmd, void *data) 
		return;

	}



	core->enc_codec_supported = sys_init_msg->enc_codec_supported;

	core->dec_codec_supported = sys_init_msg->dec_codec_supported;



	/* This should come from sys_init_done */

	core->resources.max_inst_count =

		sys_init_msg->max_sessions_supported ?
@@ -167,19 +103,13 @@ static void handle_sys_init_done(enum hal_command_response cmd, void *data) 
		core->resources.max_secure_inst_count :

		core->resources.max_inst_count;



	if (core->id == MSM_CORE_CVP &&

		(core->dec_codec_supported & HAL_VIDEO_CODEC_H264))

		core->dec_codec_supported |=

			HAL_VIDEO_CODEC_MVC;



	core->codec_count = sys_init_msg->codec_count;

	memcpy(core->capabilities, sys_init_msg->capabilities,

		sys_init_msg->codec_count * sizeof(struct msm_cvp_capability));



	dprintk(CVP_DBG,

		"%s: supported_codecs[%d]: enc = %#x, dec = %#x\n",

		__func__, core->codec_count, core->enc_codec_supported,

		core->dec_codec_supported);

		"%s: max_inst_count %d, max_secure_inst_count %d\n",

		__func__, core->resources.max_inst_count,

		core->resources.max_secure_inst_count);



	complete(&(core->completions[index]));

}
@@ -455,9 +385,6 @@ static int wait_for_state(struct msm_cvp_inst *inst, 


void msm_cvp_queue_v4l2_event(struct msm_cvp_inst *inst, int event_type)

{

	struct v4l2_event event = {.id = 0, .type = event_type};



	v4l2_event_queue_fh(&inst->event_handler, &event);

}



static void msm_cvp_comm_generate_max_clients_error(struct msm_cvp_inst *inst)
@@ -749,15 +676,6 @@ static void handle_operation_config(enum hal_command_response cmd, void *data) 
			__func__);

}



enum hal_buffer msm_cvp_comm_get_hal_output_buffer(struct msm_cvp_inst *inst)

{

	if (msm_cvp_comm_get_stream_output_mode(inst) ==

		HAL_VIDEO_DECODER_SECONDARY)

		return HAL_BUFFER_OUTPUT2;

	else

		return HAL_BUFFER_OUTPUT;

}



void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)

{

	dprintk(CVP_DBG, "Command response = %d\n", cmd);
@@ -1094,7 +1012,7 @@ static int msm_cvp_deinit_core(struct msm_cvp_inst *inst) 


	mutex_lock(&core->lock);

	if (core->state == CVP_CORE_UNINIT) {

		dprintk(CVP_INFO, "Video core: %d is already in state: %d\n",

		dprintk(CVP_INFO, "CVP core: %d is already in state: %d\n",

				core->id, core->state);

		goto core_already_uninited;

	}
@@ -1155,7 +1073,6 @@ static int msm_comm_session_init(int flipped_state, 
	struct msm_cvp_inst *inst)

{

	int rc = 0;

	int fourcc = 0;

	struct hfi_device *hdev;



	if (!inst || !inst->core || !inst->core->device) {
@@ -1169,9 +1086,7 @@ static int msm_comm_session_init(int flipped_state, 
						inst, inst->state);

		goto exit;

	}

	if (inst->session_type == MSM_CVP_CORE) {

		fourcc = V4L2_PIX_FMT_CVP;

	} else {

	if (inst->session_type != MSM_CVP_CORE) {

		dprintk(CVP_ERR, "Invalid session\n");

		return -EINVAL;

	}
@@ -1184,15 +1099,14 @@ static int msm_comm_session_init(int flipped_state, 


	dprintk(CVP_DBG, "%s: inst %pK\n", __func__, inst);

	rc = call_hfi_op(hdev, session_init, hdev->hfi_device_data,

			inst, get_cvp_hal_domain(inst->session_type),

			get_cvp_hal_codec(fourcc),

			inst, HAL_VIDEO_DOMAIN_CVP,

			HAL_VIDEO_CODEC_CVP,

			&inst->session);



	if (rc || !inst->session) {

		dprintk(CVP_ERR,

			"Failed to call session init for: %pK, %pK, %d, %d\n",

			inst->core->device, inst,

			inst->session_type, fourcc);

			"Failed to call session init for: %pK, %pK, %d\n",

			inst->core->device, inst, inst->session_type);

		rc = -EINVAL;

		goto exit;

	}
@@ -1387,71 +1301,6 @@ int msm_cvp_comm_try_state(struct msm_cvp_inst *inst, int state) 
	return rc;

}



enum hal_buffer cvp_get_hal_buffer_type(unsigned int type,

		unsigned int plane_num)

{

	if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {

		if (plane_num == 0)

			return HAL_BUFFER_INPUT;

		else

			return HAL_BUFFER_EXTRADATA_INPUT;

	} else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {

		if (plane_num == 0)

			return HAL_BUFFER_OUTPUT;

		else

			return HAL_BUFFER_EXTRADATA_OUTPUT;

	} else {

		return -EINVAL;

	}

}



int msm_cvp_comm_num_queued_bufs(struct msm_cvp_inst *inst, u32 type)

{

	int count = 0;

	struct msm_video_buffer *mbuf;



	if (!inst) {

		dprintk(CVP_ERR, "%s: invalid params\n", __func__);

		return 0;

	}



	mutex_lock(&inst->registeredbufs.lock);

	list_for_each_entry(mbuf, &inst->registeredbufs.list, list) {

		if (mbuf->vvb.vb2_buf.type != type)

			continue;

		if (!(mbuf->flags & MSM_CVP_FLAG_QUEUED))

			continue;

		count++;

	}

	mutex_unlock(&inst->registeredbufs.lock);



	return count;

}



int msm_cvp_comm_set_buffer_count(struct msm_cvp_inst *inst,

	int host_count, int act_count, enum hal_buffer type)

{

	int rc = 0;

	struct hfi_device *hdev;

	struct hal_buffer_count_actual buf_count;



	hdev = inst->core->device;



	buf_count.buffer_type = type;

	buf_count.buffer_count_actual = act_count;

	buf_count.buffer_count_min_host = host_count;

	dprintk(CVP_DBG, "%s: %x : hal_buffer %d min_host %d actual %d\n",

		__func__, hash32_ptr(inst->session), type,

		host_count, act_count);

	rc = call_hfi_op(hdev, session_set_property,

		inst->session, HAL_PARAM_BUFFER_COUNT_ACTUAL, &buf_count);

	if (rc)

		dprintk(CVP_ERR,

			"Failed to set actual buffer count %d for buffer type %d\n",

			act_count, type);

	return rc;

}



int msm_cvp_noc_error_info(struct msm_cvp_core *core)

{

	struct hfi_device *hdev;
@@ -1661,10 +1510,8 @@ void msm_cvp_fw_unload_handler(struct work_struct *work) 


void msm_cvp_comm_print_inst_info(struct msm_cvp_inst *inst)

{

	struct msm_video_buffer *mbuf;

	struct msm_cvp_internal_buffer *cbuf;

	struct internal_buf *buf;

	bool is_decode = false;

	enum cvp_ports port;

	bool is_secure = false;



	if (!inst) {
@@ -1673,16 +1520,14 @@ void msm_cvp_comm_print_inst_info(struct msm_cvp_inst *inst) 
		return;

	}



	is_decode = inst->session_type == MSM_CVP_DECODER;

	port = is_decode ? OUTPUT_PORT : CAPTURE_PORT;

	is_secure = inst->flags & CVP_SECURE;

	dprintk(CVP_ERR,

			"---Buffer details for inst: %pK of type: %d---\n",

			inst, inst->session_type);

	mutex_lock(&inst->registeredbufs.lock);

	dprintk(CVP_ERR, "registered buffer list:\n");

	list_for_each_entry(mbuf, &inst->registeredbufs.list, list)

		print_video_buffer(CVP_ERR, "buf", inst, mbuf);

	list_for_each_entry(cbuf, &inst->registeredbufs.list, list)

		print_cvp_buffer(CVP_ERR, "buf", inst, cbuf);

	mutex_unlock(&inst->registeredbufs.lock);



	mutex_lock(&inst->persistbufs.lock);
@@ -1694,109 +1539,31 @@ void msm_cvp_comm_print_inst_info(struct msm_cvp_inst *inst) 
	mutex_unlock(&inst->persistbufs.lock);

}



void print_video_buffer(u32 tag, const char *str, struct msm_cvp_inst *inst,

		struct msm_video_buffer *mbuf)

void print_cvp_buffer(u32 tag, const char *str, struct msm_cvp_inst *inst,

		struct msm_cvp_internal_buffer *cbuf)

{

	struct vb2_buffer *vb2 = NULL;



	if (!(tag & msm_cvp_debug) || !inst || !mbuf)

		return;



	vb2 = &mbuf->vvb.vb2_buf;

}



	if (vb2->num_planes == 1)

		dprintk(tag,

			"%s: %s: %x : idx %2d fd %d off %d daddr %x size %d filled %d flags 0x%x ts %lld refcnt %d mflags 0x%x\n",

			str, vb2->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ?

			"OUTPUT" : "CAPTURE", hash32_ptr(inst->session),

			vb2->index, vb2->planes[0].m.fd,

			vb2->planes[0].data_offset, mbuf->smem[0].device_addr,

			vb2->planes[0].length, vb2->planes[0].bytesused,

			mbuf->vvb.flags, mbuf->vvb.vb2_buf.timestamp,

			mbuf->smem[0].refcount, mbuf->flags);

	else

		dprintk(tag,

			"%s: %s: %x : idx %2d fd %d off %d daddr %x size %d filled %d flags 0x%x ts %lld refcnt %d mflags 0x%x, extradata: fd %d off %d daddr %x size %d filled %d refcnt %d\n",

			str, vb2->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ?

			"OUTPUT" : "CAPTURE", hash32_ptr(inst->session),

			vb2->index, vb2->planes[0].m.fd,

			vb2->planes[0].data_offset, mbuf->smem[0].device_addr,

			vb2->planes[0].length, vb2->planes[0].bytesused,

			mbuf->vvb.flags, mbuf->vvb.vb2_buf.timestamp,

			mbuf->smem[0].refcount, mbuf->flags,

			vb2->planes[1].m.fd, vb2->planes[1].data_offset,

			mbuf->smem[1].device_addr, vb2->planes[1].length,

			vb2->planes[1].bytesused, mbuf->smem[1].refcount);

}



int msm_cvp_comm_unmap_video_buffer(struct msm_cvp_inst *inst,

		struct msm_video_buffer *mbuf)

int msm_cvp_comm_unmap_cvp_buffer(struct msm_cvp_inst *inst,

		struct msm_cvp_internal_buffer *cbuf)

{

	int rc = 0, i;

	int rc = 0;



	if (!inst || !mbuf) {

	if (!inst || !cbuf) {

		dprintk(CVP_ERR, "%s: invalid params %pK %pK\n",

			__func__, inst, mbuf);

		return -EINVAL;

	}

	if (mbuf->vvb.vb2_buf.num_planes > VIDEO_MAX_PLANES) {

		dprintk(CVP_ERR, "%s: invalid num_planes %d\n", __func__,

			mbuf->vvb.vb2_buf.num_planes);

			__func__, inst, cbuf);

		return -EINVAL;

	}



	for (i = 0; i < mbuf->vvb.vb2_buf.num_planes; i++) {

		u32 refcount = mbuf->smem[i].refcount;



		while (refcount) {

			if (msm_cvp_smem_unmap_dma_buf(inst, &mbuf->smem[i]))

				print_video_buffer(CVP_ERR,

					"unmap failed for buf", inst, mbuf);

			refcount--;

		}

	rc = msm_cvp_smem_unmap_dma_buf(inst, &cbuf->smem);

	if (rc) {

		print_cvp_buffer(CVP_ERR,

			"unmap failed for buf", inst, cbuf);

	}



	return rc;

}



static void kref_free_mbuf(struct kref *kref)

{

	struct msm_video_buffer *mbuf = container_of(kref,

			struct msm_video_buffer, kref);



	kfree(mbuf);

}



void kref_cvp_put_mbuf(struct msm_video_buffer *mbuf)

{

	if (!mbuf)

		return;



	kref_put(&mbuf->kref, kref_free_mbuf);

}



bool kref_cvp_get_mbuf(struct msm_cvp_inst *inst, struct msm_video_buffer *mbuf)

{

	struct msm_video_buffer *temp;

	bool matches = false;

	bool ret = false;



	if (!inst || !mbuf)

		return false;



	mutex_lock(&inst->registeredbufs.lock);

	list_for_each_entry(temp, &inst->registeredbufs.list, list) {

		if (temp == mbuf) {

			matches = true;

			break;

		}

	}

	ret = (matches && kref_get_unless_zero(&mbuf->kref)) ? true : false;

	mutex_unlock(&inst->registeredbufs.lock);



	return ret;

}



static int set_internal_buf_on_fw(struct msm_cvp_inst *inst,

				enum hal_buffer buffer_type,

				struct msm_smem *handle, bool reuse)