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

Commit 2ae01046 authored by George Shen's avatar George Shen
Browse files

msm: cvp: optimize CVP HFI packet handling 



Remove redundant handling logic. Rename CVP system call
command structure to avoid name conflict with video driver.
Add new commands needed by camera processing pipeline.

Change-Id: I59a628f7ae2bf9ad7c6e075ed3e1a3794f25e05c
Signed-off-by: default avatarGeorge Shen <sqiao@codeaurora.org>
parent eaab7394

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

+69 −186
Original line number Diff line number Diff line
@@ -37,6 +37,45 @@ 
#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_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 +186,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 +1343,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 +2692,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 +2710,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;
@@ -4014,30 +3917,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 +4630,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

+0 −36
Original line number Diff line number Diff line
@@ -581,42 +581,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

+28 −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,21 @@ 
/* 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_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 +1098,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,
@@ -1411,73 +1427,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 +1462,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 +1497,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(

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

+3 −19
Original line number Diff line number Diff line
@@ -79,26 +79,10 @@ struct hfi_packetization_ops { 
	int (*session_sync_process)(

		struct hfi_cmd_session_sync_process_packet *pkt,

		struct hal_session *session);

	int (*session_cvp_dfs_config)(

			struct hfi_cmd_session_cvp_dfs_config_packet *pkt,

	int (*session_cvp_hfi_packetize)(

			struct cvp_kmd_hfi_packet *out_pkt,

			struct hal_session *session,

			struct msm_cvp_internal_dfsconfig *dfs_config);

	int (*session_cvp_dfs_frame)(

			struct hfi_cmd_session_cvp_dfs_frame_packet *pkt,

			struct hal_session *session,

			struct msm_cvp_internal_dfsframe *dfs_frame);

	int (*session_cvp_dme_config)(

			struct hfi_cmd_session_cvp_dme_config_packet *pkt,

			struct hal_session *session,

			struct msm_cvp_internal_dmeconfig *dme_config);

	int (*session_cvp_dme_frame)(

			struct hfi_cmd_session_cvp_dme_frame_packet *pkt,

			struct hal_session *session,

			struct msm_cvp_internal_dmeframe *dme_frame);

	int (*session_cvp_persist)(

			struct hfi_cmd_session_cvp_persist_packet *pkt,

			struct hal_session *session,

			struct msm_cvp_internal_persist_cmd *pbuf_cmd);

			struct cvp_kmd_hfi_packet *in_pkt);

};



struct hfi_packetization_ops *cvp_hfi_get_pkt_ops_handle(