[PATCH v1 05/14] net/zxdh: add tables dump address ops

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

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

Configure the storage address for
the dtb queue to save tables contents.

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

diff --git a/drivers/net/zxdh/zxdh_np.c b/drivers/net/zxdh/zxdh_np.c
index 1f16f75a23..845d06a056 100644
--- a/drivers/net/zxdh/zxdh_np.c
+++ b/drivers/net/zxdh/zxdh_np.c
@@ -28,6 +28,7 @@ static uint64_t g_np_fw_compat_addr[ZXDH_DEV_CHANNEL_MAX];
 static ZXDH_VERSION_COMPATIBLE_REG_T g_np_sdk_version = {
 	ZXDH_NPSDK_COMPAT_ITEM_ID, 1, 0, 0, 0, {0} };
 uint32_t hardware_ep_id[5] = {5, 6, 7, 8, 9};
+ZXDH_RB_CFG *g_dtb_dump_addr_rb[ZXDH_DEV_CHANNEL_MAX][ZXDH_DTB_QUEUE_NUM_MAX];
 
 ZXDH_FIELD_T g_smmu0_smmu0_cpu_ind_cmd_reg[] = {
 	{"cpu_ind_rw", ZXDH_FIELD_FLAG_RW, 31, 1, 0x0, 0x0},
@@ -347,6 +348,58 @@ zxdh_np_comm_convert32(uint32_t dw_data)
 #define ZXDH_DTB_QUEUE_INIT_FLAG_GET(DEV_ID, QUEUE_ID)       \
 		(p_dpp_dtb_mgr[(DEV_ID)]->queue_info[(QUEUE_ID)].init_flag)
 
+#define ZXDH_DTB_TAB_UP_USER_VIR_ADDR_GET(DEV_ID, QUEUE_ID, INDEX)     \
+		(p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_up.user_addr[INDEX].vir_addr)
+
+#define ZXDH_DTB_TAB_UP_USER_ADDR_FLAG_SET(DEV_ID, QUEUE_ID, INDEX, VAL)     \
+		(p_dpp_dtb_mgr[DEV_ID]->queue_info[QUEUE_ID].tab_up.user_addr[INDEX].user_flag = \
+		VAL)
+
+#define ZXDH_INIT_D_NODE(ptr, pdata) \
+	do {\
+		ZXDH_D_NODE *temp_ptr = ptr;\
+		(temp_ptr)->data = pdata;\
+		(temp_ptr)->prev = NULL;\
+		(temp_ptr)->next = NULL;\
+	} while (0)
+
+#define ZXDH_INIT_RBT_TN(p_tn, p_newkey) \
+	do {\
+		ZXDH_RB_TN *p_temp_tn = p_tn;\
+		(p_temp_tn)->p_key    = p_newkey; \
+		(p_temp_tn)->color_lsv = 0; \
+		(p_temp_tn)->p_left   = NULL; \
+		(p_temp_tn)->p_right  = NULL; \
+		(p_temp_tn)->p_parent = NULL; \
+		ZXDH_INIT_D_NODE(&((p_temp_tn)->tn_ln), (p_temp_tn));\
+	} while (0)
+
+#define ZXDH_GET_TN_LSV(p_tn)   \
+		((p_tn)->color_lsv >> 2)
+
+#define ZXDH_SET_TN_LSV(p_tn, list_val) \
+	do {\
+		ZXDH_RB_TN *p_temp_tn = p_tn;\
+		(p_temp_tn)->color_lsv &= 0x3;\
+		(p_temp_tn)->color_lsv |= ((list_val) << 2); \
+	} while (0)
+
+#define ZXDH_SET_TN_COLOR(p_tn, color) \
+	do {\
+		ZXDH_RB_TN *p_temp_tn = p_tn;\
+		(p_temp_tn)->color_lsv  &= 0xfffffffc;\
+		(p_temp_tn)->color_lsv  |= ((color) & 0x3);\
+	} while (0)
+
+static inline uint32_t
+zxdh_np_get_tn_color(ZXDH_RB_TN *p_tn)
+{
+	return ((p_tn == NULL) ? ZXDH_RBT_BLACK : (p_tn)->color_lsv & 0x3);
+}
+
+#define ZXDH_GET_TN_COLOR(p_tn) \
+	zxdh_np_get_tn_color(p_tn)
+
 static uint32_t
 zxdh_np_comm_mutex_create(ZXDH_MUTEX_T *p_mutex)
 {
@@ -449,6 +502,947 @@ zxdh_np_comm_swap(uint8_t *p_uc_data, uint32_t dw_byte_len)
 	}
 }
 
+static uint32_t
+zxdh_comm_double_link_init(uint32_t elmemtnum, ZXDH_D_HEAD *p_head)
+{
+	uint32_t err_code = 0;
+
+	if (elmemtnum == 0) {
+		err_code = ZXDH_DOUBLE_LINK_INIT_ELEMENT_NUM_ERR;
+		PMD_DRV_LOG(ERR, "Error:[0x%x] doule_link_init Element Num Err !",
+			err_code);
+		return err_code;
+	}
+
+	p_head->maxnum   = elmemtnum;
+	p_head->used	 = 0;
+	p_head->p_next   = NULL;
+	p_head->p_prev   = NULL;
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_np_comm_liststack_creat(uint32_t element_num, ZXDH_LISTSTACK_MANAGER **p_list)
+{
+	ZXDH_LISTSTACK_MANAGER *p_local_list = NULL;
+	uint32_t dw_list_size = 0;
+	uint32_t dw_manage_size = 0;
+	uint32_t dw_actual_element_num = 0;
+	uint32_t i = 0;
+
+	if (p_list == NULL) {
+		PMD_DRV_LOG(INFO, " p_list is NULL!");
+		return ZXDH_LIST_STACK_POINT_NULL;
+	}
+	if (element_num <= 0) {
+		*p_list = NULL;
+		PMD_DRV_LOG(INFO, " FtmComm_ListStackCreat_dwElementNum <=0");
+		return ZXDH_LIST_STACK_ELEMENT_NUM_ERR;
+	}
+
+	if (element_num > ZXDH_LISTSTACK_MAX_ELEMENT - 1)
+		dw_actual_element_num = ZXDH_LISTSTACK_MAX_ELEMENT;
+	else
+		dw_actual_element_num = element_num + 1;
+
+	dw_list_size = (dw_actual_element_num * sizeof(ZXDH_COMM_FREELINK)) & 0xffffffff;
+	dw_manage_size = ((sizeof(ZXDH_LISTSTACK_MANAGER) & 0xFFFFFFFFU) + dw_list_size) &
+		0xffffffff;
+
+	p_local_list = (ZXDH_LISTSTACK_MANAGER *)rte_zmalloc(NULL, dw_manage_size, 0);
+	if (p_local_list == NULL) {
+		*p_list = NULL;
+		PMD_DRV_LOG(ERR, " %s Fail", __func__);
+		return ZXDH_LIST_STACK_ALLOC_MEMORY_FAIL;
+	}
+
+	p_local_list->p_array = (ZXDH_COMM_FREELINK *)((uint8_t *)p_local_list +
+		sizeof(ZXDH_LISTSTACK_MANAGER));
+
+	p_local_list->capacity = dw_actual_element_num;
+	p_local_list->free_num = dw_actual_element_num - 1;
+	p_local_list->used_num = 0;
+
+	for (i = 1; i < (dw_actual_element_num - 1); i++) {
+		p_local_list->p_array[i].index = i;
+		p_local_list->p_array[i].next = i + 1;
+	}
+
+	p_local_list->p_array[0].index = 0;
+	p_local_list->p_array[0].next =  0;
+
+	p_local_list->p_array[dw_actual_element_num - 1].index = dw_actual_element_num - 1;
+	p_local_list->p_array[dw_actual_element_num - 1].next = 0xffffffff;
+
+	p_local_list->p_head = p_local_list->p_array[1].index;
+
+	*p_list = p_local_list;
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_np_comm_liststack_alloc(ZXDH_LISTSTACK_MANAGER *p_list, uint32_t *p_index)
+{
+	uint32_t dw_alloc_index = 0;
+	uint32_t dw_next_free = 0;
+
+	if (p_list == NULL) {
+		*p_index = ZXDH_LISTSTACK_INVALID_INDEX;
+		PMD_DRV_LOG(INFO, " %s! ERROR LINE:%d ", __func__, __LINE__);
+		return ZXDH_LIST_STACK_POINT_NULL;
+	}
+
+	if (p_list->p_head == ZXDH_LISTSTACK_INVALID_INDEX) {
+		*p_index = ZXDH_LISTSTACK_INVALID_INDEX;
+		return ZXDH_LIST_STACK_ISEMPTY_ERR;
+	}
+
+	dw_alloc_index = p_list->p_head;
+
+	dw_next_free = p_list->p_array[dw_alloc_index].next;
+	p_list->p_array[dw_alloc_index].next = ZXDH_LISTSTACK_INVALID_INDEX;
+
+	if (dw_next_free != 0xffffffff)
+		p_list->p_head = p_list->p_array[dw_next_free].index;
+	else
+		p_list->p_head = ZXDH_LISTSTACK_INVALID_INDEX;
+
+	*p_index = dw_alloc_index - 1;
+
+	p_list->free_num--;
+	p_list->used_num++;
+
+	if (p_list->free_num == 0 || (p_list->used_num == (p_list->capacity - 1)))
+		p_list->p_head = ZXDH_LISTSTACK_INVALID_INDEX;
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_liststack_free(ZXDH_LISTSTACK_MANAGER *p_list, uint32_t index)
+{
+	uint32_t	 dw_free_index = 0;
+	uint32_t	 dw_prev_free  = 0;
+	uint32_t	 dw_index	  = 0;
+
+	dw_index	  = index + 1;
+
+	if (p_list == NULL) {
+		PMD_DRV_LOG(INFO, " %s is null! LINE:%d ", __func__, __LINE__);
+		return ZXDH_LIST_STACK_POINT_NULL;
+	}
+
+	if (dw_index >= p_list->capacity) {
+		PMD_DRV_LOG(INFO, " %s is null! LINE:%d ", __func__, __LINE__);
+		return ZXDH_LIST_STACK_FREE_INDEX_INVALID;
+	}
+
+	if (p_list->p_array[dw_index].next != ZXDH_LISTSTACK_INVALID_INDEX)
+		return ZXDH_OK;
+
+	dw_free_index = dw_index;
+	dw_prev_free = p_list->p_head;
+
+	if (dw_prev_free != 0)
+		p_list->p_array[dw_free_index].next =  p_list->p_array[dw_prev_free].index;
+	else
+		p_list->p_array[dw_free_index].next = 0xffffffff;
+
+	p_list->p_head = p_list->p_array[dw_free_index].index;
+
+	p_list->free_num++;
+	p_list->used_num--;
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_double_link_insert_1st(ZXDH_D_NODE *p_newnode, ZXDH_D_HEAD *p_head)
+{
+	RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
+	RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
+
+	p_newnode->next = p_head->p_next;
+	p_newnode->prev = NULL;
+
+	if (p_head->p_next)
+		p_head->p_next->prev = p_newnode;
+	else
+		p_head->p_prev = p_newnode;
+
+	p_head->p_next = p_newnode;
+	p_head->used++;
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_double_link_insert_aft(ZXDH_D_NODE *p_newnode,
+								ZXDH_D_NODE *p_oldnode,
+								ZXDH_D_HEAD *p_head)
+{
+	RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
+	RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
+
+	p_newnode->next = p_oldnode->next;
+	p_newnode->prev = p_oldnode;
+
+	if (p_oldnode->next)
+		p_oldnode->next->prev = p_newnode;
+	else
+		p_head->p_prev = p_newnode;
+
+	p_oldnode->next = p_newnode;
+	p_head->used++;
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_double_link_insert_pre(ZXDH_D_NODE *p_newnode,
+	ZXDH_D_NODE *p_oldnode, ZXDH_D_HEAD *p_head)
+{
+	RTE_ASSERT(!(!p_head->p_next && p_head->p_prev));
+	RTE_ASSERT(!(p_head->p_next && !p_head->p_prev));
+
+	p_newnode->next = p_oldnode;
+	p_newnode->prev = p_oldnode->prev;
+
+	if (p_oldnode->prev)
+		p_oldnode->prev->next = p_newnode;
+	else
+		p_head->p_next = p_newnode;
+
+	p_oldnode->prev = 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)
+{
+	ZXDH_D_NODE *next = NULL;
+	ZXDH_D_NODE *pre  = NULL;
+
+	next = delnode->next;
+	pre  = delnode->prev;
+
+	if (next)
+		next->prev = delnode->prev;
+	else
+		p_head->p_prev = delnode->prev;
+
+	if (pre)
+		pre->next = delnode->next;
+	else
+		p_head->p_next = delnode->next;
+
+	p_head->used--;
+	delnode->next = NULL;
+	delnode->prev = NULL;
+	return ZXDH_OK;
+}
+
+static int32_t
+zxdh_comm_rb_def_cmp(void *p_new, void *p_old, uint32_t key_size)
+{
+	return memcmp(p_new, p_old, key_size);
+}
+
+static void
+zxdh_comm_rb_swich_color(ZXDH_RB_TN  *p_tn1, ZXDH_RB_TN *p_tn2)
+{
+	uint32_t color1, color2;
+
+	color1 = ZXDH_GET_TN_COLOR(p_tn1);
+	color2 = ZXDH_GET_TN_COLOR(p_tn2);
+
+	ZXDH_SET_TN_COLOR(p_tn1, color2);
+	ZXDH_SET_TN_COLOR(p_tn2, color1);
+}
+
+static ZXDH_RB_TN *
+zxdh_comm_rb_get_brotn(ZXDH_RB_TN *p_cur_tn)
+{
+	return (p_cur_tn->p_parent->p_left == p_cur_tn) ? p_cur_tn->p_parent->p_right :
+		p_cur_tn->p_parent->p_left;
+}
+
+static uint32_t
+zxdh_comm_rb_handle_ins(__rte_unused ZXDH_RB_CFG *p_rb_cfg,
+						ZXDH_RB_TN  ***stack_tn,
+						uint32_t	  stack_top)
+{
+	ZXDH_RB_TN  **pp_cur_tn		= NULL;
+	ZXDH_RB_TN  *p_cur_tn		  = NULL;
+	ZXDH_RB_TN  **pp_tmp_tn		= NULL;
+	ZXDH_RB_TN  *p_tmp_tn		  = NULL;
+
+	while (stack_top > 0) {
+		pp_cur_tn = stack_tn[stack_top];
+		p_cur_tn  = *pp_cur_tn;
+
+		if (!p_cur_tn->p_parent) {
+			ZXDH_SET_TN_COLOR(p_cur_tn, ZXDH_RBT_BLACK);
+			break;
+		} else if (ZXDH_GET_TN_COLOR(p_cur_tn->p_parent) == ZXDH_RBT_RED) {
+			ZXDH_RB_TN *p_unc_tn = zxdh_comm_rb_get_brotn(p_cur_tn->p_parent);
+
+			RTE_ASSERT(p_cur_tn->p_parent == *stack_tn[stack_top - 1]);
+
+			if (ZXDH_GET_TN_COLOR(p_unc_tn) == ZXDH_RBT_RED) {
+				RTE_ASSERT(p_unc_tn);
+				ZXDH_SET_TN_COLOR(p_cur_tn->p_parent, ZXDH_RBT_BLACK);
+				ZXDH_SET_TN_COLOR(p_unc_tn, ZXDH_RBT_BLACK);
+
+				RTE_ASSERT(p_cur_tn->p_parent->p_parent ==
+					*stack_tn[stack_top - 2]);
+
+				ZXDH_SET_TN_COLOR(p_cur_tn->p_parent->p_parent, ZXDH_RBT_RED);
+				stack_top -= 2;
+			} else {
+				ZXDH_RB_TN *p_bro_tn = NULL;
+
+				pp_tmp_tn = stack_tn[stack_top - 2];
+				p_tmp_tn  = *pp_tmp_tn;
+
+				if (p_cur_tn->p_parent == p_tmp_tn->p_left && p_cur_tn ==
+				p_cur_tn->p_parent->p_left) {
+					*pp_tmp_tn = p_cur_tn->p_parent;
+
+					p_bro_tn  = zxdh_comm_rb_get_brotn(p_cur_tn);
+					p_cur_tn->p_parent->p_parent = p_tmp_tn->p_parent;
+
+					p_tmp_tn->p_left   = p_bro_tn;
+					p_tmp_tn->p_parent = p_cur_tn->p_parent;
+					p_cur_tn->p_parent->p_right = p_tmp_tn;
+
+					if (p_bro_tn)
+						p_bro_tn->p_parent  = p_tmp_tn;
+
+					zxdh_comm_rb_swich_color(*pp_tmp_tn, p_tmp_tn);
+				} else if (p_cur_tn->p_parent == p_tmp_tn->p_left && p_cur_tn ==
+				p_cur_tn->p_parent->p_right) {
+					*pp_tmp_tn = p_cur_tn;
+
+					p_cur_tn->p_parent->p_right = p_cur_tn->p_left;
+
+					if (p_cur_tn->p_left)
+						p_cur_tn->p_left->p_parent = p_cur_tn->p_parent;
+
+					p_cur_tn->p_parent->p_parent = p_cur_tn;
+					p_tmp_tn->p_left = p_cur_tn->p_right;
+
+					if (p_cur_tn->p_right)
+						p_cur_tn->p_right->p_parent = p_tmp_tn;
+
+					p_cur_tn->p_left = p_cur_tn->p_parent;
+					p_cur_tn->p_right = p_tmp_tn;
+
+					p_cur_tn->p_parent = p_tmp_tn->p_parent;
+					p_tmp_tn->p_parent = p_cur_tn;
+
+					zxdh_comm_rb_swich_color(*pp_tmp_tn, p_tmp_tn);
+				} else if (p_cur_tn->p_parent == p_tmp_tn->p_right && p_cur_tn ==
+				p_cur_tn->p_parent->p_right) {
+					*pp_tmp_tn = p_cur_tn->p_parent;
+					p_bro_tn  = zxdh_comm_rb_get_brotn(p_cur_tn);
+
+					p_cur_tn->p_parent->p_parent = p_tmp_tn->p_parent;
+
+					p_tmp_tn->p_right = p_cur_tn->p_parent->p_left;
+					p_tmp_tn->p_parent = p_cur_tn->p_parent;
+					p_cur_tn->p_parent->p_left = p_tmp_tn;
+
+					if (p_bro_tn)
+						p_bro_tn->p_parent  = p_tmp_tn;
+
+					zxdh_comm_rb_swich_color(*pp_tmp_tn, p_tmp_tn);
+				} else {
+					*pp_tmp_tn = p_cur_tn;
+					p_cur_tn->p_parent->p_left = p_cur_tn->p_right;
+
+					if (p_cur_tn->p_right)
+						p_cur_tn->p_right->p_parent = p_cur_tn->p_parent;
+
+					p_cur_tn->p_parent->p_parent = p_cur_tn;
+					p_tmp_tn->p_right = p_cur_tn->p_left;
+
+					if (p_cur_tn->p_left)
+						p_cur_tn->p_left->p_parent = p_tmp_tn;
+
+					p_cur_tn->p_right = p_cur_tn->p_parent;
+					p_cur_tn->p_left = p_tmp_tn;
+
+					p_cur_tn->p_parent = p_tmp_tn->p_parent;
+					p_tmp_tn->p_parent = p_cur_tn;
+
+					zxdh_comm_rb_swich_color(*pp_tmp_tn, p_tmp_tn);
+				}
+				break;
+			}
+		} else {
+			break;
+		}
+	}
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_rb_init(ZXDH_RB_CFG *p_rb_cfg,
+				uint32_t	  total_num,
+				uint32_t	  key_size,
+				ZXDH_RB_CMPFUN cmpfun)
+{
+	uint32_t	  rtn  = ZXDH_OK;
+	uint32_t	  malloc_size = 0;
+
+	if (p_rb_cfg->is_init) {
+		PMD_DRV_LOG(ERR, " %s already init!", __func__);
+		return ZXDH_OK;
+	}
+
+	p_rb_cfg->key_size =  key_size;
+	p_rb_cfg->p_root   =  NULL;
+
+	if (cmpfun)
+		p_rb_cfg->p_cmpfun =  cmpfun;
+	else
+		p_rb_cfg->p_cmpfun = zxdh_comm_rb_def_cmp;
+
+	if (total_num) {
+		p_rb_cfg->is_dynamic = 0;
+
+		rtn = zxdh_comm_double_link_init(total_num, &p_rb_cfg->tn_list);
+		ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_init");
+
+		rtn = zxdh_np_comm_liststack_creat(total_num, &p_rb_cfg->p_lsm);
+		ZXDH_COMM_CHECK_RC(rtn, "zxdh_np_comm_liststack_creat");
+
+		p_rb_cfg->p_keybase = (uint8_t *)rte_zmalloc(NULL,
+			total_num * p_rb_cfg->key_size, 0);
+		if (p_rb_cfg->p_keybase == NULL) {
+			PMD_DRV_LOG(ERR, "%s point null!", __func__);
+			return ZXDH_PAR_CHK_POINT_NULL;
+		}
+
+		malloc_size = ((sizeof(ZXDH_RB_TN) & 0xFFFFFFFFU) * total_num) & UINT32_MAX;
+
+		p_rb_cfg->p_tnbase  = (ZXDH_RB_TN *)rte_zmalloc(NULL, malloc_size, 0);
+		if (p_rb_cfg->p_tnbase == NULL) {
+			PMD_DRV_LOG(ERR, "%s point null!", __func__);
+			return ZXDH_PAR_CHK_POINT_NULL;
+		}
+	} else {
+		p_rb_cfg->is_dynamic = 1;
+
+		rtn = zxdh_comm_double_link_init(0xFFFFFFFF, &p_rb_cfg->tn_list);
+		ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_init");
+	}
+	p_rb_cfg->is_init = 1;
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_rb_insert(ZXDH_RB_CFG *p_rb_cfg,
+						 void	   *p_key,
+						 void	   *out_val)
+{
+	uint32_t	 rtn			= 0;
+	uint32_t	 stack_top	  = 1;
+	int32_t		 cmprtn		 = 0;
+	uint32_t	 lsm_out		= 0;
+
+	ZXDH_RB_TN  **stack_tn[ZXDH_RBT_MAX_DEPTH] = {0};
+	ZXDH_RB_TN  *p_cur_tn	  = NULL;
+	ZXDH_RB_TN  *p_pre_tn	  = NULL;
+	ZXDH_RB_TN **pp_cur_tn	 = NULL;
+	void	   *p_cur_key	 = NULL;
+	ZXDH_RB_TN  *p_ins_tn	  = p_key;
+
+	p_cur_key = p_rb_cfg->is_dynamic ? ((ZXDH_RB_TN *)p_key)->p_key : p_key;
+
+	pp_cur_tn = &p_rb_cfg->p_root;
+
+	for (;;) {
+		p_cur_tn = *pp_cur_tn;
+
+		if (!p_cur_tn) {
+			if (p_rb_cfg->is_dynamic == 0) {
+				rtn = zxdh_np_comm_liststack_alloc(p_rb_cfg->p_lsm, &lsm_out);
+
+				if (rtn == ZXDH_LIST_STACK_ISEMPTY_ERR)
+					return ZXDH_RBT_RC_FULL;
+
+				ZXDH_COMM_CHECK_RC(rtn, "zxdh_np_comm_liststack_alloc");
+
+				p_ins_tn = p_rb_cfg->p_tnbase + lsm_out;
+
+				ZXDH_INIT_RBT_TN(p_ins_tn, p_rb_cfg->key_size * lsm_out +
+					p_rb_cfg->p_keybase);
+
+				rte_memcpy(p_ins_tn->p_key, p_key, p_rb_cfg->key_size);
+
+				ZXDH_SET_TN_LSV(p_ins_tn, lsm_out);
+
+				if (out_val)
+					*((uint32_t *)out_val) = lsm_out;
+			} else {
+				ZXDH_INIT_D_NODE(&p_ins_tn->tn_ln, p_ins_tn);
+			}
+
+			ZXDH_SET_TN_COLOR(p_ins_tn, ZXDH_RBT_RED);
+
+			if (cmprtn < 0) {
+				rtn = zxdh_comm_double_link_insert_pre(&p_ins_tn->tn_ln,
+					&p_pre_tn->tn_ln, &p_rb_cfg->tn_list);
+				ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_insert_pre");
+			} else if (cmprtn > 0) {
+				rtn = zxdh_comm_double_link_insert_aft(&p_ins_tn->tn_ln,
+					&p_pre_tn->tn_ln, &p_rb_cfg->tn_list);
+				ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_insert_aft");
+			} else {
+				RTE_ASSERT(!p_pre_tn);
+
+				rtn = zxdh_comm_double_link_insert_1st(&p_ins_tn->tn_ln,
+					&p_rb_cfg->tn_list);
+				ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_insert_1st");
+			}
+
+			break;
+		}
+
+		stack_tn[stack_top++] =  pp_cur_tn;
+		p_pre_tn = p_cur_tn;
+		cmprtn = p_rb_cfg->p_cmpfun(p_cur_key, p_cur_tn->p_key, p_rb_cfg->key_size);
+
+		if (cmprtn > 0) {
+			pp_cur_tn = &p_cur_tn->p_right;
+		} else if (cmprtn < 0) {
+			pp_cur_tn = &p_cur_tn->p_left;
+		} else {
+			PMD_DRV_LOG(INFO, "info , rb_key is same");
+
+			if (p_rb_cfg->is_dynamic) {
+				if (out_val)
+					*((ZXDH_RB_TN **)out_val) = p_cur_tn;
+			} else {
+				if (out_val)
+					*((uint32_t *)out_val) = ZXDH_GET_TN_LSV(p_cur_tn);
+			}
+
+			return ZXDH_RBT_RC_UPDATE;
+		}
+	}
+
+	p_ins_tn->p_parent = (stack_top > 1) ? *stack_tn[stack_top - 1] : NULL;
+	stack_tn[stack_top] = pp_cur_tn;
+
+	*pp_cur_tn = p_ins_tn;
+
+	rtn = zxdh_comm_rb_handle_ins(p_rb_cfg, stack_tn, stack_top);
+	ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_rb_handle_ins");
+
+	if (p_rb_cfg->is_dynamic) {
+		if (out_val)
+			*((ZXDH_RB_TN **)out_val) = p_ins_tn;
+	}
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_rb_handle_del(__rte_unused ZXDH_RB_CFG *p_rb_cfg,
+							ZXDH_RB_TN ***stack_tn,
+							uint32_t   stack_top)
+{
+	ZXDH_RB_TN  **pp_cur_tn		= NULL;
+	ZXDH_RB_TN  *p_cur_tn		  = NULL;
+	ZXDH_RB_TN  *p_tmp_tn		  = NULL;
+	ZXDH_RB_TN  *p_unc_tn		  = NULL;
+	ZXDH_RB_TN  *p_par_tn		  = NULL;
+
+	while (stack_top > 1) {
+		pp_cur_tn =  stack_tn[stack_top];
+		p_cur_tn  = *pp_cur_tn;
+
+		p_par_tn  = *stack_tn[stack_top - 1];
+
+		if (p_cur_tn && p_cur_tn->p_parent) {
+			p_unc_tn  = zxdh_comm_rb_get_brotn(p_cur_tn);
+		} else if (p_cur_tn && !p_cur_tn->p_parent) {
+			RTE_ASSERT(p_par_tn == p_cur_tn->p_parent);
+
+			ZXDH_SET_TN_COLOR(p_cur_tn, ZXDH_RBT_BLACK);
+
+			break;
+		}
+		if (!p_cur_tn) {
+			RTE_ASSERT(!p_cur_tn);
+
+			if (p_par_tn)
+				p_unc_tn = p_par_tn->p_left ? p_par_tn->p_left : p_par_tn->p_right;
+			else
+				break;
+		}
+
+		if (p_unc_tn)
+			RTE_ASSERT(p_unc_tn->p_parent == p_par_tn);
+
+		if (!p_unc_tn) {
+			RTE_ASSERT(0);
+			RTE_ASSERT(ZXDH_GET_TN_COLOR(p_par_tn) ==  ZXDH_RBT_RED);
+
+			ZXDH_SET_TN_COLOR(p_par_tn, ZXDH_RBT_BLACK);
+
+			break;
+		}
+		if (ZXDH_GET_TN_COLOR(p_unc_tn) == ZXDH_RBT_RED) {
+			if (p_unc_tn == p_par_tn->p_left) {
+				*stack_tn[stack_top - 1] = p_unc_tn;
+				p_unc_tn->p_parent = p_par_tn->p_parent;
+				p_par_tn->p_left = p_unc_tn->p_right;
+
+				if (p_unc_tn->p_right)
+					p_unc_tn->p_right->p_parent = p_par_tn;
+
+				p_par_tn->p_parent = p_unc_tn;
+				p_unc_tn->p_right = p_par_tn;
+
+				stack_tn[stack_top++] = &p_unc_tn->p_right;
+				stack_tn[stack_top]   = &p_par_tn->p_right;
+			} else {
+				RTE_ASSERT(p_unc_tn == p_par_tn->p_right);
+				*stack_tn[stack_top - 1] = p_unc_tn;
+				p_unc_tn->p_parent = p_par_tn->p_parent;
+				p_par_tn->p_right = p_unc_tn->p_left;
+
+				if (p_unc_tn->p_left)
+					p_unc_tn->p_left->p_parent = p_par_tn;
+
+				p_par_tn->p_parent = p_unc_tn;
+				p_unc_tn->p_left  = p_par_tn;
+
+				stack_tn[stack_top++] = &p_unc_tn->p_left;
+				stack_tn[stack_top]   = &p_par_tn->p_left;
+			}
+
+			zxdh_comm_rb_swich_color(p_unc_tn, p_par_tn);
+		} else {
+			if (ZXDH_GET_TN_COLOR(p_unc_tn->p_left) == ZXDH_RBT_BLACK &&
+			ZXDH_GET_TN_COLOR(p_unc_tn->p_right) == ZXDH_RBT_BLACK) {
+				if (ZXDH_GET_TN_COLOR(p_unc_tn->p_parent) == ZXDH_RBT_BLACK) {
+					ZXDH_SET_TN_COLOR(p_unc_tn, ZXDH_RBT_RED);
+					stack_top--;
+				} else {
+					RTE_ASSERT(ZXDH_GET_TN_COLOR(p_unc_tn->p_parent)
+						== ZXDH_RBT_RED);
+
+					zxdh_comm_rb_swich_color(p_unc_tn->p_parent, p_unc_tn);
+
+					break;
+				}
+			} else if (p_unc_tn == p_par_tn->p_right) {
+				if (ZXDH_GET_TN_COLOR(p_unc_tn->p_right) == ZXDH_RBT_RED) {
+					*stack_tn[stack_top - 1] = p_unc_tn;
+					p_unc_tn->p_parent = p_par_tn->p_parent;
+					p_par_tn->p_right = p_unc_tn->p_left;
+
+					if (p_unc_tn->p_left)
+						p_unc_tn->p_left->p_parent = p_par_tn;
+
+					p_par_tn->p_parent = p_unc_tn;
+					p_unc_tn->p_left  = p_par_tn;
+
+					zxdh_comm_rb_swich_color(p_unc_tn, p_par_tn);
+
+					ZXDH_SET_TN_COLOR(p_unc_tn->p_right, ZXDH_RBT_BLACK);
+
+					break;
+				}
+				RTE_ASSERT(ZXDH_GET_TN_COLOR(p_unc_tn->p_left)
+					== ZXDH_RBT_RED);
+
+				p_tmp_tn = p_unc_tn->p_left;
+
+				p_par_tn->p_right  = p_tmp_tn;
+				p_tmp_tn->p_parent = p_par_tn;
+				p_unc_tn->p_left  = p_tmp_tn->p_right;
+
+				if (p_tmp_tn->p_right)
+					p_tmp_tn->p_right->p_parent = p_unc_tn;
+
+				p_tmp_tn->p_right = p_unc_tn;
+				p_unc_tn->p_parent = p_tmp_tn;
+
+				zxdh_comm_rb_swich_color(p_tmp_tn, p_unc_tn);
+			} else {
+				RTE_ASSERT(p_unc_tn == p_par_tn->p_left);
+
+				if (ZXDH_GET_TN_COLOR(p_unc_tn->p_left) == ZXDH_RBT_RED) {
+					*stack_tn[stack_top - 1] = p_unc_tn;
+					p_unc_tn->p_parent = p_par_tn->p_parent;
+					p_par_tn->p_left  = p_unc_tn->p_right;
+
+					if (p_unc_tn->p_right)
+						p_unc_tn->p_right->p_parent = p_par_tn;
+
+					p_par_tn->p_parent = p_unc_tn;
+					p_unc_tn->p_right = p_par_tn;
+
+					zxdh_comm_rb_swich_color(p_unc_tn, p_par_tn);
+
+					ZXDH_SET_TN_COLOR(p_unc_tn->p_left, ZXDH_RBT_BLACK);
+					break;
+				}
+				RTE_ASSERT(ZXDH_GET_TN_COLOR(p_unc_tn->p_right)
+					== ZXDH_RBT_RED);
+
+				p_tmp_tn = p_unc_tn->p_right;
+
+				p_par_tn->p_left  = p_tmp_tn;
+				p_tmp_tn->p_parent = p_par_tn;
+				p_unc_tn->p_right  = p_tmp_tn->p_left;
+
+				if (p_tmp_tn->p_left)
+					p_tmp_tn->p_left->p_parent = p_unc_tn;
+
+				p_tmp_tn->p_left = p_unc_tn;
+				p_unc_tn->p_parent = p_tmp_tn;
+
+				zxdh_comm_rb_swich_color(p_tmp_tn, p_unc_tn);
+			}
+		}
+	}
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_rb_delete(ZXDH_RB_CFG *p_rb_cfg,
+						 void	   *p_key,
+						 void	   *out_val)
+{
+	uint32_t	 rtn			= 0;
+	uint32_t	 stack_top	  = 1;
+	int32_t	cmprtn		 = 0;
+	uint32_t	 rsv_stack	  = 0;
+	uint32_t	 del_is_red	 = 0;
+	ZXDH_RB_TN  **stack_tn[ZXDH_RBT_MAX_DEPTH] = {0};
+	ZXDH_RB_TN  *p_cur_tn	  = NULL;
+	ZXDH_RB_TN **pp_cur_tn	 = NULL;
+	void	   *p_cur_key	 = NULL;
+	ZXDH_RB_TN  *p_rsv_tn	  = NULL;
+	ZXDH_RB_TN  *p_del_tn	  = NULL;
+
+	p_cur_key = p_key;
+
+	pp_cur_tn = &p_rb_cfg->p_root;
+
+	for (;;) {
+		p_cur_tn = *pp_cur_tn;
+
+		if (!p_cur_tn)
+			return ZXDH_RBT_RC_SRHFAIL;
+
+		stack_tn[stack_top++] = pp_cur_tn;
+
+		cmprtn = p_rb_cfg->p_cmpfun(p_cur_key, p_cur_tn->p_key, p_rb_cfg->key_size);
+
+		if (cmprtn > 0) {
+			pp_cur_tn = &p_cur_tn->p_right;
+		} else if (cmprtn < 0) {
+			pp_cur_tn = &p_cur_tn->p_left;
+		} else {
+			PMD_DRV_LOG(DEBUG, " find the key!");
+
+			break;
+		}
+	}
+
+	rsv_stack =  stack_top - 1;
+	p_rsv_tn  =  p_cur_tn;
+
+	pp_cur_tn = &p_cur_tn->p_right;
+	p_cur_tn  = *pp_cur_tn;
+
+	if (p_cur_tn) {
+		stack_tn[stack_top++] = pp_cur_tn;
+
+		pp_cur_tn = &p_cur_tn->p_left;
+		p_cur_tn  = *pp_cur_tn;
+
+		while (p_cur_tn) {
+			stack_tn[stack_top++] = pp_cur_tn;
+			pp_cur_tn = &p_cur_tn->p_left;
+			p_cur_tn  = *pp_cur_tn;
+		}
+
+		p_del_tn = *stack_tn[stack_top - 1];
+
+		*stack_tn[stack_top - 1] = p_del_tn->p_right;
+
+		if (p_del_tn->p_right)
+			p_del_tn->p_right->p_parent =  p_del_tn->p_parent;
+
+		if (ZXDH_GET_TN_COLOR(p_del_tn) == ZXDH_RBT_RED)
+			del_is_red = 1;
+
+		*stack_tn[rsv_stack]   = p_del_tn;
+
+		stack_tn[rsv_stack + 1]  = &p_del_tn->p_right;
+
+		ZXDH_SET_TN_COLOR(p_del_tn, ZXDH_GET_TN_COLOR(p_rsv_tn));
+		p_del_tn->p_parent = p_rsv_tn->p_parent;
+
+		p_del_tn->p_left   = p_rsv_tn->p_left;
+
+		if (p_rsv_tn->p_left)
+			p_rsv_tn->p_left->p_parent = p_del_tn;
+
+		p_del_tn->p_right  = p_rsv_tn->p_right;
+
+		if (p_rsv_tn->p_right)
+			p_rsv_tn->p_right->p_parent = p_del_tn;
+	} else {
+		if (ZXDH_GET_TN_COLOR(p_rsv_tn) == ZXDH_RBT_RED)
+			del_is_red = 1;
+
+		*stack_tn[stack_top - 1] = p_rsv_tn->p_left;
+
+		if (p_rsv_tn->p_left)
+			p_rsv_tn->p_left->p_parent = p_rsv_tn->p_parent;
+	}
+
+	stack_top--;
+	if (ZXDH_GET_TN_COLOR(*stack_tn[stack_top]) == ZXDH_RBT_RED) {
+		ZXDH_SET_TN_COLOR(*stack_tn[stack_top], ZXDH_RBT_BLACK);
+	} else if (!del_is_red) {
+		rtn = zxdh_comm_rb_handle_del(p_rb_cfg, stack_tn, stack_top);
+		ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_rb_handle_del");
+	}
+
+	rtn = zxdh_comm_double_link_del(&p_rsv_tn->tn_ln, &p_rb_cfg->tn_list);
+	ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_double_link_del");
+
+	if (p_rb_cfg->is_dynamic) {
+		*(ZXDH_RB_TN **)out_val = p_rsv_tn;
+	} else {
+		rtn = zxdh_comm_liststack_free(p_rb_cfg->p_lsm, ZXDH_GET_TN_LSV(p_rsv_tn));
+		ZXDH_COMM_CHECK_RC(rtn, "zxdh_comm_liststack_free");
+
+		*(uint32_t *)out_val = ZXDH_GET_TN_LSV(p_rsv_tn);
+
+		memset(p_rsv_tn->p_key, 0, p_rb_cfg->key_size);
+		memset(p_rsv_tn, 0, sizeof(ZXDH_RB_TN));
+	}
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_liststack_destroy(ZXDH_LISTSTACK_MANAGER *p_list)
+{
+	if (p_list == NULL) {
+		PMD_DRV_LOG(INFO, " %s! LINE:%d ", __func__, __LINE__);
+		return ZXDH_LIST_STACK_POINT_NULL;
+	}
+	rte_free(p_list);
+
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_comm_rb_destroy(ZXDH_RB_CFG *p_rb_cfg)
+{
+	uint32_t	   rtn	 = 0;
+
+	if (p_rb_cfg->is_dynamic == 0)
+		zxdh_comm_liststack_destroy(p_rb_cfg->p_lsm);
+
+	if (p_rb_cfg->p_keybase != NULL) {
+		rte_free(p_rb_cfg->p_keybase);
+		p_rb_cfg->p_keybase = NULL;
+	}
+
+	if (p_rb_cfg->p_tnbase != NULL) {
+		rte_free(p_rb_cfg->p_tnbase);
+		p_rb_cfg->p_tnbase = NULL;
+	}
+
+	memset(p_rb_cfg, 0, sizeof(ZXDH_RB_CFG));
+
+	return rtn;
+}
+
+static int
+zxdh_np_se_apt_key_default_cmp(void *p_new_key,
+	void *p_old_key, __rte_unused uint32_t key_len)
+{
+	return memcmp((uint32_t *)p_new_key, (uint32_t *)p_old_key, sizeof(uint32_t));
+}
+
+static uint32_t
+zxdh_np_se_apt_rb_insert(ZXDH_RB_CFG *rb_cfg, void *p_data, uint32_t len)
+{
+	uint8_t *p_rb_key		 = NULL;
+	ZXDH_RB_TN *p_rb_new	 = NULL;
+	ZXDH_RB_TN *p_rb_rtn	 = NULL;
+	uint32_t rc				 = ZXDH_OK;
+
+	p_rb_key = (uint8_t *)rte_zmalloc(NULL, len, 0);
+	if (p_rb_key == NULL) {
+		PMD_DRV_LOG(ERR, "%s point null!", __func__);
+		return ZXDH_PAR_CHK_POINT_NULL;
+	}
+	rte_memcpy(p_rb_key, p_data, len);
+
+	p_rb_new = (ZXDH_RB_TN *)rte_zmalloc(NULL, sizeof(ZXDH_RB_TN), 0);
+	if (NULL == (p_rb_new)) {
+		rte_free(p_rb_key);
+		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_new, p_rb_key);
+
+	rc = zxdh_comm_rb_insert(rb_cfg, p_rb_new, &p_rb_rtn);
+	if (rc == ZXDH_RBT_RC_UPDATE) {
+		if (p_rb_rtn == NULL) {
+			PMD_DRV_LOG(ERR, "p_rb_rtn point null!");
+			return ZXDH_PAR_CHK_POINT_NULL;
+		}
+
+		rte_memcpy(p_rb_rtn->p_key, p_data, len);
+		rte_free(p_rb_new);
+		rte_free(p_rb_key);
+		PMD_DRV_LOG(DEBUG, "update exist entry!");
+		return ZXDH_OK;
+	}
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_se_apt_rb_delete(ZXDH_RB_CFG *rb_cfg, void *p_data, __rte_unused uint32_t len)
+{
+	uint32_t rc = ZXDH_OK;
+	ZXDH_RB_TN *p_rb_rtn	 = NULL;
+
+	rc = zxdh_comm_rb_delete(rb_cfg, p_data, &p_rb_rtn);
+	if (rc != ZXDH_OK)
+		return rc;
+	rte_free(p_rb_rtn->p_key);
+	rte_free(p_rb_rtn);
+
+	return rc;
+}
+
 static uint32_t
 zxdh_np_dev_init(void)
 {
@@ -1954,10 +2948,112 @@ zxdh_np_dtb_queue_id_free(uint32_t dev_id,
 
 	rc = zxdh_np_dtb_queue_unused_item_num_get(dev_id, queue_id, &item_num);
 
+	if (item_num != ZXDH_DTB_QUEUE_ITEM_NUM_MAX)
+		return ZXDH_RC_DTB_QUEUE_IS_WORKING;
+
 	p_dtb_mgr->queue_info[queue_id].init_flag = 0;
 	p_dtb_mgr->queue_info[queue_id].vport = 0;
 	p_dtb_mgr->queue_info[queue_id].vector = 0;
 
+	memset(&p_dtb_mgr->queue_info[queue_id].tab_up, 0, sizeof(ZXDH_DTB_TAB_UP_INFO_T));
+	memset(&p_dtb_mgr->queue_info[queue_id].tab_down, 0, sizeof(ZXDH_DTB_TAB_DOWN_INFO_T));
+
+	return rc;
+}
+
+static ZXDH_RB_CFG *
+zxdh_np_dtb_dump_addr_rb_get(uint32_t dev_id, uint32_t queue_id)
+{
+	return g_dtb_dump_addr_rb[dev_id][queue_id];
+}
+
+static uint32_t
+zxdh_np_dtb_dump_addr_rb_set(uint32_t dev_id, uint32_t queue_id, ZXDH_RB_CFG *p_dump_addr_rb)
+{
+	g_dtb_dump_addr_rb[dev_id][queue_id] = p_dump_addr_rb;
+	return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_np_dtb_dump_sdt_addr_clear(uint32_t dev_id,
+								uint32_t queue_id,
+								uint32_t sdt_no)
+{
+	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_delete(p_dtb_dump_addr_rb, &dtb_dump_addr_info,
+		sizeof(ZXDH_DTB_ADDR_INFO_T));
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_apt_rb_delete");
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_dtb_dump_addr_rb_destroy(uint32_t dev_id, uint32_t queue_id)
+{
+	uint32_t rc = ZXDH_OK;
+	ZXDH_D_NODE *p_node = NULL;
+	ZXDH_RB_TN *p_rb_tn = NULL;
+	ZXDH_DTB_ADDR_INFO_T *p_rbkey = NULL;
+	ZXDH_D_HEAD *p_head_dtb_rb = NULL;
+	ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
+	uint32_t sdt_no = 0;
+
+	p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
+	ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dtb_dump_addr_rb);
+
+	p_head_dtb_rb = &p_dtb_dump_addr_rb->tn_list;
+
+	while (p_head_dtb_rb->used) {
+		p_node = p_head_dtb_rb->p_next;
+		p_rb_tn = (ZXDH_RB_TN *)p_node->data;
+		p_rbkey = (ZXDH_DTB_ADDR_INFO_T *)p_rb_tn->p_key;
+
+		sdt_no = p_rbkey->sdt_no;
+		rc = zxdh_np_dtb_dump_sdt_addr_clear(dev_id, queue_id, sdt_no);
+
+		if (rc == ZXDH_HASH_RC_DEL_SRHFAIL)
+			PMD_DRV_LOG(ERR, "dtb dump delete key is not exist,"
+				"std:%d", sdt_no);
+		else
+			ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_clear");
+	}
+
+	rc  =  zxdh_comm_rb_destroy(p_dtb_dump_addr_rb);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
+
+	return rc;
+}
+
+static uint32_t
+zxdh_np_dtb_dump_addr_rb_init(uint32_t dev_id, uint32_t queue_id)
+{
+	uint32_t rc = ZXDH_OK;
+
+	ZXDH_RB_CFG *p_dtb_dump_addr_rb = NULL;
+	p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
+
+	if (p_dtb_dump_addr_rb == NULL) {
+		p_dtb_dump_addr_rb = (ZXDH_RB_CFG *)rte_zmalloc(NULL, sizeof(ZXDH_RB_CFG), 0);
+		if (p_dtb_dump_addr_rb == NULL) {
+			PMD_DRV_LOG(ERR, "%s point null!", __func__);
+			return ZXDH_PAR_CHK_POINT_NULL;
+		}
+
+		rc = zxdh_np_dtb_dump_addr_rb_set(dev_id, queue_id, p_dtb_dump_addr_rb);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_rb_set");
+	}
+
+	rc = zxdh_comm_rb_init(p_dtb_dump_addr_rb, 0,
+		sizeof(ZXDH_DTB_ADDR_INFO_T), zxdh_np_se_apt_key_default_cmp);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_comm_rb_init");
+
 	return rc;
 }
 
@@ -1988,6 +3084,9 @@ zxdh_np_dtb_queue_request(uint32_t dev_id, char p_name[32],
 
 	PMD_DRV_LOG(DEBUG, "dtb request queue is %d.", queue_id);
 
+	rc = zxdh_np_dtb_dump_addr_rb_init(dev_id, queue_id);
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_addr_rb_init");
+
 	*p_queue_id = queue_id;
 
 	PMD_DRV_LOG(INFO, "%s:dev_id %d vport 0x%x name %s queue_id %d done.",
@@ -2027,6 +3126,9 @@ zxdh_np_dtb_queue_release(uint32_t devid,
 
 	zxdh_np_comm_mutex_unlock(p_dtb_mutex);
 
+	rc = zxdh_np_dtb_dump_addr_rb_destroy(devid, queueid);
+	ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dtb_dump_addr_rb_destroy");
+
 	rc = zxdh_np_dtb_queue_id_free(devid, queueid);
 	ZXDH_COMM_CHECK_DEV_RC(devid, rc, "zxdh_np_dtb_queue_id_free");
 
@@ -3435,12 +4537,43 @@ zxdh_np_dtb_user_info_set(uint32_t dev_id, uint32_t queue_id, uint16_t vport, ui
 	return rc;
 }
 
+static uint32_t
+zxdh_np_dtb_dump_sdt_addr_set(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;
+	dtb_dump_addr_info.phy_addr = phy_addr;
+	dtb_dump_addr_info.vir_addr = vir_addr;
+	dtb_dump_addr_info.size = size;
+
+	p_dtb_dump_addr_rb = zxdh_np_dtb_dump_addr_rb_get(dev_id, queue_id);
+	ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dtb_dump_addr_rb);
+
+	rc = zxdh_np_se_apt_rb_insert(p_dtb_dump_addr_rb,
+		&dtb_dump_addr_info, sizeof(ZXDH_DTB_ADDR_INFO_T));
+	ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_apt_rb_insert");
+
+	return rc;
+}
+
 static uint32_t
 zxdh_np_apt_dtb_res_init(uint32_t dev_id, ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
 {
 	uint32_t rc = ZXDH_OK;
 
 	uint32_t queue_id = 0;
+	uint32_t index = 0;
+	uint32_t dump_sdt_num = 0;
+	ZXDH_DTB_ADDR_INFO_T *p_dump_info = NULL;
 
 	rc = zxdh_np_dtb_queue_request(dev_id, p_dev_init_ctrl->port_name,
 		p_dev_init_ctrl->vport, &queue_id);
@@ -3458,6 +4591,19 @@ zxdh_np_apt_dtb_res_init(uint32_t dev_id, ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl)
 	zxdh_np_dtb_dump_channel_addr_set(dev_id, queue_id,
 		p_dev_init_ctrl->dump_phy_addr, p_dev_init_ctrl->dump_vir_addr, 0);
 
+	dump_sdt_num = p_dev_init_ctrl->dump_sdt_num;
+	for (index = 0; index < dump_sdt_num; index++) {
+		p_dump_info = p_dev_init_ctrl->dump_addr_info + index;
+		ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dump_info);
+		rc = zxdh_np_dtb_dump_sdt_addr_set(dev_id,
+							queue_id,
+							p_dump_info->sdt_no,
+							p_dump_info->phy_addr,
+							p_dump_info->vir_addr,
+							p_dump_info->size);
+		ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dtb_dump_sdt_addr_set");
+	}
+
 	return ZXDH_OK;
 }
 
diff --git a/drivers/net/zxdh/zxdh_np.h b/drivers/net/zxdh/zxdh_np.h
index 887760b3d8..f7d09f3fae 100644
--- a/drivers/net/zxdh/zxdh_np.h
+++ b/drivers/net/zxdh/zxdh_np.h
@@ -122,6 +122,13 @@
 #define ZXDH_VFUNC_NUM(VPORT)                   (((VPORT) & 0x00FF))
 #define ZXDH_IS_PF(VPORT)                       (!ZXDH_VF_ACTIVE(VPORT))
 
+#define ZXDH_RBT_RED                            (0x1)
+#define ZXDH_RBT_BLACK                          (0x2)
+#define ZXDH_RBT_MAX_DEPTH                      (128)
+
+#define ZXDH_LISTSTACK_INVALID_INDEX	        (0)
+#define ZXDH_LISTSTACK_MAX_ELEMENT		        (0x0ffffffe)
+
 /**errco code */
 #define ZXDH_RC_BASE                            (0x1000U)
 #define ZXDH_PARAMETER_CHK_BASE                 (ZXDH_RC_BASE            | 0x200)
@@ -140,6 +147,26 @@
 #define ZXDH_MUTEX_LOCK_ULOCK_FAIL              (ZXDH_MUTEX_LOCK_BASE    | 0X003)
 #define ZXDH_MUTEX_LOCK_DESTROY_FAIL            (ZXDH_MUTEX_LOCK_BASE    | 0X004)
 
+#define ZXDH_DOUBLE_LINK_BASE                   (ZXDH_RC_BASE            | 0x500)
+#define ZXDH_DOUBLE_LINK_ELEMENT_NUM_ERR        (ZXDH_DOUBLE_LINK_BASE   | 0x001)
+#define ZXDH_DOUBLE_LINK_MALLOC_FAIL            (ZXDH_DOUBLE_LINK_BASE   | 0x002)
+#define ZXDH_DOUBLE_LINK_POINT_NULL             (ZXDH_DOUBLE_LINK_BASE   | 0x003)
+#define ZXDH_DOUBLE_LINK_CHK_SUM_ERR            (ZXDH_DOUBLE_LINK_BASE   | 0x004)
+#define ZXDH_DOUBLE_LINK_NO_EXIST_FREENODE      (ZXDH_DOUBLE_LINK_BASE   | 0x005)
+#define ZXDH_DOUBLE_LINK_FREE_INDX_INVALID      (ZXDH_DOUBLE_LINK_BASE   | 0x006)
+#define ZXDH_DOUBLE_LINK_NO_EXIST_PRENODE       (ZXDH_DOUBLE_LINK_BASE   | 0x007)
+#define ZXDH_DOUBLE_LINK_INPUT_INDX_INVALID     (ZXDH_DOUBLE_LINK_BASE   | 0x008)
+#define ZXDH_DOUBLE_LINK_INIT_ELEMENT_NUM_ERR   (ZXDH_DOUBLE_LINK_BASE   | 0x009)
+
+#define ZXDH_LIST_STACK_BASE                    (ZXDH_RC_BASE            | 0x800)
+#define ZXDH_LIST_STACK_ELEMENT_NUM_ERR         (ZXDH_LIST_STACK_BASE    | 0x001)
+#define ZXDH_LIST_STACK_POINT_NULL              (ZXDH_LIST_STACK_BASE    | 0x002)
+#define ZXDH_LIST_STACK_ALLOC_MEMORY_FAIL       (ZXDH_LIST_STACK_BASE    | 0x003)
+#define ZXDH_LIST_STACK_ISEMPTY_ERR             (ZXDH_LIST_STACK_BASE    | 0x004)
+#define ZXDH_LIST_STACK_FREE_INDEX_INVALID      (ZXDH_LIST_STACK_BASE    | 0x005)
+#define ZXDH_LIST_STACK_ALLOC_INDEX_INVALID     (ZXDH_LIST_STACK_BASE    | 0x006)
+#define ZXDH_LIST_STACK_ALLOC_INDEX_USED        (ZXDH_LIST_STACK_BASE    | 0x007)
+
 #define ZXDH_ERAM128_BADDR_MASK                 (0x3FFFF80)
 
 #define ZXDH_DTB_TABLE_MODE_ERAM                (0)
@@ -184,6 +211,34 @@
 #define ZXDH_RC_CTRLCH_MSG_OPER_NOT_SUPPORT     (ZXDH_RC_CTRLCH_BASE | 0x3)
 #define ZXDH_RC_CTRLCH_MSG_DROP                 (ZXDH_RC_CTRLCH_BASE | 0x4)
 
+#define ZXDH_RBT_RC_BASE                        (0x1000)
+#define ZXDH_RBT_RC_UPDATE                      (ZXDH_RBT_RC_BASE | 0x1)
+#define ZXDH_RBT_RC_SRHFAIL                     (ZXDH_RBT_RC_BASE | 0x2)
+#define ZXDH_RBT_RC_FULL                        (ZXDH_RBT_RC_BASE | 0x3)
+#define ZXDH_RBT_ISEMPTY_ERR                    (ZXDH_RBT_RC_BASE | 0x4)
+#define ZXDH_RBT_PARA_INVALID                   (ZXDH_RBT_RC_BASE | 0x5)
+
+#define ZXDH_SE_RC_BASE                         (0x50000)
+#define ZXDH_SE_RC_HASH_BASE                    (ZXDH_SE_RC_BASE | 0x4000)
+#define ZXDH_HASH_RC_INVALID_FUNCINFO           (ZXDH_SE_RC_HASH_BASE | 0x1)
+#define ZXDH_HASH_RC_INVALID_ZBLCK              (ZXDH_SE_RC_HASH_BASE | 0x2)
+#define ZXDH_HASH_RC_INVALID_ZCELL              (ZXDH_SE_RC_HASH_BASE | 0x3)
+#define ZXDH_HASH_RC_INVALID_KEY                (ZXDH_SE_RC_HASH_BASE | 0x4)
+#define ZXDH_HASH_RC_INVALID_TBL_ID_INFO        (ZXDH_SE_RC_HASH_BASE | 0x5)
+#define ZXDH_HASH_RC_RB_TREE_FULL               (ZXDH_SE_RC_HASH_BASE | 0x6)
+#define ZXDH_HASH_RC_INVALID_KEY_TYPE           (ZXDH_SE_RC_HASH_BASE | 0x7)
+#define ZXDH_HASH_RC_ADD_UPDATE                 (ZXDH_SE_RC_HASH_BASE | 0x8)
+#define ZXDH_HASH_RC_DEL_SRHFAIL                (ZXDH_SE_RC_HASH_BASE | 0x9)
+#define ZXDH_HASH_RC_ITEM_FULL                  (ZXDH_SE_RC_HASH_BASE | 0xa)
+#define ZXDH_HASH_RC_INVALID_DDR_WIDTH_MODE     (ZXDH_SE_RC_HASH_BASE | 0xb)
+#define ZXDH_HASH_RC_INVALID_PARA               (ZXDH_SE_RC_HASH_BASE | 0xc)
+#define ZXDH_HASH_RC_TBL_FULL                   (ZXDH_SE_RC_HASH_BASE | 0xd)
+#define ZXDH_HASH_RC_SRH_FAIL                   (ZXDH_SE_RC_HASH_BASE | 0xe)
+#define ZXDH_HASH_RC_MATCH_ITEM_FAIL            (ZXDH_SE_RC_HASH_BASE | 0xf)
+#define ZXDH_HASH_RC_DDR_WIDTH_MODE_ERR         (ZXDH_SE_RC_HASH_BASE | 0x10)
+#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)
+
 typedef enum zxdh_module_base_addr_e {
 	ZXDH_MODULE_SE_SMMU0_BASE_ADDR = 0x00000000,
 	ZXDH_MODULE_DTB_ENQ_BASE_ADDR  = 0x00000000,
@@ -289,6 +344,42 @@ typedef struct zxdh_d_head {
 	ZXDH_D_NODE *p_prev;
 } ZXDH_D_HEAD;
 
+typedef struct zxdh_s_freelink {
+	uint32_t index;
+	uint32_t next;
+} ZXDH_COMM_FREELINK;
+
+typedef struct zxdh_s_list_stack_manager {
+	ZXDH_COMM_FREELINK  *p_array;
+	uint32_t capacity;
+	uint32_t p_head;
+	uint32_t free_num;
+	uint32_t used_num;
+} ZXDH_LISTSTACK_MANAGER;
+
+typedef struct zxdh_rb_tn {
+	void        *p_key;
+	uint32_t    color_lsv;
+	struct    zxdh_rb_tn   *p_left;
+	struct    zxdh_rb_tn   *p_right;
+	struct    zxdh_rb_tn   *p_parent;
+	ZXDH_D_NODE    tn_ln;
+} ZXDH_RB_TN;
+
+typedef int32_t  (*ZXDH_RB_CMPFUN)(void *p_new, void *p_old, uint32_t keysize);
+
+typedef struct _rb_cfg {
+	uint32_t				key_size;
+	uint32_t				is_dynamic;
+	ZXDH_RB_TN				*p_root;
+	ZXDH_D_HEAD				tn_list;
+	ZXDH_RB_CMPFUN			p_cmpfun;
+	ZXDH_LISTSTACK_MANAGER	*p_lsm;
+	uint8_t					*p_keybase;
+	ZXDH_RB_TN				*p_tnbase;
+	uint32_t				is_init;
+} ZXDH_RB_CFG;
+
 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: 110600 bytes --]