[PATCH v1 08/14] net/zxdh: support hash resources configuration

[Bingbin Chen <chen.bingbin@zte.com.cn>]

[-- Attachment #1.1.1: Type: text/plain, Size: 35030 bytes --]

Implement the hash functions and tables configuration.

Signed-off-by: Bingbin Chen <chen.bingbin@zte.com.cn>
---
 drivers/net/zxdh/zxdh_np.c | 798 +++++++++++++++++++++++++++++++++++++
 drivers/net/zxdh/zxdh_np.h | 260 ++++++++++++
 2 files changed, 1058 insertions(+)

diff --git a/drivers/net/zxdh/zxdh_np.c b/drivers/net/zxdh/zxdh_np.c
index 1e4b214a6e..bcae32e94e 100644
--- a/drivers/net/zxdh/zxdh_np.c
+++ b/drivers/net/zxdh/zxdh_np.c
@@ -36,6 +36,23 @@ static const char * const g_dpp_dtb_name[] = {
 	"DOWN TAB",
 	"UP TAB",
 };
+ZXDH_SE_CFG *g_apt_se_cfg[ZXDH_DEV_CHANNEL_MAX];
+ZXDH_SE_CFG *dpp_se_cfg[ZXDH_DEV_CHANNEL_MAX];
+static uint16_t g_lpm_crc[ZXDH_SE_ZBLK_NUM] = {
+	0x1021, 0x8005, 0x3D65, 0xab47, 0x3453, 0x0357, 0x0589, 0xa02b,
+	0x1021, 0x8005, 0x3D65, 0xab47, 0x3453, 0x0357, 0x0589, 0xa02b,
+	0x1021, 0x8005, 0x3D65, 0xab47, 0x3453, 0x0357, 0x0589, 0xa02b,
+	0x1021, 0x8005, 0x3D65, 0xab47, 0x3453, 0x0357, 0x0589, 0xa02b
+};
+uint32_t g_hash_zblk_idx[ZXDH_DEV_CHANNEL_MAX]
+				[ZXDH_HASH_FUNC_ID_NUM]
+				[ZXDH_HASH_TBL_ID_NUM] = {0};
+static uint32_t g_ddr_hash_arg[ZXDH_HASH_DDR_CRC_NUM] = {
+	0x04C11DB7,
+	0xF4ACFB13,
+	0x20044009,
+	0x00210801
+};
 
 ZXDH_FIELD_T g_smmu0_smmu0_cpu_ind_cmd_reg[] = {
 	{"cpu_ind_rw", ZXDH_FIELD_FLAG_RW, 31, 1, 0x0, 0x0},
@@ -519,6 +536,20 @@ zxdh_np_get_tn_color(ZXDH_RB_TN *p_tn)
 #define ZXDH_GET_TN_COLOR(p_tn) \
 	zxdh_np_get_tn_color(p_tn)
 
+#define ZXDH_SE_GET_ZBLK_CFG(p_se, zblk_idx) \
+	(&(((ZXDH_SE_CFG *)(p_se))->zblk_info[zblk_idx]))
+
+#define GET_ZBLK_IDX(zcell_idx) \
+	(((zcell_idx) & 0x7F) >> 2)
+
+#define GET_ZCELL_IDX(zcell_idx) \
+	((zcell_idx) & 0x3)
+
+#define ZXDH_GET_FUN_INFO(p_se, fun_id) \
+	(&(((ZXDH_SE_CFG *)(p_se))->fun_info[fun_id]))
+
+#define GET_DDR_HASH_ARG(ddr_crc_sel) (g_ddr_hash_arg[ddr_crc_sel])
+
 static uint32_t
 zxdh_np_comm_mutex_create(ZXDH_MUTEX_T *p_mutex)
 {
@@ -840,6 +871,33 @@ zxdh_comm_double_link_insert_pre(ZXDH_D_NODE *p_newnode,
 	return ZXDH_OK;
 }
 
+static uint32_t
+zxdh_comm_double_link_insert_last(ZXDH_D_NODE *p_newnode, ZXDH_D_HEAD *p_head)
+{
+	ZXDH_D_NODE *p_dnode = NULL;
+
+	RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
+	RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
+
+	p_dnode = p_head->p_prev;
+
+	if (!p_dnode) {
+		p_head->p_next  = p_newnode;
+		p_head->p_prev  = p_newnode;
+		p_newnode->next = NULL;
+		p_newnode->prev = NULL;
+	} else {
+		p_newnode->prev = p_dnode;
+		p_newnode->next = NULL;
+		p_head->p_prev  = p_newnode;
+		p_dnode->next   = p_newnode;
+	}
+
+	p_head->used++;
+
+	return ZXDH_OK;
+}
+
 static uint32_t
 zxdh_comm_double_link_del(ZXDH_D_NODE *delnode, ZXDH_D_HEAD *p_head)
 {
@@ -865,6 +923,46 @@ zxdh_comm_double_link_del(ZXDH_D_NODE *delnode, ZXDH_D_HEAD *p_head)
 	return ZXDH_OK;
 }
 
+static int32_t
+zxdh_comm_double_link_default_cmp_fuc(ZXDH_D_NODE *p_data1,
+	ZXDH_D_NODE *p_data2, __rte_unused void *p_data)
+{
+	uint32_t data1 = *(uint32_t *)p_data1->data;
+	uint32_t data2 = *(uint32_t *)p_data2->data;
+
+	if (data1 > data2)
+		return 1;
+	else if (data1 == data2)
+		return 0;
+	else
+		return -1;
+}
+
+static uint32_t
+zxdh_comm_double_link_insert_sort(ZXDH_D_NODE *p_newnode,
+			ZXDH_D_HEAD *p_head, ZXDH_CMP_FUNC cmp_fuc, void *cmp_data)
+{
+	ZXDH_D_NODE *pre_node = NULL;
+
+	if (cmp_fuc == NULL)
+		cmp_fuc = zxdh_comm_double_link_default_cmp_fuc;
+
+	if (p_head->used == 0)
+		return zxdh_comm_double_link_insert_1st(p_newnode, p_head);
+
+	pre_node = p_head->p_next;
+
+	while (pre_node != NULL) {
+		if (cmp_fuc(p_newnode, pre_node, cmp_data) <= 0)
+			return zxdh_comm_double_link_insert_pre(p_newnode,
+				pre_node, p_head);
+		else
+			pre_node = pre_node->next;
+	}
+
+	return zxdh_comm_double_link_insert_last(p_newnode, p_head);
+}
+
 static int32_t
 zxdh_comm_rb_def_cmp(void *p_new, void *p_old, uint32_t key_size)
 {
@@ -5715,6 +5813,703 @@ zxdh_np_agent_se_res_get(uint32_t dev_id, uint32_t type)
 	return rc;
 }
 
+static uint32_t
+zxdh_np_se_init_ex(uint32_t dev_id, ZXDH_SE_CFG *p_se_cfg)
+{
+	uint32_t i = 0;
+	uint32_t j = 0;
+
+	ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
+	ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
+
+	if (dpp_se_cfg[dev_id] != NULL) {
+		PMD_DRV_LOG(DEBUG, "SE global config is already initialized.");
+		return ZXDH_OK;
+	}
+
+	memset(p_se_cfg, 0, sizeof(ZXDH_SE_CFG));
+
+	p_se_cfg->dev_id = dev_id;
+	dpp_se_cfg[p_se_cfg->dev_id] = p_se_cfg;
+
+	p_se_cfg->p_as_rslt_wrt_fun = NULL;
+	p_se_cfg->p_client = ZXDH_COMM_VAL_TO_PTR(dev_id);
+
+	for (i = 0; i < ZXDH_SE_ZBLK_NUM; i++) {
+		p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_se_cfg, i);
+
+		p_zblk_cfg->zblk_idx = i;
+		p_zblk_cfg->is_used  = 0;
+		p_zblk_cfg->hash_arg = g_lpm_crc[i];
+		p_zblk_cfg->zcell_bm = 0;
+		ZXDH_INIT_D_NODE(&p_zblk_cfg->zblk_dn, p_zblk_cfg);
+
+		for (j = 0; j < ZXDH_SE_ZCELL_NUM; j++) {
+			p_zcell_cfg = &p_zblk_cfg->zcell_info[j];
+
+			p_zcell_cfg->zcell_idx = (i << 2) + j;
+			p_zcell_cfg->item_used = 0;
+			p_zcell_cfg->mask_len  = 0;
+
+			ZXDH_INIT_D_NODE(&p_zcell_cfg->zcell_dn, p_zcell_cfg);
+
+			p_zcell_cfg->zcell_avl.p_key = p_zcell_cfg;
+		}
+	}
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_np_apt_hash_global_res_init(uint32_t dev_id)
+{
+	if (g_apt_se_cfg[dev_id] == NULL) {
+		g_apt_se_cfg[dev_id] = (ZXDH_SE_CFG *)rte_zmalloc(NULL, sizeof(ZXDH_SE_CFG), 0);
+		if (g_apt_se_cfg[dev_id] == NULL) {
+			PMD_DRV_LOG(ERR, "%s point null!", __func__);
+			return ZXDH_PAR_CHK_POINT_NULL;
+		}
+
+		zxdh_np_se_init_ex(dev_id, g_apt_se_cfg[dev_id]);
+
+		g_apt_se_cfg[dev_id]->p_client = ZXDH_COMM_VAL_TO_PTR(dev_id);
+	}
+
+	return ZXDH_OK;
+}
+
+static void
+se_apt_get_zblock_index(uint32_t zblock_bitmap, uint32_t *zblk_idx)
+{
+	uint32_t index0 = 0;
+	uint32_t index1 = 0;
+
+	for (index0 = 0; index0 < 32; index0++) {
+		if ((zblock_bitmap >> index0) & 0x1) {
+			*(zblk_idx + index1) = index0;
+			index1++;
+		}
+	}
+}
+
+static uint32_t
+zxdh_np_crc32_calc(uint8_t *p_input_key, uint32_t dw_byte_num, uint32_t dw_crc_poly)
+{
+	uint32_t dw_result = 0;
+	uint32_t dw_data_type = 0;
+
+	uint32_t i = 0;
+	uint32_t j = 0;
+
+	while (i < dw_byte_num) {
+		dw_data_type = (uint32_t)((dw_result & 0xff000000) ^ (p_input_key[i] << 24));
+		for (j = 0; j < 8; j++) {
+			if (dw_data_type & 0x80000000) {
+				dw_data_type <<= 1;
+				dw_data_type ^= dw_crc_poly;
+			} else {
+				dw_data_type <<= 1;
+			}
+		}
+		dw_result <<= 8;
+		dw_result ^= dw_data_type;
+
+		i++;
+	}
+
+	return dw_result;
+}
+
+static uint16_t
+zxdh_np_crc16_calc(uint8_t *p_input_key, uint32_t dw_byte_num, uint16_t dw_crc_poly)
+{
+	uint16_t dw_result = 0;
+	uint16_t dw_data_type = 0;
+
+	uint32_t i = 0;
+	uint32_t j = 0;
+
+	while (i < dw_byte_num) {
+		dw_data_type = (uint16_t)(((dw_result & 0xff00) ^ (p_input_key[i] << 8)) & 0xFFFF);
+		for (j = 0; j < 8; j++) {
+			if (dw_data_type & 0x8000) {
+				dw_data_type <<= 1;
+				dw_data_type ^= dw_crc_poly;
+			} else {
+				dw_data_type <<= 1;
+			}
+		}
+		dw_result <<= 8;
+		dw_result ^= dw_data_type;
+
+		i++;
+	}
+
+	return dw_result;
+}
+
+static uint32_t
+zxdh_np_se_fun_init(ZXDH_SE_CFG *p_se_cfg,
+						   uint8_t	   id,
+						   uint32_t	 fun_type)
+{
+	ZXDH_FUNC_ID_INFO  *p_fun_info = NULL;
+
+	p_fun_info = ZXDH_GET_FUN_INFO(p_se_cfg, id);
+
+	if (p_fun_info->is_used) {
+		PMD_DRV_LOG(ERR, "Error[0x%x], fun_id [%d] is already used!",
+			ZXDH_SE_RC_FUN_INVALID, id);
+		return ZXDH_SE_RC_FUN_INVALID;
+	}
+
+	p_fun_info->fun_id = id;
+	p_fun_info->is_used = 1;
+
+	switch (fun_type) {
+	case (ZXDH_FUN_HASH):
+	{
+		p_fun_info->fun_type = ZXDH_FUN_HASH;
+		p_fun_info->fun_ptr = rte_zmalloc(NULL, sizeof(ZXDH_HASH_CFG), 0);
+		if (p_fun_info->fun_ptr == NULL) {
+			PMD_DRV_LOG(ERR, "%s point null!", __func__);
+			return ZXDH_PAR_CHK_POINT_NULL;
+		}
+		((ZXDH_HASH_CFG *)(p_fun_info->fun_ptr))->p_se_info = p_se_cfg;
+	}
+	break;
+
+	default:
+	{
+		PMD_DRV_LOG(ERR, "Error, unrecgnized fun_type[ %d]", fun_type);
+		RTE_ASSERT(0);
+		return ZXDH_SE_RC_BASE;
+	}
+	break;
+	}
+
+	return ZXDH_OK;
+}
+
+static int32_t
+zxdh_np_hash_list_cmp(ZXDH_D_NODE *data1, ZXDH_D_NODE *data2, void *data)
+{
+	uint32_t flag = 0;
+	uint32_t data_new = 0;
+	uint32_t data_pre = 0;
+
+	flag = *(uint32_t *)data;
+
+	if (flag == ZXDH_HASH_CMP_ZCELL) {
+		data_new = ((ZXDH_SE_ZCELL_CFG *)data1->data)->zcell_idx;
+		data_pre = ((ZXDH_SE_ZCELL_CFG *)data2->data)->zcell_idx;
+	} else if (flag == ZXDH_HASH_CMP_ZBLK) {
+		data_new = ((ZXDH_SE_ZBLK_CFG *)data1->data)->zblk_idx;
+		data_pre = ((ZXDH_SE_ZBLK_CFG *)data2->data)->zblk_idx;
+	}
+
+	if (data_new > data_pre)
+		return 1;
+	else if (data_new == data_pre)
+		return 0;
+	else
+		return -1;
+}
+
+static int32_t
+zxdh_np_hash_rb_key_cmp(void *p_new, void *p_old, __rte_unused uint32_t key_size)
+{
+	ZXDH_HASH_RBKEY_INFO *p_rbkey_new = NULL;
+	ZXDH_HASH_RBKEY_INFO *p_rbkey_old = NULL;
+
+	p_rbkey_new = (ZXDH_HASH_RBKEY_INFO *)(p_new);
+	p_rbkey_old = (ZXDH_HASH_RBKEY_INFO *)(p_old);
+
+	return memcmp(p_rbkey_new->key, p_rbkey_old->key, ZXDH_HASH_KEY_MAX);
+}
+
+static int32_t
+zxdh_np_hash_ddr_cfg_rb_key_cmp(void *p_new, void *p_old, __rte_unused uint32_t key_size)
+{
+	HASH_DDR_CFG *p_rbkey_new = NULL;
+	HASH_DDR_CFG *p_rbkey_old = NULL;
+
+	p_rbkey_new = (HASH_DDR_CFG *)(p_new);
+	p_rbkey_old = (HASH_DDR_CFG *)(p_old);
+
+	return memcmp(&p_rbkey_new->ddr_baddr, &p_rbkey_old->ddr_baddr, sizeof(uint32_t));
+}
+
+static uint32_t
+zxdh_np_hash_zcam_resource_init(ZXDH_HASH_CFG *p_hash_cfg,
+		uint32_t zblk_num, uint32_t *zblk_idx_array)
+{
+	uint32_t rc = ZXDH_OK;
+
+	uint32_t i = 0;
+	uint32_t j = 0;
+	uint32_t cmp_type = 0;
+	uint32_t zblk_idx = 0;
+	uint32_t zcell_idx = 0;
+	uint32_t dev_id = 0;
+
+	ZXDH_D_HEAD *p_zblk_list = NULL;
+	ZXDH_D_HEAD *p_zcell_free = NULL;
+	ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
+	ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
+
+	dev_id = p_hash_cfg->p_se_info->dev_id;
+
+	p_zblk_list = &p_hash_cfg->hash_shareram.zblk_list;
+	rc = zxdh_comm_double_link_init(ZXDH_SE_ZBLK_NUM, p_zblk_list);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
+
+	p_zcell_free = &p_hash_cfg->hash_shareram.zcell_free_list;
+	rc = zxdh_comm_double_link_init(ZXDH_SE_ZBLK_NUM * ZXDH_SE_ZCELL_NUM, p_zcell_free);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_init");
+
+	for (i = 0; i < zblk_num; i++) {
+		zblk_idx = zblk_idx_array[i];
+
+		p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_hash_cfg->p_se_info, zblk_idx);
+
+		if (p_zblk_cfg->is_used) {
+			PMD_DRV_LOG(ERR, "ErrorCode:[0x%x],"
+				"ZBlock[%d] is already used by other function!",
+				ZXDH_HASH_RC_INVALID_ZBLCK, zblk_idx);
+			RTE_ASSERT(0);
+			return ZXDH_HASH_RC_INVALID_ZBLCK;
+		}
+
+		for (j = 0; j < ZXDH_SE_ZCELL_NUM; j++) {
+			zcell_idx = p_zblk_cfg->zcell_info[j].zcell_idx;
+			p_zcell_cfg = &(((ZXDH_SE_CFG *)(p_hash_cfg->p_se_info))->
+			zblk_info[GET_ZBLK_IDX(zcell_idx)].zcell_info[GET_ZCELL_IDX(zcell_idx)]);
+
+			if (p_zcell_cfg->is_used) {
+				PMD_DRV_LOG(ERR, "ErrorCode:[0x%x], ZBlk[%d],"
+					"ZCell[%d] is already used by other function!",
+					ZXDH_HASH_RC_INVALID_ZCELL, zblk_idx, zcell_idx);
+				RTE_ASSERT(0);
+				return ZXDH_HASH_RC_INVALID_ZCELL;
+			}
+
+			p_zcell_cfg->is_used = 1;
+
+			cmp_type = ZXDH_HASH_CMP_ZCELL;
+			rc = zxdh_comm_double_link_insert_sort(&p_zcell_cfg->zcell_dn,
+				p_zcell_free, zxdh_np_hash_list_cmp, &cmp_type);
+			ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_sort");
+		}
+
+		p_zblk_cfg->is_used = 1;
+		cmp_type = ZXDH_HASH_CMP_ZBLK;
+		rc = zxdh_comm_double_link_insert_sort(&p_zblk_cfg->zblk_dn,
+			p_zblk_list, zxdh_np_hash_list_cmp, &cmp_type);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_insert_last");
+	}
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_hash_init(ZXDH_SE_CFG *p_se_cfg,
+				uint32_t fun_id,
+				uint32_t zblk_num,
+				uint32_t *zblk_idx,
+				uint32_t ddr_dis)
+{
+	uint32_t rc = ZXDH_OK;
+
+	uint32_t i = 0;
+	uint32_t dev_id = 0;
+
+	ZXDH_FUNC_ID_INFO *p_func_info = NULL;
+	ZXDH_HASH_CFG *p_hash_cfg = NULL;
+
+	dev_id = p_se_cfg->dev_id;
+
+	rc = zxdh_np_se_fun_init(p_se_cfg, (fun_id & 0xff), ZXDH_FUN_HASH);
+	if (rc == ZXDH_SE_RC_FUN_INVALID)
+		return ZXDH_OK;
+
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_fun_init");
+
+	p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, fun_id);
+	p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
+	p_hash_cfg->fun_id = fun_id;
+	p_hash_cfg->p_hash32_fun = zxdh_np_crc32_calc;
+	p_hash_cfg->p_hash16_fun = zxdh_np_crc16_calc;
+	p_hash_cfg->p_se_info = p_se_cfg;
+
+	if (ddr_dis == 1)
+		p_hash_cfg->ddr_valid = 0;
+	else
+		p_hash_cfg->ddr_valid = 1;
+
+	p_hash_cfg->hash_stat.zblock_num = zblk_num;
+	rc = zxdh_np_hash_zcam_resource_init(p_hash_cfg, zblk_num, zblk_idx);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_zcam_resource_init");
+
+	for (i = 0; i < zblk_num; i++)
+		p_hash_cfg->hash_stat.zblock_array[i] = zblk_idx[i];
+
+	rc = (uint32_t)zxdh_comm_rb_init(&p_hash_cfg->hash_rb,
+								 0,
+								 sizeof(ZXDH_HASH_RBKEY_INFO),
+								 zxdh_np_hash_rb_key_cmp);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
+
+	rc = (uint32_t)zxdh_comm_rb_init(&p_hash_cfg->ddr_cfg_rb,
+								 0,
+								 sizeof(HASH_DDR_CFG),
+								 zxdh_np_hash_ddr_cfg_rb_key_cmp);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
+
+	for (i = 0; i < zblk_num; i++)
+		g_hash_zblk_idx[dev_id][fun_id][i] = zblk_idx[i];
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_apt_hash_func_res_init(uint32_t dev_id, uint32_t func_num,
+		ZXDH_APT_HASH_FUNC_RES_T *p_hash_func_res)
+{
+	uint32_t rc = ZXDH_OK;
+	uint32_t index = 0;
+	uint32_t zblk_idx[32] = {0};
+	ZXDH_APT_HASH_FUNC_RES_T *p_hash_func_res_temp = NULL;
+	ZXDH_SE_CFG *p_se_cfg = NULL;
+
+	p_se_cfg = g_apt_se_cfg[dev_id];
+
+	for (index = 0; index < func_num; index++) {
+		memset(zblk_idx, 0, sizeof(zblk_idx));
+		p_hash_func_res_temp = p_hash_func_res + index;
+		ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_func_res_temp);
+
+		se_apt_get_zblock_index(p_hash_func_res_temp->zblk_bitmap, zblk_idx);
+
+		rc = zxdh_np_hash_init(p_se_cfg,
+							p_hash_func_res_temp->func_id,
+							p_hash_func_res_temp->zblk_num,
+							zblk_idx,
+							p_hash_func_res_temp->ddr_dis);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_init");
+	}
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_hash_bulk_init(ZXDH_SE_CFG *p_se_cfg,
+						uint32_t fun_id,
+						uint32_t bulk_id,
+						ZXDH_HASH_DDR_RESC_CFG_T *p_ddr_resc_cfg,
+						uint32_t zcell_num,
+						uint32_t zreg_num)
+{
+	uint32_t rc = ZXDH_OK;
+
+	uint32_t i = 0;
+	uint32_t j = 0;
+	uint32_t zblk_idx = 0;
+	uint32_t dev_id = 0;
+	uint32_t ddr_item_num = 0;
+
+	ZXDH_D_NODE *p_zblk_dn = NULL;
+	ZXDH_D_NODE *p_zcell_dn = NULL;
+	ZXDH_RB_TN *p_rb_tn_new = NULL;
+	ZXDH_RB_TN *p_rb_tn_rtn = NULL;
+	ZXDH_SE_ZBLK_CFG *p_zblk_cfg = NULL;
+	ZXDH_SE_ZREG_CFG *p_zreg_cfg = NULL;
+	HASH_DDR_CFG *p_ddr_cfg = NULL;
+	HASH_DDR_CFG *p_rbkey_new = NULL;
+	HASH_DDR_CFG *p_rbkey_rtn = NULL;
+	ZXDH_SE_ZCELL_CFG *p_zcell_cfg = NULL;
+	ZXDH_HASH_CFG *p_hash_cfg = NULL;
+	ZXDH_FUNC_ID_INFO *p_func_info = NULL;
+	ZXDH_SE_ITEM_CFG **p_item_array = NULL;
+	ZXDH_HASH_BULK_ZCAM_STAT *p_bulk_zcam_mono = NULL;
+
+	dev_id = p_se_cfg->dev_id;
+
+	p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, fun_id);
+	p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
+	if (p_hash_cfg == NULL) {
+		PMD_DRV_LOG(ERR, "p_hash_cfg point null!");
+		return ZXDH_PAR_CHK_POINT_NULL;
+	}
+
+	if (p_hash_cfg->hash_stat.p_bulk_zcam_mono[bulk_id] != NULL) {
+		PMD_DRV_LOG(ERR, "fun_id[%u] bulk_id[%u] is already init,"
+			"do not init again!", fun_id, bulk_id);
+		return ZXDH_OK;
+	}
+
+	PMD_DRV_LOG(DEBUG, "p_hash_cfg->ddr_valid = %d!", p_hash_cfg->ddr_valid);
+	if (p_hash_cfg->ddr_valid == 1) {
+		ddr_item_num = p_ddr_resc_cfg->ddr_item_num;
+		if (ZXDH_DDR_WIDTH_512b == p_ddr_resc_cfg->ddr_width_mode)
+			ddr_item_num = p_ddr_resc_cfg->ddr_item_num >> 1;
+
+		p_rbkey_new = (HASH_DDR_CFG *)rte_zmalloc(NULL, sizeof(HASH_DDR_CFG), 0);
+		if (p_rbkey_new == NULL) {
+			PMD_DRV_LOG(ERR, "%s point null!", __func__);
+			return ZXDH_PAR_CHK_POINT_NULL;
+		}
+
+		p_rbkey_new->ddr_baddr = p_ddr_resc_cfg->ddr_baddr;
+
+		p_rb_tn_new = (ZXDH_RB_TN *)rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
+		if (p_rb_tn_new == NULL) {
+			rte_free(p_rbkey_new);
+			PMD_DRV_LOG(ERR, "ICM %s:%d[Error:POINT NULL] !"
+				"FUNCTION : %s!", __FILE__, __LINE__, __func__);
+			return ZXDH_PAR_CHK_POINT_NULL;
+		}
+		ZXDH_INIT_RBT_TN(p_rb_tn_new, p_rbkey_new);
+
+		rc = zxdh_comm_rb_insert(&p_hash_cfg->ddr_cfg_rb,
+			(void *)p_rb_tn_new, (void *)(&p_rb_tn_rtn));
+		if (rc == ZXDH_RBT_RC_FULL) {
+			PMD_DRV_LOG(ERR, "The red black tree is full!");
+			rte_free(p_rbkey_new);
+			rte_free(p_rb_tn_new);
+			RTE_ASSERT(0);
+			return ZXDH_HASH_RC_RB_TREE_FULL;
+		} else if (rc == ZXDH_RBT_RC_UPDATE) {
+			PMD_DRV_LOG(DEBUG, "some bulk_id share one bulk!");
+
+			ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
+			p_rbkey_rtn = (HASH_DDR_CFG *)(p_rb_tn_rtn->p_key);
+
+			p_ddr_cfg = p_hash_cfg->p_bulk_ddr_info[p_rbkey_rtn->bulk_id];
+
+			if (p_ddr_cfg->hash_ddr_arg !=
+			GET_DDR_HASH_ARG(p_ddr_resc_cfg->ddr_crc_sel) ||
+				p_ddr_cfg->width_mode   != p_ddr_resc_cfg->ddr_width_mode ||
+				p_ddr_cfg->ddr_ecc_en   != p_ddr_resc_cfg->ddr_ecc_en	 ||
+				p_ddr_cfg->item_num	 != ddr_item_num) {
+				PMD_DRV_LOG(ERR, "The base address is same but other ddr attribute is different");
+				rte_free(p_rbkey_new);
+				rte_free(p_rb_tn_new);
+				RTE_ASSERT(0);
+				return ZXDH_HASH_RC_INVALID_PARA;
+			}
+
+			p_hash_cfg->p_bulk_ddr_info[bulk_id] =
+				p_hash_cfg->p_bulk_ddr_info[p_rbkey_rtn->bulk_id];
+
+			rte_free(p_rbkey_new);
+			rte_free(p_rb_tn_new);
+		} else {
+			p_item_array = (ZXDH_SE_ITEM_CFG **)rte_zmalloc(NULL, ddr_item_num *
+				sizeof(ZXDH_SE_ITEM_CFG *), 0);
+			if (NULL == (p_item_array)) {
+				rte_free(p_rbkey_new);
+				rte_free(p_rb_tn_new);
+				PMD_DRV_LOG(ERR, "ICM %s:%d[Error:POINT NULL] !"
+					"FUNCTION : %s!", __FILE__, __LINE__, __func__);
+				return ZXDH_PAR_CHK_POINT_NULL;
+			}
+
+			p_rbkey_new->p_item_array = p_item_array;
+			p_rbkey_new->bulk_id = bulk_id;
+			p_rbkey_new->hw_baddr = 0;
+			p_rbkey_new->width_mode = p_ddr_resc_cfg->ddr_width_mode;
+			p_rbkey_new->item_num = ddr_item_num;
+			p_rbkey_new->ddr_ecc_en = p_ddr_resc_cfg->ddr_ecc_en;
+			p_rbkey_new->hash_ddr_arg = GET_DDR_HASH_ARG(p_ddr_resc_cfg->ddr_crc_sel);
+			p_rbkey_new->bulk_use = 1;
+			p_rbkey_new->zcell_num = zcell_num;
+			p_rbkey_new->zreg_num = zreg_num;
+			p_hash_cfg->p_bulk_ddr_info[bulk_id] = p_rbkey_new;
+
+			PMD_DRV_LOG(DEBUG, "one new ddr_bulk init!");
+		}
+	}
+
+	p_bulk_zcam_mono = (ZXDH_HASH_BULK_ZCAM_STAT *)rte_zmalloc(NULL,
+		sizeof(ZXDH_HASH_BULK_ZCAM_STAT), 0);
+	if (NULL == (p_bulk_zcam_mono)) {
+		rte_free(p_rbkey_new);
+		rte_free(p_rb_tn_new);
+		rte_free(p_item_array);
+		PMD_DRV_LOG(ERR, "ICM %s:%d[Error:POINT NULL] ! FUNCTION"
+			": %s!", __FILE__, __LINE__, __func__);
+		return ZXDH_PAR_CHK_POINT_NULL;
+	}
+	(&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[bulk_id] = p_bulk_zcam_mono;
+
+	for (i = 0; i < ZXDH_SE_ZBLK_NUM * ZXDH_SE_ZCELL_NUM; i++)
+		p_bulk_zcam_mono->zcell_mono_idx[i] = 0xffffffff;
+
+	for (i = 0; i < ZXDH_SE_ZBLK_NUM; i++) {
+		for (j = 0; j < ZXDH_SE_ZREG_NUM; j++) {
+			p_bulk_zcam_mono->zreg_mono_id[i][j].zblk_id = 0xffffffff;
+			p_bulk_zcam_mono->zreg_mono_id[i][j].zreg_id = 0xffffffff;
+		}
+	}
+
+	if (zcell_num > 0) {
+		p_hash_cfg->bulk_ram_mono[bulk_id] = 1;
+
+		p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
+
+		i = 0;
+
+		while (p_zcell_dn) {
+			p_zcell_cfg = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
+
+			if (p_zcell_cfg->is_used) {
+				if (!(p_zcell_cfg->flag & ZXDH_ZCELL_FLAG_IS_MONO)) {
+					p_zcell_cfg->flag	 |= ZXDH_ZCELL_FLAG_IS_MONO;
+					p_zcell_cfg->bulk_id = bulk_id;
+
+					p_bulk_zcam_mono->zcell_mono_idx[p_zcell_cfg->zcell_idx] =
+						p_zcell_cfg->zcell_idx;
+
+					if (++i >= zcell_num)
+						break;
+				}
+			} else {
+				PMD_DRV_LOG(ERR, "zcell[ %d ] is not init before"
+					" used!", p_zcell_cfg->zcell_idx);
+				RTE_ASSERT(0);
+				return ZXDH_HASH_RC_INVALID_PARA;
+			}
+
+			p_zcell_dn = p_zcell_dn->next;
+		}
+
+		if (i < zcell_num)
+			PMD_DRV_LOG(ERR, "Input param 'zcell_num' is [ %d ],"
+				"actually bulk[ %d ]monopolize zcells is [ %d ]!",
+				zcell_num, bulk_id, i);
+	}
+
+	if (zreg_num > 0) {
+		p_hash_cfg->bulk_ram_mono[bulk_id] = 1;
+
+		p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
+		j = 0;
+
+		while (p_zblk_dn) {
+			p_zblk_cfg = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
+			zblk_idx = p_zblk_cfg->zblk_idx;
+
+			if (p_zblk_cfg->is_used) {
+				for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
+					p_zreg_cfg = &p_zblk_cfg->zreg_info[i];
+
+					if (!(p_zreg_cfg->flag & ZXDH_ZREG_FLAG_IS_MONO)) {
+						p_zreg_cfg->flag = ZXDH_ZREG_FLAG_IS_MONO;
+						p_zreg_cfg->bulk_id = bulk_id;
+
+					p_bulk_zcam_mono->zreg_mono_id[zblk_idx][i].zblk_id =
+						zblk_idx;
+					p_bulk_zcam_mono->zreg_mono_id[zblk_idx][i].zreg_id = i;
+
+					if (++j >= zreg_num)
+						break;
+					}
+				}
+
+				if (j >= zreg_num)
+					break;
+			} else {
+				PMD_DRV_LOG(ERR, "zblk [ %d ] is not init"
+					" before used!", p_zblk_cfg->zblk_idx);
+				RTE_ASSERT(0);
+				return ZXDH_HASH_RC_INVALID_PARA;
+			}
+
+			p_zblk_dn = p_zblk_dn->next;
+		}
+
+		if (j < zreg_num)
+			PMD_DRV_LOG(ERR, "Input param 'zreg_num' is [ %d ],"
+				"actually bulk[ %d ]monopolize zregs is [ %d ]!",
+				zreg_num, bulk_id, j);
+	}
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_np_apt_hash_bulk_res_init(uint32_t dev_id, uint32_t bulk_num,
+						   ZXDH_APT_HASH_BULK_RES_T *p_bulk_res)
+{
+	uint32_t rc = ZXDH_OK;
+	uint32_t index = 0;
+	ZXDH_APT_HASH_BULK_RES_T *p_hash_bulk_res_temp = NULL;
+	ZXDH_HASH_DDR_RESC_CFG_T ddr_resc_cfg = {0};
+	ZXDH_SE_CFG *p_se_cfg = NULL;
+
+	p_se_cfg = g_apt_se_cfg[dev_id];
+
+	for (index = 0; index < bulk_num; index++) {
+		memset(&ddr_resc_cfg, 0, sizeof(ZXDH_HASH_DDR_RESC_CFG_T));
+		p_hash_bulk_res_temp = p_bulk_res + index;
+		ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_bulk_res_temp);
+
+		ddr_resc_cfg.ddr_baddr = p_hash_bulk_res_temp->ddr_baddr;
+		ddr_resc_cfg.ddr_item_num = p_hash_bulk_res_temp->ddr_item_num;
+		ddr_resc_cfg.ddr_width_mode = p_hash_bulk_res_temp->ddr_width_mode;
+		ddr_resc_cfg.ddr_crc_sel = p_hash_bulk_res_temp->ddr_crc_sel;
+		ddr_resc_cfg.ddr_ecc_en = p_hash_bulk_res_temp->ddr_ecc_en;
+
+		rc = zxdh_np_hash_bulk_init(p_se_cfg,
+							p_hash_bulk_res_temp->func_id,
+							p_hash_bulk_res_temp->bulk_id,
+							&ddr_resc_cfg,
+							p_hash_bulk_res_temp->zcell_num,
+							p_hash_bulk_res_temp->zreg_num);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_bulk_init");
+	}
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_se_res_init(uint32_t dev_id, uint32_t type)
+{
+	uint32_t rc = ZXDH_OK;
+	ZXDH_APT_SE_RES_T *p_se_res = NULL;
+	ZXDH_APT_HASH_RES_INIT_T hash_res_init = {0};
+
+	p_se_res = (ZXDH_APT_SE_RES_T *)zxdh_np_dev_get_se_res_ptr(dev_id, type);
+	if (!p_se_res->valid) {
+		PMD_DRV_LOG(ERR, "%s dev_id[0x%x],se_type[0x%x] invlaid!",
+			__func__, dev_id, type);
+		return ZXDH_ERR;
+	}
+
+	hash_res_init.func_num = p_se_res->hash_func_num;
+	hash_res_init.bulk_num = p_se_res->hash_bulk_num;
+	hash_res_init.func_res = p_se_res->hash_func;
+	hash_res_init.bulk_res = p_se_res->hash_bulk;
+
+	rc = zxdh_np_apt_hash_global_res_init(dev_id);
+	ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_global_res_init");
+
+	if (hash_res_init.func_num) {
+		rc = zxdh_np_apt_hash_func_res_init(dev_id, hash_res_init.func_num,
+			hash_res_init.func_res);
+		ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_func_res_init");
+	}
+
+	if (hash_res_init.bulk_num) {
+		rc = zxdh_np_apt_hash_bulk_res_init(dev_id, hash_res_init.bulk_num,
+			hash_res_init.bulk_res);
+		ZXDH_COMM_CHECK_RC(rc, "zxdh_np_apt_hash_bulk_res_init");
+	}
+
+	return rc;
+}
+
 uint32_t
 zxdh_np_se_res_get_and_init(uint32_t dev_id, uint32_t type)
 {
@@ -5723,5 +6518,8 @@ zxdh_np_se_res_get_and_init(uint32_t dev_id, uint32_t type)
 	rc = zxdh_np_agent_se_res_get(dev_id, type);
 	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_se_res_get");
 
+	rc = zxdh_np_se_res_init(dev_id, type);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_res_init");
+
 	return rc;
 }
diff --git a/drivers/net/zxdh/zxdh_np.h b/drivers/net/zxdh/zxdh_np.h
index 39e31b12f7..31d4af2c05 100644
--- a/drivers/net/zxdh/zxdh_np.h
+++ b/drivers/net/zxdh/zxdh_np.h
@@ -136,6 +136,43 @@
 #define ZXDH_ETCAM_MAX_NUM                      (8)
 #define ZXDH_ETCAM_BLOCK_NUM                    (8)
 
+#define ZXDH_SE_RAM_DEPTH                       (512)
+#define ZXDH_SE_ZCELL_NUM                       (4)
+#define ZXDH_SE_ZREG_NUM                        (4)
+#define ZXDH_SE_ALG_BANK_NUM                    (29)
+#define ZXDH_SE_ZBLK_NUM                        (32)
+#define ZXDH_MAX_FUN_NUM                        (8)
+#define ZXDH_HASH_KEY_MAX                       (49)
+#define ZXDH_HASH_RST_MAX                       (32)
+#define ZXDH_HASH_TBL_ID_NUM                    (32)
+#define ZXDH_HASH_BULK_NUM                      (8)
+#define ZXDH_HASH_CMP_ZCELL                     (1)
+#define ZXDH_HASH_CMP_ZBLK                      (2)
+#define ZXDH_HASH_FUNC_ID_NUM                   (4)
+#define ZXDH_ZCELL_FLAG_IS_MONO                 (1)
+#define ZXDH_ZREG_FLAG_IS_MONO                  (1)
+#define ZXDH_HASH_DDR_CRC_NUM                   (4)
+#define ZXDH_HASH_TBL_FLAG_AGE                  (1 << 0)
+#define ZXDH_HASH_TBL_FLAG_LEARN                (1 << 1)
+#define ZXDH_HASH_TBL_FLAG_MC_WRT               (1 << 2)
+#define ZXDH_HASH_ACTU_KEY_STEP                 (1)
+#define ZXDH_HASH_KEY_CTR_SIZE                  (1)
+#define ZXDH_ZCELL_IDX_BT_WIDTH                 (2)
+#define ZXDH_ZBLK_IDX_BT_WIDTH                  (3)
+#define ZXDH_ZGRP_IDX_BT_WIDTH                  (2)
+#define ZXDH_HASH_ENTRY_POS_STEP                (16)
+#define ZXDH_HASH_TBL_ID_NUM                    (32)
+#define ZXDH_SE_ITEM_WIDTH_MAX                  (64)
+#define ZXDH_SE_ENTRY_WIDTH_MAX                 (64)
+#define ZXDH_REG_SRAM_FLAG_BT_START             (16)
+#define ZXDH_ZBLK_NUM_PER_ZGRP                  (8)
+#define ZXDH_ZBLK_IDX_BT_START                  (11)
+#define ZXDH_ZBLK_WRT_MASK_BT_START             (17)
+#define ZXDH_ZCELL_ADDR_BT_WIDTH                (9)
+
+#define ZXDH_COMM_PTR_TO_VAL(p)                 ((uint64_t)(p))
+#define ZXDH_COMM_VAL_TO_PTR(v)                 ((void *)((uint64_t)(v)))
+
 /**errco code */
 #define ZXDH_RC_BASE                            (0x1000U)
 #define ZXDH_PARAMETER_CHK_BASE                 (ZXDH_RC_BASE            | 0x200)
@@ -249,6 +286,11 @@
 #define ZXDH_HASH_RC_INVALID_ITEM_TYPE          (ZXDH_SE_RC_HASH_BASE | 0x11)
 #define ZXDH_HASH_RC_REPEAT_INIT                (ZXDH_SE_RC_HASH_BASE | 0x12)
 
+#define ZXDH_SE_RC_CFG_BASE                     (ZXDH_SE_RC_BASE | 0x1000)
+#define ZXDH_SE_RC_ZBLK_FULL                    (ZXDH_SE_RC_CFG_BASE | 0x1)
+#define ZXDH_SE_RC_FUN_INVALID                  (ZXDH_SE_RC_CFG_BASE | 0x2)
+#define ZXDH_SE_RC_PARA_INVALID                 (ZXDH_SE_RC_CFG_BASE | 0x3)
+
 typedef enum zxdh_module_base_addr_e {
 	ZXDH_MODULE_SE_SMMU0_BASE_ADDR = 0x00000000,
 	ZXDH_MODULE_DTB_ENQ_BASE_ADDR  = 0x00000000,
@@ -377,6 +419,13 @@ typedef struct zxdh_rb_tn {
 } ZXDH_RB_TN;
 
 typedef int32_t  (*ZXDH_RB_CMPFUN)(void *p_new, void *p_old, uint32_t keysize);
+typedef int32_t (*ZXDH_CMP_FUNC)(ZXDH_D_NODE *data1, ZXDH_D_NODE *data2, void*);
+typedef uint32_t (*ZXDH_WRITE32_FUN)(uint32_t dev_id, uint32_t addr, uint32_t write_data);
+typedef uint32_t (*ZXDH_READ32_FUN) (uint32_t dev_id, uint32_t addr, uint32_t *read_data);
+typedef uint32_t (*ZXDH_LPM_AS_RSLT_WRT_FUNCTION)(uint32_t dev_id,
+		uint32_t as_type, uint32_t tbl_id, uint32_t index, uint8_t *p_data);
+typedef uint16_t (*ZXDH_HASH_FUNCTION)(uint8_t *pkey, uint32_t width, uint16_t arg);
+typedef uint32_t (*ZXDH_HASH_FUNCTION32)(uint8_t *pkey, uint32_t width, uint32_t arg);
 
 typedef struct _rb_cfg {
 	uint32_t				key_size;
@@ -390,6 +439,217 @@ typedef struct _rb_cfg {
 	uint32_t				is_init;
 } ZXDH_RB_CFG;
 
+typedef enum zxdh_se_fun_type_e {
+	ZXDH_FUN_HASH = 1,
+	ZXDH_FUN_LPM,
+	ZXDH_FUN_ACL,
+	ZXDH_FUN_MAX
+} ZXDH_SE_FUN_TYPE;
+
+typedef struct zxdh_avl_node_t {
+	void                    *p_key;
+	uint32_t                result;
+	int32_t                 avl_height;
+	struct zxdh_avl_node_t  *p_avl_left;
+	struct zxdh_avl_node_t  *p_avl_right;
+	ZXDH_D_NODE             avl_node_list;
+} ZXDH_AVL_NODE;
+
+typedef struct zxdh_se_item_cfg_t {
+	ZXDH_D_HEAD  item_list;
+	uint32_t  item_index;
+	uint32_t  hw_addr;
+	uint32_t  bulk_id;
+	uint32_t  item_type;
+	uint8_t    wrt_mask;
+	uint8_t    valid;
+	uint8_t    pad[2];
+} ZXDH_SE_ITEM_CFG;
+
+typedef struct zxdh_se_zcell_cfg_t {
+	uint8_t            flag;
+	uint32_t           bulk_id;
+	uint32_t           zcell_idx;
+	uint16_t           mask_len;
+	uint8_t            is_used;
+	uint8_t            is_share;
+	uint32_t           item_used;
+	ZXDH_SE_ITEM_CFG   item_info[ZXDH_SE_RAM_DEPTH];
+	ZXDH_D_NODE        zcell_dn;
+	ZXDH_AVL_NODE      zcell_avl;
+} ZXDH_SE_ZCELL_CFG;
+
+typedef struct zxdh_se_zreg_cfg_t {
+	uint8_t            flag;
+	uint8_t            pad[3];
+	uint32_t           bulk_id;
+	ZXDH_SE_ITEM_CFG   item_info;
+} ZXDH_SE_ZREG_CFG;
+
+typedef struct zxdh_se_zblk_cfg_t {
+	uint32_t          zblk_idx;
+	uint16_t          is_used;
+	uint16_t          zcell_bm;
+	uint16_t          hash_arg;
+	uint16_t          pad;
+	ZXDH_SE_ZCELL_CFG    zcell_info[ZXDH_SE_ZCELL_NUM];
+	ZXDH_SE_ZREG_CFG     zreg_info[ZXDH_SE_ZREG_NUM];
+	ZXDH_D_NODE          zblk_dn;
+} ZXDH_SE_ZBLK_CFG;
+
+typedef struct zxdh_func_id_info_t {
+	void *fun_ptr;
+	uint8_t  fun_type;
+	uint8_t  fun_id;
+	uint8_t  is_used;
+	uint8_t  pad;
+} ZXDH_FUNC_ID_INFO;
+
+typedef struct zxdh_ddr_mem_t {
+	uint32_t     total_num;
+	uint32_t     base_addr;
+	uint32_t     base_addr_offset;
+	uint32_t     ecc_en;
+	uint32_t     bank_num;
+	uint32_t     bank_info[ZXDH_SE_ALG_BANK_NUM];
+	uint32_t     share_type;
+	uint32_t     item_used;
+	ZXDH_LISTSTACK_MANAGER *p_ddr_mng;
+} ZXDH_DDR_MEM;
+
+typedef struct zxdh_share_ram_t {
+	uint32_t       zblk_array[ZXDH_SE_ZBLK_NUM];
+	ZXDH_D_HEAD    zblk_list;
+	ZXDH_D_HEAD    zcell_free_list;
+	uint32_t       def_route_num;
+	ZXDH_RB_CFG    def_rb;
+	struct def_route_info  *p_dr_info;
+	ZXDH_DDR_MEM   ddr4_info;
+	ZXDH_DDR_MEM   ddr6_info;
+} ZXDH_SHARE_RAM;
+
+typedef struct zxdh_se_cfg_t {
+	ZXDH_SE_ZBLK_CFG   zblk_info[ZXDH_SE_ZBLK_NUM];
+	ZXDH_FUNC_ID_INFO  fun_info[ZXDH_MAX_FUN_NUM];
+	ZXDH_SHARE_RAM     route_shareram;
+	uint32_t           reg_base;
+	ZXDH_WRITE32_FUN   p_write32_fun;
+	ZXDH_READ32_FUN    p_read32_fun;
+	uint32_t           lpm_flags;
+	void               *p_client;
+	uint32_t           dev_id;
+	ZXDH_LPM_AS_RSLT_WRT_FUNCTION p_as_rslt_wrt_fun;
+} ZXDH_SE_CFG;
+
+typedef struct hash_ddr_cfg_t {
+	uint32_t bulk_use;
+	uint32_t ddr_baddr;
+	uint32_t ddr_ecc_en;
+	uint32_t item_num;
+	uint32_t bulk_id;
+	uint32_t hash_ddr_arg;
+	uint32_t width_mode;
+	uint32_t hw_baddr;
+	uint32_t zcell_num;
+	uint32_t zreg_num;
+	ZXDH_SE_ITEM_CFG  **p_item_array;
+} HASH_DDR_CFG;
+
+typedef struct zxdh_hash_tbl_info_t {
+	uint32_t fun_id;
+	uint32_t actu_key_size;
+	uint32_t key_type;
+	uint8_t is_init;
+	uint8_t mono_zcell;
+	uint8_t zcell_num;
+	uint8_t mono_zreg;
+	uint8_t zreg_num;
+	uint8_t is_age;
+	uint8_t is_lrn;
+	uint8_t is_mc_wrt;
+} ZXDH_HASH_TBL_ID_INFO;
+
+typedef struct zxdh_hash_rbkey_info_t {
+	uint8_t          key[ZXDH_HASH_KEY_MAX];
+	uint8_t          rst[ZXDH_HASH_RST_MAX];
+	ZXDH_D_NODE      entry_dn;
+	ZXDH_SE_ITEM_CFG *p_item_info;
+	uint32_t         entry_size;
+	uint32_t         entry_pos;
+} ZXDH_HASH_RBKEY_INFO;
+
+typedef struct zxdh_hash_table_stat_t {
+	float ddr;
+	float zcell;
+	float zreg;
+	float sum;
+} ZXDH_HASH_TABLE_STAT;
+
+typedef struct zxdh_hash_zreg_mono_stat_t {
+	uint32_t zblk_id;
+	uint32_t zreg_id;
+} ZXDH_HASH_ZREG_MONO_STAT;
+
+typedef struct zxdh_hash_bulk_zcam_stat_t {
+	uint32_t zcell_mono_idx[ZXDH_SE_ZBLK_NUM * ZXDH_SE_ZCELL_NUM];
+	ZXDH_HASH_ZREG_MONO_STAT zreg_mono_id[ZXDH_SE_ZBLK_NUM][ZXDH_SE_ZREG_NUM];
+} ZXDH_HASH_BULK_ZCAM_STAT;
+
+typedef struct zxdh_hash_stat_t {
+	uint32_t insert_ok;
+	uint32_t insert_fail;
+	uint32_t insert_same;
+	uint32_t insert_ddr;
+	uint32_t insert_zcell;
+	uint32_t insert_zreg;
+	uint32_t delete_ok;
+	uint32_t delete_fail;
+	uint32_t search_ok;
+	uint32_t search_fail;
+	uint32_t zblock_num;
+	uint32_t zblock_array[ZXDH_SE_ZBLK_NUM];
+	ZXDH_HASH_TABLE_STAT insert_table[ZXDH_HASH_TBL_ID_NUM];
+	ZXDH_HASH_BULK_ZCAM_STAT *p_bulk_zcam_mono[ZXDH_HASH_BULK_NUM];
+} ZXDH_HASH_STAT;
+
+typedef struct zxdh_hash_cfg_t {
+	uint32_t              fun_id;
+	uint8_t               ddr_valid;
+	uint8_t               pad[3];
+	ZXDH_HASH_FUNCTION32  p_hash32_fun;
+	ZXDH_HASH_FUNCTION    p_hash16_fun;
+	HASH_DDR_CFG          *p_bulk_ddr_info[ZXDH_HASH_BULK_NUM];
+	uint8_t               bulk_ram_mono[ZXDH_HASH_BULK_NUM];
+	ZXDH_SHARE_RAM        hash_shareram;
+	ZXDH_SE_CFG           *p_se_info;
+	ZXDH_RB_CFG           hash_rb;
+	ZXDH_RB_CFG           ddr_cfg_rb;
+	ZXDH_HASH_STAT        hash_stat;
+} ZXDH_HASH_CFG;
+
+typedef struct hash_entry_cfg_t {
+	uint32_t fun_id;
+	uint8_t bulk_id;
+	uint8_t table_id;
+	uint8_t key_type;
+	uint8_t rsp_mode;
+	uint32_t actu_key_size;
+	uint32_t key_by_size;
+	uint32_t rst_by_size;
+	ZXDH_SE_CFG *p_se_cfg;
+	ZXDH_HASH_CFG *p_hash_cfg;
+	ZXDH_HASH_RBKEY_INFO *p_rbkey_new;
+	ZXDH_RB_TN *p_rb_tn_new;
+} HASH_ENTRY_CFG;
+
+typedef struct zxdh_hash_ddr_resc_cfg_t {
+	uint32_t ddr_width_mode;
+	uint32_t ddr_crc_sel;
+	uint32_t ddr_item_num;
+	uint32_t ddr_baddr;
+	uint32_t ddr_ecc_en;
+} ZXDH_HASH_DDR_RESC_CFG_T;
+
 typedef struct zxdh_dtb_tab_up_user_addr_t {
 	uint32_t user_flag;
 	uint64_t phy_addr;
-- 
2.27.0

[-- Attachment #1.1.2: Type: text/html , Size: 90949 bytes --]