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

Commit f38e09e3 authored by qctecmdr Service's avatar qctecmdr Service Committed by Gerrit - the friendly Code Review server
Browse files

Merge "msm: cvp: Add synX support for Camera to use CVP"

parents 25b980ea a436bfcc

drivers/media/platform/msm/cvp/Makefile

+1 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

ccflags-y += -I$(srctree)/drivers/media/platform/msm/cvp/

ccflags-y += -I$(srctree)/drivers/media/platform/msm/synx/



msm-cvp-objs := msm_v4l2_cvp.o \

				msm_v4l2_private.o \

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

+77 −186
Original line number Diff line number Diff line
@@ -37,6 +37,52 @@ 
#define REG_ADDR_OFFSET_BITMASK	0x000FFFFF

#define QDSS_IOVA_START 0x80001000



const struct msm_cvp_hfi_defs cvp_hfi_defs[] = {

	{

		.size = HFI_DFS_CONFIG_CMD_SIZE,

		.type = HFI_CMD_SESSION_CVP_DFS_CONFIG,

		.buf_offset = 0,

		.buf_num = 0,

		.resp = HAL_SESSION_DFS_CONFIG_CMD_DONE,

	},

	{

		.size = HFI_DFS_FRAME_CMD_SIZE,

		.type = HFI_CMD_SESSION_CVP_DFS_FRAME,

		.buf_offset = HFI_DFS_FRAME_BUFFERS_OFFSET,

		.buf_num = HFI_DFS_BUF_NUM,

		.resp = HAL_NO_RESP,

	},

	{

		.size = HFI_DME_CONFIG_CMD_SIZE,

		.type = HFI_CMD_SESSION_CVP_DME_CONFIG,

		.buf_offset = 0,

		.buf_num = 0,

		.resp = HAL_SESSION_DME_CONFIG_CMD_DONE,

	},

	{

		.size = HFI_DME_BASIC_CONFIG_CMD_SIZE,

		.type = HFI_CMD_SESSION_CVP_DME_BASIC_CONFIG,

		.buf_offset = 0,

		.buf_num = 0,

		.resp = HAL_SESSION_DME_BASIC_CONFIG_CMD_DONE,

	},

	{

		.size = HFI_DME_FRAME_CMD_SIZE,

		.type = HFI_CMD_SESSION_CVP_DME_FRAME,

		.buf_offset = HFI_DME_FRAME_BUFFERS_OFFSET,

		.buf_num = HFI_DME_BUF_NUM,

		.resp = HAL_NO_RESP,

	},

	{

		.size = HFI_PERSIST_CMD_SIZE,

		.type = HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS,

		.buf_offset = HFI_PERSIST_BUFFERS_OFFSET,

		.buf_num = HFI_PERSIST_BUF_NUM,

		.resp = HAL_NO_RESP,

	},



};



static struct hal_device_data hal_ctxt;



#define TZBSP_MEM_PROTECT_VIDEO_VAR 0x8
@@ -147,6 +193,18 @@ static inline bool is_sys_cache_present(struct venus_hfi_device *device) 


#define ROW_SIZE 32



int get_pkt_index(struct cvp_hal_session_cmd_pkt *hdr)

{

	int i, pkt_num = ARRAY_SIZE(cvp_hfi_defs);



	for (i = 0; i < pkt_num; i++)

		if ((cvp_hfi_defs[i].size*sizeof(unsigned int) == hdr->size) &&

			(cvp_hfi_defs[i].type == hdr->packet_type))

			return i;



	return -EINVAL;

}



static void __dump_packet(u8 *packet, enum cvp_msg_prio log_level)

{

	u32 c = 0, packet_size = *(u32 *)packet;
@@ -1292,7 +1350,7 @@ static int __set_clocks(struct venus_hfi_device *device, u32 freq) 
			}



			trace_msm_cvp_perf_clock_scale(cl->name, freq);

			dprintk(CVP_PROF, "Scaling clock %s to %u\n",

			dprintk(CVP_DBG, "Scaling clock %s to %u\n",

					cl->name, freq);

		}

	}
@@ -2641,11 +2699,11 @@ static int venus_hfi_session_stop(void *session) 
	return rc;

}



static int venus_hfi_session_cvp_dme_config(void *sess,

		struct msm_cvp_internal_dmeconfig *dme_config)

static int venus_hfi_session_send(void *sess,

		struct cvp_kmd_hfi_packet *in_pkt)

{

	int rc = 0;

	struct hfi_cmd_session_cvp_dme_config_packet pkt;

	struct cvp_kmd_hfi_packet pkt;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;
@@ -2659,174 +2717,26 @@ static int venus_hfi_session_cvp_dme_config(void *sess, 


	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		goto dme_config_err;

		goto err_send_pkt;

	}

	rc = call_hfi_pkt_op(device, session_cvp_dme_config,

			&pkt, session, dme_config);

	rc = call_hfi_pkt_op(device, session_cvp_hfi_packetize,

			&pkt, session, in_pkt);

	if (rc) {

		dprintk(CVP_ERR,

				"Session get buf req: failed to create pkt\n");

		goto dme_config_err;

				"failed to create pkt\n");

		goto err_send_pkt;

	}



	if (__iface_cmdq_write(session->device, &pkt))

		rc = -ENOTEMPTY;

	dprintk(CVP_DBG, "%s: calling __iface_cmdq_write\n", __func__);

dme_config_err:

	mutex_unlock(&device->lock);

	return rc;

}



static int venus_hfi_session_cvp_dme_frame(void *sess,

				struct msm_cvp_internal_dmeframe *dme_frame)

{

	int rc = 0;

	struct hfi_cmd_session_cvp_dme_frame_packet pkt;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!session || !session->device) {

		dprintk(CVP_ERR, "invalid session");

		return -ENODEV;

	}



	device = session->device;

	mutex_lock(&device->lock);



	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		goto dme_frame_err;

	}

	rc = call_hfi_pkt_op(device, session_cvp_dme_frame,

			&pkt, session, dme_frame);

	if (rc) {

		dprintk(CVP_ERR,

				"Session get buf req: failed to create pkt\n");

		goto dme_frame_err;

	}



	if (__iface_cmdq_write(session->device, &pkt))

		rc = -ENOTEMPTY;

	dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);

dme_frame_err:

	mutex_unlock(&device->lock);

	return rc;

}





static int venus_hfi_session_cvp_persist(void *sess,

		struct msm_cvp_internal_persist_cmd *pbuf_cmd)

{

	int rc = 0;

	struct hfi_cmd_session_cvp_persist_packet pkt;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!session || !session->device) {

		dprintk(CVP_ERR, "invalid session");

		return -ENODEV;

	}



	device = session->device;

	mutex_lock(&device->lock);



	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		goto persist_err;

	}

	rc = call_hfi_pkt_op(device, session_cvp_persist,

			&pkt, session, pbuf_cmd);

	if (rc) {

		dprintk(CVP_ERR,

				"Failed to create persist pkt\n");

		goto persist_err;

	}



	if (__iface_cmdq_write(session->device, &pkt))

		rc = -ENOTEMPTY;



	dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);

persist_err:

	mutex_unlock(&device->lock);

	return rc;

}



static int venus_hfi_session_cvp_dfs_config(void *sess,

		struct msm_cvp_internal_dfsconfig *dfs_config)

{

	int rc = 0;

	struct hfi_cmd_session_cvp_dfs_config_packet pkt;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!session || !session->device) {

		dprintk(CVP_ERR, "invalid session");

		return -ENODEV;

	}



	device = session->device;

	mutex_lock(&device->lock);



	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		goto err_create_pkt;

	}

	rc = call_hfi_pkt_op(device, session_cvp_dfs_config,

			&pkt, session, dfs_config);

	if (rc) {

		dprintk(CVP_ERR,

				"Session get buf req: failed to create pkt\n");

		goto err_create_pkt;

	}



	dprintk(CVP_DBG, "%s: calling __iface_cmdq_write\n", __func__);

	if (__iface_cmdq_write(session->device, &pkt))

		rc = -ENOTEMPTY;

	dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);

err_create_pkt:

err_send_pkt:

	mutex_unlock(&device->lock);

	return rc;



	return rc;

}



static int venus_hfi_session_cvp_dfs_frame(void *sess,

				struct msm_cvp_internal_dfsframe *dfs_frame)

{

	int rc = 0;

	struct hfi_cmd_session_cvp_dfs_frame_packet pkt;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!session || !session->device) {

		dprintk(CVP_ERR, "invalid session");

		return -ENODEV;

	}



	device = session->device;

	mutex_lock(&device->lock);



	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		goto err_create_pkt;

	}

	rc = call_hfi_pkt_op(device, session_cvp_dfs_frame,

			&pkt, session, dfs_frame);

	if (rc) {

		dprintk(CVP_ERR,

				"Session get buf req: failed to create pkt\n");

		goto err_create_pkt;

	}



	dprintk(CVP_DBG, "%s: calling __iface_cmdq_write\n", __func__);

	if (__iface_cmdq_write(session->device, &pkt))

		rc = -ENOTEMPTY;

	dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);

err_create_pkt:

	mutex_unlock(&device->lock);

	return rc;

}



static int venus_hfi_session_get_buf_req(void *sess)

{

	struct hfi_cmd_session_get_property_packet pkt;
@@ -3284,6 +3194,7 @@ static void **get_session_id(struct msm_cvp_cb_info *info) 
	case HAL_SESSION_UNREGISTER_BUFFER_DONE:

	case HAL_SESSION_DFS_CONFIG_CMD_DONE:

	case HAL_SESSION_DME_CONFIG_CMD_DONE:

	case HAL_SESSION_DME_BASIC_CONFIG_CMD_DONE:

	case HAL_SESSION_DFS_FRAME_CMD_DONE:

	case HAL_SESSION_DME_FRAME_CMD_DONE:

	case HAL_SESSION_PERSIST_CMD_DONE:
@@ -4014,30 +3925,14 @@ static int __enable_regulators(struct venus_hfi_device *device) 
	dprintk(CVP_DBG, "Enabling regulators\n");



	venus_hfi_for_each_regulator(device, rinfo) {

		if (rinfo->has_hw_power_collapse) {

			rc = regulator_set_mode(rinfo->regulator,

				REGULATOR_MODE_FAST);

			if (rc) {

				dprintk(CVP_ERR,

					"Failed to enable hwctrl%s: %d\n",

						rinfo->name, rc);

				goto err_reg_enable_failed;

			}

			dprintk(CVP_DBG, "Enabled regulator %s hw ctrl\n",

					rinfo->name);



		} else {

		rc = regulator_enable(rinfo->regulator);

		if (rc) {

				dprintk(CVP_ERR,

						"Failed to enable %s: %d\n",

			dprintk(CVP_ERR, "Failed to enable %s: %d\n",

					rinfo->name, rc);

			goto err_reg_enable_failed;

		}



			dprintk(CVP_DBG, "Enabled regulator %s\n",

					rinfo->name);

		}

		dprintk(CVP_DBG, "Enabled regulator %s\n", rinfo->name);

		c++;

	}
@@ -4743,11 +4638,7 @@ static void venus_init_hfi_callbacks(struct hfi_device *hdev) 
	hdev->session_continue = venus_hfi_session_continue;

	hdev->session_stop = venus_hfi_session_stop;

	hdev->session_get_buf_req = venus_hfi_session_get_buf_req;

	hdev->session_cvp_dfs_config = venus_hfi_session_cvp_dfs_config;

	hdev->session_cvp_dfs_frame = venus_hfi_session_cvp_dfs_frame;

	hdev->session_cvp_dme_config = venus_hfi_session_cvp_dme_config;

	hdev->session_cvp_dme_frame = venus_hfi_session_cvp_dme_frame;

	hdev->session_cvp_persist = venus_hfi_session_cvp_persist;

	hdev->session_cvp_hfi_send = venus_hfi_session_send;

	hdev->session_flush = venus_hfi_session_flush;

	hdev->session_set_property = venus_hfi_session_set_property;

	hdev->session_get_property = venus_hfi_session_get_property;

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

+2 −36
Original line number Diff line number Diff line
@@ -382,6 +382,8 @@ struct hfi_uncompressed_plane_actual_constraints_info { 


#define  HFI_CMD_SESSION_CVP_DME_CONFIG\

	(HFI_CMD_SESSION_CVP_START + 0x039)

#define  HFI_CMD_SESSION_CVP_DME_BASIC_CONFIG\

	(HFI_CMD_SESSION_CVP_START + 0x03B)

#define  HFI_CMD_SESSION_CVP_DME_FRAME\

	(HFI_CMD_SESSION_CVP_START + 0x03A)
@@ -581,42 +583,6 @@ struct HFI_CVP_COLOR_PLANE_INFO { 
	u32 buf_size[HFI_MAX_PLANES];

};



struct hfi_cmd_session_hdr {

	u32 size;

	u32 packet_type;

	u32 session_id;

};



struct hfi_cmd_session_cvp_dfs_config_packet {

	u32 cvp_internal_dfs_config[CVP_DFS_CONFIG_CMD_SIZE];

};



struct hfi_cmd_session_cvp_dfs_frame_packet {

	u32 cvp_dfs_frame[CVP_DFS_FRAME_BUFFERS_OFFSET];

	u32 left_view_buffer_addr;

	u32 left_view_buffer_size;

	u32 right_view_buffer_addr;

	u32 right_view_buffer_size;

	u32 disparity_map_buffer_addr;

	u32 disparity_map_buffer_size;

	u32 occlusion_mask_buffer_addr;

	u32 occlusion_mask_buffer_size;

};



struct hfi_cmd_session_cvp_dme_config_packet {

	u32 cvp_internal_dme_config[CVP_DME_CONFIG_CMD_SIZE];

};



struct hfi_cmd_session_cvp_dme_frame_packet {

	u32 cvp_dme_frame[CVP_DME_FRAME_BUFFERS_OFFSET];

	struct buf_desc bufs[8];

};



struct hfi_cmd_session_cvp_persist_packet {

	u32 cvp_persist_frame[CVP_PERSIST_BUFFERS_OFFSET];

	struct buf_desc bufs[CVP_PSRSIST_BUF_NUM];

};



struct hfi_cmd_session_release_buffer_packet {

	u32 size;

	u32 packet_type;

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

+30 −75
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/hash.h>

#include "msm_cvp_core.h"

#include "msm_cvp_resources.h"

#include "cvp_hfi_helper.h"



#define CONTAINS(__a, __sz, __t) (\

	(__t >= __a) && \
@@ -56,6 +57,22 @@ 
/* 16 encoder and 16 decoder sessions */

#define CVP_MAX_SESSIONS               32



#define HFI_DFS_CONFIG_CMD_SIZE	38

#define HFI_DFS_FRAME_CMD_SIZE	16

#define HFI_DFS_FRAME_BUFFERS_OFFSET 8

#define HFI_DFS_BUF_NUM 4



#define HFI_DME_CONFIG_CMD_SIZE	194

#define HFI_DME_BASIC_CONFIG_CMD_SIZE	51

#define HFI_DME_FRAME_CMD_SIZE	28

#define HFI_DME_FRAME_BUFFERS_OFFSET 12

#define HFI_DME_BUF_NUM 8



#define HFI_PERSIST_CMD_SIZE	11

#define HFI_PERSIST_BUFFERS_OFFSET 7

#define HFI_PERSIST_BUF_NUM     2





enum cvp_status {

	CVP_ERR_NONE = 0x0,

	CVP_ERR_FAIL = 0x80000000,
@@ -1082,7 +1099,7 @@ union hal_get_property { 
#define IS_HAL_SESSION_CMD(cmd) ((cmd) >= HAL_SESSION_EVENT_CHANGE && \

		(cmd) <= HAL_SESSION_ERROR)

enum hal_command_response {

	/* SYSTEM COMMANDS_DONE*/

	HAL_NO_RESP,

	HAL_SYS_INIT_DONE,

	HAL_SYS_SET_RESOURCE_DONE,

	HAL_SYS_RELEASE_RESOURCE_DONE,
@@ -1112,6 +1129,7 @@ enum hal_command_response { 
	HAL_SESSION_DFS_CONFIG_CMD_DONE,

	HAL_SESSION_DFS_FRAME_CMD_DONE,

	HAL_SESSION_DME_CONFIG_CMD_DONE,

	HAL_SESSION_DME_BASIC_CONFIG_CMD_DONE,

	HAL_SESSION_DME_FRAME_CMD_DONE,

	HAL_SESSION_PERSIST_CMD_DONE,

	HAL_SESSION_PROPERTY_INFO,
@@ -1411,73 +1429,17 @@ struct hal_vbv_hdr_buf_size { 
	(((q) && (q)->op) ? ((q)->op(args)) : 0)



/* DFS related structures */

struct msm_cvp_internal_dfsconfig {

	struct list_head list;

	struct msm_smem smem;

	struct msm_cvp_dfs_config dfs_config;

};



struct	buf_desc {

	u32 fd;

	u32 size;

};



/**

 * struct msm_cvp_dfs_frame_kmd - argument passed with VIDIOC_CVP_CMD

 * @cvp_dfs_frame:                parameters for DFS frame command

 * @left_view_buffer_fd:          fd for left view buffer

 * @left_view_buffer_size:        size for left view buffer

 * @right_view_buffer_fd:         fd for right view buffer

 * @right_view_buffer_size:       size for right view buffer

 * @disparity_map_buffer_fd:      fd for disparity map buffer

 * @disparity_map_buffer_size:    size for disparity map buffer

 * @occlusion_mask_buffer_fd:     fd for occlusion mask buffer

 * @occlusion_mask_buffer_size:   size for occlusion mask buffer

 */



struct msm_cvp_dfs_frame_kmd {

	unsigned int cvp_dfs_frame[CVP_DFS_FRAME_BUFFERS_OFFSET];

	unsigned int left_view_buffer_fd;

	unsigned int left_view_buffer_size;

	unsigned int right_view_buffer_fd;

	unsigned int right_view_buffer_size;

	unsigned int disparity_map_buffer_fd;

	unsigned int disparity_map_buffer_size;

	unsigned int occlusion_mask_buffer_fd;

	unsigned int occlusion_mask_buffer_size;

};





struct msm_cvp_internal_dfsframe {

	struct list_head list;

	struct msm_cvp_dfs_frame_kmd dfs_frame;

};



/* DME related structures */

struct msm_cvp_internal_dmeconfig {

	struct list_head list;

	struct msm_smem smem;

	struct msm_cvp_dme_config dme_config;

};



struct msm_cvp_dme_frame_kmd {

	unsigned int cvp_dme_frame[CVP_DME_FRAME_BUFFERS_OFFSET];

	struct buf_desc bufs[CVP_DME_BUF_NUM];

};



struct msm_cvp_internal_dmeframe {

	struct list_head list;

	struct msm_cvp_dme_frame_kmd dme_frame;

};



struct msm_cvp_persist_kmd {

	unsigned int cvp_pcmd[CVP_PERSIST_BUFFERS_OFFSET];

	struct buf_desc bufs[CVP_PSRSIST_BUF_NUM];

};



struct msm_cvp_internal_persist_cmd {

	struct list_head list;

	struct msm_cvp_persist_kmd persist_cmd;

struct msm_cvp_hfi_defs {

	unsigned int size;

	unsigned int type;

	unsigned int buf_offset;

	unsigned int buf_num;

	enum hal_command_response resp;

};



struct hfi_device {
@@ -1502,18 +1464,8 @@ struct hfi_device { 
	int (*session_start)(void *sess);

	int (*session_continue)(void *sess);

	int (*session_stop)(void *sess);

	int (*session_cvp_operation_config)(void *sess,

		struct cvp_frame_data *input_frame);

	int (*session_cvp_dfs_config)(void *sess,

		struct msm_cvp_internal_dfsconfig *dfs_config);

	int (*session_cvp_dfs_frame)(void *sess,

		struct msm_cvp_internal_dfsframe *dfs_frame);

	int (*session_cvp_dme_config)(void *sess,

		struct msm_cvp_internal_dmeconfig *dme_config);

	int (*session_cvp_dme_frame)(void *sess,

		struct msm_cvp_internal_dmeframe *dme_frame);

	int (*session_cvp_persist)(void *sess,

		struct msm_cvp_internal_persist_cmd *pbuf_cmd);

	int (*session_cvp_hfi_send)(void *sess,

		struct cvp_kmd_hfi_packet *in_pkt);

	int (*session_get_buf_req)(void *sess);

	int (*session_flush)(void *sess, enum hal_flush flush_mode);

	int (*session_set_property)(void *sess, enum hal_property ptype,
@@ -1547,4 +1499,7 @@ u32 cvp_get_hfi_codec(enum hal_video_codec hal_codec); 
enum hal_domain cvp_get_hal_domain(u32 hfi_domain);

enum hal_video_codec cvp_get_hal_codec(u32 hfi_codec);



int get_pkt_index(struct cvp_hal_session_cmd_pkt *hdr);

extern const struct msm_cvp_hfi_defs cvp_hfi_defs[];



#endif /*__CVP_HFI_API_H__ */

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

+20 −157
Original line number Diff line number Diff line
@@ -465,6 +465,7 @@ static int create_pkt_cmd_sys_ubwc_config( 
	hfi->bank_spreading = ubwc_config->bank_spreading;

	hfi->override_bit_info.bank_spreading_override =

		ubwc_config->override_bit_info.bank_spreading_override;

	hfi->size = sizeof(struct hfi_cmd_sys_set_ubwc_config_packet_type);



	return rc;

}
@@ -852,171 +853,42 @@ int cvp_create_pkt_cmd_session_get_buf_req( 
	return rc;

}



int cvp_create_pkt_cmd_session_cvp_dfs_config(

		struct hfi_cmd_session_cvp_dfs_config_packet *pkt,

int cvp_create_pkt_cmd_hfi_packetize(

		struct cvp_kmd_hfi_packet *out_pkt,

		struct hal_session *session,

		struct msm_cvp_internal_dfsconfig *dfs_config)

		struct cvp_kmd_hfi_packet *in_pkt)

{

	struct hfi_cmd_session_hdr *ptr =

		(struct hfi_cmd_session_hdr *)pkt;

	int def_idx;

	struct cvp_hal_session_cmd_pkt *ptr =

		(struct cvp_hal_session_cmd_pkt *)in_pkt;



	if (!pkt || !session)

		return -EINVAL;



	memcpy(pkt, &dfs_config->dfs_config,

		CVP_DFS_CONFIG_CMD_SIZE*sizeof(unsigned int));



	if (ptr->size != CVP_DFS_CONFIG_CMD_SIZE*sizeof(unsigned int))

		goto error_dfs_config;



	if (ptr->packet_type != HFI_CMD_SESSION_CVP_DFS_CONFIG)

		goto error_dfs_config;



	if (ptr->session_id != hash32_ptr(session))

		goto error_dfs_config;



	return 0;



error_dfs_config:

	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",

		__func__, ptr->size, ptr->packet_type, ptr->session_id);



	return -EINVAL;

}





int cvp_create_pkt_cmd_session_cvp_dfs_frame(

		struct hfi_cmd_session_cvp_dfs_frame_packet *pkt,

		struct hal_session *session,

		struct msm_cvp_internal_dfsframe *dfs_frame)

{

	struct hfi_cmd_session_hdr *ptr =

		(struct hfi_cmd_session_hdr *)pkt;



	if (!pkt || !session)

	if (!out_pkt || !in_pkt || !session)

		return -EINVAL;



	memcpy(pkt, &dfs_frame->dfs_frame,

		CVP_DFS_FRAME_CMD_SIZE*sizeof(unsigned int));

	def_idx = get_pkt_index(ptr);

	if (def_idx < 0)

		goto error_hfi_packet;



	if (ptr->size != CVP_DFS_FRAME_CMD_SIZE*sizeof(unsigned int))

		goto error_dfs_frame;

	if (cvp_hfi_defs[def_idx].type != ptr->packet_type)

		goto error_hfi_packet;



	if (ptr->packet_type != HFI_CMD_SESSION_CVP_DFS_FRAME)

		goto error_dfs_frame;

	if ((cvp_hfi_defs[def_idx].size*sizeof(unsigned int)) != ptr->size)

		goto error_hfi_packet;



	if (ptr->session_id != hash32_ptr(session))

		goto error_dfs_frame;

		goto error_hfi_packet;



	memcpy(out_pkt, in_pkt, ptr->size);



	return 0;



error_dfs_frame:

	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",

error_hfi_packet:

	dprintk(CVP_ERR, "%s incorrect packet: size=%d type=%d sessionid=%d\n",

		__func__, ptr->size, ptr->packet_type, ptr->session_id);



	return -EINVAL;

}



int cvp_create_pkt_cmd_session_cvp_dme_config(

		struct hfi_cmd_session_cvp_dme_config_packet *pkt,

		struct hal_session *session,

		struct msm_cvp_internal_dmeconfig *dme_config)

{

	struct hfi_cmd_session_hdr *ptr =

		(struct hfi_cmd_session_hdr *)pkt;



	if (!pkt || !session)

		return -EINVAL;



	memcpy(pkt, &dme_config->dme_config,

		CVP_DME_CONFIG_CMD_SIZE*sizeof(unsigned int));



	if (ptr->size != CVP_DME_CONFIG_CMD_SIZE*sizeof(unsigned int))

		goto error_dme_config;



	if (ptr->packet_type != HFI_CMD_SESSION_CVP_DME_CONFIG)

		goto error_dme_config;



	if (ptr->session_id != hash32_ptr(session))

		goto error_dme_config;



	return 0;



error_dme_config:

	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",

		__func__, ptr->size, ptr->packet_type, ptr->session_id);



	return -EINVAL;

}





int cvp_create_pkt_cmd_session_cvp_dme_frame(

		struct hfi_cmd_session_cvp_dme_frame_packet *pkt,

		struct hal_session *session,

		struct msm_cvp_internal_dmeframe *dme_frame)

{

	struct hfi_cmd_session_hdr *ptr =

		(struct hfi_cmd_session_hdr *)pkt;



	if (!pkt || !session)

		return -EINVAL;



	memcpy(pkt, &dme_frame->dme_frame,

		CVP_DME_FRAME_CMD_SIZE*sizeof(unsigned int));



	if (ptr->size != CVP_DME_FRAME_CMD_SIZE*sizeof(unsigned int))

		goto error_dme_frame;



	if (ptr->packet_type != HFI_CMD_SESSION_CVP_DME_FRAME)

		goto error_dme_frame;



	if (ptr->session_id != hash32_ptr(session))

		goto error_dme_frame;



	return 0;



error_dme_frame:

	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",

		__func__, ptr->size, ptr->packet_type, ptr->session_id);



	return -EINVAL;

}



int cvp_create_pckt_cmd_session_cvp_persist(

		struct hfi_cmd_session_cvp_persist_packet *pkt,

		struct hal_session *session,

		struct msm_cvp_internal_persist_cmd *pbuf_cmd)

{

	struct hfi_cmd_session_hdr *ptr =

		(struct hfi_cmd_session_hdr *)pkt;



	if (!pkt || !session)

		return -EINVAL;



	memcpy(pkt, &pbuf_cmd->persist_cmd,

		CVP_PERSIST_CMD_SIZE*sizeof(unsigned int));



	if (ptr->size != CVP_PERSIST_CMD_SIZE*sizeof(unsigned int))

		goto error_persist;



	if (ptr->packet_type != HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS)

		goto error_persist;



	if (ptr->session_id != hash32_ptr(session))

		goto error_persist;



	return 0;



error_persist:

	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",

		__func__, ptr->size, ptr->packet_type, ptr->session_id);



	return -EINVAL;



}





int cvp_create_pkt_cmd_session_flush(struct hfi_cmd_session_flush_packet *pkt,

			struct hal_session *session, enum hal_flush flush_mode)

{
@@ -2221,16 +2093,7 @@ static struct hfi_packetization_ops hfi_default = { 
	.session_flush = cvp_create_pkt_cmd_session_flush,

	.session_get_property = cvp_create_pkt_cmd_session_get_property,

	.session_set_property = cvp_create_pkt_cmd_session_set_property,

	.session_cvp_dfs_config =

		cvp_create_pkt_cmd_session_cvp_dfs_config,

	.session_cvp_dfs_frame =

		cvp_create_pkt_cmd_session_cvp_dfs_frame,

	.session_cvp_dme_config =

		cvp_create_pkt_cmd_session_cvp_dme_config,

	.session_cvp_dme_frame =

		cvp_create_pkt_cmd_session_cvp_dme_frame,

	.session_cvp_persist =

		cvp_create_pckt_cmd_session_cvp_persist,

	.session_cvp_hfi_packetize = cvp_create_pkt_cmd_hfi_packetize,

};



struct hfi_packetization_ops *cvp_hfi_get_pkt_ops_handle(