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=90ba38d05b8db9b0d0b6e7ef9a01d629e22707b4;hpb=3fe124d2536c5b6d4aa9f7de77f90651b8fcd8e3;p=dpdk.git diff --git a/drivers/net/bnxt/tf_ulp/ulp_mapper.c b/drivers/net/bnxt/tf_ulp/ulp_mapper.c index 90ba38d05b..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) { @@ -58,13 +67,15 @@ static int32_t ulp_mapper_glb_resource_read(struct bnxt_ulp_mapper_data *mapper_data, enum tf_dir dir, uint16_t idx, - uint64_t *regval) + uint64_t *regval, + bool *shared) { - if (!mapper_data || !regval || + if (!mapper_data || !regval || !shared || dir >= TF_DIR_MAX || idx >= BNXT_ULP_GLB_RF_IDX_LAST) return -EINVAL; *regval = mapper_data->glb_res_tbl[dir][idx].resource_hndl; + *shared = mapper_data->glb_res_tbl[dir][idx].shared; return 0; } @@ -78,7 +89,7 @@ ulp_mapper_glb_resource_read(struct bnxt_ulp_mapper_data *mapper_data, static int32_t ulp_mapper_glb_resource_write(struct bnxt_ulp_mapper_data *data, struct bnxt_ulp_glb_resource_info *res, - uint64_t regval) + uint64_t regval, bool shared) { struct bnxt_ulp_mapper_glb_resource_entry *ent; @@ -92,6 +103,7 @@ ulp_mapper_glb_resource_write(struct bnxt_ulp_mapper_data *data, ent->resource_func = res->resource_func; ent->resource_type = res->resource_type; ent->resource_hndl = regval; + ent->shared = shared; return 0; } @@ -111,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; @@ -129,8 +141,12 @@ ulp_mapper_resource_ident_allocate(struct bnxt_ulp_context *ulp_ctx, /* entries are stored as big-endian format */ regval = tfp_cpu_to_be_64((uint64_t)iparms.id); - /* write to the mapper global resource */ - rc = ulp_mapper_glb_resource_write(mapper_data, glb_res, regval); + /* + * write to the mapper global resource + * Shared resources are never allocated through this method, so the + * shared flag is always false. + */ + rc = ulp_mapper_glb_resource_write(mapper_data, glb_res, regval, false); if (rc) { BNXT_TF_DBG(ERR, "Failed to write to global resource id\n"); /* Free the identifier when update failed */ @@ -160,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; @@ -186,8 +202,12 @@ ulp_mapper_resource_index_tbl_alloc(struct bnxt_ulp_context *ulp_ctx, /* entries are stored as big-endian format */ regval = tfp_cpu_to_be_64((uint64_t)aparms.idx); - /* write to the mapper global resource */ - rc = ulp_mapper_glb_resource_write(mapper_data, glb_res, regval); + /* + * write to the mapper global resource + * Shared resources are never allocated through this method, so the + * shared flag is always false. + */ + rc = ulp_mapper_glb_resource_write(mapper_data, glb_res, regval, false); if (rc) { BNXT_TF_DBG(ERR, "Failed to write to global resource id\n"); /* Free the identifier when update failed */ @@ -207,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; @@ -398,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) { @@ -408,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); } @@ -720,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; @@ -755,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) { @@ -801,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; @@ -847,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", @@ -871,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) @@ -901,331 +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); + BNXT_TF_DBG(ERR, "Invalid port_data %d\n", port_data); 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); - 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; - - /* 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; - } - + 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; + + *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; @@ -1233,52 +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)) { - BNXT_TF_DBG(ERR, "%s global regfile[%d] read failed.\n", - name, idx); + 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); @@ -1289,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); @@ -1361,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; + } + 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; + } } - offset = ULP_BITS_2_BYTE_NR(offset); + } - /* 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; } /* @@ -1463,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; @@ -1513,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); @@ -1559,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); @@ -1605,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); @@ -1671,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; @@ -1838,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; @@ -1866,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); @@ -1876,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); @@ -1887,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, @@ -2004,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", @@ -2032,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 }; @@ -2042,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"); @@ -2066,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; @@ -2208,14 +2248,16 @@ 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; + 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; @@ -2293,10 +2335,9 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, if (ulp_mapper_glb_resource_read(parms->mapper_data, tbl->direction, tbl->tbl_operand, - ®val)) { + ®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; } @@ -2346,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; @@ -2400,8 +2442,13 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, regval = tfp_cpu_to_be_64(regval); if (global) { + /* + * Shared resources are never allocated through this + * method, so the shared flag is always false. + */ rc = ulp_mapper_glb_resource_write(parms->mapper_data, - &glb_res, regval); + &glb_res, regval, + false); } else { rc = ulp_regfile_write(parms->regfile, tbl->tbl_operand, regval); @@ -2422,11 +2469,12 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, sparms.data_sz_in_bytes = ULP_BITS_2_BYTE(tmplen); sparms.idx = index; sparms.tbl_scope_id = tbl_scope_id; + if (shared) + tfp = bnxt_ulp_cntxt_shared_tfp_get(parms->ulp_ctx); 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); @@ -2453,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) { @@ -2469,6 +2518,9 @@ ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, } return rc; error: + /* Shared resources are not freed */ + if (shared) + return rc; /* * Free the allocated resource since we failed to either * write to the entry or link the flow @@ -2495,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)) { @@ -2600,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; @@ -2623,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", @@ -2677,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, @@ -2781,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); @@ -2810,7 +2870,8 @@ ulp_mapper_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, struct bnxt_ulp_mapper_data *mapper_data) { struct bnxt_ulp_glb_resource_info *glb_res; - uint32_t num_glb_res_ids, idx; + uint32_t num_glb_res_ids, idx, dev_id; + uint8_t app_id; int32_t rc = 0; glb_res = ulp_mapper_glb_resource_info_list_get(&num_glb_res_ids); @@ -2819,8 +2880,25 @@ ulp_mapper_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, return -EINVAL; } + rc = bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &dev_id); + if (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 glb init (%d)\n", + rc); + return rc; + } + /* Iterate the global resources and process each one */ for (idx = 0; idx < num_glb_res_ids; idx++) { + if (dev_id != glb_res[idx].device_id || + glb_res[idx].app_id != app_id) + continue; switch (glb_res[idx].resource_func) { case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER: rc = ulp_mapper_resource_ident_allocate(ulp_ctx, @@ -2845,41 +2923,115 @@ ulp_mapper_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, } /* - * Function to process the memtype opcode of the mapper table. - * returns 1 to skip the table. - * return 0 to continue processing the table. - * - * defaults to skip + * Iterate over the shared resources assigned during tf_open_session and store + * them in the global regfile with the shared flag. */ static int32_t -ulp_mapper_tbl_memtype_opcode_process(struct bnxt_ulp_mapper_parms *parms, - struct bnxt_ulp_mapper_tbl_info *tbl) +ulp_mapper_app_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, + struct bnxt_ulp_mapper_data *mapper_data) { - enum bnxt_ulp_flow_mem_type mtype = BNXT_ULP_FLOW_MEM_TYPE_INT; - int32_t rc = 1; + 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; + struct tf *tfp; + uint8_t app_id; - if (bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype)) { - BNXT_TF_DBG(ERR, "Failed to get the mem type\n"); + 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"); + return -EINVAL; + } + /* + * Retrieve the resources that were assigned during the shared session + * creation. + */ + rc = tf_get_session_info(tfp, &sparms); + if (rc) { + BNXT_TF_DBG(ERR, "Failed to get session info (%d)\n", rc); return rc; } - switch (tbl->mem_type_opcode) { - case BNXT_ULP_MEM_TYPE_OPC_EXECUTE_IF_INT: - if (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT) - rc = 0; - break; - case BNXT_ULP_MEM_TYPE_OPC_EXECUTE_IF_EXT: - if (mtype == BNXT_ULP_FLOW_MEM_TYPE_EXT) - rc = 0; - break; - case BNXT_ULP_MEM_TYPE_OPC_NOP: - rc = 0; - break; - default: - BNXT_TF_DBG(ERR, - "Invalid arg in mapper in memtype opcode\n"); - break; + rc = bnxt_ulp_cntxt_app_id_get(ulp_ctx, &app_id); + if (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 dev id for app glb init (%d)\n", + rc); + return rc; + } + + /* Store all the app global resources */ + for (i = 0; i < num_entries; i++) { + if (dev_id != glb_res[i].device_id || + app_id != glb_res[i].app_id) + 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: + res_info = &sparms.session_info.tcam[dir].info[res]; + break; + case BNXT_ULP_RESOURCE_FUNC_EM_TABLE: + res_info = &sparms.session_info.em[dir].info[res]; + break; + default: + BNXT_TF_DBG(ERR, "Unknown resource func (0x%x)\n", + glb_res[i].resource_func); + continue; + } + regval = tfp_cpu_to_be_64((uint64_t)res_info->start); + res_info->start += addend; + /* + * All resources written to the global regfile are shared for + * this function. + */ + rc = ulp_mapper_glb_resource_write(mapper_data, &glb_res[i], + regval, true); + if (rc) + return rc; } + return rc; } @@ -2893,6 +3045,7 @@ ulp_mapper_cond_opc_process(struct bnxt_ulp_mapper_parms *parms, uint32_t operand, int32_t *res) { + enum bnxt_ulp_flow_mem_type mtype = BNXT_ULP_FLOW_MEM_TYPE_INT; int32_t rc = 0; uint8_t bit; uint64_t regval; @@ -3002,6 +3155,20 @@ ulp_mapper_cond_opc_process(struct bnxt_ulp_mapper_parms *parms, return -EINVAL; } break; + case BNXT_ULP_COND_OPC_EXT_MEM_IS_SET: + if (bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype)) { + BNXT_TF_DBG(ERR, "Failed to get the mem type\n"); + return -EINVAL; + } + *res = (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT) ? 0 : 1; + break; + case BNXT_ULP_COND_OPC_EXT_MEM_NOT_SET: + if (bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype)) { + BNXT_TF_DBG(ERR, "Failed to get the mem type\n"); + return -EINVAL; + } + *res = (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT) ? 1 : 0; + break; default: BNXT_TF_DBG(ERR, "Invalid conditional opcode %d\n", opc); rc = -EINVAL; @@ -3010,6 +3177,149 @@ ulp_mapper_cond_opc_process(struct bnxt_ulp_mapper_parms *parms, return (rc); } +static int32_t +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 (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 = ULP_COMP_FLD_IDX_RD(parms, func_opr); + break; + 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_FUNC_SRC_GLB_REGFILE: + if (ulp_mapper_glb_resource_read(parms->mapper_data, dir, + func_opr, ®val, &shared)) { + BNXT_TF_DBG(ERR, "global regfile[%d] read failed.\n", + 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", func_src); + return -EINVAL; + } + return 0; +} + +static int32_t +ulp_mapper_func_info_process(struct bnxt_ulp_mapper_parms *parms, + struct bnxt_ulp_mapper_tbl_info *tbl) +{ + 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; + + /* 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; + } + + 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; + } + + 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; + } + + /* 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_FUNC_OPC_NE: + if (res1 != res2) + res = 1; + break; + case BNXT_ULP_FUNC_OPC_GE: + if (res1 >= res2) + res = 1; + break; + case BNXT_ULP_FUNC_OPC_GT: + if (res1 > res2) + res = 1; + break; + case BNXT_ULP_FUNC_OPC_LE: + if (res1 <= res2) + res = 1; + break; + case BNXT_ULP_FUNC_OPC_LT: + if (res1 < res2) + res = 1; + break; + 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, func_info->func_dst_opr, + tfp_cpu_to_be_64(res))) { + 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. @@ -3045,6 +3355,7 @@ ulp_mapper_cond_opc_list_process(struct bnxt_ulp_mapper_parms *parms, default: BNXT_TF_DBG(ERR, "Invalid conditional list opcode %d\n", list_opc); + *res = 0; return -EINVAL; } @@ -3088,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) { @@ -3121,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", @@ -3184,10 +3495,12 @@ 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]; - /* Handle the table level opcodes to determine if required. */ - if (ulp_mapper_tbl_memtype_opcode_process(parms, tbl)) { - cond_goto = tbl->execute_info.cond_false_goto; - goto next_iteration; + 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; } cond_tbls = ulp_mapper_tbl_execute_list_get(parms, tbl, @@ -3197,9 +3510,9 @@ 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); - return rc; + BNXT_TF_DBG(ERR, "Failed to proc cond opc list (%d)\n", + rc); + goto error; } /* Skip the table if False */ if (!cond_rc) { @@ -3251,6 +3564,26 @@ ulp_mapper_tbls_process(struct bnxt_ulp_mapper_parms *parms, uint32_t tid) goto error; } next_iteration: + if (cond_goto == BNXT_ULP_COND_GOTO_REJECT) { + BNXT_TF_DBG(ERR, "reject the flow\n"); + rc = -EINVAL; + goto error; + } else if (cond_goto & BNXT_ULP_COND_GOTO_RF) { + uint32_t rf_idx; + uint64_t regval; + + /* least significant 16 bits from reg_file index */ + rf_idx = (uint32_t)(cond_goto & 0xFFFF); + if (!ulp_regfile_read(parms->regfile, rf_idx, + ®val)) { + BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", + rf_idx); + rc = -EINVAL; + goto error; + } + cond_goto = (int32_t)regval; + } + if (cond_goto < 0 && ((int32_t)tbl_idx + cond_goto) < 0) { BNXT_TF_DBG(ERR, "invalid conditional goto %d\n", cond_goto); @@ -3279,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; @@ -3388,11 +3723,11 @@ ulp_mapper_glb_resource_info_deinit(struct bnxt_ulp_context *ulp_ctx, /* Iterate the global resources and process each one */ for (dir = TF_DIR_RX; dir < TF_DIR_MAX; dir++) { - for (idx = 0; idx < BNXT_ULP_GLB_RESOURCE_TBL_MAX_SZ; - idx++) { + for (idx = 0; idx < BNXT_ULP_GLB_RF_IDX_LAST; idx++) { ent = &mapper_data->glb_res_tbl[dir][idx]; if (ent->resource_func == - BNXT_ULP_RESOURCE_FUNC_INVALID) + BNXT_ULP_RESOURCE_FUNC_INVALID || + ent->shared) continue; memset(&res, 0, sizeof(struct ulp_flow_db_res_params)); res.resource_func = ent->resource_func; @@ -3445,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; @@ -3457,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)) { @@ -3543,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; @@ -3568,6 +3904,18 @@ ulp_mapper_init(struct bnxt_ulp_context *ulp_ctx) goto error; } + /* + * Only initialize the app global resources if a shared session was + * created. + */ + 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 init app glb resources\n"); + goto error; + } + } + /* Allocate the generic table list */ rc = ulp_mapper_generic_tbl_list_init(data); if (rc) { @@ -3590,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; } @@ -3603,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. */