X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Ftf_ulp%2Fulp_mapper.c;h=7774a5537a8210c256243f0a5e31f5c0b021c67c;hb=06d1a5d056b30dd18b1e4abc98c19cde57a8016c;hp=05e2106c38c4c21d5c5f9e0a5aede28d34ce7c8a;hpb=286569d5ed9140ef1c39f43415824f46f2e31c80;p=dpdk.git diff --git a/drivers/net/bnxt/tf_ulp/ulp_mapper.c b/drivers/net/bnxt/tf_ulp/ulp_mapper.c index 05e2106c38..7774a5537a 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_mapper.c +++ b/drivers/net/bnxt/tf_ulp/ulp_mapper.c @@ -19,6 +19,8 @@ #include "tf_util.h" #include "ulp_template_db_tbl.h" #include "ulp_port_db.h" +#include "ulp_ha_mgr.h" +#include "bnxt_tf_pmd_shim.h" static uint8_t mapper_fld_zeros[16] = { 0 }; @@ -121,7 +123,7 @@ ulp_mapper_resource_ident_allocate(struct bnxt_ulp_context *ulp_ctx, struct tf *tfp; int32_t rc = 0; - tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx); + tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO); if (!tfp) return -EINVAL; @@ -174,7 +176,7 @@ ulp_mapper_resource_index_tbl_alloc(struct bnxt_ulp_context *ulp_ctx, uint32_t tbl_scope_id; int32_t rc = 0; - tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx); + tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO); if (!tfp) return -EINVAL; @@ -187,13 +189,12 @@ ulp_mapper_resource_index_tbl_alloc(struct bnxt_ulp_context *ulp_ctx, aparms.type = glb_res->resource_type; aparms.dir = glb_res->direction; - aparms.search_enable = 0; aparms.tbl_scope_id = tbl_scope_id; /* Allocate the index tbl using tf api */ rc = tf_alloc_tbl_entry(tfp, &aparms); if (rc) { - BNXT_TF_DBG(ERR, "Failed to alloc identifier [%s][%d]\n", + BNXT_TF_DBG(ERR, "Failed to alloc index table [%s][%d]\n", tf_dir_2_str(aparms.dir), aparms.type); return rc; } @@ -225,8 +226,11 @@ ulp_mapper_glb_field_tbl_get(struct bnxt_ulp_mapper_parms *parms, { uint32_t t_idx; - t_idx = parms->class_tid << (BNXT_ULP_HDR_SIG_ID_SHIFT + - BNXT_ULP_GLB_FIELD_TBL_SHIFT); + t_idx = parms->app_id << (BNXT_ULP_APP_ID_SHIFT + + BNXT_ULP_HDR_SIG_ID_SHIFT + + BNXT_ULP_GLB_FIELD_TBL_SHIFT); + t_idx += parms->class_tid << (BNXT_ULP_HDR_SIG_ID_SHIFT + + BNXT_ULP_GLB_FIELD_TBL_SHIFT); t_idx += ULP_COMP_FLD_IDX_RD(parms, BNXT_ULP_CF_IDX_HDR_SIG_ID) << BNXT_ULP_GLB_FIELD_TBL_SHIFT; t_idx += operand; @@ -415,8 +419,79 @@ ulp_mapper_ident_fields_get(struct bnxt_ulp_mapper_parms *mparms, return &dev_tbls->ident_list[idx]; } +static enum tf_tbl_type +ulp_mapper_dyn_tbl_type_get(struct bnxt_ulp_mapper_parms *mparms, + struct bnxt_ulp_mapper_tbl_info *tbl, + struct ulp_blob *bdata, + uint16_t *out_len) +{ + struct bnxt_ulp_device_params *d_params = mparms->device_params; + uint16_t blob_len = ulp_blob_data_len_get(bdata); + struct bnxt_ulp_dyn_size_map *size_map; + uint32_t i; + + if (d_params->dynamic_sram_en) { + switch (tbl->resource_type) { + case TF_TBL_TYPE_ACT_ENCAP_8B: + case TF_TBL_TYPE_ACT_ENCAP_16B: + case TF_TBL_TYPE_ACT_ENCAP_32B: + case TF_TBL_TYPE_ACT_ENCAP_64B: + size_map = d_params->dyn_encap_sizes; + for (i = 0; i < d_params->dyn_encap_list_size; i++) { + if (blob_len <= size_map[i].slab_size) { + *out_len = size_map[i].slab_size; + return size_map[i].tbl_type; + } + } + break; + case TF_TBL_TYPE_ACT_MODIFY_8B: + case TF_TBL_TYPE_ACT_MODIFY_16B: + case TF_TBL_TYPE_ACT_MODIFY_32B: + case TF_TBL_TYPE_ACT_MODIFY_64B: + size_map = d_params->dyn_modify_sizes; + for (i = 0; i < d_params->dyn_modify_list_size; i++) { + if (blob_len <= size_map[i].slab_size) { + *out_len = size_map[i].slab_size; + return size_map[i].tbl_type; + } + } + break; + default: + break; + } + } + return tbl->resource_type; +} + +static uint16_t +ulp_mapper_dyn_blob_size_get(struct bnxt_ulp_mapper_parms *mparms, + struct bnxt_ulp_mapper_tbl_info *tbl) +{ + struct bnxt_ulp_device_params *d_params = mparms->device_params; + + if (d_params->dynamic_sram_en) { + switch (tbl->resource_type) { + case TF_TBL_TYPE_ACT_ENCAP_8B: + case TF_TBL_TYPE_ACT_ENCAP_16B: + case TF_TBL_TYPE_ACT_ENCAP_32B: + case TF_TBL_TYPE_ACT_ENCAP_64B: + case TF_TBL_TYPE_ACT_MODIFY_8B: + case TF_TBL_TYPE_ACT_MODIFY_16B: + case TF_TBL_TYPE_ACT_MODIFY_32B: + case TF_TBL_TYPE_ACT_MODIFY_64B: + /* return max size */ + return BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS; + default: + break; + } + } else if (tbl->encap_num_fields) { + return BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS; + } + return tbl->result_bit_size; +} + static inline int32_t -ulp_mapper_tcam_entry_free(struct bnxt_ulp_context *ulp __rte_unused, +ulp_mapper_tcam_entry_free(struct bnxt_ulp_context *ulp, struct tf *tfp, struct ulp_flow_db_res_params *res) { @@ -426,6 +501,30 @@ ulp_mapper_tcam_entry_free(struct bnxt_ulp_context *ulp __rte_unused, .idx = (uint16_t)res->resource_hndl }; + /* If HA is enabled, we may have to remap the TF Type */ + if (bnxt_ulp_cntxt_ha_enabled(ulp)) { + enum ulp_ha_mgr_region region; + int32_t rc; + + switch (res->resource_type) { + case TF_TCAM_TBL_TYPE_WC_TCAM_HIGH: + case TF_TCAM_TBL_TYPE_WC_TCAM_LOW: + rc = ulp_ha_mgr_region_get(ulp, ®ion); + if (rc) + /* Log this, but assume region is correct */ + BNXT_TF_DBG(ERR, + "Unable to get HA region (%d)\n", + rc); + else + fparms.tcam_tbl_type = + (region == ULP_HA_REGION_LOW) ? + TF_TCAM_TBL_TYPE_WC_TCAM_LOW : + TF_TCAM_TBL_TYPE_WC_TCAM_HIGH; + break; + default: + break; + } + } return tf_free_tcam_entry(tfp, &fparms); } @@ -497,34 +596,14 @@ ulp_mapper_parent_flow_free(struct bnxt_ulp_context *ulp, uint32_t parent_fid, struct ulp_flow_db_res_params *res) { - uint32_t idx, child_fid = 0, parent_idx; - struct bnxt_ulp_flow_db *flow_db; - - parent_idx = (uint32_t)res->resource_hndl; - - /* check the validity of the parent fid */ - if (ulp_flow_db_parent_flow_idx_get(ulp, parent_fid, &idx) || - idx != parent_idx) { - BNXT_TF_DBG(ERR, "invalid parent flow id %x\n", parent_fid); - return -EINVAL; - } + uint32_t pc_idx; - /* Clear all the child flows parent index */ - flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp); - while (!ulp_flow_db_parent_child_flow_next_entry_get(flow_db, idx, - &child_fid)) { - /* update the child flows resource handle */ - if (ulp_flow_db_child_flow_reset(ulp, BNXT_ULP_FDB_TYPE_REGULAR, - child_fid)) { - BNXT_TF_DBG(ERR, "failed to reset child flow %x\n", - child_fid); - return -EINVAL; - } - } + pc_idx = (uint32_t)res->resource_hndl; - /* free the parent entry in the parent table flow */ - if (ulp_flow_db_parent_flow_free(ulp, parent_fid)) { - BNXT_TF_DBG(ERR, "failed to free parent flow %x\n", parent_fid); + /* reset the child flow bitset*/ + if (ulp_flow_db_pc_db_parent_flow_set(ulp, pc_idx, parent_fid, 0)) { + BNXT_TF_DBG(ERR, "error in reset parent flow bitset %x:%x\n", + pc_idx, parent_fid); return -EINVAL; } return 0; @@ -535,16 +614,14 @@ ulp_mapper_child_flow_free(struct bnxt_ulp_context *ulp, uint32_t child_fid, struct ulp_flow_db_res_params *res) { - uint32_t parent_fid; + uint32_t pc_idx; - parent_fid = (uint32_t)res->resource_hndl; - if (!parent_fid) - return 0; /* Already freed - orphan child*/ + pc_idx = (uint32_t)res->resource_hndl; /* reset the child flow bitset*/ - if (ulp_flow_db_parent_child_flow_set(ulp, parent_fid, child_fid, 0)) { + if (ulp_flow_db_pc_db_child_flow_set(ulp, pc_idx, child_fid, 0)) { BNXT_TF_DBG(ERR, "error in resetting child flow bitset %x:%x\n", - parent_fid, child_fid); + pc_idx, child_fid); return -EINVAL; } return 0; @@ -738,7 +815,7 @@ ulp_mapper_ident_process(struct bnxt_ulp_mapper_parms *parms, struct tf *tfp; int rc; - tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx); + tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); if (!tfp) { BNXT_TF_DBG(ERR, "Failed to get tf pointer\n"); return -EINVAL; @@ -756,6 +833,9 @@ ulp_mapper_ident_process(struct bnxt_ulp_mapper_parms *parms, tf_ident_2_str(iparms.ident_type)); return rc; } + BNXT_TF_INF("Alloc ident %s:%s.success.\n", + tf_dir_2_str(iparms.dir), + tf_ident_2_str(iparms.ident_type)); id = (uint64_t)tfp_cpu_to_be_64(iparms.id); if (ulp_regfile_write(parms->regfile, idx, id)) { @@ -773,6 +853,7 @@ ulp_mapper_ident_process(struct bnxt_ulp_mapper_parms *parms, fid_parms.resource_type = ident->ident_type; fid_parms.resource_hndl = iparms.id; fid_parms.critical_resource = tbl->critical_resource; + ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); if (rc) { @@ -819,7 +900,7 @@ ulp_mapper_ident_extract(struct bnxt_ulp_mapper_parms *parms, int rc; /* Get the tfp from ulp context */ - tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx); + tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); if (!tfp) { BNXT_TF_DBG(ERR, "Failed to get tf pointer\n"); return -EINVAL; @@ -848,6 +929,10 @@ ulp_mapper_ident_extract(struct bnxt_ulp_mapper_parms *parms, sparms.search_id); return rc; } + BNXT_TF_INF("Search ident %s:%s:%x.success.\n", + tf_dir_2_str(sparms.dir), + tf_tbl_type_2_str(sparms.ident_type), + sparms.search_id); /* Write it to the regfile */ id = (uint64_t)tfp_cpu_to_be_64(sparms.search_id); @@ -865,6 +950,8 @@ ulp_mapper_ident_extract(struct bnxt_ulp_mapper_parms *parms, fid_parms.resource_type = ident->ident_type; fid_parms.resource_hndl = sparms.search_id; fid_parms.critical_resource = tbl->critical_resource; + ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); + rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); if (rc) { BNXT_TF_DBG(ERR, "Failed to link res to flow rc = %d\n", @@ -965,13 +1052,13 @@ ulp_mapper_field_src_process(struct bnxt_ulp_mapper_parms *parms, return -EINVAL; } idx = tfp_be_to_cpu_16(idx); - if (idx >= BNXT_ULP_CF_IDX_LAST || bytelen > sizeof(uint32_t)) { + if (idx >= BNXT_ULP_CF_IDX_LAST || bytelen > sizeof(uint64_t)) { BNXT_TF_DBG(ERR, "comp field [%d] read oob %d\n", idx, bytelen); return -EINVAL; } buffer = (uint8_t *)&parms->comp_fld[idx]; - *val = &buffer[sizeof(uint32_t) - bytelen]; + *val = &buffer[sizeof(uint64_t) - bytelen]; *value = ULP_COMP_FLD_IDX_RD(parms, idx); break; case BNXT_ULP_FIELD_SRC_RF: @@ -1170,8 +1257,47 @@ ulp_mapper_field_src_process(struct bnxt_ulp_mapper_parms *parms, BNXT_TF_DBG(ERR, "field port table failed\n"); return -EINVAL; } + break; + case BNXT_ULP_FIELD_SRC_ENC_HDR_BIT: + if (!ulp_operand_read(field_opr, + (uint8_t *)&lregval, sizeof(uint64_t))) { + BNXT_TF_DBG(ERR, "Header bit read failed\n"); + return -EINVAL; + } + lregval = tfp_be_to_cpu_64(lregval); + if (ULP_BITMAP_ISSET(parms->enc_hdr_bitmap->bits, lregval)) { + *val = mapper_fld_one; + *value = 1; + } else { + *val = mapper_fld_zeros; + } + break; + case BNXT_ULP_FIELD_SRC_ENC_FIELD: + if (!ulp_operand_read(field_opr, + (uint8_t *)&idx, sizeof(uint16_t))) { + BNXT_TF_DBG(ERR, "Header field read failed\n"); + return -EINVAL; + } + idx = tfp_be_to_cpu_16(idx); + /* get the index from the global field list */ + if (idx >= BNXT_ULP_ENC_FIELD_LAST) { + BNXT_TF_DBG(ERR, "invalid encap field tbl idx %d\n", + idx); + return -EINVAL; + } + buffer = parms->enc_field[idx].spec; + field_size = parms->enc_field[idx].size; + if (bytelen > field_size) { + BNXT_TF_DBG(ERR, "Encap field[%d] size small %u\n", + idx, field_size); + return -EINVAL; + } + *val = &buffer[field_size - bytelen]; + break; case BNXT_ULP_FIELD_SRC_SKIP: /* do nothing */ + *val = mapper_fld_zeros; + *val_len = 0; break; case BNXT_ULP_FIELD_SRC_REJECT: return -EINVAL; @@ -1225,6 +1351,8 @@ static int32_t ulp_mapper_field_blob_write(enum bnxt_ulp_field_src fld_src, BNXT_TF_DBG(ERR, "encap blob push failed\n"); return -EINVAL; } + } else if (fld_src == BNXT_ULP_FIELD_SRC_SKIP) { + /* do nothing */ } else { if (!ulp_blob_push(blob, val, val_len)) { BNXT_TF_DBG(ERR, "push of val1 failed\n"); @@ -1350,21 +1478,18 @@ ulp_mapper_field_opc_process(struct bnxt_ulp_mapper_parms *parms, /* process the field opcodes */ switch (fld->field_opc) { case BNXT_ULP_FIELD_OPC_SRC1: - if (ulp_mapper_field_blob_write(fld->field_src1, - blob, val1, val1_len, &val)) - goto error; + rc = ulp_mapper_field_blob_write(fld->field_src1, + blob, val1, val1_len, &val); val_len = val1_len; break; case BNXT_ULP_FIELD_OPC_SRC1_THEN_SRC2_ELSE_SRC3: if (value1) { - if (ulp_mapper_field_blob_write(fld->field_src2, blob, - val2, val2_len, &val)) - goto error; + rc = ulp_mapper_field_blob_write(fld->field_src2, blob, + val2, val2_len, &val); val_len = val2_len; } else { - if (ulp_mapper_field_blob_write(fld->field_src3, blob, - val3, val3_len, &val)) - goto error; + rc = ulp_mapper_field_blob_write(fld->field_src3, blob, + val3, val3_len, &val); val_len = val3_len; } break; @@ -1373,64 +1498,56 @@ ulp_mapper_field_opc_process(struct bnxt_ulp_mapper_parms *parms, val_int = val1_int + val2_int; val_int = tfp_cpu_to_be_64(val_int); val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); - if (!val) { - BNXT_TF_DBG(ERR, "push to blob failed\n"); - goto error; - } + if (!val) + rc = -EINVAL; break; case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2: case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2_POST: val_int = val1_int - val2_int; val_int = tfp_cpu_to_be_64(val_int); val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); - if (!val) { - BNXT_TF_DBG(ERR, "push to blob failed\n"); - goto error; - } + if (!val) + rc = -EINVAL; break; case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2: val_int = val1_int | val2_int; val_int = tfp_cpu_to_be_64(val_int); val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); - if (!val) { - BNXT_TF_DBG(ERR, "push to blob failed\n"); - goto error; - } + if (!val) + rc = -EINVAL; break; case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2_OR_SRC3: val_int = val1_int | val2_int | val3_int; val_int = tfp_cpu_to_be_64(val_int); val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); - if (!val) { - BNXT_TF_DBG(ERR, "push to blob failed\n"); - goto error; - } + if (!val) + rc = -EINVAL; break; case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2: val_int = val1_int & val2_int; val_int = tfp_cpu_to_be_64(val_int); val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); - if (!val) { - BNXT_TF_DBG(ERR, "push to blob failed\n"); - goto error; - } + if (!val) + rc = -EINVAL; break; case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2_OR_SRC3: val_int = val1_int & (val2_int | val3_int); val_int = tfp_cpu_to_be_64(val_int); val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); - if (!val) { - BNXT_TF_DBG(ERR, "push to blob failed\n"); - goto error; - } + if (!val) + rc = -EINVAL; break; case BNXT_ULP_FIELD_OPC_SKIP: break; default: + BNXT_TF_DBG(ERR, "Invalid fld opcode %u\n", fld->field_opc); + rc = -EINVAL; break; } - return rc; + if (!rc) { + return rc; + } error: BNXT_TF_DBG(ERR, "Error in %s:%s process %u:%u\n", name, fld->description, (val) ? write_idx : 0, val_len); @@ -1448,7 +1565,8 @@ ulp_mapper_tbl_result_build(struct bnxt_ulp_mapper_parms *parms, const char *name) { struct bnxt_ulp_mapper_field_info *dflds; - uint32_t i, num_flds = 0, encap_flds = 0; + uint32_t i = 0, num_flds = 0, encap_flds = 0; + struct ulp_blob encap_blob; int32_t rc = 0; /* Get the result field list */ @@ -1465,26 +1583,67 @@ ulp_mapper_tbl_result_build(struct bnxt_ulp_mapper_parms *parms, return -EINVAL; } - /* process the result fields, loop through them */ - for (i = 0; i < (num_flds + encap_flds); i++) { - /* set the swap index if encap swap bit is enabled */ - if (parms->device_params->encap_byte_swap && encap_flds && - i == num_flds) - ulp_blob_encap_swap_idx_set(data); - - /* Process the result fields */ + /* process the result fields */ + for (i = 0; i < num_flds; i++) { rc = ulp_mapper_field_opc_process(parms, tbl->direction, &dflds[i], data, 0, name); if (rc) { - BNXT_TF_DBG(ERR, "data field failed\n"); + BNXT_TF_DBG(ERR, "result field processing failed\n"); return rc; } } - /* if encap bit swap is enabled perform the bit swap */ - if (parms->device_params->encap_byte_swap && encap_flds) - ulp_blob_perform_encap_swap(data); + /* process encap fields if any */ + if (encap_flds) { + uint32_t pad = 0; + /* Initialize the encap blob */ + if (!tbl->record_size && + !parms->device_params->dynamic_sram_en) { + BNXT_TF_DBG(ERR, "Encap tbl record size incorrect\n"); + return -EINVAL; + } + if (!ulp_blob_init(&encap_blob, + ULP_BYTE_2_BITS(tbl->record_size), + parms->device_params->encap_byte_order)) { + BNXT_TF_DBG(ERR, "blob inits failed.\n"); + return -EINVAL; + } + for (; i < encap_flds; i++) { + rc = ulp_mapper_field_opc_process(parms, tbl->direction, + &dflds[i], + &encap_blob, 0, name); + if (rc) { + BNXT_TF_DBG(ERR, + "encap field processing failed\n"); + return rc; + } + } + /* add the dynamic pad push */ + if (parms->device_params->dynamic_sram_en) { + uint16_t rec_s = ULP_BYTE_2_BITS(tbl->record_size); + + (void)ulp_mapper_dyn_tbl_type_get(parms, tbl, + &encap_blob, &rec_s); + pad = rec_s - ulp_blob_data_len_get(&encap_blob); + } else { + pad = ULP_BYTE_2_BITS(tbl->record_size) - + ulp_blob_data_len_get(&encap_blob); + } + if (ulp_blob_pad_push(&encap_blob, pad) < 0) { + BNXT_TF_DBG(ERR, "encap buffer padding failed\n"); + return -EINVAL; + } + + /* perform the 64 bit byte swap */ + ulp_blob_perform_64B_byte_swap(&encap_blob); + /* Append encap blob to the result blob */ + rc = ulp_blob_buffer_copy(data, &encap_blob); + if (rc) { + BNXT_TF_DBG(ERR, "encap buffer copy failed\n"); + return rc; + } + } return rc; } @@ -1523,6 +1682,8 @@ ulp_mapper_mark_gfid_process(struct bnxt_ulp_mapper_parms *parms, fid_parms.critical_resource = tbl->critical_resource; fid_parms.resource_type = mark_flag; fid_parms.resource_hndl = gfid; + ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); + rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); if (rc) BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc); @@ -1569,6 +1730,8 @@ ulp_mapper_mark_act_ptr_process(struct bnxt_ulp_mapper_parms *parms, fid_parms.critical_resource = tbl->critical_resource; fid_parms.resource_type = mark_flag; fid_parms.resource_hndl = act_idx; + ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); + rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); if (rc) BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc); @@ -1615,6 +1778,8 @@ ulp_mapper_mark_vfr_idx_process(struct bnxt_ulp_mapper_parms *parms, fid_parms.critical_resource = tbl->critical_resource; fid_parms.resource_type = mark_flag; fid_parms.resource_hndl = act_idx; + ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); + rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); if (rc) BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc); @@ -1681,7 +1846,7 @@ ulp_mapper_tcam_tbl_entry_write(struct bnxt_ulp_mapper_parms *parms, uint16_t tmplen; int32_t rc; - tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx); + tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); if (!tfp) { BNXT_TF_DBG(ERR, "Failed to get truflow pointer\n"); return -EINVAL; @@ -1701,6 +1866,9 @@ ulp_mapper_tcam_tbl_entry_write(struct bnxt_ulp_mapper_parms *parms, tf_dir_2_str(sparms.dir), sparms.idx); return -EIO; } + BNXT_TF_INF("tcam[%s][%s][%x] write success.\n", + tf_tcam_tbl_2_str(sparms.tcam_tbl_type), + tf_dir_2_str(sparms.dir), sparms.idx); /* Mark action */ rc = ulp_mapper_mark_act_ptr_process(parms, tbl); @@ -1816,6 +1984,15 @@ static void ulp_mapper_wc_tcam_tbl_post_process(struct ulp_blob *blob) ulp_blob_perform_64B_byte_swap(blob); } +static int32_t ulp_mapper_tcam_is_wc_tcam(struct bnxt_ulp_mapper_tbl_info *tbl) +{ + if (tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM || + tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM_HIGH || + tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM_LOW) + return 1; + return 0; +} + static int32_t ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, struct bnxt_ulp_mapper_tbl_info *tbl) @@ -1835,6 +2012,7 @@ ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, uint32_t hit = 0; uint16_t tmplen = 0; uint16_t idx; + enum bnxt_ulp_byte_order key_byte_order; /* Set the key and mask to the original key and mask. */ key = &okey; @@ -1848,23 +2026,35 @@ ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, return 0; } - tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx); + tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); if (!tfp) { BNXT_TF_DBG(ERR, "Failed to get truflow pointer\n"); return -EINVAL; } + /* If only allocation of identifier then perform and exit */ + if (tbl->tbl_opcode == BNXT_ULP_TCAM_TBL_OPC_ALLOC_IDENT) { + rc = ulp_mapper_tcam_tbl_scan_ident_alloc(parms, tbl); + return rc; + } + kflds = ulp_mapper_key_fields_get(parms, tbl, &num_kflds); if (!kflds || !num_kflds) { BNXT_TF_DBG(ERR, "Failed to get key fields\n"); return -EINVAL; } - if (!ulp_blob_init(key, tbl->blob_key_bit_size, tbl->byte_order) || - !ulp_blob_init(mask, tbl->blob_key_bit_size, tbl->byte_order) || - !ulp_blob_init(&data, tbl->result_bit_size, dparms->byte_order) || + if (ulp_mapper_tcam_is_wc_tcam(tbl)) + key_byte_order = dparms->wc_key_byte_order; + else + key_byte_order = dparms->key_byte_order; + + if (!ulp_blob_init(key, tbl->blob_key_bit_size, key_byte_order) || + !ulp_blob_init(mask, tbl->blob_key_bit_size, key_byte_order) || + !ulp_blob_init(&data, tbl->result_bit_size, + dparms->result_byte_order) || !ulp_blob_init(&update_data, tbl->result_bit_size, - dparms->byte_order)) { + dparms->result_byte_order)) { BNXT_TF_DBG(ERR, "blob inits failed.\n"); return -EINVAL; } @@ -1897,7 +2087,7 @@ ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, } /* For wild card tcam perform the post process to swap the blob */ - if (tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM) { + if (ulp_mapper_tcam_is_wc_tcam(tbl)) { if (dparms->dynamic_pad_en) { /* Sets up the slices for writing to the WC TCAM */ rc = ulp_mapper_wc_tcam_tbl_dyn_post_process(dparms, @@ -2014,6 +2204,8 @@ ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, fid_parms.resource_type = tbl->resource_type; fid_parms.critical_resource = tbl->critical_resource; fid_parms.resource_hndl = idx; + ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); + rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); if (rc) { BNXT_TF_DBG(ERR, "Failed to link resource to flow rc = %d\n", @@ -2042,7 +2234,7 @@ ulp_mapper_em_tbl_process(struct bnxt_ulp_mapper_parms *parms, struct ulp_blob key, data; uint32_t i, num_kflds; uint16_t tmplen; - struct tf *tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx); + struct tf *tfp; struct ulp_flow_db_res_params fid_parms = { 0 }; struct tf_insert_em_entry_parms iparms = { 0 }; struct tf_delete_em_entry_parms free_parms = { 0 }; @@ -2051,7 +2243,9 @@ ulp_mapper_em_tbl_process(struct bnxt_ulp_mapper_parms *parms, int32_t trc; int32_t rc = 0; int32_t pad = 0; + enum bnxt_ulp_byte_order key_order, res_order; + tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); rc = bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype); if (rc) { BNXT_TF_DBG(ERR, "Failed to get the mem type for EM\n"); @@ -2064,11 +2258,12 @@ ulp_mapper_em_tbl_process(struct bnxt_ulp_mapper_parms *parms, return -EINVAL; } + key_order = dparms->em_byte_order; + res_order = dparms->em_byte_order; + /* Initialize the key/result blobs */ - if (!ulp_blob_init(&key, tbl->blob_key_bit_size, - tbl->byte_order) || - !ulp_blob_init(&data, tbl->result_bit_size, - tbl->byte_order)) { + if (!ulp_blob_init(&key, tbl->blob_key_bit_size, key_order) || + !ulp_blob_init(&data, tbl->result_bit_size, res_order)) { BNXT_TF_DBG(ERR, "blob inits failed.\n"); return -EINVAL; } @@ -2218,24 +2413,23 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, struct tf_get_tbl_entry_parms gparms = { 0 }; struct tf_free_tbl_entry_parms free_parms = { 0 }; uint32_t tbl_scope_id; - struct tf *tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx); - struct bnxt_ulp_glb_resource_info glb_res; + struct tf *tfp; + struct bnxt_ulp_glb_resource_info glb_res = { 0 }; uint16_t bit_size; bool alloc = false; bool write = false; bool global = false; uint64_t act_rec_size; bool shared = false; + enum tf_tbl_type tbl_type = tbl->resource_type; - /* use the max size if encap is enabled */ - if (tbl->encap_num_fields) - bit_size = BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS; - else - bit_size = tbl->result_bit_size; + tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); + /* compute the blob size */ + bit_size = ulp_mapper_dyn_blob_size_get(parms, tbl); /* Initialize the blob data */ if (!ulp_blob_init(&data, bit_size, - parms->device_params->byte_order)) { + parms->device_params->result_byte_order)) { BNXT_TF_DBG(ERR, "Failed to initialize index table blob\n"); return -EINVAL; } @@ -2306,8 +2500,7 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, tbl->tbl_operand, ®val, &shared)) { BNXT_TF_DBG(ERR, - "Failed to get tbl idx from Global " - "regfile[%d].\n", + "Failed to get tbl idx from Glb RF[%d].\n", tbl->tbl_operand); return -EINVAL; } @@ -2341,7 +2534,7 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, gparms.dir = tbl->direction; gparms.type = tbl->resource_type; gparms.data = ulp_blob_data_get(&data, &tmplen); - gparms.data_sz_in_bytes = ULP_BITS_2_BYTE(tbl->result_bit_size); + gparms.data_sz_in_bytes = ULP_BITS_2_BYTE(tmplen); gparms.idx = index; rc = tf_get_tbl_entry(tfp, &gparms); if (rc) { @@ -2357,8 +2550,9 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, gparms.data_sz_in_bytes, data.byte_order); if (rc) { - BNXT_TF_DBG(ERR, "Failed to read fields on tbl read " - "rc=%d\n", rc); + BNXT_TF_DBG(ERR, + "Failed to get flds on tbl read rc=%d\n", + rc); return rc; } return 0; @@ -2382,14 +2576,16 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, if (alloc) { aparms.dir = tbl->direction; - aparms.type = tbl->resource_type; + tbl_type = ulp_mapper_dyn_tbl_type_get(parms, tbl, + &data, &tmplen); + aparms.type = tbl_type; aparms.tbl_scope_id = tbl_scope_id; /* All failures after the alloc succeeds require a free */ rc = tf_alloc_tbl_entry(tfp, &aparms); if (rc) { BNXT_TF_DBG(ERR, "Alloc table[%s][%s] failed rc=%d\n", - tf_tbl_type_2_str(tbl->resource_type), + tf_tbl_type_2_str(aparms.type), tf_dir_2_str(tbl->direction), rc); return rc; } @@ -2433,8 +2629,10 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, if (write) { sparms.dir = tbl->direction; - sparms.type = tbl->resource_type; sparms.data = ulp_blob_data_get(&data, &tmplen); + tbl_type = ulp_mapper_dyn_tbl_type_get(parms, tbl, &data, + &tmplen); + sparms.type = tbl_type; sparms.data_sz_in_bytes = ULP_BITS_2_BYTE(tmplen); sparms.idx = index; sparms.tbl_scope_id = tbl_scope_id; @@ -2443,13 +2641,15 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, rc = tf_set_tbl_entry(tfp, &sparms); if (rc) { BNXT_TF_DBG(ERR, - "Index table[%s][%s][%x] write failed " - "rc=%d\n", + "Index table[%s][%s][%x] write fail rc=%d\n", tf_tbl_type_2_str(sparms.type), tf_dir_2_str(sparms.dir), sparms.idx, rc); goto error; } + BNXT_TF_INF("Index table[%s][%s][%x] write successful.\n", + tf_tbl_type_2_str(sparms.type), + tf_dir_2_str(sparms.dir), sparms.idx); /* Calculate action record size */ if (tbl->resource_type == TF_TBL_TYPE_EXT) { @@ -2467,10 +2667,11 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, memset(&fid_parms, 0, sizeof(fid_parms)); fid_parms.direction = tbl->direction; fid_parms.resource_func = tbl->resource_func; - fid_parms.resource_type = tbl->resource_type; + fid_parms.resource_type = tbl_type; fid_parms.resource_sub_type = tbl->resource_sub_type; fid_parms.resource_hndl = index; fid_parms.critical_resource = tbl->critical_resource; + ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); if (rc) { @@ -2495,7 +2696,7 @@ error: * write to the entry or link the flow */ free_parms.dir = tbl->direction; - free_parms.type = tbl->resource_type; + free_parms.type = tbl_type; free_parms.idx = index; free_parms.tbl_scope_id = tbl_scope_id; @@ -2516,13 +2717,14 @@ ulp_mapper_if_tbl_process(struct bnxt_ulp_mapper_parms *parms, int32_t rc = 0; struct tf_set_if_tbl_entry_parms iftbl_params = { 0 }; struct tf_get_if_tbl_entry_parms get_parms = { 0 }; - struct tf *tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx); + struct tf *tfp; enum bnxt_ulp_if_tbl_opc if_opc = tbl->tbl_opcode; uint32_t res_size; + tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); /* Initialize the blob data */ if (!ulp_blob_init(&data, tbl->result_bit_size, - parms->device_params->byte_order)) { + parms->device_params->result_byte_order)) { BNXT_TF_DBG(ERR, "Failed initial index table blob\n"); return -EINVAL; } @@ -2553,7 +2755,7 @@ ulp_mapper_if_tbl_process(struct bnxt_ulp_mapper_parms *parms, case BNXT_ULP_IF_TBL_OPC_RD_COMP_FIELD: /* Initialize the result blob */ if (!ulp_blob_init(&res_blob, tbl->result_bit_size, - parms->device_params->byte_order)) { + parms->device_params->result_byte_order)) { BNXT_TF_DBG(ERR, "Failed initial result blob\n"); return -EINVAL; } @@ -2604,6 +2806,10 @@ ulp_mapper_if_tbl_process(struct bnxt_ulp_mapper_parms *parms, iftbl_params.idx, rc); return rc; } + BNXT_TF_INF("Set table[%s][%s][%x] success.\n", + tf_if_tbl_2_str(iftbl_params.type), + tf_dir_2_str(iftbl_params.dir), + iftbl_params.idx); /* * TBD: Need to look at the need to store idx in flow db for restore @@ -2621,7 +2827,7 @@ ulp_mapper_gen_tbl_process(struct bnxt_ulp_mapper_parms *parms, struct ulp_flow_db_res_params fid_parms; struct ulp_mapper_gen_tbl_entry gen_tbl_ent, *g; struct ulp_gen_hash_entry_params hash_entry; - uint16_t tmplen; + uint16_t tmplen = 0; struct ulp_blob key, data; uint8_t *cache_key; int32_t tbl_idx; @@ -2638,7 +2844,7 @@ ulp_mapper_gen_tbl_process(struct bnxt_ulp_mapper_parms *parms, } if (!ulp_blob_init(&key, tbl->key_bit_size, - parms->device_params->byte_order)) { + parms->device_params->key_byte_order)) { BNXT_TF_DBG(ERR, "Failed to alloc blob\n"); return -EINVAL; } @@ -2698,6 +2904,11 @@ ulp_mapper_gen_tbl_process(struct bnxt_ulp_mapper_parms *parms, } } else { /* convert key to index directly */ + if (ULP_BITS_2_BYTE(tmplen) > (int32_t)sizeof(key_index)) { + BNXT_TF_DBG(ERR, "%s: keysize is bigger then 4 bytes\n", + gen_tbl_list->gen_tbl_name); + return -EINVAL; + } memcpy(&key_index, cache_key, ULP_BITS_2_BYTE(tmplen)); /* Get the generic table entry */ if (ulp_mapper_gen_tbl_entry_get(gen_tbl_list, key_index, @@ -2802,6 +3013,8 @@ ulp_mapper_gen_tbl_process(struct bnxt_ulp_mapper_parms *parms, fid_parms.resource_sub_type = tbl->resource_sub_type; fid_parms.resource_hndl = key_index; fid_parms.critical_resource = tbl->critical_resource; + ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); + rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); if (rc) BNXT_TF_DBG(ERR, "Fail to add gen ent flowdb %d\n", rc); @@ -2843,15 +3056,15 @@ ulp_mapper_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, rc = bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &dev_id); if (rc) { - BNXT_TF_DBG(ERR, "Failed to get device id for " - "global init (%d)\n", rc); + BNXT_TF_DBG(ERR, "Failed to get device id for glb init (%d)\n", + rc); return rc; } rc = bnxt_ulp_cntxt_app_id_get(ulp_ctx, &app_id); if (rc) { - BNXT_TF_DBG(ERR, "Failed to get app id for " - "global init (%d)\n", rc); + BNXT_TF_DBG(ERR, "Failed to get app id for glb init (%d)\n", + rc); return rc; } @@ -2891,10 +3104,12 @@ static int32_t ulp_mapper_app_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, struct bnxt_ulp_mapper_data *mapper_data) { + struct tf_get_shared_tbl_increment_parms iparms; struct bnxt_ulp_glb_resource_info *glb_res; struct tf_get_session_info_parms sparms; uint32_t num_entries, i, dev_id, res; struct tf_resource_info *res_info; + uint32_t addend; uint64_t regval; enum tf_dir dir; int32_t rc = 0; @@ -2902,13 +3117,11 @@ ulp_mapper_app_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, uint8_t app_id; memset(&sparms, 0, sizeof(sparms)); - glb_res = bnxt_ulp_app_glb_resource_info_list_get(&num_entries); if (!glb_res || !num_entries) { BNXT_TF_DBG(ERR, "Invalid Arguments\n"); return -EINVAL; } - tfp = bnxt_ulp_cntxt_shared_tfp_get(ulp_ctx); if (!tfp) { BNXT_TF_DBG(ERR, "Failed to get tfp for app global init"); @@ -2926,15 +3139,15 @@ ulp_mapper_app_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, rc = bnxt_ulp_cntxt_app_id_get(ulp_ctx, &app_id); if (rc) { - BNXT_TF_DBG(ERR, "Failed to get the app id in global init " - "(%d).\n", rc); + BNXT_TF_DBG(ERR, "Failed to get the app id in glb init (%d).\n", + rc); return rc; } rc = bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &dev_id); if (rc) { - BNXT_TF_DBG(ERR, "Failed to get device id for app " - "global init (%d)\n", rc); + BNXT_TF_DBG(ERR, "Failed to get dev id for app glb init (%d)\n", + rc); return rc; } @@ -2945,12 +3158,29 @@ ulp_mapper_app_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, continue; dir = glb_res[i].direction; res = glb_res[i].resource_type; + addend = 1; switch (glb_res[i].resource_func) { case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER: res_info = &sparms.session_info.ident[dir].info[res]; break; case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE: + /* + * Tables may have various strides for the allocations. + * Need to account. + */ + memset(&iparms, 0, sizeof(iparms)); + iparms.dir = dir; + iparms.type = res; + rc = tf_get_shared_tbl_increment(tfp, &iparms); + if (rc) { + BNXT_TF_DBG(ERR, + "Failed to get addend for %s[%s] rc=(%d)\n", + tf_tbl_type_2_str(res), + tf_dir_2_str(dir), rc); + return rc; + } + addend = iparms.increment_cnt; res_info = &sparms.session_info.tbl[dir].info[res]; break; case BNXT_ULP_RESOURCE_FUNC_TCAM_TABLE: @@ -2964,10 +3194,8 @@ ulp_mapper_app_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, glb_res[i].resource_func); continue; } - regval = tfp_cpu_to_be_64((uint64_t)res_info->start); - res_info->start++; - + res_info->start += addend; /* * All resources written to the global regfile are shared for * this function. @@ -3088,18 +3316,10 @@ ulp_mapper_cond_opc_process(struct bnxt_ulp_mapper_parms *parms, *res = regval == 0; break; case BNXT_ULP_COND_OPC_FLOW_PAT_MATCH: - if (parms->flow_pattern_id == operand) { - BNXT_TF_DBG(ERR, "field pattern match failed %x\n", - parms->flow_pattern_id); - return -EINVAL; - } + *res = parms->flow_pattern_id == operand; break; case BNXT_ULP_COND_OPC_ACT_PAT_MATCH: - if (parms->act_pattern_id == operand) { - BNXT_TF_DBG(ERR, "act pattern match failed %x\n", - parms->act_pattern_id); - return -EINVAL; - } + *res = parms->act_pattern_id == operand; break; case BNXT_ULP_COND_OPC_EXT_MEM_IS_SET: if (bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype)) { @@ -3115,6 +3335,26 @@ ulp_mapper_cond_opc_process(struct bnxt_ulp_mapper_parms *parms, } *res = (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT) ? 1 : 0; break; + case BNXT_ULP_COND_OPC_ENC_HDR_BIT_IS_SET: + if (operand < BNXT_ULP_HDR_BIT_LAST) { + *res = ULP_BITMAP_ISSET(parms->enc_hdr_bitmap->bits, + operand); + } else { + BNXT_TF_DBG(ERR, "header bit out of bounds %d\n", + operand); + rc = -EINVAL; + } + break; + case BNXT_ULP_COND_OPC_ENC_HDR_BIT_NOT_SET: + if (operand < BNXT_ULP_HDR_BIT_LAST) { + *res = !ULP_BITMAP_ISSET(parms->enc_hdr_bitmap->bits, + operand); + } else { + BNXT_TF_DBG(ERR, "header bit out of bounds %d\n", + operand); + rc = -EINVAL; + } + break; default: BNXT_TF_DBG(ERR, "Invalid conditional opcode %d\n", opc); rc = -EINVAL; @@ -3124,116 +3364,147 @@ ulp_mapper_cond_opc_process(struct bnxt_ulp_mapper_parms *parms, } static int32_t -ulp_mapper_cc_upd_opr_compute(struct bnxt_ulp_mapper_parms *parms, - enum tf_dir dir, - enum bnxt_ulp_cc_upd_src cc_src, - uint16_t cc_opr, - uint64_t *result) +ulp_mapper_func_opr_compute(struct bnxt_ulp_mapper_parms *parms, + enum tf_dir dir, + enum bnxt_ulp_func_src func_src, + uint16_t func_opr, + uint64_t *result) { uint64_t regval; bool shared; *result = false; - switch (cc_src) { - case BNXT_ULP_CC_UPD_SRC_COMP_FIELD: - if (cc_opr >= BNXT_ULP_CF_IDX_LAST) { - BNXT_TF_DBG(ERR, "invalid index %u\n", cc_opr); + switch (func_src) { + case BNXT_ULP_FUNC_SRC_COMP_FIELD: + if (func_opr >= BNXT_ULP_CF_IDX_LAST) { + BNXT_TF_DBG(ERR, "invalid index %u\n", func_opr); return -EINVAL; } - *result = (uint64_t)ULP_COMP_FLD_IDX_RD(parms, cc_opr); + *result = ULP_COMP_FLD_IDX_RD(parms, func_opr); break; - case BNXT_ULP_CC_UPD_SRC_REGFILE: - if (!ulp_regfile_read(parms->regfile, cc_opr, ®val)) { - BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", cc_opr); + case BNXT_ULP_FUNC_SRC_REGFILE: + if (!ulp_regfile_read(parms->regfile, func_opr, ®val)) { + BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", func_opr); return -EINVAL; } *result = tfp_be_to_cpu_64(regval); break; - case BNXT_ULP_CC_UPD_SRC_GLB_REGFILE: + case BNXT_ULP_FUNC_SRC_GLB_REGFILE: if (ulp_mapper_glb_resource_read(parms->mapper_data, dir, - cc_opr, ®val, &shared)) { + func_opr, ®val, &shared)) { BNXT_TF_DBG(ERR, "global regfile[%d] read failed.\n", - cc_opr); + func_opr); return -EINVAL; } *result = tfp_be_to_cpu_64(regval); break; - case BNXT_ULP_CC_UPD_SRC_CONST: - *result = cc_opr; + case BNXT_ULP_FUNC_SRC_CONST: + *result = func_opr; break; default: - BNXT_TF_DBG(ERR, "invalid src code %u\n", cc_src); + BNXT_TF_DBG(ERR, "invalid src code %u\n", func_src); return -EINVAL; } return 0; } static int32_t -ulp_mapper_cc_upd_info_process(struct bnxt_ulp_mapper_parms *parms, - struct bnxt_ulp_mapper_tbl_info *tbl) +ulp_mapper_func_info_process(struct bnxt_ulp_mapper_parms *parms, + struct bnxt_ulp_mapper_tbl_info *tbl) { - struct bnxt_ulp_mapper_cc_upd_info *cc_upd = &tbl->cc_upd_info; - uint64_t res = 0, res1, res2; + struct bnxt_ulp_mapper_func_info *func_info = &tbl->func_info; + uint64_t res = 0, res1 = 0, res2 = 0; int32_t rc = 0; + uint32_t process_src1 = 0, process_src2 = 0; - if (cc_upd->cc_opc == BNXT_ULP_CC_UPD_OPC_NOP) + /* determine which functional operands to compute */ + switch (func_info->func_opc) { + case BNXT_ULP_FUNC_OPC_NOP: return rc; + case BNXT_ULP_FUNC_OPC_EQ: + case BNXT_ULP_FUNC_OPC_NE: + case BNXT_ULP_FUNC_OPC_GE: + case BNXT_ULP_FUNC_OPC_GT: + case BNXT_ULP_FUNC_OPC_LE: + case BNXT_ULP_FUNC_OPC_LT: + process_src1 = 1; + process_src2 = 1; + break; + case BNXT_ULP_FUNC_OPC_COPY_SRC1_TO_RF: + process_src1 = 1; + break; + default: + break; + } - rc = ulp_mapper_cc_upd_opr_compute(parms, tbl->direction, - cc_upd->cc_src1, - cc_upd->cc_opr1, &res1); - if (rc) - return rc; + if (process_src1) { + rc = ulp_mapper_func_opr_compute(parms, tbl->direction, + func_info->func_src1, + func_info->func_opr1, &res1); + if (rc) + return rc; + } - rc = ulp_mapper_cc_upd_opr_compute(parms, tbl->direction, - cc_upd->cc_src2, - cc_upd->cc_opr2, &res2); - if (rc) - return rc; + if (process_src2) { + rc = ulp_mapper_func_opr_compute(parms, tbl->direction, + func_info->func_src2, + func_info->func_opr2, &res2); + if (rc) + return rc; + } - switch (cc_upd->cc_opc) { - case BNXT_ULP_CC_UPD_OPC_NOP: - res = 1; - break; - case BNXT_ULP_CC_UPD_OPC_EQ: + /* perform the functional opcode operations */ + switch (func_info->func_opc) { + case BNXT_ULP_FUNC_OPC_EQ: if (res1 == res2) res = 1; break; - case BNXT_ULP_CC_UPD_OPC_NE: + case BNXT_ULP_FUNC_OPC_NE: if (res1 != res2) res = 1; break; - case BNXT_ULP_CC_UPD_OPC_GE: + case BNXT_ULP_FUNC_OPC_GE: if (res1 >= res2) res = 1; break; - case BNXT_ULP_CC_UPD_OPC_GT: + case BNXT_ULP_FUNC_OPC_GT: if (res1 > res2) res = 1; break; - case BNXT_ULP_CC_UPD_OPC_LE: + case BNXT_ULP_FUNC_OPC_LE: if (res1 <= res2) res = 1; break; - case BNXT_ULP_CC_UPD_OPC_LT: + case BNXT_ULP_FUNC_OPC_LT: if (res1 < res2) res = 1; break; - case BNXT_ULP_CC_UPD_OPC_LAST: - BNXT_TF_DBG(ERR, "invalid code %u\n", cc_upd->cc_opc); + case BNXT_ULP_FUNC_OPC_COPY_SRC1_TO_RF: + res = res1; + break; + case BNXT_ULP_FUNC_OPC_RSS_CONFIG: + /* apply the rss config using pmd method */ + return bnxt_rss_config_action_apply(parms); + case BNXT_ULP_FUNC_OPC_GET_PARENT_MAC_ADDR: + rc = bnxt_pmd_get_parent_mac_addr(parms, (uint8_t *)&res); + if (rc) + return -EINVAL; + res = tfp_be_to_cpu_64(res); + break; + default: + BNXT_TF_DBG(ERR, "invalid func code %u\n", func_info->func_opc); return -EINVAL; } - if (ulp_regfile_write(parms->regfile, cc_upd->cc_dst_opr, + if (ulp_regfile_write(parms->regfile, func_info->func_dst_opr, tfp_cpu_to_be_64(res))) { - BNXT_TF_DBG(ERR, "Failed write the cc_opc %u\n", - cc_upd->cc_dst_opr); + BNXT_TF_DBG(ERR, "Failed write the func_opc %u\n", + func_info->func_dst_opr); return -EINVAL; } return rc; } - /* * Processes a list of conditions and returns both a status and result of the * list. The status must be checked prior to verifying the result. @@ -3313,7 +3584,7 @@ ulp_mapper_conflict_resolution_process(struct bnxt_ulp_mapper_parms *parms, { int32_t rc = 0; uint64_t regval; - uint64_t comp_sig_id; + uint64_t comp_sig; *res = 0; switch (tbl->accept_opcode) { @@ -3346,14 +3617,14 @@ ulp_mapper_conflict_resolution_process(struct bnxt_ulp_mapper_parms *parms, BNXT_ULP_RF_IDX_FLOW_SIG_ID); return -EINVAL; } - comp_sig_id = ULP_COMP_FLD_IDX_RD(parms, - BNXT_ULP_CF_IDX_FLOW_SIG_ID); + comp_sig = ULP_COMP_FLD_IDX_RD(parms, + BNXT_ULP_CF_IDX_FLOW_SIG_ID); regval = tfp_be_to_cpu_64(regval); - if (comp_sig_id == regval) + if (comp_sig == regval) *res = 1; else - BNXT_TF_DBG(ERR, "failed signature match %x:%x\n", - (uint32_t)comp_sig_id, (uint32_t)regval); + BNXT_TF_DBG(ERR, "failed signature match 0x%016" + PRIX64 ":%x\n", comp_sig, (uint32_t)regval); break; default: BNXT_TF_DBG(ERR, "Invalid accept opcode %d\n", @@ -3409,8 +3680,9 @@ ulp_mapper_tbls_process(struct bnxt_ulp_mapper_parms *parms, uint32_t tid) for (tbl_idx = 0; tbl_idx < num_tbls && cond_goto;) { tbl = &tbls[tbl_idx]; - /* Process the conditional code update opcodes */ - if (ulp_mapper_cc_upd_info_process(parms, tbl)) { + cond_goto = tbl->execute_info.cond_true_goto; + /* Process the conditional func code opcodes */ + if (ulp_mapper_func_info_process(parms, tbl)) { BNXT_TF_DBG(ERR, "Failed to process cond update\n"); rc = -EINVAL; goto error; @@ -3423,8 +3695,8 @@ ulp_mapper_tbls_process(struct bnxt_ulp_mapper_parms *parms, uint32_t tid) cond_tbls, num_cond_tbls, &cond_rc); if (rc) { - BNXT_TF_DBG(ERR, "Failed to process cond opc list " - "(%d)\n", rc); + BNXT_TF_DBG(ERR, "Failed to proc cond opc list (%d)\n", + rc); goto error; } /* Skip the table if False */ @@ -3525,8 +3797,10 @@ ulp_mapper_resource_free(struct bnxt_ulp_context *ulp, BNXT_TF_DBG(ERR, "Unable to free resource\n "); return -EINVAL; } - - tfp = bnxt_ulp_cntxt_tfp_get(ulp); + if (res->fdb_flags & ULP_FDB_FLAG_SHARED_SESSION) + tfp = bnxt_ulp_cntxt_tfp_get(ulp, BNXT_ULP_SHARED_SESSION_YES); + else + tfp = bnxt_ulp_cntxt_tfp_get(ulp, BNXT_ULP_SHARED_SESSION_NO); if (!tfp) { BNXT_TF_DBG(ERR, "Unable to free resource failed to get tfp\n"); return -EINVAL; @@ -3581,8 +3855,7 @@ ulp_mapper_resources_free(struct bnxt_ulp_context *ulp_ctx, * Set the critical resource on the first resource del, then iterate * while status is good */ - if (flow_type != BNXT_ULP_FDB_TYPE_RID) - res_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_YES; + res_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_YES; rc = ulp_flow_db_resource_del(ulp_ctx, flow_type, fid, &res_parms); @@ -3687,22 +3960,25 @@ ulp_mapper_flow_create(struct bnxt_ulp_context *ulp_ctx, parms.act_prop = cparms->act_prop; parms.act_bitmap = cparms->act; parms.hdr_bitmap = cparms->hdr_bitmap; + parms.enc_hdr_bitmap = cparms->enc_hdr_bitmap; parms.regfile = ®file; parms.hdr_field = cparms->hdr_field; + parms.enc_field = cparms->enc_field; parms.fld_bitmap = cparms->fld_bitmap; parms.comp_fld = cparms->comp_fld; - parms.tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx); parms.ulp_ctx = ulp_ctx; parms.act_tid = cparms->act_tid; parms.class_tid = cparms->class_tid; parms.flow_type = cparms->flow_type; parms.parent_flow = cparms->parent_flow; - parms.parent_fid = cparms->parent_fid; + parms.child_flow = cparms->child_flow; parms.fid = cparms->flow_id; parms.tun_idx = cparms->tun_idx; parms.app_priority = cparms->app_priority; parms.flow_pattern_id = cparms->flow_pattern_id; parms.act_pattern_id = cparms->act_pattern_id; + parms.app_id = cparms->app_id; + parms.port_id = cparms->port_id; /* Get the device id from the ulp context */ if (bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &parms.dev_id)) { @@ -3760,7 +4036,7 @@ ulp_mapper_flow_create(struct bnxt_ulp_context *ulp_ctx, rc = ulp_flow_db_parent_flow_create(&parms); if (rc) goto flow_error; - } else if (parms.parent_fid) { + } else if (parms.child_flow) { /* create a child flow details */ rc = ulp_flow_db_child_flow_create(&parms); if (rc) @@ -3789,7 +4065,7 @@ ulp_mapper_init(struct bnxt_ulp_context *ulp_ctx) if (!ulp_ctx) return -EINVAL; - tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx); + tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO); if (!tfp) return -EINVAL; @@ -3821,8 +4097,7 @@ ulp_mapper_init(struct bnxt_ulp_context *ulp_ctx) if (bnxt_ulp_cntxt_shared_session_enabled(ulp_ctx)) { rc = ulp_mapper_app_glb_resource_info_init(ulp_ctx, data); if (rc) { - BNXT_TF_DBG(ERR, "Failed to initialize app " - "global resources\n"); + BNXT_TF_DBG(ERR, "Failed to init app glb resources\n"); goto error; } } @@ -3849,8 +4124,7 @@ ulp_mapper_deinit(struct bnxt_ulp_context *ulp_ctx) if (!ulp_ctx) { BNXT_TF_DBG(ERR, - "Failed to acquire ulp context, so data may " - "not be released.\n"); + "Failed to acquire ulp context, so data may not be released.\n"); return; } @@ -3862,7 +4136,7 @@ ulp_mapper_deinit(struct bnxt_ulp_context *ulp_ctx) return; } - tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx); + tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO); if (!tfp) { BNXT_TF_DBG(ERR, "Failed to acquire tfp.\n"); /* Free the mapper data regardless of errors. */