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