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