X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Ftf_ulp%2Fulp_mapper.c;h=871dbad0fe4743419414d9de8a862327925767aa;hb=45633c460c223a67dd1a7cc084c3eceb5e17687c;hp=58104eeedff9b15a3d0d4254aa289ea4cfda612a;hpb=c6062ec0f78cd018d911fe0182cc1bdf417435de;p=dpdk.git diff --git a/drivers/net/bnxt/tf_ulp/ulp_mapper.c b/drivers/net/bnxt/tf_ulp/ulp_mapper.c index 58104eeedf..871dbad0fe 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_mapper.c +++ b/drivers/net/bnxt/tf_ulp/ulp_mapper.c @@ -19,12 +19,21 @@ #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 }; static uint8_t mapper_fld_ones[16] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; +static uint8_t mapper_fld_one[16] = { + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 +}; + static const char * ulp_mapper_tmpl_name_str(enum bnxt_ulp_template_type tmpl_type) { @@ -114,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; @@ -167,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; @@ -218,8 +227,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; @@ -409,7 +421,7 @@ ulp_mapper_ident_fields_get(struct bnxt_ulp_mapper_parms *mparms, } 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) { @@ -419,6 +431,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); } @@ -731,7 +767,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; @@ -766,6 +802,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) { @@ -812,7 +849,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; @@ -858,6 +895,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", @@ -882,7 +921,6 @@ error: static int32_t ulp_mapper_field_port_db_process(struct bnxt_ulp_mapper_parms *parms, - struct bnxt_ulp_mapper_field_info *fld, uint32_t port_id, uint16_t val16, uint8_t **val) @@ -912,332 +950,122 @@ ulp_mapper_field_port_db_process(struct bnxt_ulp_mapper_parms *parms, } break; default: - BNXT_TF_DBG(ERR, "Invalid port_data %s\n", fld->description); - return -EINVAL; - } - return 0; -} - -static int32_t -ulp_mapper_field_process_inc_dec(struct bnxt_ulp_mapper_field_info *fld, - struct ulp_blob *blob, - uint64_t *val64, - uint16_t const_val16, - uint32_t bitlen, - uint32_t *update_flag) -{ - uint64_t l_val64 = *val64; - - if (fld->field_opc == BNXT_ULP_FIELD_OPC_SRC1_PLUS_CONST || - fld->field_opc == BNXT_ULP_FIELD_OPC_SRC1_PLUS_CONST_POST) { - l_val64 += const_val16; - l_val64 = tfp_be_to_cpu_64(l_val64); - ulp_blob_push_64(blob, &l_val64, bitlen); - } else if (fld->field_opc == BNXT_ULP_FIELD_OPC_SRC1_MINUS_CONST || - fld->field_opc == BNXT_ULP_FIELD_OPC_SRC1_MINUS_CONST_POST) { - l_val64 -= const_val16; - l_val64 = tfp_be_to_cpu_64(l_val64); - ulp_blob_push_64(blob, &l_val64, bitlen); - } else { - BNXT_TF_DBG(ERR, "Invalid field opcode %u\n", fld->field_opc); + BNXT_TF_DBG(ERR, "Invalid port_data %d\n", port_data); return -EINVAL; } - - if (fld->field_opc == BNXT_ULP_FIELD_OPC_SRC1_MINUS_CONST_POST || - fld->field_opc == BNXT_ULP_FIELD_OPC_SRC1_PLUS_CONST_POST) { - *val64 = l_val64; - *update_flag = 1; - } return 0; } static int32_t -ulp_mapper_field_process(struct bnxt_ulp_mapper_parms *parms, - enum tf_dir dir, - struct bnxt_ulp_mapper_field_info *fld, - struct ulp_blob *blob, - uint8_t is_key, - const char *name) +ulp_mapper_field_src_process(struct bnxt_ulp_mapper_parms *parms, + enum bnxt_ulp_field_src field_src, + uint8_t *field_opr, + enum tf_dir dir, + uint8_t is_key, + uint32_t bitlen, + uint8_t **val, + uint32_t *val_len, + uint64_t *value) { - uint32_t val_size = 0, field_size = 0; - uint64_t hdr_bit, act_bit, regval; - uint16_t write_idx = blob->write_idx; - uint16_t idx, size_idx, bitlen, offset; - uint8_t *val = NULL; - uint8_t tmpval[16]; + struct bnxt_ulp_mapper_data *m; uint8_t bit; - uint32_t src1_sel = 0; - enum bnxt_ulp_field_src fld_src; - uint8_t *fld_src_oper; - enum bnxt_ulp_field_cond_src field_cond_src; - uint16_t const_val = 0; - uint32_t update_flag = 0; - uint64_t src1_val64; - uint32_t port_id; + uint32_t port_id, val_size, field_size; + uint16_t idx, size_idx, offset; + uint32_t bytelen = ULP_BITS_2_BYTE(bitlen); + uint8_t *buffer; + uint64_t lregval; bool shared; - /* process the field opcode */ - if (fld->field_opc != BNXT_ULP_FIELD_OPC_COND_OP) { - field_cond_src = BNXT_ULP_FIELD_COND_SRC_TRUE; - /* Read the constant from the second operand */ - memcpy(&const_val, fld->field_opr2, sizeof(uint16_t)); - const_val = tfp_be_to_cpu_16(const_val); - } else { - field_cond_src = fld->field_cond_src; - } - - bitlen = fld->field_bit_size; - /* Evaluate the condition */ - switch (field_cond_src) { - case BNXT_ULP_FIELD_COND_SRC_TRUE: - src1_sel = 1; - break; - case BNXT_ULP_FIELD_COND_SRC_CF: - if (!ulp_operand_read(fld->field_cond_opr, - (uint8_t *)&idx, sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed.\n", name); - return -EINVAL; - } - idx = tfp_be_to_cpu_16(idx); - if (idx >= BNXT_ULP_CF_IDX_LAST) { - BNXT_TF_DBG(ERR, "%s invalid index %u\n", name, idx); - return -EINVAL; - } - /* check if the computed field is set */ - if (ULP_COMP_FLD_IDX_RD(parms, idx)) - src1_sel = 1; - break; - case BNXT_ULP_FIELD_COND_SRC_RF: - if (!ulp_operand_read(fld->field_cond_opr, - (uint8_t *)&idx, sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); - return -EINVAL; - } - - idx = tfp_be_to_cpu_16(idx); - /* Uninitialized regfile entries return 0 */ - if (!ulp_regfile_read(parms->regfile, idx, ®val)) { - BNXT_TF_DBG(ERR, "%s regfile[%d] read oob\n", - name, idx); - return -EINVAL; - } - if (regval) - src1_sel = 1; - break; - case BNXT_ULP_FIELD_COND_SRC_ACT_BIT: - if (!ulp_operand_read(fld->field_cond_opr, - (uint8_t *)&act_bit, sizeof(uint64_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); - return -EINVAL; - } - act_bit = tfp_be_to_cpu_64(act_bit); - if (ULP_BITMAP_ISSET(parms->act_bitmap->bits, act_bit)) - src1_sel = 1; - break; - case BNXT_ULP_FIELD_COND_SRC_HDR_BIT: - if (!ulp_operand_read(fld->field_cond_opr, - (uint8_t *)&hdr_bit, sizeof(uint64_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); - return -EINVAL; - } - hdr_bit = tfp_be_to_cpu_64(hdr_bit); - if (ULP_BITMAP_ISSET(parms->hdr_bitmap->bits, hdr_bit)) - src1_sel = 1; - break; - case BNXT_ULP_FIELD_COND_SRC_FIELD_BIT: - if (!ulp_operand_read(fld->field_cond_opr, (uint8_t *)&idx, - sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed.\n", name); - return -EINVAL; - } - idx = tfp_be_to_cpu_16(idx); - /* get the index from the global field list */ - if (ulp_mapper_glb_field_tbl_get(parms, idx, &bit)) { - BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n", - idx); - return -EINVAL; - } - if (bit && (ULP_INDEX_BITMAP_GET(parms->fld_bitmap->bits, bit))) - src1_sel = 1; - break; - default: - BNXT_TF_DBG(ERR, "%s invalid field opcode 0x%x at %d\n", - name, fld->field_cond_src, write_idx); - return -EINVAL; - } - - /* pick the selected source */ - if (src1_sel) { - fld_src = fld->field_src1; - fld_src_oper = fld->field_opr1; - } else { - fld_src = fld->field_src2; - fld_src_oper = fld->field_opr2; - } - + *val_len = bitlen; + *value = 0; /* Perform the action */ - switch (fld_src) { + switch (field_src) { case BNXT_ULP_FIELD_SRC_ZERO: - if (ulp_blob_pad_push(blob, bitlen) < 0) { - BNXT_TF_DBG(ERR, "%s too large for blob\n", name); - return -EINVAL; - } + *val = mapper_fld_zeros; break; case BNXT_ULP_FIELD_SRC_CONST: - val = fld_src_oper; - if (!ulp_blob_push(blob, val, bitlen)) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", name); - return -EINVAL; - } + *val = field_opr; break; case BNXT_ULP_FIELD_SRC_ONES: - val = mapper_fld_ones; - if (!ulp_blob_push(blob, val, bitlen)) { - BNXT_TF_DBG(ERR, "%s too large for blob\n", name); - return -EINVAL; - } + *val = mapper_fld_ones; + *value = 1; break; case BNXT_ULP_FIELD_SRC_CF: - if (!ulp_operand_read(fld_src_oper, + if (!ulp_operand_read(field_opr, (uint8_t *)&idx, sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed.\n", - name); + BNXT_TF_DBG(ERR, "CF operand read failed\n"); return -EINVAL; } idx = tfp_be_to_cpu_16(idx); - if (idx >= BNXT_ULP_CF_IDX_LAST) { - BNXT_TF_DBG(ERR, "%s comp field [%d] read oob\n", - name, idx); + 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; } - if (fld->field_opc == BNXT_ULP_FIELD_OPC_COND_OP) { - val = ulp_blob_push_32(blob, &parms->comp_fld[idx], - bitlen); - if (!val) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", - name); - return -EINVAL; - } - } else if (fld->field_opc == BNXT_ULP_FIELD_OPC_PORT_TABLE) { - port_id = ULP_COMP_FLD_IDX_RD(parms, idx); - if (ulp_mapper_field_port_db_process(parms, fld, - port_id, const_val, - &val)) { - BNXT_TF_DBG(ERR, "%s field port table failed\n", - name); - return -EINVAL; - } - if (!ulp_blob_push(blob, val, bitlen)) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", - name); - return -EINVAL; - } - } else { - src1_val64 = ULP_COMP_FLD_IDX_RD(parms, idx); - if (ulp_mapper_field_process_inc_dec(fld, blob, - &src1_val64, - const_val, - bitlen, - &update_flag)) { - BNXT_TF_DBG(ERR, "%s field cond opc failed\n", - name); - return -EINVAL; - } - if (update_flag) { - BNXT_TF_DBG(ERR, "%s invalid field cond opc\n", - name); - return -EINVAL; - } - } + buffer = (uint8_t *)&parms->comp_fld[idx]; + *val = &buffer[sizeof(uint64_t) - bytelen]; + *value = ULP_COMP_FLD_IDX_RD(parms, idx); break; case BNXT_ULP_FIELD_SRC_RF: - if (!ulp_operand_read(fld_src_oper, + if (!ulp_operand_read(field_opr, (uint8_t *)&idx, sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); + BNXT_TF_DBG(ERR, "RF operand read failed\n"); return -EINVAL; } idx = tfp_be_to_cpu_16(idx); /* Uninitialized regfile entries return 0 */ - if (!ulp_regfile_read(parms->regfile, idx, ®val)) { - BNXT_TF_DBG(ERR, "%s regfile[%d] read oob\n", - name, idx); + if (!ulp_regfile_read(parms->regfile, idx, &lregval) || + sizeof(uint64_t) < bytelen) { + BNXT_TF_DBG(ERR, "regfile[%d] read oob %u\n", idx, + bytelen); return -EINVAL; } - if (fld->field_opc == BNXT_ULP_FIELD_OPC_COND_OP) { - val = ulp_blob_push_64(blob, ®val, bitlen); - if (!val) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", - name); - return -EINVAL; - } - } else { - if (ulp_mapper_field_process_inc_dec(fld, blob, - ®val, - const_val, - bitlen, - &update_flag)) { - BNXT_TF_DBG(ERR, "%s field cond opc failed\n", - name); - return -EINVAL; - } - if (update_flag) { - regval = tfp_cpu_to_be_64(regval); - if (ulp_regfile_write(parms->regfile, idx, - regval)) { - BNXT_TF_DBG(ERR, - "Write regfile[%d] fail\n", - idx); - return -EINVAL; - } - } - } + buffer = (uint8_t *)&parms->regfile->entry[idx].data; + *val = &buffer[sizeof(uint64_t) - bytelen]; + *value = tfp_be_to_cpu_64(lregval); break; case BNXT_ULP_FIELD_SRC_ACT_PROP: - if (!ulp_operand_read(fld_src_oper, + if (!ulp_operand_read(field_opr, (uint8_t *)&idx, sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); + BNXT_TF_DBG(ERR, "Action operand read failed\n"); return -EINVAL; } idx = tfp_be_to_cpu_16(idx); - if (idx >= BNXT_ULP_ACT_PROP_IDX_LAST) { - BNXT_TF_DBG(ERR, "%s act_prop[%d] oob\n", name, idx); + BNXT_TF_DBG(ERR, "act_prop[%d] oob\n", idx); return -EINVAL; } - val = &parms->act_prop->act_details[idx]; + buffer = &parms->act_prop->act_details[idx]; field_size = ulp_mapper_act_prop_size_get(idx); - if (bitlen < ULP_BYTE_2_BITS(field_size)) { - field_size = field_size - ((bitlen + 7) / 8); - val += field_size; - } - if (!ulp_blob_push(blob, val, bitlen)) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", name); + if (bytelen > field_size) { + BNXT_TF_DBG(ERR, "act_prop[%d] field size small %u\n", + idx, field_size); return -EINVAL; } + *val = &buffer[field_size - bytelen]; break; case BNXT_ULP_FIELD_SRC_ACT_PROP_SZ: - if (!ulp_operand_read(fld_src_oper, + if (!ulp_operand_read(field_opr, (uint8_t *)&idx, sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); + BNXT_TF_DBG(ERR, "Action sz operand read failed\n"); return -EINVAL; } idx = tfp_be_to_cpu_16(idx); if (idx >= BNXT_ULP_ACT_PROP_IDX_LAST) { - BNXT_TF_DBG(ERR, "%s act_prop[%d] oob\n", name, idx); + BNXT_TF_DBG(ERR, "act_prop_sz[%d] oob\n", idx); return -EINVAL; } - val = &parms->act_prop->act_details[idx]; + *val = &parms->act_prop->act_details[idx]; /* get the size index next */ - if (!ulp_operand_read(&fld_src_oper[sizeof(uint16_t)], + if (!ulp_operand_read(&field_opr[sizeof(uint16_t)], (uint8_t *)&size_idx, sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); + BNXT_TF_DBG(ERR, "Action sz operand read failed\n"); return -EINVAL; } size_idx = tfp_be_to_cpu_16(size_idx); - if (size_idx >= BNXT_ULP_ACT_PROP_IDX_LAST) { BNXT_TF_DBG(ERR, "act_prop[%d] oob\n", size_idx); return -EINVAL; @@ -1245,51 +1073,32 @@ ulp_mapper_field_process(struct bnxt_ulp_mapper_parms *parms, memcpy(&val_size, &parms->act_prop->act_details[size_idx], sizeof(uint32_t)); val_size = tfp_be_to_cpu_32(val_size); - val_size = ULP_BYTE_2_BITS(val_size); - ulp_blob_push_encap(blob, val, val_size); + *val_len = ULP_BYTE_2_BITS(val_size); break; case BNXT_ULP_FIELD_SRC_GLB_RF: - if (!ulp_operand_read(fld_src_oper, - (uint8_t *)&idx, - sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed.\n", name); + if (!ulp_operand_read(field_opr, + (uint8_t *)&idx, sizeof(uint16_t))) { + BNXT_TF_DBG(ERR, "Global regfile read failed\n"); return -EINVAL; } idx = tfp_be_to_cpu_16(idx); - if (ulp_mapper_glb_resource_read(parms->mapper_data, dir, - idx, ®val, &shared)) { - BNXT_TF_DBG(ERR, "%s global regfile[%d] read failed.\n", - name, idx); + if (ulp_mapper_glb_resource_read(parms->mapper_data, + dir, idx, &lregval, &shared) || + sizeof(uint64_t) < bytelen) { + BNXT_TF_DBG(ERR, "Global regfile[%d] read failed %u\n", + idx, bytelen); return -EINVAL; } - if (fld->field_opc == BNXT_ULP_FIELD_OPC_COND_OP) { - val = ulp_blob_push_64(blob, ®val, bitlen); - if (!val) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", - name); - return -EINVAL; - } - } else { - if (ulp_mapper_field_process_inc_dec(fld, blob, - ®val, - const_val, - bitlen, - &update_flag)) { - BNXT_TF_DBG(ERR, "%s field cond opc failed\n", - name); - return -EINVAL; - } - if (update_flag) { - BNXT_TF_DBG(ERR, "%s invalid field cond opc\n", - name); - return -EINVAL; - } - } + m = parms->mapper_data; + buffer = (uint8_t *)&m->glb_res_tbl[dir][idx].resource_hndl; + *val = &buffer[sizeof(uint64_t) - bytelen]; + *value = tfp_be_to_cpu_64(lregval); break; case BNXT_ULP_FIELD_SRC_HF: - if (!ulp_operand_read(fld_src_oper, (uint8_t *)&idx, - sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed.\n", name); + case BNXT_ULP_FIELD_SRC_SUB_HF: + 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); @@ -1300,69 +1109,67 @@ ulp_mapper_field_process(struct bnxt_ulp_mapper_parms *parms, return -EINVAL; } if (is_key) - val = parms->hdr_field[bit].spec; + buffer = parms->hdr_field[bit].spec; else - val = parms->hdr_field[bit].mask; + buffer = parms->hdr_field[bit].mask; - /* - * Need to account for how much data was pushed to the header - * field vs how much is to be inserted in the key/mask. - */ field_size = parms->hdr_field[bit].size; - if (bitlen < ULP_BYTE_2_BITS(field_size)) { - field_size = field_size - ((bitlen + 7) / 8); - val += field_size; - } - - if (!ulp_blob_push(blob, val, bitlen)) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", name); + if (bytelen > field_size) { + BNXT_TF_DBG(ERR, "Hdr field[%d] size small %u\n", + bit, field_size); return -EINVAL; } + if (field_src == BNXT_ULP_FIELD_SRC_HF) { + *val = &buffer[field_size - bytelen]; + } else { + /* get the offset next */ + if (!ulp_operand_read(&field_opr[sizeof(uint16_t)], + (uint8_t *)&offset, + sizeof(uint16_t))) { + BNXT_TF_DBG(ERR, "Hdr fld size read failed\n"); + return -EINVAL; + } + offset = tfp_be_to_cpu_16(offset); + offset = ULP_BITS_2_BYTE_NR(offset); + if ((offset + bytelen) > field_size) { + BNXT_TF_DBG(ERR, "Hdr field[%d] oob\n", bit); + return -EINVAL; + } + *val = &buffer[offset]; + } break; case BNXT_ULP_FIELD_SRC_HDR_BIT: - if (!ulp_operand_read(fld_src_oper, - (uint8_t *)&hdr_bit, sizeof(uint64_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); + if (!ulp_operand_read(field_opr, + (uint8_t *)&lregval, sizeof(uint64_t))) { + BNXT_TF_DBG(ERR, "Header bit read failed\n"); return -EINVAL; } - hdr_bit = tfp_be_to_cpu_64(hdr_bit); - memset(tmpval, 0, sizeof(tmpval)); - if (ULP_BITMAP_ISSET(parms->hdr_bitmap->bits, hdr_bit)) - tmpval[0] = 1; - if (bitlen > ULP_BYTE_2_BITS(sizeof(tmpval))) { - BNXT_TF_DBG(ERR, "%s field size is incorrect\n", name); - return -EINVAL; - } - if (!ulp_blob_push(blob, tmpval, bitlen)) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", name); - return -EINVAL; + lregval = tfp_be_to_cpu_64(lregval); + if (ULP_BITMAP_ISSET(parms->hdr_bitmap->bits, lregval)) { + *val = mapper_fld_one; + *value = 1; + } else { + *val = mapper_fld_zeros; } - val = tmpval; break; case BNXT_ULP_FIELD_SRC_ACT_BIT: - if (!ulp_operand_read(fld_src_oper, - (uint8_t *)&act_bit, sizeof(uint64_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); - return -EINVAL; - } - act_bit = tfp_be_to_cpu_64(act_bit); - memset(tmpval, 0, sizeof(tmpval)); - if (ULP_BITMAP_ISSET(parms->act_bitmap->bits, act_bit)) - tmpval[0] = 1; - if (bitlen > ULP_BYTE_2_BITS(sizeof(tmpval))) { - BNXT_TF_DBG(ERR, "%s field size is incorrect\n", name); + if (!ulp_operand_read(field_opr, + (uint8_t *)&lregval, sizeof(uint64_t))) { + BNXT_TF_DBG(ERR, "Action bit read failed\n"); return -EINVAL; } - if (!ulp_blob_push(blob, tmpval, bitlen)) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", name); - return -EINVAL; + lregval = tfp_be_to_cpu_64(lregval); + if (ULP_BITMAP_ISSET(parms->act_bitmap->bits, lregval)) { + *val = mapper_fld_one; + *value = 1; + } else { + *val = mapper_fld_zeros; } - val = tmpval; break; case BNXT_ULP_FIELD_SRC_FIELD_BIT: - if (!ulp_operand_read(fld_src_oper, (uint8_t *)&idx, - sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed.\n", name); + if (!ulp_operand_read(field_opr, + (uint8_t *)&idx, sizeof(uint16_t))) { + BNXT_TF_DBG(ERR, "Field bit read failed\n"); return -EINVAL; } idx = tfp_be_to_cpu_16(idx); @@ -1372,70 +1179,281 @@ ulp_mapper_field_process(struct bnxt_ulp_mapper_parms *parms, idx); return -EINVAL; } - memset(tmpval, 0, sizeof(tmpval)); - if (ULP_INDEX_BITMAP_GET(parms->fld_bitmap->bits, bit)) - tmpval[0] = 1; - if (bitlen > ULP_BYTE_2_BITS(sizeof(tmpval))) { - BNXT_TF_DBG(ERR, "%s field size is incorrect\n", name); + if (ULP_INDEX_BITMAP_GET(parms->fld_bitmap->bits, bit)) { + *val = mapper_fld_one; + *value = 1; + } else { + *val = mapper_fld_zeros; + } + break; + case BNXT_ULP_FIELD_SRC_PORT_TABLE: + /* The port id is present in the comp field list */ + port_id = ULP_COMP_FLD_IDX_RD(parms, + BNXT_ULP_CF_IDX_DEV_PORT_ID); + /* get the port table enum */ + if (!ulp_operand_read(field_opr, + (uint8_t *)&idx, sizeof(uint16_t))) { + BNXT_TF_DBG(ERR, "Port table enum read failed\n"); return -EINVAL; } - if (!ulp_blob_push(blob, tmpval, bitlen)) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", name); + idx = tfp_be_to_cpu_16(idx); + if (ulp_mapper_field_port_db_process(parms, port_id, idx, + val)) { + BNXT_TF_DBG(ERR, "field port table failed\n"); return -EINVAL; } - val = tmpval; - break; case BNXT_ULP_FIELD_SRC_SKIP: /* do nothing */ break; case BNXT_ULP_FIELD_SRC_REJECT: return -EINVAL; - case BNXT_ULP_FIELD_SRC_SUB_HF: - if (!ulp_operand_read(fld_src_oper, - (uint8_t *)&idx, sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); + default: + BNXT_TF_DBG(ERR, "invalid field opcode 0x%x\n", field_src); + return -EINVAL; + } + return 0; +} + +static int32_t ulp_mapper_field_buffer_eval(uint8_t *buffer, uint32_t bitlen, + uint64_t *output) +{ + uint16_t val_16; + uint32_t val_32; + uint64_t val_64; + uint32_t bytelen; + + bytelen = ULP_BITS_2_BYTE(bitlen); + if (bytelen == sizeof(uint8_t)) { + *output = *((uint8_t *)buffer); + } else if (bytelen == sizeof(uint16_t)) { + val_16 = *((uint16_t *)buffer); + *output = tfp_be_to_cpu_16(val_16); + } else if (bytelen == sizeof(uint32_t)) { + val_32 = *((uint32_t *)buffer); + *output = tfp_be_to_cpu_32(val_32); + } else if (bytelen == sizeof(val_64)) { + val_64 = *((uint64_t *)buffer); + *output = tfp_be_to_cpu_64(val_64); + } else { + *output = 0; + return -EINVAL; + } + return 0; +} + +static int32_t ulp_mapper_field_blob_write(enum bnxt_ulp_field_src fld_src, + struct ulp_blob *blob, + uint8_t *val, + uint32_t val_len, + uint8_t **out_val) +{ + if (fld_src == BNXT_ULP_FIELD_SRC_ZERO) { + if (ulp_blob_pad_push(blob, val_len) < 0) { + BNXT_TF_DBG(ERR, "too large for blob\n"); return -EINVAL; } - idx = tfp_be_to_cpu_16(idx); - /* get the index from the global field list */ - if (ulp_mapper_glb_field_tbl_get(parms, idx, &bit)) { - BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n", - idx); + } else if (fld_src == BNXT_ULP_FIELD_SRC_ACT_PROP_SZ) { + if (ulp_blob_push_encap(blob, val, val_len) < 0) { + BNXT_TF_DBG(ERR, "encap blob push failed\n"); return -EINVAL; } - - /* get the offset next */ - if (!ulp_operand_read(&fld_src_oper[sizeof(uint16_t)], - (uint8_t *)&offset, sizeof(uint16_t))) { - BNXT_TF_DBG(ERR, "%s operand read failed\n", name); + } else { + if (!ulp_blob_push(blob, val, val_len)) { + BNXT_TF_DBG(ERR, "push of val1 failed\n"); return -EINVAL; } - offset = tfp_be_to_cpu_16(offset); - if ((offset + bitlen) > - ULP_BYTE_2_BITS(parms->hdr_field[bit].size) || - ULP_BITS_IS_BYTE_NOT_ALIGNED(offset)) { - BNXT_TF_DBG(ERR, "Hdr field[%s] oob\n", name); - return -EINVAL; + } + *out_val = val; + return 0; +} + +static int32_t +ulp_mapper_field_opc_process(struct bnxt_ulp_mapper_parms *parms, + enum tf_dir dir, + struct bnxt_ulp_mapper_field_info *fld, + struct ulp_blob *blob, + uint8_t is_key, + const char *name) +{ + uint16_t write_idx = blob->write_idx; + uint8_t *val = NULL, *val1, *val2, *val3; + uint32_t val_len = 0, val1_len = 0, val2_len = 0, val3_len = 0; + uint8_t process_src1 = 0, process_src2 = 0, process_src3 = 0; + uint8_t eval_src1 = 0, eval_src2 = 0, eval_src3 = 0; + uint64_t val_int = 0, val1_int = 0, val2_int = 0, val3_int = 0; + uint64_t value1 = 0, value2 = 0, value3 = 0; + int32_t rc = 0; + + /* prepare the field source and values */ + switch (fld->field_opc) { + case BNXT_ULP_FIELD_OPC_SRC1: + process_src1 = 1; + break; + case BNXT_ULP_FIELD_OPC_SRC1_THEN_SRC2_ELSE_SRC3: + process_src1 = 1; + break; + case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2_OR_SRC3: + case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2_OR_SRC3: + process_src3 = 1; + eval_src3 = 1; + process_src1 = 1; + process_src2 = 1; + eval_src1 = 1; + eval_src2 = 1; + break; + case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2: + case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2: + case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2_POST: + case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2_POST: + case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2: + case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2: + process_src1 = 1; + process_src2 = 1; + eval_src1 = 1; + eval_src2 = 1; + break; + default: + break; + } + + /* process the src1 opcode */ + if (process_src1) { + if (ulp_mapper_field_src_process(parms, fld->field_src1, + fld->field_opr1, dir, is_key, + fld->field_bit_size, &val1, + &val1_len, &value1)) { + BNXT_TF_DBG(ERR, "fld src1 process failed\n"); + goto error; } - offset = ULP_BITS_2_BYTE_NR(offset); + if (eval_src1) { + if (ulp_mapper_field_buffer_eval(val1, val1_len, + &val1_int)) { + BNXT_TF_DBG(ERR, "fld src1 eval failed\n"); + goto error; + } + } + } - /* write the value into blob */ - if (is_key) - val = &parms->hdr_field[bit].spec[offset]; + /* for "if then clause" set the correct process */ + if (fld->field_opc == BNXT_ULP_FIELD_OPC_SRC1_THEN_SRC2_ELSE_SRC3) { + if (value1) + process_src2 = 1; else - val = &parms->hdr_field[bit].mask[offset]; + process_src3 = 1; + } - if (!ulp_blob_push(blob, val, bitlen)) { - BNXT_TF_DBG(ERR, "%s push to blob failed\n", name); - return -EINVAL; + /* process src2 opcode */ + if (process_src2) { + if (ulp_mapper_field_src_process(parms, fld->field_src2, + fld->field_opr2, dir, is_key, + fld->field_bit_size, &val2, + &val2_len, &value2)) { + BNXT_TF_DBG(ERR, "fld src2 process failed\n"); + goto error; + } + if (eval_src2) { + if (ulp_mapper_field_buffer_eval(val2, val2_len, + &val2_int)) { + BNXT_TF_DBG(ERR, "fld src2 eval failed\n"); + goto error; + } + } + } + + /* process src3 opcode */ + if (process_src3) { + if (ulp_mapper_field_src_process(parms, fld->field_src3, + fld->field_opr3, dir, is_key, + fld->field_bit_size, &val3, + &val3_len, &value3)) { + BNXT_TF_DBG(ERR, "fld src3 process failed\n"); + goto error; + } + if (eval_src3) { + if (ulp_mapper_field_buffer_eval(val3, val3_len, + &val3_int)) { + BNXT_TF_DBG(ERR, "fld src3 eval failed\n"); + goto error; + } } + } + + val_len = fld->field_bit_size; + /* process the field opcodes */ + switch (fld->field_opc) { + case BNXT_ULP_FIELD_OPC_SRC1: + 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) { + rc = ulp_mapper_field_blob_write(fld->field_src2, blob, + val2, val2_len, &val); + val_len = val2_len; + } else { + rc = ulp_mapper_field_blob_write(fld->field_src3, blob, + val3, val3_len, &val); + val_len = val3_len; + } + break; + case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2: + case BNXT_ULP_FIELD_OPC_SRC1_PLUS_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) + 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) + 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) + 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) + 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) + 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) + rc = -EINVAL; + break; + case BNXT_ULP_FIELD_OPC_SKIP: break; default: - BNXT_TF_DBG(ERR, "%s invalid field opcode 0x%x at %d\n", - name, fld_src, write_idx); - return -EINVAL; + BNXT_TF_DBG(ERR, "Invalid fld opcode %u\n", fld->field_opc); + rc = -EINVAL; + break; } - return 0; + + return rc; +error: + BNXT_TF_DBG(ERR, "Error in %s:%s process %u:%u\n", name, + fld->description, (val) ? write_idx : 0, val_len); + return -EINVAL; } /* @@ -1474,8 +1492,8 @@ ulp_mapper_tbl_result_build(struct bnxt_ulp_mapper_parms *parms, ulp_blob_encap_swap_idx_set(data); /* Process the result fields */ - rc = ulp_mapper_field_process(parms, tbl->direction, - &dflds[i], data, 0, name); + rc = ulp_mapper_field_opc_process(parms, tbl->direction, + &dflds[i], data, 0, name); if (rc) { BNXT_TF_DBG(ERR, "data field failed\n"); return rc; @@ -1524,6 +1542,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); @@ -1570,6 +1590,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); @@ -1616,6 +1638,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); @@ -1682,7 +1706,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; @@ -1849,7 +1873,7 @@ 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; @@ -1877,9 +1901,9 @@ ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, */ for (i = 0; i < num_kflds; i++) { /* Setup the key */ - rc = ulp_mapper_field_process(parms, tbl->direction, - &kflds[i].field_info_spec, - key, 1, "TCAM Key"); + rc = ulp_mapper_field_opc_process(parms, tbl->direction, + &kflds[i].field_info_spec, + key, 1, "TCAM Key"); if (rc) { BNXT_TF_DBG(ERR, "Key field set failed %s\n", kflds[i].field_info_spec.description); @@ -1887,9 +1911,9 @@ ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, } /* Setup the mask */ - rc = ulp_mapper_field_process(parms, tbl->direction, - &kflds[i].field_info_mask, - mask, 0, "TCAM Mask"); + rc = ulp_mapper_field_opc_process(parms, tbl->direction, + &kflds[i].field_info_mask, + mask, 0, "TCAM Mask"); if (rc) { BNXT_TF_DBG(ERR, "Mask field set failed %s\n", kflds[i].field_info_mask.description); @@ -1898,7 +1922,9 @@ 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 (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) { 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, @@ -2015,6 +2041,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", @@ -2043,7 +2071,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 }; @@ -2053,6 +2081,7 @@ ulp_mapper_em_tbl_process(struct bnxt_ulp_mapper_parms *parms, int32_t rc = 0; int32_t pad = 0; + 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"); @@ -2077,9 +2106,9 @@ ulp_mapper_em_tbl_process(struct bnxt_ulp_mapper_parms *parms, /* create the key */ for (i = 0; i < num_kflds; i++) { /* Setup the key */ - rc = ulp_mapper_field_process(parms, tbl->direction, - &kflds[i].field_info_spec, - &key, 1, "EM Key"); + rc = ulp_mapper_field_opc_process(parms, tbl->direction, + &kflds[i].field_info_spec, + &key, 1, "EM Key"); if (rc) { BNXT_TF_DBG(ERR, "Key field set failed.\n"); return rc; @@ -2219,8 +2248,8 @@ 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; @@ -2228,6 +2257,7 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, uint64_t act_rec_size; bool shared = false; + tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); /* use the max size if encap is enabled */ if (tbl->encap_num_fields) bit_size = BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS; @@ -2307,8 +2337,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; } @@ -2358,8 +2387,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; @@ -2444,8 +2474,7 @@ 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); @@ -2472,6 +2501,7 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, 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) { @@ -2517,10 +2547,11 @@ 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)) { @@ -2622,7 +2653,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; @@ -2645,9 +2676,9 @@ ulp_mapper_gen_tbl_process(struct bnxt_ulp_mapper_parms *parms, } for (i = 0; i < num_kflds; i++) { /* Setup the key */ - rc = ulp_mapper_field_process(parms, tbl->direction, - &kflds[i].field_info_spec, - &key, 1, "Gen Tbl Key"); + rc = ulp_mapper_field_opc_process(parms, tbl->direction, + &kflds[i].field_info_spec, + &key, 1, "Gen Tbl Key"); if (rc) { BNXT_TF_DBG(ERR, "Failed to create key for Gen tbl rc=%d\n", @@ -2699,6 +2730,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, @@ -2803,6 +2839,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); @@ -2844,15 +2882,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; } @@ -2892,10 +2930,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; @@ -2903,13 +2943,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"); @@ -2927,15 +2965,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; } @@ -2946,12 +2984,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: @@ -2965,10 +3020,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. @@ -3125,106 +3178,141 @@ 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_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; } @@ -3311,7 +3399,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) { @@ -3344,14 +3432,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", @@ -3407,8 +3495,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; @@ -3421,8 +3510,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 */ @@ -3523,8 +3612,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; @@ -3689,7 +3780,6 @@ ulp_mapper_flow_create(struct bnxt_ulp_context *ulp_ctx, parms.hdr_field = cparms->hdr_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; @@ -3701,6 +3791,8 @@ ulp_mapper_flow_create(struct bnxt_ulp_context *ulp_ctx, 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)) { @@ -3787,7 +3879,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; @@ -3819,8 +3911,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; } } @@ -3847,8 +3938,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; } @@ -3860,7 +3950,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. */