msm: cvp: Reduce kmd's feature dependency

Move feature configuration processing out of kmd. Relocate
feature specific code to msm_cvp_platform.c and cvp_hfi.h.

Change-Id: I425ee8b8638bd7b81c653c860f1ed1f5d95abac8
Signed-off-by: George Shen <[email protected]>

msm/eva/cvp_comm_def.h

@@ -18,7 +18,8 @@ enum op_mode {
 enum queue_state {
 	QUEUE_INIT,
 	QUEUE_ACTIVE = 1,
-	QUEUE_STOP = 2,
+	QUEUE_START,
+	QUEUE_STOP,
 	QUEUE_INVALID,
 };
 #endif

msm/eva/cvp_hfi.c

@@ -36,262 +36,6 @@
 #define QDSS_IOVA_START 0x80001000
 #define MIN_PAYLOAD_SIZE 3
 
-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 = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_SGM_OF_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_SGM_OF_CONFIG_CMD_DONE,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_SGM_OF_FRAME,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_WARP_NCC_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_WARP_NCC_CONFIG_CMD_DONE,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_WARP_NCC_FRAME,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_WARP_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_WARP_CONFIG_CMD_DONE,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_WARP_DS_PARAMS,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_WARP_DS_PARAMS_CMD_DONE,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_WARP_FRAME,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_DMM_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_DMM_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_DMM_CONFIG_CMD_DONE,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_DMM_PARAMS,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_DMM_PARAMS_CMD_DONE,
-	},
-	{
-		.size = HFI_DMM_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_DMM_FRAME,
-		.buf_offset = HFI_DMM_FRAME_BUFFERS_OFFSET,
-		.buf_num = HFI_DMM_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_SESSION_PERSIST_SET_DONE,
-	},
-	{
-		.size = 0xffffffff,
-		.type = HFI_CMD_SESSION_CVP_RELEASE_PERSIST_BUFFERS,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_PERSIST_REL_DONE,
-	},
-	{
-		.size = HFI_DS_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_DS,
-		.buf_offset = HFI_DS_BUFFERS_OFFSET,
-		.buf_num = HFI_DS_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_OF_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_CV_TME_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_TME_CONFIG_CMD_DONE,
-	},
-	{
-		.size = HFI_OF_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_CV_TME_FRAME,
-		.buf_offset = HFI_OF_BUFFERS_OFFSET,
-		.buf_num = HFI_OF_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_ODT_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_CV_ODT_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_ODT_CONFIG_CMD_DONE,
-	},
-	{
-		.size = HFI_ODT_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_CV_ODT_FRAME,
-		.buf_offset = HFI_ODT_BUFFERS_OFFSET,
-		.buf_num = HFI_ODT_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_OD_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_CV_OD_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_OD_CONFIG_CMD_DONE,
-	},
-	{
-		.size = HFI_OD_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_CV_OD_FRAME,
-		.buf_offset = HFI_OD_BUFFERS_OFFSET,
-		.buf_num = HFI_OD_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_NCC_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_NCC_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_NCC_CONFIG_CMD_DONE,
-	},
-	{
-		.size = HFI_NCC_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_NCC_FRAME,
-		.buf_offset = HFI_NCC_BUFFERS_OFFSET,
-		.buf_num = HFI_NCC_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_ICA_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_ICA_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_ICA_CONFIG_CMD_DONE,
-	},
-	{
-		.size = HFI_ICA_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_ICA_FRAME,
-		.buf_offset = HFI_ICA_BUFFERS_OFFSET,
-		.buf_num = HFI_ICA_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_HCD_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_HCD_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_HCD_CONFIG_CMD_DONE,
-	},
-	{
-		.size = HFI_HCD_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_HCD_FRAME,
-		.buf_offset = HFI_HCD_BUFFERS_OFFSET,
-		.buf_num = HFI_HCD_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_DCM_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_DC_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_DC_CONFIG_CMD_DONE,
-	},
-	{
-		.size = HFI_DCM_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_DC_FRAME,
-		.buf_offset = HFI_DCM_BUFFERS_OFFSET,
-		.buf_num = HFI_DCM_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_DCM_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_DCM_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_DCM_CONFIG_CMD_DONE,
-	},
-	{
-		.size = HFI_DCM_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_DCM_FRAME,
-		.buf_offset = HFI_DCM_BUFFERS_OFFSET,
-		.buf_num = HFI_DCM_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = HFI_PYS_HCD_CONFIG_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_PYS_HCD_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_PYS_HCD_CONFIG_CMD_DONE,
-	},
-	{
-		.size = HFI_PYS_HCD_FRAME_CMD_SIZE,
-		.type = HFI_CMD_SESSION_CVP_PYS_HCD_FRAME,
-		.buf_offset = HFI_PYS_HCD_BUFFERS_OFFSET,
-		.buf_num = HFI_PYS_HCD_BUF_NUM,
-		.resp = HAL_NO_RESP,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_SET_MODEL_BUFFERS,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_MODEL_BUF_CMD_DONE,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_FD_CONFIG,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_SESSION_FD_CONFIG_CMD_DONE,
-	},
-	{
-		.size = 0xFFFFFFFF,
-		.type = HFI_CMD_SESSION_CVP_FD_FRAME,
-		.buf_offset = 0,
-		.buf_num = 0,
-		.resp = HAL_NO_RESP,
-	},
-
-};
-
 struct cvp_tzbsp_memprot {
 	u32 cp_start;
 	u32 cp_size;
@@ -389,17 +133,6 @@ static inline bool is_sys_cache_present(struct iris_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].type == hdr->packet_type)
-			return i;
-
-	return -EINVAL;
-}
-
 int get_hfi_version(void)
 {
 	struct msm_cvp_core *core;
@@ -469,17 +202,6 @@ int get_msg_opconfigs(void *msg, unsigned int *session_id,
 	return 0;
 }
 
-int get_signal_from_pkt_type(unsigned int type)
-{
-	int i, pkt_num = ARRAY_SIZE(cvp_hfi_defs);
-
-	for (i = 0; i < pkt_num; i++)
-		if (cvp_hfi_defs[i].type == type)
-			return cvp_hfi_defs[i].resp;
-
-	return -EINVAL;
-}
-
 static void __dump_packet(u8 *packet, enum cvp_msg_prio log_level)
 {
 	u32 c = 0, packet_size = *(u32 *)packet;
@@ -2929,26 +2651,6 @@ static void **get_session_id(struct msm_cvp_cb_info *info)
 	case HAL_SESSION_RELEASE_BUFFER_DONE:
 	case HAL_SESSION_REGISTER_BUFFER_DONE:
 	case HAL_SESSION_UNREGISTER_BUFFER_DONE:
-	case HAL_SESSION_DFS_CONFIG_CMD_DONE:
-	case HAL_SESSION_DMM_CONFIG_CMD_DONE:
-	case HAL_SESSION_WARP_CONFIG_CMD_DONE:
-	case HAL_SESSION_WARP_NCC_CONFIG_CMD_DONE:
-	case HAL_SESSION_SGM_OF_CONFIG_CMD_DONE:
-	case HAL_SESSION_TME_CONFIG_CMD_DONE:
-	case HAL_SESSION_ODT_CONFIG_CMD_DONE:
-	case HAL_SESSION_OD_CONFIG_CMD_DONE:
-	case HAL_SESSION_NCC_CONFIG_CMD_DONE:
-	case HAL_SESSION_ICA_CONFIG_CMD_DONE:
-	case HAL_SESSION_HCD_CONFIG_CMD_DONE:
-	case HAL_SESSION_DCM_CONFIG_CMD_DONE:
-	case HAL_SESSION_DC_CONFIG_CMD_DONE:
-	case HAL_SESSION_PYS_HCD_CONFIG_CMD_DONE:
-	case HAL_SESSION_DMM_PARAMS_CMD_DONE:
-	case HAL_SESSION_WARP_DS_PARAMS_CMD_DONE:
-	case HAL_SESSION_PERSIST_SET_DONE:
-	case HAL_SESSION_PERSIST_REL_DONE:
-	case HAL_SESSION_FD_CONFIG_CMD_DONE:
-	case HAL_SESSION_MODEL_BUF_CMD_DONE:
 	case HAL_SESSION_PROPERTY_INFO:
 	case HAL_SESSION_EVENT_CHANGE:
 		session_id = &info->response.cmd.session_id;

msm/eva/cvp_hfi.h

@@ -207,6 +207,46 @@
 #define CVP_IFACEQ_VAR_LARGE_PKT_SIZE 512
 #define CVP_IFACEQ_VAR_HUGE_PKT_SIZE  (1024*12)
 
+/* HFI packet info needed for sanity check */
+#define HFI_DFS_CONFIG_CMD_SIZE	38
+#define HFI_DFS_FRAME_CMD_SIZE	16
+
+#define HFI_DMM_CONFIG_CMD_SIZE	194
+#define HFI_DMM_BASIC_CONFIG_CMD_SIZE	51
+#define HFI_DMM_FRAME_CMD_SIZE	28
+
+#define HFI_PERSIST_CMD_SIZE	11
+
+#define HFI_DS_CMD_SIZE	50
+
+#define HFI_OF_CONFIG_CMD_SIZE 34
+#define HFI_OF_FRAME_CMD_SIZE 24
+
+#define HFI_ODT_CONFIG_CMD_SIZE 23
+#define HFI_ODT_FRAME_CMD_SIZE 33
+
+#define HFI_OD_CONFIG_CMD_SIZE 24
+#define HFI_OD_FRAME_CMD_SIZE 12
+
+#define HFI_NCC_CONFIG_CMD_SIZE 47
+#define HFI_NCC_FRAME_CMD_SIZE 22
+
+#define HFI_ICA_CONFIG_CMD_SIZE 127
+#define HFI_ICA_FRAME_CMD_SIZE 14
+
+#define HFI_HCD_CONFIG_CMD_SIZE 46
+#define HFI_HCD_FRAME_CMD_SIZE 18
+
+#define HFI_DCM_CONFIG_CMD_SIZE 20
+#define HFI_DCM_FRAME_CMD_SIZE 19
+
+#define HFI_PYS_HCD_CONFIG_CMD_SIZE 461
+#define HFI_PYS_HCD_FRAME_CMD_SIZE 66
+
+#define HFI_FD_CONFIG_CMD_SIZE 28
+#define HFI_FD_FRAME_CMD_SIZE  10
+
+
 struct cvp_hfi_cmd_session_flush_packet {
 	u32 size;
 	u32 packet_type;
@@ -247,19 +287,23 @@ struct cvp_hal_session {
 	void *device;
 };
 
-struct msm_cvp_fw {
-	int cookie;
+enum buf_map_type {
+	MAP_PERSIST = 1,
+	UNMAP_PERSIST = 2,
+	MAP_FRAME = 3,
+	MAP_INVALID,
 };
 
-int cvp_hfi_process_msg_packet(u32 device_id,
-	void *msg_hdr, struct msm_cvp_cb_info *info);
-
-enum cvp_status cvp_hfi_process_sys_init_done_prop_read(
-	struct cvp_hfi_msg_sys_init_done_packet *pkt,
-	struct cvp_hal_sys_init_done *sys_init_done);
-
-enum cvp_status hfi_process_session_init_done_prop_read(
-	struct cvp_hfi_msg_sys_session_init_done_packet *pkt,
-	struct cvp_hal_session_init_done *session_init_done);
-
+static inline enum buf_map_type cvp_find_map_type(int pkt_type)
+{
+	if (pkt_type == HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS ||
+			pkt_type == HFI_CMD_SESSION_CVP_SET_MODEL_BUFFERS ||
+			pkt_type == HFI_CMD_SESSION_CVP_DMM_PARAMS ||
+			pkt_type == HFI_CMD_SESSION_CVP_WARP_DS_PARAMS)
+		return MAP_PERSIST;
+	else if (pkt_type == HFI_CMD_SESSION_CVP_RELEASE_PERSIST_BUFFERS)
+		return UNMAP_PERSIST;
+	else
+		return MAP_FRAME;
+}
 #endif

msm/eva/cvp_hfi_api.h

@@ -30,74 +30,6 @@
 /* 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_DMM_CONFIG_CMD_SIZE	194
-#define HFI_DMM_BASIC_CONFIG_CMD_SIZE	51
-#define HFI_DMM_FRAME_CMD_SIZE	28
-#define HFI_DMM_FRAME_BUFFERS_OFFSET 12
-#define HFI_DMM_BUF_NUM 8
-
-#define HFI_PERSIST_CMD_SIZE	11
-#define HFI_PERSIST_BUFFERS_OFFSET 7
-#define HFI_PERSIST_BUF_NUM     2
-
-#define HFI_DS_CMD_SIZE	50
-#define HFI_DS_BUFFERS_OFFSET	44
-#define HFI_DS_BUF_NUM	3
-
-#define HFI_OF_CONFIG_CMD_SIZE 34
-#define HFI_OF_FRAME_CMD_SIZE 24
-#define HFI_OF_BUFFERS_OFFSET 8
-#define HFI_OF_BUF_NUM 8
-
-#define HFI_ODT_CONFIG_CMD_SIZE 23
-#define HFI_ODT_FRAME_CMD_SIZE 33
-#define HFI_ODT_BUFFERS_OFFSET 11
-#define HFI_ODT_BUF_NUM 11
-
-#define HFI_OD_CONFIG_CMD_SIZE 24
-#define HFI_OD_FRAME_CMD_SIZE 12
-#define HFI_OD_BUFFERS_OFFSET 6
-#define HFI_OD_BUF_NUM 3
-
-#define HFI_NCC_CONFIG_CMD_SIZE 47
-#define HFI_NCC_FRAME_CMD_SIZE 22
-#define HFI_NCC_BUFFERS_OFFSET 8
-#define HFI_NCC_BUF_NUM 7
-
-#define HFI_ICA_CONFIG_CMD_SIZE 127
-#define HFI_ICA_FRAME_CMD_SIZE 14
-#define HFI_ICA_BUFFERS_OFFSET 6
-#define HFI_ICA_BUF_NUM 4
-
-#define HFI_HCD_CONFIG_CMD_SIZE 46
-#define HFI_HCD_FRAME_CMD_SIZE 18
-#define HFI_HCD_BUFFERS_OFFSET 12
-#define HFI_HCD_BUF_NUM 3
-
-#define HFI_DCM_CONFIG_CMD_SIZE 20
-#define HFI_DCM_FRAME_CMD_SIZE 19
-#define HFI_DCM_BUFFERS_OFFSET 9
-#define HFI_DCM_BUF_NUM 5
-
-#define HFI_PYS_HCD_CONFIG_CMD_SIZE 461
-#define HFI_PYS_HCD_FRAME_CMD_SIZE 66
-#define HFI_PYS_HCD_BUFFERS_OFFSET 14
-#define HFI_PYS_HCD_BUF_NUM 26
-
-#define HFI_FD_CONFIG_CMD_SIZE 28
-#define HFI_FD_FRAME_CMD_SIZE  10
-#define HFI_FD_BUFFERS_OFFSET  6
-#define HFI_FD_BUF_NUM 2
-
-#define HFI_MODEL_CMD_SIZE 9
-#define HFI_MODEL_BUFFERS_OFFSET 7
-#define HFI_MODEL_BUF_NUM 1
-
 #define HFI_VERSION_MAJOR_MASK 0xFF000000
 #define HFI_VERSION_MAJOR_SHFIT 24
 #define HFI_VERSION_MINOR_MASK 0x00FFFFE0
@@ -210,26 +142,6 @@ enum hal_command_response {
 	HAL_SESSION_REGISTER_BUFFER_DONE,
 	HAL_SESSION_UNREGISTER_BUFFER_DONE,
 	HAL_SESSION_RELEASE_RESOURCE_DONE,
-	HAL_SESSION_SGM_OF_CONFIG_CMD_DONE,
-	HAL_SESSION_DFS_CONFIG_CMD_DONE,
-	HAL_SESSION_DMM_CONFIG_CMD_DONE,
-	HAL_SESSION_DMM_PARAMS_CMD_DONE,
-	HAL_SESSION_WARP_CONFIG_CMD_DONE,
-	HAL_SESSION_WARP_DS_PARAMS_CMD_DONE,
-	HAL_SESSION_WARP_NCC_CONFIG_CMD_DONE,
-	HAL_SESSION_TME_CONFIG_CMD_DONE,
-	HAL_SESSION_ODT_CONFIG_CMD_DONE,
-	HAL_SESSION_OD_CONFIG_CMD_DONE,
-	HAL_SESSION_NCC_CONFIG_CMD_DONE,
-	HAL_SESSION_ICA_CONFIG_CMD_DONE,
-	HAL_SESSION_HCD_CONFIG_CMD_DONE,
-	HAL_SESSION_DC_CONFIG_CMD_DONE,
-	HAL_SESSION_DCM_CONFIG_CMD_DONE,
-	HAL_SESSION_PYS_HCD_CONFIG_CMD_DONE,
-	HAL_SESSION_FD_CONFIG_CMD_DONE,
-	HAL_SESSION_PERSIST_SET_DONE,
-	HAL_SESSION_PERSIST_REL_DONE,
-	HAL_SESSION_MODEL_BUF_CMD_DONE,
 	HAL_SESSION_PROPERTY_INFO,
 	HAL_SESSION_ERROR,
 	HAL_RESPONSE_UNUSED = 0x10000000,
@@ -324,8 +236,7 @@ struct cvp_hal_cmd_sys_get_property_packet {
 struct msm_cvp_hfi_defs {
 	unsigned int size;
 	unsigned int type;
-	unsigned int buf_offset;
-	unsigned int buf_num;
+	bool is_config_pkt;
 	enum hal_command_response resp;
 };
 
@@ -359,6 +270,20 @@ typedef void (*hfi_cmd_response_callback) (enum hal_command_response cmd,
 			void *data);
 typedef void (*msm_cvp_callback) (enum hal_command_response response,
 			void *callback);
+struct msm_cvp_fw {
+	int cookie;
+};
+
+int cvp_hfi_process_msg_packet(u32 device_id,
+	void *msg_hdr, struct msm_cvp_cb_info *info);
+
+enum cvp_status cvp_hfi_process_sys_init_done_prop_read(
+	struct cvp_hfi_msg_sys_init_done_packet *pkt,
+	struct cvp_hal_sys_init_done *sys_init_done);
+
+enum cvp_status hfi_process_session_init_done_prop_read(
+	struct cvp_hfi_msg_sys_session_init_done_packet *pkt,
+	struct cvp_hal_session_init_done *session_init_done);
 
 struct cvp_hfi_device *cvp_hfi_initialize(enum msm_cvp_hfi_type hfi_type,
 		u32 device_id, struct msm_cvp_platform_resources *res,
@@ -367,7 +292,6 @@ void cvp_hfi_deinitialize(enum msm_cvp_hfi_type hfi_type,
 			struct cvp_hfi_device *hdev);
 
 int get_pkt_index(struct cvp_hal_session_cmd_pkt *hdr);
-int get_signal_from_pkt_type(unsigned int type);
 int get_hfi_version(void);
 unsigned int get_msg_size(struct cvp_hfi_msg_session_hdr *hdr);
 unsigned int get_msg_session_id(void *msg);

msm/eva/cvp_hfi_helper.h

@@ -222,13 +222,6 @@ struct cvp_hfi_cmd_sys_get_property_packet {
 	u32 rg_property_data[1];
 };
 
-enum HFI_SESSION_TYPE {
-	HFI_SESSION_CV = 1,
-	HFI_SESSION_DMM,
-	HFI_SESSION_ODT,
-	HFI_SESSION_FD
-};
-
 struct cvp_hfi_cmd_sys_session_init_packet {
 	u32 size;
 	u32 packet_type;

msm/eva/hfi_response_handler.c

@@ -388,66 +388,6 @@ static int hfi_process_session_rel_buf_done(u32 device_id,
 	return 0;
 }
 
-static int hfi_process_session_cvp_operation_config(u32 device_id,
-		void *hdr, struct msm_cvp_cb_info *info)
-{
-	struct cvp_hfi_msg_session_op_cfg_packet *pkt =
-		(struct cvp_hfi_msg_session_op_cfg_packet *)hdr;
-	struct cvp_hfi_msg_session_hdr *lhdr =
-		(struct cvp_hfi_msg_session_hdr *)hdr;
-	struct msm_cvp_cb_cmd_done cmd_done = {0};
-	int signal;
-	unsigned int conf_id, session_id, error_type;
-
-	if (!pkt) {
-		dprintk(CVP_ERR, "%s: invalid param\n", __func__);
-		return -EINVAL;
-	} else if (pkt->size < get_msg_size(lhdr)) {
-		dprintk(CVP_ERR,
-				"%s: bad_pkt_size\n", __func__);
-		return -E2BIG;
-	}
-
-	get_msg_opconfigs(pkt, &session_id, &error_type, &conf_id);
-	cmd_done.device_id = device_id;
-	cmd_done.session_id = (void *)(uintptr_t)session_id;
-	cmd_done.status = hfi_map_err_status(error_type);
-	cmd_done.size = 0;
-
-	dprintk(CVP_HFI,
-		"%s: device_id=%d status=%d, sessionid=%pK config=%x\n",
-		__func__, device_id, cmd_done.status,
-		cmd_done.session_id, pkt->op_conf_id);
-
-	if (pkt->packet_type == HFI_MSG_SESSION_CVP_SET_PERSIST_BUFFERS)
-		signal = get_signal_from_pkt_type(
-				HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS);
-	else if (pkt->packet_type ==
-			HFI_MSG_SESSION_CVP_RELEASE_PERSIST_BUFFERS)
-		signal = get_signal_from_pkt_type(
-			HFI_CMD_SESSION_CVP_RELEASE_PERSIST_BUFFERS);
-	else if (pkt->packet_type == HFI_MSG_SESSION_CVP_SET_MODEL_BUFFERS)
-		signal = get_signal_from_pkt_type(
-				HFI_CMD_SESSION_CVP_SET_MODEL_BUFFERS);
-	else if (pkt->packet_type == HFI_MSG_SESSION_CVP_DMM_PARAMS)
-		signal = get_signal_from_pkt_type(
-				HFI_CMD_SESSION_CVP_DMM_PARAMS);
-	else if (pkt->packet_type == HFI_MSG_SESSION_CVP_WARP_DS_PARAMS)
-		signal = get_signal_from_pkt_type(
-				HFI_CMD_SESSION_CVP_WARP_DS_PARAMS);
-	else
-		signal = get_signal_from_pkt_type(conf_id);
-
-	if (signal < 0) {
-		dprintk(CVP_ERR, "%s Invalid op config id\n", __func__);
-		return -EINVAL;
-	}
-
-	info->response_type = signal;
-	info->response.cmd = cmd_done;
-	return 0;
-}
-
 static struct msm_cvp_inst *cvp_get_inst_from_id(struct msm_cvp_core *core,
 	unsigned int session_id)
 {
@@ -658,24 +598,6 @@ int cvp_hfi_process_msg_packet(u32 device_id, void *hdr,
 	case HFI_MSG_SESSION_CVP_FLUSH:
 		pkt_func = (pkt_func_def)hfi_process_session_flush_done;
 		break;
-	case HFI_MSG_SESSION_CVP_OPERATION_CONFIG:
-	case HFI_MSG_SESSION_CVP_SET_PERSIST_BUFFERS:
-	case HFI_MSG_SESSION_CVP_RELEASE_PERSIST_BUFFERS:
-	case HFI_MSG_SESSION_CVP_SET_MODEL_BUFFERS:
-	case HFI_MSG_SESSION_CVP_DMM_PARAMS:
-	case HFI_MSG_SESSION_CVP_WARP_DS_PARAMS:
-		pkt_func =
-			(pkt_func_def)hfi_process_session_cvp_operation_config;
-		break;
-	case HFI_MSG_SESSION_CVP_DS:
-	case HFI_MSG_SESSION_CVP_DFS:
-	case HFI_MSG_SESSION_CVP_DMM:
-	case HFI_MSG_SESSION_CVP_WARP:
-	case HFI_MSG_SESSION_CVP_WARP_NCC:
-	case HFI_MSG_SESSION_CVP_FD:
-	case HFI_MSG_SESSION_CVP_SGM_OF:
-		pkt_func = (pkt_func_def)hfi_process_session_cvp_msg;
-		break;
 	default:
 		dprintk(CVP_HFI, "Use default msg handler: %#x\n",
 				msg_hdr->packet);

msm/eva/msm_cvp.c

@@ -47,7 +47,7 @@ static bool cvp_msg_pending(struct cvp_session_queue *sq,
 
 	mptr = NULL;
 	spin_lock(&sq->lock);
-	if (sq->state != QUEUE_ACTIVE) {
+	if (sq->state == QUEUE_INIT || sq->state == QUEUE_INVALID) {
 		/* The session is being deleted */
 		spin_unlock(&sq->lock);
 		*msg = NULL;
@@ -101,7 +101,8 @@ static int cvp_wait_process_message(struct msm_cvp_inst *inst,
 					sq->state, sq->msg_count);
 
 		if (inst->state >= MSM_CVP_CLOSE_DONE ||
-				sq->state != QUEUE_ACTIVE) {
+				(sq->state != QUEUE_ACTIVE &&
+				sq->state != QUEUE_START)) {
 			rc = -ECONNRESET;
 			goto exit;
 		}
@@ -160,9 +161,11 @@ static int msm_cvp_session_process_hfi(
 {
 	int pkt_idx, pkt_type, rc = 0;
 	struct cvp_hfi_device *hdev;
-	unsigned int offset, buf_num, signal;
+	unsigned int offset = 0, buf_num = 0, signal;
 	struct cvp_session_queue *sq;
 	struct msm_cvp_inst *s;
+	bool is_config_pkt;
+	enum buf_map_type map_type;
 
 	if (!inst || !inst->core || !in_pkt) {
 		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
@@ -183,17 +186,25 @@ static int msm_cvp_session_process_hfi(
 				in_pkt->pkt_data[1]);
 		goto exit;
 	} else {
-		offset = cvp_hfi_defs[pkt_idx].buf_offset;
-		buf_num = cvp_hfi_defs[pkt_idx].buf_num;
 		signal = cvp_hfi_defs[pkt_idx].resp;
+		is_config_pkt = cvp_hfi_defs[pkt_idx].is_config_pkt;
 	}
+
 	if (signal == HAL_NO_RESP) {
 		/* Frame packets are not allowed before session starts*/
 		sq = &inst->session_queue;
 		spin_lock(&sq->lock);
-		if (sq->state != QUEUE_ACTIVE) {
+		if ((sq->state != QUEUE_START && !is_config_pkt) ||
+			(sq->state >= QUEUE_INVALID)) {
+			/*
+			 * A init packet is allowed in case of
+			 * QUEUE_ACTIVE, QUEUE_START, QUEUE_STOP
+			 * A frame packet is only allowed in case of
+			 * QUEUE_START
+			 */
 			spin_unlock(&sq->lock);
-			dprintk(CVP_ERR, "%s: invalid queue state\n", __func__);
+			dprintk(CVP_ERR, "%s: invalid queue state %d\n",
+				__func__, sq->state);
 			rc = -EINVAL;
 			goto exit;
 		}
@@ -209,12 +220,11 @@ static int msm_cvp_session_process_hfi(
 		return -EINVAL;
 	}
 	pkt_type = in_pkt->pkt_data[1];
-	if (pkt_type == HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS ||
-		pkt_type == HFI_CMD_SESSION_CVP_SET_MODEL_BUFFERS ||
-		pkt_type == HFI_CMD_SESSION_CVP_DMM_PARAMS ||
-		pkt_type == HFI_CMD_SESSION_CVP_WARP_DS_PARAMS)
+	map_type = cvp_find_map_type(pkt_type);
+
+	if (map_type == MAP_PERSIST)
 		rc = msm_cvp_map_user_persist(inst, in_pkt, offset, buf_num);
-	else if (pkt_type == HFI_CMD_SESSION_CVP_RELEASE_PERSIST_BUFFERS)
+	else if (map_type == UNMAP_PERSIST)
 		rc = msm_cvp_mark_user_persist(inst, in_pkt, offset, buf_num);
 	else
 		rc = msm_cvp_map_frame(inst, in_pkt, offset, buf_num);
@@ -230,22 +240,10 @@ static int msm_cvp_session_process_hfi(
 		goto exit;
 	}
 
-	if (signal != HAL_NO_RESP) {
-		rc = wait_for_sess_signal_receipt(inst, signal);
-		if (rc) {
-			dprintk(CVP_ERR,
-				"%s: wait for signal failed, rc %d %d, %x %d\n",
-				__func__, rc,
-				in_pkt->pkt_data[0],
-				in_pkt->pkt_data[1],
-				signal);
-			goto exit;
-		}
-		if (pkt_type == HFI_CMD_SESSION_CVP_RELEASE_PERSIST_BUFFERS)
-			rc = msm_cvp_unmap_user_persist(inst, in_pkt,
-					offset, buf_num);
+	if (signal != HAL_NO_RESP)
+		dprintk(CVP_ERR, "%s signal %d from UMD is not HAL_NO_RESP\n",
+			__func__, signal);
 
-	}
 exit:
 	inst->cur_cmd_type = 0;
 	cvp_put_inst(inst);
@@ -261,7 +259,7 @@ static bool cvp_fence_wait(struct cvp_fence_queue *q,
 	*fence = NULL;
 	mutex_lock(&q->lock);
 	*state = q->state;
-	if (*state != QUEUE_ACTIVE) {
+	if (*state != QUEUE_START) {
 		mutex_unlock(&q->lock);
 		return true;
 	}
@@ -582,7 +580,7 @@ wait:
 
 	f = NULL;
 	wait_event_interruptible(q->wq, cvp_fence_wait(q, &f, &state));
-	if (state != QUEUE_ACTIVE)
+	if (state != QUEUE_START)
 		goto exit;
 
 	if (!f)
@@ -608,7 +606,7 @@ wait:
 
 	cvp_free_fence_data(f);
 
-	if (rc && state != QUEUE_ACTIVE)
+	if (rc && state != QUEUE_START)
 		goto exit;
 
 	goto wait;
@@ -629,7 +627,7 @@ static int msm_cvp_session_process_hfi_fence(struct msm_cvp_inst *inst,
 	struct eva_kmd_hfi_synx_packet *synx_pkt;
 	struct eva_kmd_fence_ctrl *kfc;
 	struct cvp_hfi_cmd_session_hdr *pkt;
-	unsigned int offset, buf_num, in_offset, in_buf_num;
+	unsigned int offset = 0, buf_num = 0, in_offset, in_buf_num;
 	struct msm_cvp_inst *s;
 	struct cvp_fence_command *f;
 	struct cvp_fence_queue *q;
@@ -674,9 +672,6 @@ static int msm_cvp_session_process_hfi_fence(struct msm_cvp_inst *inst,
 	if (in_offset && in_buf_num) {
 		offset = in_offset;
 		buf_num = in_buf_num;
-	} else {
-		offset = cvp_hfi_defs[idx].buf_offset;
-		buf_num = cvp_hfi_defs[idx].buf_num;
 	}
 
 	if (!is_buf_param_valid(buf_num, offset)) {
@@ -1014,6 +1009,7 @@ int msm_cvp_session_create(struct msm_cvp_inst *inst)
 {
 	int rc = 0;
 	struct synx_initialization_params params;
+	struct cvp_session_queue *sq;
 
 	if (!inst || !inst->core)
 		return -EINVAL;
@@ -1049,6 +1045,11 @@ int msm_cvp_session_create(struct msm_cvp_inst *inst)
 		rc = -EFAULT;
 	}
 
+	sq = &inst->session_queue;
+	spin_lock(&sq->lock);
+	sq->state = QUEUE_ACTIVE;
+	spin_unlock(&sq->lock);
+
 fail_init:
 	return rc;
 }
@@ -1080,7 +1081,7 @@ static int cvp_fence_thread_start(struct msm_cvp_inst *inst)
 
 	q = &inst->fence_cmd_queue;
 	mutex_lock(&q->lock);
-	q->state = QUEUE_ACTIVE;
+	q->state = QUEUE_START;
 	mutex_unlock(&q->lock);
 
 	for (i = 0; i < inst->prop.fthread_nr; ++i) {
@@ -1100,7 +1101,7 @@ static int cvp_fence_thread_start(struct msm_cvp_inst *inst)
 
 	sq = &inst->session_queue_fence;
 	spin_lock(&sq->lock);
-	sq->state = QUEUE_ACTIVE;
+	sq->state = QUEUE_START;
 	spin_unlock(&sq->lock);
 
 exit:
@@ -1151,7 +1152,7 @@ static int msm_cvp_session_start(struct msm_cvp_inst *inst,
 		spin_unlock(&sq->lock);
 		return -EINVAL;
 	}
-	sq->state = QUEUE_ACTIVE;
+	sq->state = QUEUE_START;
 	spin_unlock(&sq->lock);
 
 	return cvp_fence_thread_start(inst);
@@ -1597,9 +1598,10 @@ static void cvp_clean_fence_queue(struct msm_cvp_inst *inst, int synx_state)
 	mutex_unlock(&q->lock);
 }
 
-int cvp_stop_clean_fence_queue(struct msm_cvp_inst *inst)
+int cvp_clean_session_queues(struct msm_cvp_inst *inst)
 {
 	struct cvp_fence_queue *q;
+	struct cvp_session_queue *sq;
 	u32 count = 0, max_retries = 100;
 
 	cvp_clean_fence_queue(inst, SYNX_STATE_SIGNALED_ERROR);
@@ -1619,6 +1621,16 @@ retry:
 		return -EBUSY;
 
 	goto retry;
+
+	sq = &inst->session_queue_fence;
+	spin_lock(&sq->lock);
+	sq->state = QUEUE_INVALID;
+	spin_unlock(&sq->lock);
+
+	sq = &inst->session_queue_fence;
+	spin_lock(&sq->lock);
+	sq->state = QUEUE_INVALID;
+	spin_unlock(&sq->lock);
 }
 
 static int cvp_flush_all(struct msm_cvp_inst *inst)
@@ -1917,7 +1929,7 @@ int msm_cvp_session_init(struct msm_cvp_inst *inst)
 	inst->clk_data.ddr_bw = 1000;
 	inst->clk_data.sys_cache_bw = 1000;
 
-	inst->prop.type = HFI_SESSION_CV;
+	inst->prop.type = 1;
 	inst->prop.kernel_mask = 0xFFFFFFFF;
 	inst->prop.priority = 0;
 	inst->prop.is_secure = 0;

msm/eva/msm_cvp.h

@@ -37,5 +37,5 @@ int msm_cvp_session_create(struct msm_cvp_inst *inst);
 int msm_cvp_session_delete(struct msm_cvp_inst *inst);
 int msm_cvp_get_session_info(struct msm_cvp_inst *inst, u32 *session);
 int msm_cvp_update_power(struct msm_cvp_inst *inst);
-int cvp_stop_clean_fence_queue(struct msm_cvp_inst *inst);
+int cvp_clean_session_queues(struct msm_cvp_inst *inst);
 #endif

msm/eva/msm_cvp_common.c

@@ -214,42 +214,6 @@ struct msm_cvp_inst *cvp_get_inst_validate(struct msm_cvp_core *core,
 	return s;
 }
 
-static void cvp_handle_session_cmd_done(enum hal_command_response cmd,
-	void *data)
-{
-	struct msm_cvp_cb_cmd_done *response = data;
-	struct msm_cvp_inst *inst;
-
-	if (!response) {
-		dprintk(CVP_ERR, "%s: Invalid release_buf_done response\n",
-			__func__);
-		return;
-	}
-
-	inst = cvp_get_inst(get_cvp_core(response->device_id),
-			response->session_id);
-	if (!inst) {
-		dprintk(CVP_ERR, "%s: Got response for an inactive session\n",
-			__func__);
-		return;
-	}
-
-	if (response->status)
-		dprintk(CVP_ERR, "HFI MSG error %d cmd response %d\n",
-			response->status, cmd);
-
-	dprintk(CVP_SESS, "%s: inst=%pK\n", __func__, inst);
-
-	if (IS_HAL_SESSION_CMD(cmd)) {
-		dprintk(CVP_INFO, "%s: calling completion for index = %d",
-			__func__, SESSION_MSG_INDEX(cmd));
-		complete(&inst->completions[SESSION_MSG_INDEX(cmd)]);
-	} else
-		dprintk(CVP_ERR,
-			"%s: Invalid inst cmd response: %d\n", __func__, cmd);
-	cvp_put_inst(inst);
-}
-
 static void handle_session_set_buf_done(enum hal_command_response cmd,
 	void *data)
 {
@@ -666,7 +630,7 @@ static void handle_sys_error(enum hal_command_response cmd, void *data)
 				inst->cur_cmd_type, inst->state);
 		if (inst->state != MSM_CVP_CORE_INVALID) {
 			change_cvp_inst_state(inst, MSM_CVP_CORE_INVALID);
-			if (cvp_stop_clean_fence_queue(inst))
+			if (cvp_clean_session_queues(inst))
 				dprintk(CVP_ERR, "Failed to clean fences\n");
 			for (i = 0; i < ARRAY_SIZE(inst->completions); i++)
 				complete(&inst->completions[i]);
@@ -792,28 +756,6 @@ void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
 	case HAL_SESSION_RELEASE_BUFFER_DONE:
 		handle_session_release_buf_done(cmd, data);
 		break;
-	case HAL_SESSION_SGM_OF_CONFIG_CMD_DONE:
-	case HAL_SESSION_DFS_CONFIG_CMD_DONE:
-	case HAL_SESSION_DMM_CONFIG_CMD_DONE:
-	case HAL_SESSION_DMM_PARAMS_CMD_DONE:
-	case HAL_SESSION_WARP_CONFIG_CMD_DONE:
-	case HAL_SESSION_WARP_DS_PARAMS_CMD_DONE:
-	case HAL_SESSION_WARP_NCC_CONFIG_CMD_DONE:
-	case HAL_SESSION_PERSIST_SET_DONE:
-	case HAL_SESSION_PERSIST_REL_DONE:
-	case HAL_SESSION_TME_CONFIG_CMD_DONE:
-	case HAL_SESSION_ODT_CONFIG_CMD_DONE:
-	case HAL_SESSION_OD_CONFIG_CMD_DONE:
-	case HAL_SESSION_NCC_CONFIG_CMD_DONE:
-	case HAL_SESSION_ICA_CONFIG_CMD_DONE:
-	case HAL_SESSION_HCD_CONFIG_CMD_DONE:
-	case HAL_SESSION_DCM_CONFIG_CMD_DONE:
-	case HAL_SESSION_DC_CONFIG_CMD_DONE:
-	case HAL_SESSION_PYS_HCD_CONFIG_CMD_DONE:
-	case HAL_SESSION_FD_CONFIG_CMD_DONE:
-	case HAL_SESSION_MODEL_BUF_CMD_DONE:
-		cvp_handle_session_cmd_done(cmd, data);
-		break;
 	default:
 		dprintk(CVP_HFI, "response unhandled: %d\n", cmd);
 		break;

msm/eva/msm_cvp_core.c

@@ -119,7 +119,7 @@ static void __deinit_session_queue(struct msm_cvp_inst *inst)
 		kmem_cache_free(cvp_driver->msg_cache, msg);
 	}
 	inst->session_queue.msg_count = 0;
-	inst->session_queue.state = QUEUE_STOP;
+	inst->session_queue.state = QUEUE_INVALID;
 	spin_unlock(&inst->session_queue.lock);
 
 	wake_up_all(&inst->session_queue.wq);

msm/eva/msm_cvp_platform.c

@@ -18,6 +18,8 @@
 #include <linux/of_fdt.h>
 #include "msm_cvp_internal.h"
 #include "msm_cvp_debug.h"
+#include "cvp_hfi_api.h"
+#include "cvp_hfi.h"
 
 #define UBWC_CONFIG(mco, mlo, hbo, bslo, bso, rs, mc, ml, hbb, bsl, bsp) \
 {	\
@@ -133,6 +135,237 @@ static const struct of_device_id msm_cvp_dt_match[] = {
 	{},
 };
 
+const struct msm_cvp_hfi_defs cvp_hfi_defs[] = {
+	{
+		.size = HFI_DFS_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_DFS_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_DFS_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_DFS_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_SGM_OF_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_SGM_OF_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_WARP_NCC_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_WARP_NCC_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_WARP_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_WARP_DS_PARAMS,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_WARP_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_DMM_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_DMM_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_DMM_PARAMS,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_DMM_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_DMM_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_PERSIST_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xffffffff,
+		.type = HFI_CMD_SESSION_CVP_RELEASE_PERSIST_BUFFERS,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_DS_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_DS,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_OF_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_CV_TME_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_OF_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_CV_TME_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_ODT_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_CV_ODT_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_ODT_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_CV_ODT_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_OD_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_CV_OD_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_OD_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_CV_OD_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_NCC_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_NCC_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_NCC_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_NCC_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_ICA_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_ICA_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_ICA_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_ICA_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_HCD_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_HCD_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_HCD_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_HCD_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_DCM_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_DC_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_DCM_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_DC_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_DCM_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_DCM_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_DCM_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_DCM_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_PYS_HCD_CONFIG_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_PYS_HCD_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = HFI_PYS_HCD_FRAME_CMD_SIZE,
+		.type = HFI_CMD_SESSION_CVP_PYS_HCD_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_SET_MODEL_BUFFERS,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_FD_CONFIG,
+		.is_config_pkt = true,
+		.resp = HAL_NO_RESP,
+	},
+	{
+		.size = 0xFFFFFFFF,
+		.type = HFI_CMD_SESSION_CVP_FD_FRAME,
+		.is_config_pkt = false,
+		.resp = HAL_NO_RESP,
+	},
+
+};
+
+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].type == hdr->packet_type)
+			return i;
+
+	return -EINVAL;
+}
+
 MODULE_DEVICE_TABLE(of, msm_cvp_dt_match);
 
 void *cvp_get_drv_data(struct device *dev)