Merge "msm: cvp: Remove V4L2 framework from driver" (c8f2aa4e) · Commits · e / devices / android_kernel_xiaomi_nabu

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)