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