[PATCH v1 12/14] net/zxdh: delete all hash entries

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

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

Implement hash table entries all delete operation
by dtb channel.

Signed-off-by: Bingbin Chen <chen.bingbin@zte.com.cn>
---
 drivers/net/zxdh/zxdh_ethdev.c |   45 ++
 drivers/net/zxdh/zxdh_np.c     | 1092 ++++++++++++++++++++++++++++++++
 drivers/net/zxdh/zxdh_np.h     |   19 +
 3 files changed, 1156 insertions(+)

diff --git a/drivers/net/zxdh/zxdh_ethdev.c b/drivers/net/zxdh/zxdh_ethdev.c
index 18b661b1ab..b99e79ca4a 100644
--- a/drivers/net/zxdh/zxdh_ethdev.c
+++ b/drivers/net/zxdh/zxdh_ethdev.c
@@ -966,6 +966,29 @@ zxdh_np_dtb_data_res_free(struct zxdh_hw *hw)
 		zxdh_shared_data->np_init_done = 0;
 }
 
+static int
+zxdh_tbl_entry_online_destroy(struct rte_eth_dev *dev)
+{
+	struct zxdh_hw *hw = dev->data->dev_private;
+	uint32_t sdt_no;
+	int ret = 0;
+	if (!g_dtb_data.init_done)
+		return ret;
+	if (hw->is_pf) {
+		sdt_no = ZXDH_SDT_L2_ENTRY_TABLE0 + hw->hash_search_index;
+		ret = zxdh_np_dtb_hash_online_delete(0, g_dtb_data.queueid, sdt_no);
+		if (ret)
+			PMD_DRV_LOG(ERR, "%s sdt_no %d failed. code:%d ",
+				dev->data->name, sdt_no, ret);
+		sdt_no = ZXDH_SDT_MC_TABLE0 + hw->hash_search_index;
+		ret = zxdh_np_dtb_hash_online_delete(0, g_dtb_data.queueid, sdt_no);
+		if (ret)
+			PMD_DRV_LOG(ERR, "%s sdt_no %d failed. code:%d",
+				dev->data->name, sdt_no, ret);
+	}
+	return ret;
+}
+
 static void
 zxdh_np_uninit(struct rte_eth_dev *dev)
 {
@@ -974,6 +997,8 @@ zxdh_np_uninit(struct rte_eth_dev *dev)
 	if (!g_dtb_data.init_done && !g_dtb_data.dev_refcnt)
 		return;
 
+	zxdh_tbl_entry_online_destroy(dev);
+
 	if (--g_dtb_data.dev_refcnt == 0)
 		zxdh_np_dtb_data_res_free(hw);
 }
@@ -1394,6 +1419,25 @@ zxdh_init_once(void)
 	return ret;
 }
 
+static int zxdh_tbl_entry_offline_destroy(struct zxdh_hw *hw)
+{
+	int ret = 0;
+	if (!g_dtb_data.init_done)
+		return ret;
+	if (hw->is_pf) {
+		uint32_t sdt_no;
+		sdt_no = ZXDH_SDT_L2_ENTRY_TABLE0 + hw->hash_search_index;
+		ret = zxdh_np_dtb_hash_offline_delete(0, g_dtb_data.queueid, sdt_no, 0);
+		if (ret)
+			PMD_DRV_LOG(ERR, "sdt_no %d delete failed. code:%d ", sdt_no, ret);
+		sdt_no = ZXDH_SDT_MC_TABLE0 + hw->hash_search_index;
+		ret = zxdh_np_dtb_hash_offline_delete(0, g_dtb_data.queueid, sdt_no, 0);
+		if (ret)
+			PMD_DRV_LOG(ERR, "sdt_no %d delete failed. code:%d ", sdt_no, ret);
+	}
+	return ret;
+}
+
 static int
 zxdh_np_init(struct rte_eth_dev *eth_dev)
 {
@@ -1423,6 +1467,7 @@ zxdh_np_init(struct rte_eth_dev *eth_dev)
 			PMD_DRV_LOG(ERR, "invalid hash idx %d", hw->hash_search_index);
 			return -1;
 		}
+		zxdh_tbl_entry_offline_destroy(hw);
 	}
 
 	if (zxdh_shared_data != NULL)
diff --git a/drivers/net/zxdh/zxdh_np.c b/drivers/net/zxdh/zxdh_np.c
index 09ff42b3be..230a1d44be 100644
--- a/drivers/net/zxdh/zxdh_np.c
+++ b/drivers/net/zxdh/zxdh_np.c
@@ -417,6 +417,17 @@ do {\
 	} \
 } while (0)
 
+#define ZXDH_COMM_CHECK_POINT_MEMORY_FREE2PTR(point, ptr0, ptr1)\
+do {\
+	if ((point) == NULL) {\
+		PMD_DRV_LOG(ERR, " ZXDH %s:%d[Error:POINT NULL] ! FUNCTION"\
+		": %s!", __FILE__, __LINE__, __func__);\
+		rte_free(ptr0);\
+		rte_free(ptr1);\
+		RTE_ASSERT(0);\
+	} \
+} while (0)
+
 #define ZXDH_COMM_CHECK_RC_MEMORY_FREE(rc, becall, ptr)\
 do {\
 	if ((rc) != 0) {\
@@ -578,6 +589,8 @@ zxdh_np_get_tn_color(ZXDH_RB_TN *p_tn)
 
 #define GET_HASH_TBL_ID_INFO(dev_id, fun_id, tbl_id) (&g_tbl_id_info[dev_id][fun_id][tbl_id])
 
+#define ZXDH_GET_HASH_TBL_ID(p_key)    ((p_key)[0] & 0x1F)
+
 static inline uint32_t
 zxdh_np_get_hash_entry_size(uint32_t key_type)
 {
@@ -1809,6 +1822,20 @@ zxdh_np_se_apt_rb_delete(ZXDH_RB_CFG *rb_cfg, void *p_data, __rte_unused uint32_
 	return rc;
 }
 
+static uint32_t
+zxdh_np_se_apt_rb_search(ZXDH_RB_CFG *rb_cfg, void *p_data, uint32_t len)
+{
+	uint32_t rc = ZXDH_OK;
+	ZXDH_RB_TN *p_rb_rtn	 = NULL;
+
+	rc = zxdh_comm_rb_search(rb_cfg, p_data, &p_rb_rtn);
+	if (rc != ZXDH_OK)
+		return rc;
+
+	rte_memcpy(p_data, p_rb_rtn->p_key, len);
+	return rc;
+}
+
 static uint32_t
 zxdh_np_dev_init(void)
 {
@@ -3841,6 +3868,240 @@ zxdh_np_dev_del(uint32_t dev_id)
 	}
 }
 
+static uint32_t
+zxdh_np_hash_soft_all_entry_delete(ZXDH_SE_CFG *p_se_cfg, uint32_t hash_id)
+{
+	uint32_t rc = 0;
+	uint32_t dev_id = 0;
+	uint8_t table_id = 0;
+	uint32_t bulk_id = 0;
+
+	ZXDH_D_NODE *p_node = NULL;
+	ZXDH_RB_TN *p_rb_tn = NULL;
+	ZXDH_RB_TN *p_rb_tn_rtn = NULL;
+	ZXDH_D_HEAD *p_head_hash_rb = NULL;
+	ZXDH_HASH_CFG *p_hash_cfg = NULL;
+	ZXDH_FUNC_ID_INFO *p_func_info = NULL;
+	ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
+	ZXDH_HASH_RBKEY_INFO *p_rbkey_rtn = NULL;
+	ZXDH_SE_ITEM_CFG *p_item = NULL;
+
+	dev_id = p_se_cfg->dev_id;
+
+	p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, hash_id);
+
+	p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
+	p_head_hash_rb = &p_hash_cfg->hash_rb.tn_list;
+
+	while (p_head_hash_rb->used) {
+		p_node = p_head_hash_rb->p_next;
+		p_rb_tn = (ZXDH_RB_TN *)p_node->data;
+		p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_rb_tn->p_key;
+		table_id = ZXDH_GET_HASH_TBL_ID(p_rbkey->key);
+		bulk_id = ((table_id >> 2) & 0x7);
+
+		rc = zxdh_comm_rb_delete(&p_hash_cfg->hash_rb, p_rbkey, &p_rb_tn_rtn);
+		if (rc == ZXDH_RBT_RC_SRHFAIL) {
+			p_hash_cfg->hash_stat.delete_fail++;
+			PMD_DRV_LOG(DEBUG, "Error!there is not item in hash!");
+			return ZXDH_HASH_RC_DEL_SRHFAIL;
+		}
+
+		ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
+		p_rbkey_rtn = (ZXDH_HASH_RBKEY_INFO *)(p_rb_tn_rtn->p_key);
+		p_item = p_rbkey_rtn->p_item_info;
+
+		rc = zxdh_comm_double_link_del(&p_rbkey_rtn->entry_dn, &p_item->item_list);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
+		p_item->wrt_mask &= ~(ZXDH_GET_HASH_ENTRY_MASK(p_rbkey_rtn->entry_size,
+			p_rbkey_rtn->entry_pos)) & 0xF;
+
+		if (p_item->item_list.used == 0) {
+			if (p_item->item_type == ZXDH_ITEM_DDR_256 ||
+				p_item->item_type == ZXDH_ITEM_DDR_512) {
+				p_hash_cfg->p_bulk_ddr_info[bulk_id]->p_item_array
+					[p_item->item_index] = NULL;
+				rte_free(p_item);
+			} else {
+				p_item->valid = 0;
+			}
+		}
+
+		rte_free(p_rbkey_rtn);
+		rte_free(p_rb_tn_rtn);
+		p_hash_cfg->hash_stat.delete_ok++;
+	}
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_hash_zcam_resource_deinit(ZXDH_HASH_CFG *p_hash_cfg)
+{
+	uint32_t rc = 0;
+	uint32_t dev_id = 0;
+	uint32_t i = 0;
+
+	ZXDH_D_NODE *p_node = NULL;
+	ZXDH_D_HEAD *p_head = 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_head = &p_hash_cfg->hash_shareram.zcell_free_list;
+
+	while (p_head->used) {
+		p_node = p_head->p_next;
+
+		rc = zxdh_comm_double_link_del(p_node, p_head);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
+		p_zcell_cfg = (ZXDH_SE_ZCELL_CFG *)p_node->data;
+		p_zcell_cfg->is_used = 0;
+		p_zcell_cfg->flag = 0;
+	}
+
+	p_head = &p_hash_cfg->hash_shareram.zblk_list;
+
+	while (p_head->used) {
+		p_node = p_head->p_next;
+
+		rc = zxdh_comm_double_link_del(p_node, p_head);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_double_link_del");
+
+		p_zblk_cfg = ZXDH_SE_GET_ZBLK_CFG(p_hash_cfg->p_se_info,
+			((ZXDH_SE_ZBLK_CFG *)p_node->data)->zblk_idx);
+		p_zblk_cfg->is_used = 0;
+		for (i = 0; i < ZXDH_SE_ZREG_NUM; i++)
+			p_zblk_cfg->zreg_info[i].flag = 0;
+	}
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_se_fun_deinit(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 == 0) {
+		PMD_DRV_LOG(ERR, " Error[0x%x], fun_id [%d] is already deinit!",
+			ZXDH_SE_RC_FUN_INVALID, id);
+		return ZXDH_OK;
+	}
+
+	switch (fun_type) {
+	case (ZXDH_FUN_HASH):
+	{
+		if (p_fun_info->fun_ptr) {
+			rte_free(p_fun_info->fun_ptr);
+			p_fun_info->fun_ptr = NULL;
+		}
+	}
+	break;
+
+	default:
+	{
+		PMD_DRV_LOG(ERR, " Error, unrecgnized fun_type[ %d] ", fun_type);
+		RTE_ASSERT(0);
+		return ZXDH_SE_RC_BASE;
+	}
+	break;
+	}
+
+	p_fun_info->fun_id = id;
+	p_fun_info->is_used = 0;
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_np_one_hash_soft_uninstall(uint32_t dev_id, uint32_t hash_id)
+{
+	uint32_t rc = 0;
+	uint32_t i = 0;
+
+	ZXDH_D_NODE *p_node = NULL;
+	ZXDH_SE_CFG *p_se_cfg = NULL;
+	ZXDH_RB_TN *p_rb_tn = NULL;
+	ZXDH_RB_TN *p_rb_tn_rtn = NULL;
+	HASH_DDR_CFG *p_rbkey = NULL;
+	ZXDH_HASH_CFG *p_hash_cfg = NULL;
+	ZXDH_FUNC_ID_INFO *p_func_info = NULL;
+	ZXDH_D_HEAD *p_head_ddr_cfg_rb = NULL;
+	HASH_DDR_CFG *p_temp_rbkey = NULL;
+
+	p_se_cfg = dpp_se_cfg[dev_id];
+	p_func_info = ZXDH_GET_FUN_INFO(p_se_cfg, hash_id);
+	if (p_func_info->is_used == 0) {
+		PMD_DRV_LOG(INFO, "Error[0x%x], fun_id [%d] is not init!",
+			ZXDH_SE_RC_FUN_INVALID, hash_id);
+		return ZXDH_OK;
+	}
+
+	rc = zxdh_np_hash_soft_all_entry_delete(p_se_cfg, hash_id);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_soft_all_entry_delete");
+
+	p_hash_cfg = (ZXDH_HASH_CFG *)p_func_info->fun_ptr;
+	for (i = 0; i < ZXDH_HASH_BULK_NUM; i++) {
+		if (p_hash_cfg->hash_stat.p_bulk_zcam_mono[i] != NULL) {
+			rte_free((&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[i]);
+			(&p_hash_cfg->hash_stat)->p_bulk_zcam_mono[i] = NULL;
+		}
+	}
+
+	p_head_ddr_cfg_rb = &p_hash_cfg->ddr_cfg_rb.tn_list;
+	while (p_head_ddr_cfg_rb->used) {
+		p_node = p_head_ddr_cfg_rb->p_next;
+
+		p_rb_tn = (ZXDH_RB_TN *)p_node->data;
+		p_rbkey = p_rb_tn->p_key;
+
+		rc = zxdh_comm_rb_delete(&p_hash_cfg->ddr_cfg_rb, p_rbkey, &p_rb_tn_rtn);
+
+		if (rc == ZXDH_RBT_RC_SRHFAIL)
+			PMD_DRV_LOG(ERR, "ddr_cfg_rb delete key is not exist, key: 0x");
+		else
+			ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_delete");
+
+		ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn_rtn);
+		p_temp_rbkey = (HASH_DDR_CFG *)(p_rb_tn_rtn->p_key);
+		rte_free(p_temp_rbkey->p_item_array);
+		p_temp_rbkey->p_item_array = NULL;
+		rte_free(p_temp_rbkey);
+		rte_free(p_rb_tn_rtn);
+	}
+
+	rc = zxdh_np_hash_zcam_resource_deinit(p_hash_cfg);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_zcam_resource_deinit");
+
+	rc = zxdh_np_se_fun_deinit(p_se_cfg, (hash_id & 0xff), ZXDH_FUN_HASH);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_fun_deinit");
+
+	memset(g_tbl_id_info[dev_id][hash_id], 0,
+		ZXDH_HASH_TBL_ID_NUM * sizeof(ZXDH_HASH_TBL_ID_INFO));
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_hash_soft_uninstall(uint32_t dev_id)
+{
+	uint32_t  rc	   = ZXDH_OK;
+	uint32_t hash_id  = 0;
+
+	for (hash_id = 0; hash_id < ZXDH_HASH_FUNC_ID_NUM; hash_id++) {
+		rc = zxdh_np_one_hash_soft_uninstall(dev_id, hash_id);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_one_hash_soft_uninstall");
+	}
+
+	return rc;
+}
+
 int
 zxdh_np_online_uninit(uint32_t dev_id,
 			char *port_name,
@@ -3853,6 +4114,10 @@ zxdh_np_online_uninit(uint32_t dev_id,
 		PMD_DRV_LOG(ERR, "%s:dtb release error,"
 			"port name %s queue id %d", __func__, port_name, queue_id);
 
+	rc = zxdh_np_hash_soft_uninstall(dev_id);
+	if (rc != ZXDH_OK)
+		PMD_DRV_LOG(ERR, "zxdh_np_hash_soft_uninstall error! ");
+
 	zxdh_np_dtb_mgr_destroy(dev_id);
 	zxdh_np_sdt_mgr_destroy(dev_id);
 	zxdh_np_dev_del(dev_id);
@@ -4120,6 +4385,25 @@ zxdh_np_dtb_zcam_dump_info_write(uint32_t dev_id,
 	return rc;
 }
 
+static void
+zxdh_np_dtb_zcam_dump_entry(uint32_t dev_id,
+					uint32_t addr,
+					uint32_t tb_width,
+					uint32_t depth,
+					uint32_t addr_high32,
+					uint32_t addr_low32,
+					ZXDH_DTB_ENTRY_T *p_entry)
+{
+	zxdh_np_dtb_zcam_dump_info_write(dev_id,
+						addr,
+						tb_width,
+						depth,
+						addr_high32,
+						addr_low32,
+						(uint32_t *)p_entry->cmd);
+	p_entry->data_in_cmd_flag = 1;
+}
+
 static uint32_t
 zxdh_np_dtb_se_smmu0_ind_write(uint32_t dev_id,
 		uint32_t base_addr,
@@ -5915,6 +6199,29 @@ zxdh_np_dtb_tab_up_item_addr_get(uint32_t dev_id,
 	return rc;
 }
 
+static void
+zxdh_np_dtb_tab_up_item_offset_addr_get(uint32_t dev_id,
+			uint32_t queue_id,
+			uint32_t item_index,
+			uint32_t addr_offset,
+			uint32_t *p_phy_haddr,
+			uint32_t *p_phy_laddr)
+{
+	uint64_t addr = 0;
+
+	if (ZXDH_DTB_TAB_UP_USER_PHY_ADDR_FLAG_GET(dev_id, queue_id, item_index) ==
+	ZXDH_DTB_TAB_UP_USER_ADDR_TYPE)
+		addr = ZXDH_DTB_TAB_UP_USER_PHY_ADDR_GET(dev_id, queue_id, item_index);
+	else
+		addr = ZXDH_DTB_TAB_UP_PHY_ADDR_GET(dev_id, queue_id, item_index) +
+			ZXDH_DTB_ITEM_ACK_SIZE;
+
+	addr = addr + addr_offset;
+
+	*p_phy_haddr = (addr >> 32) & 0xffffffff;
+	*p_phy_laddr = addr & 0xffffffff;
+}
+
 static uint32_t
 zxdh_np_dtb_dump_table_elemet_addr_get(uint32_t dev_id,
 						uint32_t queue_id,
@@ -6129,6 +6436,101 @@ zxdh_np_dtb_tab_up_free_item_get(uint32_t dev_id,
 	return 0;
 }
 
+static uint32_t
+zxdh_np_dtb_tab_up_item_user_addr_set(uint32_t dev_id,
+					uint32_t queue_id,
+					uint32_t item_index,
+					uint64_t phy_addr,
+					uint64_t vir_addr)
+{
+	ZXDH_DTB_MGR_T *p_dtb_mgr = NULL;
+
+	p_dtb_mgr = zxdh_np_dtb_mgr_get(dev_id);
+	if (p_dtb_mgr == NULL) {
+		PMD_DRV_LOG(ERR, "DTB Manager is not exist!");
+		return ZXDH_RC_DTB_MGR_NOT_EXIST;
+	}
+
+	if (ZXDH_DTB_QUEUE_INIT_FLAG_GET(dev_id, queue_id) == 0) {
+		PMD_DRV_LOG(ERR, "dtb queue %d is not init.", queue_id);
+		return ZXDH_RC_DTB_QUEUE_IS_NOT_INIT;
+	}
+
+	p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].phy_addr = phy_addr;
+	p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].vir_addr = vir_addr;
+	p_dtb_mgr->queue_info[queue_id].tab_up.user_addr[item_index].user_flag =
+		ZXDH_DTB_TAB_UP_USER_ADDR_TYPE;
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_np_dtb_dump_sdt_addr_get(uint32_t dev_id,
+							uint32_t queue_id,
+							uint32_t sdt_no,
+							uint64_t *phy_addr,
+							uint64_t *vir_addr,
+							uint32_t *size)
+{
+	uint32_t rc = ZXDH_OK;
+
+	ZXDH_DTB_ADDR_INFO_T dtb_dump_addr_info = {0};
+	ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
+
+	dtb_dump_addr_info.sdt_no = sdt_no;
+	p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
+	rc = zxdh_np_se_apt_rb_search(p_dtb_dump_addr_rb, &dtb_dump_addr_info,
+		sizeof(ZXDH_DTB_ADDR_INFO_T));
+	if (rc == ZXDH_OK) {
+		PMD_DRV_LOG(INFO, "search sdt_no %d success.", sdt_no);
+	} else {
+		PMD_DRV_LOG(ERR, "search sdt_no %d fail.", sdt_no);
+		return rc;
+	}
+
+	*phy_addr = dtb_dump_addr_info.phy_addr;
+	*vir_addr = dtb_dump_addr_info.vir_addr;
+	*size = dtb_dump_addr_info.size;
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_dtb_dump_addr_set(uint32_t dev_id,
+							uint32_t queue_id,
+							uint32_t sdt_no,
+							uint32_t *element_id)
+{
+	uint32_t rc = ZXDH_OK;
+	uint32_t dump_element_id = 0;
+	uint64_t phy_addr = 0;
+	uint64_t vir_addr = 0;
+	uint32_t size	 = 0;
+
+	rc = zxdh_np_dtb_dump_sdt_addr_get(dev_id,
+									queue_id,
+									sdt_no,
+									&phy_addr,
+									&vir_addr,
+									&size);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_get");
+	memset((uint8_t *)vir_addr, 0, size);
+
+	rc = zxdh_np_dtb_tab_up_free_item_get(dev_id, queue_id, &dump_element_id);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_free_item_get");
+
+	rc = zxdh_np_dtb_tab_up_item_user_addr_set(dev_id,
+										   queue_id,
+										   dump_element_id,
+										   phy_addr,
+										   vir_addr);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_tab_up_item_addr_set");
+
+	*element_id = dump_element_id;
+
+	return rc;
+}
+
 static uint32_t
 zxdh_np_dtb_se_smmu0_dma_dump(uint32_t dev_id,
 		uint32_t queue_id,
@@ -8673,3 +9075,693 @@ zxdh_np_se_res_get_and_init(uint32_t dev_id, uint32_t type)
 
 	return rc;
 }
+
+static uint32_t
+zxdh_np_dtb_hash_zcam_del_one_hw(uint32_t dev_id,
+								uint32_t queue_id,
+								HASH_ENTRY_CFG  *p_hash_entry_cfg,
+								ZXDH_HASH_ENTRY  *p_hash_entry,
+								ZXDH_DTB_ENTRY_T *p_entry,
+								uint8_t *p_srh_succ)
+{
+	uint32_t rc = ZXDH_OK;
+	ZXDH_HASH_RBKEY_INFO srh_rbkey = {0};
+	ZXDH_HASH_CFG *p_hash_cfg = NULL;
+	ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
+	ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
+
+	uint32_t zblk_idx = 0;
+	uint32_t pre_zblk_idx = 0xFFFFFFFF;
+	uint16_t crc16_value = 0;
+	uint32_t zcell_id = 0;
+	uint32_t item_idx = 0;
+	uint32_t element_id = 0;
+	uint32_t byte_offset = 0;
+	uint32_t addr = 0;
+	uint32_t i	= 0;
+	uint8_t srh_succ	 = 0;
+	uint8_t temp_key[ZXDH_HASH_KEY_MAX] = {0};
+	uint8_t  rd_buff[ZXDH_SE_ITEM_WIDTH_MAX]   = {0};
+
+	ZXDH_D_NODE *p_zblk_dn = NULL;
+	ZXDH_D_NODE *p_zcell_dn = NULL;
+	ZXDH_SE_CFG *p_se_cfg = NULL;
+
+	rte_memcpy(srh_rbkey.key, p_hash_entry->p_key, p_hash_entry_cfg->key_by_size);
+
+	p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
+	ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
+
+	p_se_cfg = p_hash_entry_cfg->p_se_cfg;
+	ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_se_cfg);
+
+	zxdh_np_hash_set_crc_key(p_hash_entry_cfg, p_hash_entry, temp_key);
+
+	p_zcell_dn = p_hash_cfg->hash_shareram.zcell_free_list.p_next;
+	while (p_zcell_dn) {
+		p_zcell = (ZXDH_SE_ZCELL_CFG *)p_zcell_dn->data;
+		zblk_idx = GET_ZBLK_IDX(p_zcell->zcell_idx);
+
+		if (zblk_idx != pre_zblk_idx) {
+			pre_zblk_idx = zblk_idx;
+			crc16_value = p_hash_cfg->p_hash16_fun(temp_key,
+				p_hash_entry_cfg->key_by_size, p_zblk->hash_arg);
+		}
+
+		zcell_id = GET_ZCELL_IDX(p_zcell->zcell_idx);
+		item_idx = GET_ZCELL_CRC_VAL(zcell_id, crc16_value);
+		addr = ZXDH_ZBLK_ITEM_ADDR_CALC(p_zcell->zcell_idx, item_idx);
+		rc =  zxdh_np_dtb_se_zcam_dma_dump(dev_id,
+									   queue_id,
+									   addr,
+									   ZXDH_DTB_DUMP_ZCAM_512b,
+									   1,
+									   (uint32_t *)rd_buff,
+									   &element_id);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
+		zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
+
+		rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM, p_hash_entry_cfg->key_by_size,
+			p_hash_entry, rd_buff, &byte_offset);
+		if (rc == ZXDH_OK) {
+			PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zcell.");
+			srh_succ = 1;
+			p_hash_cfg->hash_stat.search_ok++;
+			break;
+		}
+
+		p_zcell_dn = p_zcell_dn->next;
+	}
+
+	if (srh_succ == 0) {
+		p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
+		while (p_zblk_dn) {
+			p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
+			zblk_idx = p_zblk->zblk_idx;
+
+			for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
+				item_idx = i;
+				addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblk_idx, item_idx);
+				rc =  zxdh_np_dtb_se_zcam_dma_dump(dev_id,
+									   queue_id,
+									   addr,
+									   ZXDH_DTB_DUMP_ZCAM_512b,
+									   1,
+									   (uint32_t *)rd_buff,
+									   &element_id);
+				ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_zcam_dma_dump");
+				zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
+
+				rc = zxdh_np_dtb_hash_data_parse(ZXDH_ITEM_RAM,
+					p_hash_entry_cfg->key_by_size, p_hash_entry,
+					rd_buff, &byte_offset);
+				if (rc == ZXDH_OK) {
+					PMD_DRV_LOG(DEBUG, "Hash search hardware succ in zreg.");
+					srh_succ = 1;
+					p_hash_cfg->hash_stat.search_ok++;
+					break;
+				}
+			}
+			p_zblk_dn = p_zblk_dn->next;
+		}
+	}
+
+	if (srh_succ) {
+		memset(rd_buff + byte_offset, 0,
+			ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type));
+		zxdh_np_comm_swap(rd_buff, sizeof(rd_buff));
+		rc = zxdh_np_dtb_se_alg_zcam_data_write(dev_id,
+									   addr,
+									   rd_buff,
+									   p_entry);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_se_alg_zcam_data_write");
+		p_hash_cfg->hash_stat.delete_ok++;
+	}
+
+	*p_srh_succ = srh_succ;
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_dtb_hash_zcam_del_hw(uint32_t dev_id,
+						uint32_t queue_id,
+						uint32_t sdt_no,
+						uint32_t entry_num,
+						ZXDH_DTB_HASH_ENTRY_INFO_T *p_arr_hash_entry,
+						uint32_t *element_id)
+{
+	uint32_t rc = ZXDH_OK;
+	uint32_t item_cnt = 0;
+	uint32_t key_valid = 1;
+	uint32_t dtb_len = 0;
+	uint8_t srh_succ = 0;
+	uint8_t key[ZXDH_HASH_KEY_MAX] = {0};
+	uint8_t rst[ZXDH_HASH_RST_MAX] = {0};
+	uint8_t entry_cmd[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
+
+	uint8_t entry_data[ZXDH_ETCAM_WIDTH_MAX / 8] = {0};
+	uint8_t *p_data_buff = NULL;
+
+	ZXDH_HASH_ENTRY  entry = {0};
+	ZXDH_DTB_ENTRY_T   dtb_one_entry = {0};
+	HASH_ENTRY_CFG  hash_entry_cfg = {0};
+
+	dtb_one_entry.cmd = entry_cmd;
+	dtb_one_entry.data = entry_data;
+	entry.p_key = key;
+	entry.p_rst = rst;
+
+	rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
+
+	p_data_buff = (uint8_t *)rte_zmalloc(NULL, ZXDH_DTB_TABLE_DATA_BUFF_SIZE, 0);
+	if (p_data_buff == NULL) {
+		PMD_DRV_LOG(ERR, "%s point null!", __func__);
+		return ZXDH_PAR_CHK_POINT_NULL;
+	}
+
+	for (item_cnt = 0; item_cnt < entry_num; ++item_cnt) {
+		srh_succ = 0;
+		memset(key, 0, sizeof(key));
+		memset(rst, 0, sizeof(rst));
+		memset(entry_cmd, 0, sizeof(entry_cmd));
+		memset(entry_data, 0, sizeof(entry_data));
+		entry.p_key[0] = (uint8_t)(((key_valid & 0x1) << 7)
+							| ((hash_entry_cfg.key_type & 0x3) << 5)
+							| (hash_entry_cfg.table_id & 0x1f));
+		memcpy(&entry.p_key[1], p_arr_hash_entry[item_cnt].p_actu_key,
+			hash_entry_cfg.actu_key_size);
+
+		rc = zxdh_np_dtb_hash_zcam_del_one_hw(dev_id,
+										queue_id,
+										&hash_entry_cfg,
+										&entry,
+										&dtb_one_entry,
+										&srh_succ);
+		ZXDH_COMM_CHECK_RC_MEMORY_FREE(rc,
+			"zxdh_np_dtb_hash_zcam_del_one_hw", p_data_buff);
+
+		if (srh_succ) {
+			rc = zxdh_np_dtb_data_write(p_data_buff, 0, &dtb_one_entry);
+			ZXDH_COMM_CHECK_RC_MEMORY_FREE(rc,
+				"zxdh_np_dtb_data_write", p_data_buff);
+			dtb_len = dtb_one_entry.data_size / ZXDH_DTB_LEN_POS_SETP + 1;
+
+			rc = zxdh_np_dtb_write_down_table_data(dev_id, queue_id,
+				dtb_len * ZXDH_DTB_LEN_POS_SETP, p_data_buff, element_id);
+			ZXDH_COMM_CHECK_RC_MEMORY_FREE(rc,
+				"zxdh_np_dtb_write_down_table_data", p_data_buff);
+
+			rc = zxdh_np_dtb_tab_down_success_status_check(dev_id,
+						queue_id, *element_id);
+			ZXDH_COMM_CHECK_RC_MEMORY_FREE(rc,
+				"zxdh_np_dtb_tab_down_success_status_check", p_data_buff);
+		}
+	}
+
+	rte_free(p_data_buff);
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_dtb_sdt_hash_zcam_mono_space_dump(uint32_t dev_id,
+							uint32_t queue_id,
+							uint32_t sdt_no,
+							HASH_ENTRY_CFG *p_hash_entry_cfg,
+							uint8_t  *p_data,
+							uint32_t *p_dump_len)
+{
+	uint32_t rc = ZXDH_OK;
+
+	uint32_t i = 0;
+	uint32_t zblock_id = 0;
+	uint32_t zcell_id   = 0;
+	uint32_t start_addr  = 0;
+	uint32_t dtb_desc_len = 0;
+	uint32_t dump_pa_h   = 0;
+	uint32_t dump_pa_l   = 0;
+	uint32_t dma_addr_offset = 0;
+	uint32_t desc_addr_offset = 0;
+	uint32_t element_id  = 0;
+	uint8_t  *p_dump_desc_buf = NULL;
+
+	ZXDH_D_NODE *p_zblk_dn = NULL;
+	ZXDH_SE_ZBLK_CFG *p_zblk = NULL;
+	ZXDH_SE_ZREG_CFG *p_zreg = NULL;
+	ZXDH_SE_ZCELL_CFG *p_zcell = NULL;
+	ZXDH_HASH_CFG *p_hash_cfg = NULL;
+
+	ZXDH_DTB_ENTRY_T   dtb_dump_entry = {0};
+	uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
+
+	rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &element_id);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
+
+	p_dump_desc_buf = (uint8_t *)rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
+	if (p_dump_desc_buf == NULL) {
+		PMD_DRV_LOG(ERR, "%s point null!", __func__);
+		return ZXDH_PAR_CHK_POINT_NULL;
+	}
+	dtb_dump_entry.cmd = cmd_buff;
+
+	p_hash_cfg = p_hash_entry_cfg->p_hash_cfg;
+	p_zblk_dn = p_hash_cfg->hash_shareram.zblk_list.p_next;
+
+	while (p_zblk_dn) {
+		p_zblk = (ZXDH_SE_ZBLK_CFG *)p_zblk_dn->data;
+		zblock_id = p_zblk->zblk_idx;
+
+		for (i = 0; i < ZXDH_SE_ZCELL_NUM; i++) {
+			p_zcell = &p_zblk->zcell_info[i];
+
+			if ((p_zcell->flag & ZXDH_ZCELL_FLAG_IS_MONO) &&
+			p_zcell->bulk_id == p_hash_entry_cfg->bulk_id) {
+				zcell_id = p_zcell->zcell_idx;
+
+				start_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_id, 0);
+
+				zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
+						queue_id,
+						element_id,
+						dma_addr_offset,
+						&dump_pa_h,
+						&dump_pa_l);
+
+				zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
+				ZXDH_DTB_DUMP_ZCAM_512b, ZXDH_SE_RAM_DEPTH,
+				dump_pa_h, dump_pa_l, &dtb_dump_entry);
+
+				zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset,
+					&dtb_dump_entry);
+
+				dtb_desc_len++;
+				dma_addr_offset += ZXDH_SE_RAM_DEPTH * 512 / 8;
+				desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
+
+				PMD_DRV_LOG(DEBUG, "the Zblock[%d]'s bulk_id:%d Mono Zcell_id :%d",
+					zblock_id, p_hash_entry_cfg->bulk_id, zcell_id);
+			}
+		}
+
+		for (i = 0; i < ZXDH_SE_ZREG_NUM; i++) {
+			p_zreg = &p_zblk->zreg_info[i];
+
+			if ((p_zreg->flag & ZXDH_ZREG_FLAG_IS_MONO) &&
+			p_zreg->bulk_id == p_hash_entry_cfg->bulk_id) {
+				start_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblock_id, i);
+
+				zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
+						queue_id,
+						element_id,
+						dma_addr_offset,
+						&dump_pa_h,
+						&dump_pa_l);
+
+				zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
+				ZXDH_DTB_DUMP_ZCAM_512b, 1, dump_pa_h, dump_pa_l, &dtb_dump_entry);
+
+				zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset,
+					&dtb_dump_entry);
+
+				dtb_desc_len++;
+				dma_addr_offset += 512 / 8;
+				desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
+
+				PMD_DRV_LOG(DEBUG, "the Zblock[%d]'s bulk_id:%d"
+					" Mono Zreg_id :%d", zblock_id, p_zreg->bulk_id, i);
+			}
+		}
+
+		p_zblk_dn = p_zblk_dn->next;
+	}
+
+	rc = zxdh_np_dtb_write_dump_desc_info(dev_id,
+					queue_id,
+					element_id,
+					(uint32_t *)p_dump_desc_buf,
+					dma_addr_offset / 4,
+					dtb_desc_len * 4,
+					(uint32_t *)p_data);
+	ZXDH_COMM_CHECK_RC_MEMORY_FREE(rc, "zxdh_np_dtb_write_dump_desc_info",
+		p_dump_desc_buf);
+
+	zxdh_np_comm_swap(p_data, dma_addr_offset);
+	rte_free(p_dump_desc_buf);
+
+	*p_dump_len = dma_addr_offset;
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_dtb_hash_table_zcam_dump(uint32_t dev_id,
+	uint32_t queue_id,
+	uint32_t sdt_no,
+	uint32_t zblock_num,
+	uint32_t zblock_array[ZXDH_SE_ZBLK_NUM],
+	uint8_t  *p_data,
+	uint32_t *p_dump_len)
+{
+	uint32_t  rc		  = ZXDH_OK;
+	uint32_t zblk_idx	 = 0;
+	uint32_t index		= 0;
+	uint32_t zblock_id   = 0;
+	uint32_t zcell_id   = 0;
+	uint32_t start_addr  = 0;
+	uint32_t dtb_desc_len = 0;
+	uint32_t dump_pa_h   = 0;
+	uint32_t dump_pa_l   = 0;
+	uint32_t dma_addr_offset = 0;
+	uint32_t desc_addr_offset = 0;
+	uint32_t element_id  = 0;
+	uint8_t  *p_dump_desc_buf = NULL;
+
+	ZXDH_DTB_ENTRY_T   dtb_dump_entry = {0};
+	uint8_t cmd_buff[ZXDH_DTB_TABLE_CMD_SIZE_BIT / 8] = {0};
+
+	rc = zxdh_np_dtb_dump_addr_set(dev_id, queue_id, sdt_no, &element_id);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_set");
+
+	p_dump_desc_buf = (uint8_t *)rte_zmalloc(NULL, ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE, 0);
+	if (p_dump_desc_buf == NULL) {
+		PMD_DRV_LOG(ERR, "%s point null!", __func__);
+		return ZXDH_PAR_CHK_POINT_NULL;
+	}
+
+	dtb_dump_entry.cmd = cmd_buff;
+	for (zblk_idx = 0; zblk_idx < zblock_num; zblk_idx++) {
+		zblock_id = zblock_array[zblk_idx];
+		for (index = 0; index < ZXDH_SE_ZCELL_NUM; index++) {
+			zcell_id = zblock_id * ZXDH_SE_ZCELL_NUM + index;
+			start_addr = ZXDH_ZBLK_ITEM_ADDR_CALC(zcell_id, 0);
+
+			zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
+					queue_id,
+					element_id,
+					dma_addr_offset,
+					&dump_pa_h,
+					&dump_pa_l);
+
+			zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr,
+			ZXDH_DTB_DUMP_ZCAM_512b, ZXDH_SE_RAM_DEPTH,
+			dump_pa_h, dump_pa_l, &dtb_dump_entry);
+
+			zxdh_np_dtb_data_write(p_dump_desc_buf,
+				desc_addr_offset, &dtb_dump_entry);
+
+			dtb_desc_len++;
+			dma_addr_offset += ZXDH_SE_RAM_DEPTH * 512 / 8;
+			desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
+		}
+
+		zxdh_np_dtb_tab_up_item_offset_addr_get(dev_id,
+				queue_id,
+				element_id,
+				dma_addr_offset,
+				&dump_pa_h,
+				&dump_pa_l);
+
+		start_addr = ZXDH_ZBLK_HASH_LIST_REG_ADDR_CALC(zblock_id, 0);
+		zxdh_np_dtb_zcam_dump_entry(dev_id, start_addr, ZXDH_DTB_DUMP_ZCAM_512b,
+			ZXDH_SE_ZREG_NUM, dump_pa_h, dump_pa_l, &dtb_dump_entry);
+
+		zxdh_np_dtb_data_write(p_dump_desc_buf, desc_addr_offset, &dtb_dump_entry);
+
+		dtb_desc_len++;
+		dma_addr_offset += ZXDH_SE_ZREG_NUM * 512 / 8;
+		desc_addr_offset += ZXDH_DTB_LEN_POS_SETP;
+	}
+
+	rc = zxdh_np_dtb_write_dump_desc_info(dev_id,
+					queue_id,
+					element_id,
+					(uint32_t *)p_dump_desc_buf,
+					dma_addr_offset / 4,
+					dtb_desc_len * 4,
+					(uint32_t *)p_data);
+	ZXDH_COMM_CHECK_RC_MEMORY_FREE(rc, "zxdh_np_dtb_write_dump_desc_info",
+		p_dump_desc_buf);
+
+	zxdh_np_comm_swap(p_data, dma_addr_offset);
+	rte_free(p_dump_desc_buf);
+
+	*p_dump_len = dma_addr_offset;
+
+	return rc;
+}
+
+static void
+zxdh_np_dtb_dump_hash_parse(HASH_ENTRY_CFG *p_hash_entry_cfg,
+							uint32_t item_type,
+							uint8_t *pdata,
+							uint32_t dump_len,
+							uint8_t *p_outdata,
+							uint32_t *p_item_num)
+{
+	uint32_t item_num = 0;
+	uint32_t data_offset = 0;
+	uint32_t index = 0;
+	uint8_t temp_key_valid = 0;
+	uint8_t temp_key_type = 0;
+	uint8_t temp_tbl_id   = 0;
+	uint32_t srh_entry_size = 0;
+	uint32_t item_width = ZXDH_SE_ITEM_WIDTH_MAX;
+	uint8_t *p_temp_key = NULL;
+	uint8_t *p_hash_item = NULL;
+	ZXDH_DTB_HASH_ENTRY_INFO_T  *p_dtb_hash_entry = NULL;
+	ZXDH_DTB_HASH_ENTRY_INFO_T  *p_temp_entry = NULL;
+
+	if (item_type == ZXDH_ITEM_DDR_256)
+		item_width = item_width / 2;
+
+	p_dtb_hash_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_outdata;
+	srh_entry_size = ZXDH_GET_HASH_ENTRY_SIZE(p_hash_entry_cfg->key_type);
+
+	for (index = 0; index < (dump_len / item_width); index++) {
+		data_offset = 0;
+		p_hash_item = pdata + index * item_width;
+		while (data_offset < item_width) {
+			p_temp_key = p_hash_item + data_offset;
+			temp_key_valid = ZXDH_GET_HASH_KEY_VALID(p_temp_key);
+			temp_key_type = ZXDH_GET_HASH_KEY_TYPE(p_temp_key);
+			temp_tbl_id = ZXDH_GET_HASH_TBL_ID(p_temp_key);
+			p_temp_entry = p_dtb_hash_entry + item_num;
+
+			if (temp_key_valid && temp_key_type == p_hash_entry_cfg->key_type &&
+			temp_tbl_id == p_hash_entry_cfg->table_id) {
+				rte_memcpy(p_temp_entry->p_actu_key, p_temp_key + 1,
+					p_hash_entry_cfg->actu_key_size);
+				rte_memcpy(p_temp_entry->p_rst,
+					p_temp_key + p_hash_entry_cfg->key_by_size,
+					p_hash_entry_cfg->rst_by_size);
+				item_num++;
+			}
+
+			data_offset += srh_entry_size;
+		}
+	}
+
+	*p_item_num = item_num;
+}
+
+static uint32_t
+zxdh_np_dtb_hash_table_dump(uint32_t dev_id,
+						uint32_t queue_id,
+						uint32_t sdt_no,
+						ZXDH_DTB_DUMP_INDEX_T start_index,
+						uint8_t *p_dump_data,
+						uint32_t *p_entry_num,
+						ZXDH_DTB_DUMP_INDEX_T *next_start_index,
+						uint32_t *finish_flag)
+{
+	uint32_t  rc = ZXDH_OK;
+	uint8_t *p_data = NULL;
+	uint32_t data_len = 0;
+	uint32_t entry_num = 0;
+	ZXDH_HASH_CFG *p_hash_cfg = NULL;
+	HASH_ENTRY_CFG  hash_entry_cfg = {0};
+
+	rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
+
+	p_hash_cfg = hash_entry_cfg.p_hash_cfg;
+	ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
+
+	p_data = (uint8_t *)rte_zmalloc(NULL, ZXDH_DTB_DMUP_DATA_MAX, 0);
+	if (p_data == NULL) {
+		PMD_DRV_LOG(ERR, "%s point null!", __func__);
+		return ZXDH_PAR_CHK_POINT_NULL;
+	}
+
+	if (start_index.index_type == ZXDH_DTB_DUMP_ZCAM_TYPE) {
+		if (p_hash_cfg->bulk_ram_mono[hash_entry_cfg.bulk_id]) {
+			rc = zxdh_np_dtb_sdt_hash_zcam_mono_space_dump(dev_id,
+					queue_id,
+					sdt_no,
+					&hash_entry_cfg,
+					p_data,
+					&data_len);
+			ZXDH_COMM_CHECK_RC_MEMORY_FREE(rc,
+				"zxdh_np_dtb_sdt_hash_zcam_mono_space_dump", p_data);
+		} else {
+			rc = zxdh_np_dtb_hash_table_zcam_dump(dev_id,
+						queue_id,
+						sdt_no,
+						p_hash_cfg->hash_stat.zblock_num,
+						p_hash_cfg->hash_stat.zblock_array,
+						p_data,
+						&data_len);
+			ZXDH_COMM_CHECK_RC_MEMORY_FREE(rc, "zxdh_np_dtb_hash_table_zcam_dump",
+				p_data);
+		}
+
+		zxdh_np_dtb_dump_hash_parse(&hash_entry_cfg,
+									 ZXDH_ITEM_RAM,
+									 p_data,
+									 data_len,
+									 p_dump_data,
+									 &entry_num);
+
+		if (p_hash_cfg->ddr_valid) {
+			next_start_index->index = 0;
+			next_start_index->index_type = ZXDH_DTB_DUMP_DDR_TYPE;
+		} else {
+			*finish_flag = 1;
+		}
+		*p_entry_num = entry_num;
+	}
+
+	rte_free(p_data);
+	return rc;
+}
+
+static uint32_t
+zxdh_np_dtb_hash_offline_zcam_delete(uint32_t dev_id,
+								uint32_t queue_id,
+								uint32_t sdt_no)
+{
+	uint32_t rc = ZXDH_OK;
+	uint32_t entry_num = 0;
+	uint32_t finish_flag = 0;
+	uint32_t index = 0;
+	uint32_t max_item_num = 1024 * 1024;
+	uint8_t *p_dump_data = NULL;
+	uint8_t *p_key = NULL;
+	uint8_t *p_rst = NULL;
+	uint32_t element_id = 0;
+
+	ZXDH_DTB_HASH_ENTRY_INFO_T *p_dtb_hash_entry = NULL;
+	ZXDH_DTB_HASH_ENTRY_INFO_T *p_temp_entry = NULL;
+	ZXDH_DTB_DUMP_INDEX_T start_index = {0};
+	ZXDH_DTB_DUMP_INDEX_T next_start_index = {0};
+
+	ZXDH_SDT_TBL_HASH_T sdt_hash = {0};
+	start_index.index = 0;
+	start_index.index_type = ZXDH_DTB_DUMP_ZCAM_TYPE;
+
+	rc = zxdh_np_soft_sdt_tbl_get(0, sdt_no, &sdt_hash);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_soft_sdt_tbl_get");
+
+	p_dump_data = (uint8_t *)rte_zmalloc(NULL, max_item_num *
+		sizeof(ZXDH_DTB_HASH_ENTRY_INFO_T), 0);
+	if (p_dump_data == NULL) {
+		PMD_DRV_LOG(ERR, "%s point null!", __func__);
+		return ZXDH_PAR_CHK_POINT_NULL;
+	}
+	p_key = (uint8_t *)rte_zmalloc(NULL, max_item_num * ZXDH_HASH_KEY_MAX, 0);
+	ZXDH_COMM_CHECK_POINT_MEMORY_FREE(p_key, p_dump_data);
+	p_rst = (uint8_t *)rte_zmalloc(NULL, max_item_num * ZXDH_HASH_RST_MAX, 0);
+	ZXDH_COMM_CHECK_POINT_MEMORY_FREE2PTR(p_rst, p_dump_data, p_key);
+
+	p_dtb_hash_entry = (ZXDH_DTB_HASH_ENTRY_INFO_T *)p_dump_data;
+	for (index = 0; index < max_item_num; index++) {
+		p_temp_entry = p_dtb_hash_entry + index;
+		p_temp_entry->p_actu_key = p_key + index * ZXDH_HASH_KEY_MAX;
+		p_temp_entry->p_rst = p_rst + index * ZXDH_HASH_RST_MAX;
+	}
+
+	rc = zxdh_np_dtb_hash_table_dump(0, queue_id, sdt_no, start_index,
+		p_dump_data, &entry_num, &next_start_index, &finish_flag);
+
+	if (entry_num) {
+		rc = zxdh_np_dtb_hash_zcam_del_hw(0, queue_id, sdt_no,
+			entry_num, p_dtb_hash_entry, &element_id);
+	}
+
+	rte_free(p_dtb_hash_entry);
+	rte_free(p_key);
+	rte_free(p_rst);
+
+	return rc;
+}
+
+uint32_t
+zxdh_np_dtb_hash_online_delete(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no)
+{
+	uint32_t rc = 0;
+	uint8_t key_valid = 0;
+	uint32_t table_id = 0;
+	uint32_t key_type = 0;
+
+	ZXDH_D_NODE *p_node = NULL;
+	ZXDH_RB_TN *p_rb_tn = NULL;
+	ZXDH_D_HEAD *p_head_hash_rb = NULL;
+	ZXDH_HASH_CFG *p_hash_cfg = NULL;
+	ZXDH_HASH_RBKEY_INFO *p_rbkey = NULL;
+	HASH_ENTRY_CFG  hash_entry_cfg = {0};
+	ZXDH_DTB_USER_ENTRY_T del_entry = {0};
+	ZXDH_DTB_HASH_ENTRY_INFO_T hash_entry = {0};
+
+	del_entry.sdt_no = sdt_no;
+	del_entry.p_entry_data = &hash_entry;
+
+	rc = zxdh_np_hash_get_hash_info_from_sdt(dev_id, sdt_no, &hash_entry_cfg);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_hash_get_hash_info_from_sdt");
+
+	p_hash_cfg = hash_entry_cfg.p_hash_cfg;
+	ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_hash_cfg);
+
+	p_head_hash_rb = &p_hash_cfg->hash_rb.tn_list;
+	p_node = p_head_hash_rb->p_next;
+	while (p_node) {
+		p_rb_tn = (ZXDH_RB_TN *)p_node->data;
+		ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_rb_tn);
+		p_rbkey = (ZXDH_HASH_RBKEY_INFO *)p_rb_tn->p_key;
+		hash_entry.p_actu_key = p_rbkey->key + 1;
+		hash_entry.p_rst = p_rbkey->key;
+
+		key_valid = ZXDH_GET_HASH_KEY_VALID(p_rbkey->key);
+		table_id = ZXDH_GET_HASH_TBL_ID(p_rbkey->key);
+		key_type = ZXDH_GET_HASH_KEY_TYPE(p_rbkey->key);
+		if (!key_valid ||
+		table_id != hash_entry_cfg.table_id ||
+		key_type != hash_entry_cfg.key_type) {
+			p_node = p_node->next;
+			continue;
+		}
+		p_node = p_node->next;
+
+		rc = zxdh_np_dtb_table_entry_delete(dev_id, queue_id, 1, &del_entry);
+		if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
+			continue;
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_table_entry_delete");
+	}
+
+	return rc;
+}
+
+uint32_t
+zxdh_np_dtb_hash_offline_delete(uint32_t dev_id,
+								uint32_t queue_id,
+								uint32_t sdt_no,
+								__rte_unused uint32_t flush_mode)
+{
+	uint32_t rc = ZXDH_OK;
+
+	rc = zxdh_np_dtb_hash_offline_zcam_delete(dev_id, queue_id, sdt_no);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_hash_offline_zcam_delete");
+
+	return rc;
+}
diff --git a/drivers/net/zxdh/zxdh_np.h b/drivers/net/zxdh/zxdh_np.h
index 0762db5fad..2ba9554684 100644
--- a/drivers/net/zxdh/zxdh_np.h
+++ b/drivers/net/zxdh/zxdh_np.h
@@ -95,6 +95,11 @@
 #define ZXDH_DTB_ITEM_ADD_OR_UPDATE              (0)
 #define ZXDH_DTB_ITEM_DELETE                     (1)
 #define ZXDH_DTB_ZCAM_LEN_SIZE                   (5)
+#define ZXDH_DTB_DUMP_ZCAM_TYPE                  (0)
+#define ZXDH_DTB_DUMP_DDR_TYPE                   (1)
+#define ZXDH_DTB_DMUP_DATA_MAX                   (64 * 1024 * 1024)
+#define ZXDH_DTB_TABLE_DUMP_INFO_BUFF_SIZE       (1024 * 4)
+#define ZXDH_DTB_ETCAM_LEN_SIZE                  (6)
 
 #define ZXDH_ETCAM_LEN_SIZE            (6)
 #define ZXDH_ETCAM_BLOCK_NUM           (8)
@@ -231,6 +236,10 @@
 #define ZXDH_SDT_L_CLUTCH_EN_BT_POS             (0)
 #define ZXDH_SDT_L_CLUTCH_EN_BT_LEN             (1)
 
+/* hash */
+#define ZXDH_SDT_L2_ENTRY_TABLE0                (64)
+#define ZXDH_SDT_MC_TABLE0                      (76)
+
 /**errco code */
 #define ZXDH_RC_BASE                            (0x1000U)
 #define ZXDH_PARAMETER_CHK_BASE                 (ZXDH_RC_BASE            | 0x200)
@@ -1677,6 +1686,11 @@ typedef struct __rte_aligned(2) zxdh_se_stat_cfg_t {
 	uint32_t ppu_ddr_offset;
 } ZXDH_NP_SE_STAT_CFG_T;
 
+typedef struct zxdh_dtb_dump_index_t {
+	uint32_t index;
+	uint32_t index_type;
+} ZXDH_DTB_DUMP_INDEX_T;
+
 int zxdh_np_host_init(uint32_t dev_id, ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl);
 int zxdh_np_online_uninit(uint32_t dev_id, char *port_name, uint32_t queue_id);
 int zxdh_np_dtb_table_entry_write(uint32_t dev_id, uint32_t queue_id,
@@ -1691,5 +1705,10 @@ int zxdh_np_dtb_stats_get(uint32_t dev_id,
 			uint32_t index,
 			uint32_t *p_data);
 uint32_t zxdh_np_se_res_get_and_init(uint32_t dev_id, uint32_t type);
+uint32_t zxdh_np_dtb_hash_online_delete(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no);
+uint32_t zxdh_np_dtb_hash_offline_delete(uint32_t dev_id,
+						uint32_t queue_id,
+						uint32_t sdt_no,
+						__rte_unused uint32_t flush_mode);
 
 #endif /* ZXDH_NP_H */
-- 
2.27.0

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