#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)
{
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;
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;
{
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;
}
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)
{
.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);
}
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;
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) {
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;
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",
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)
}
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;
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);
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);
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;
}
/*
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;
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);
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);
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);
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;
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;
*/
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);
}
/* 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);
}
/* 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,
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",
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 };
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");
/* 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;
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;
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;
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;
}
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;
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);
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) {
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)) {
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;
}
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",
}
} 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,
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);
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;
}
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;
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");
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;
}
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:
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.
}
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;
}
{
int32_t rc = 0;
uint64_t regval;
- uint64_t comp_sig_id;
+ uint64_t comp_sig;
*res = 0;
switch (tbl->accept_opcode) {
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",
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;
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 */
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;
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;
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)) {
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;
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;
}
}
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;
}
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. */
git.droids-corp.org / dpdk.git / blobdiff