static int32_t
ulp_mapper_cache_entry_free(struct bnxt_ulp_context *ulp,
- struct tf *tfp,
- struct ulp_flow_db_res_params *res)
+ struct tf *tfp,
+ struct ulp_flow_db_res_params *res)
{
struct bnxt_ulp_mapper_cache_entry *cache_entry;
struct tf_free_identifier_parms ident_parms;
uint8_t act_val;
switch (fld->result_opcode) {
- case BNXT_ULP_RESULT_OPC_SET_TO_CONSTANT:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_CONSTANT:
val = fld->result_operand;
if (!ulp_blob_push(blob, val, fld->field_bit_size)) {
BNXT_TF_DBG(ERR, "%s failed to add field\n", name);
return -EINVAL;
}
break;
- case BNXT_ULP_RESULT_OPC_SET_TO_ACT_PROP:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_ACT_PROP:
if (!ulp_operand_read(fld->result_operand,
(uint8_t *)&idx, sizeof(uint16_t))) {
BNXT_TF_DBG(ERR, "%s operand read failed\n", name);
return -EINVAL;
}
break;
- case BNXT_ULP_RESULT_OPC_SET_TO_ACT_BIT:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_ACT_BIT:
if (!ulp_operand_read(fld->result_operand,
(uint8_t *)&act_bit, sizeof(uint64_t))) {
BNXT_TF_DBG(ERR, "%s operand read failed\n", name);
}
val = &act_val;
break;
- case BNXT_ULP_RESULT_OPC_SET_TO_ENCAP_ACT_PROP_SZ:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_ENCAP_ACT_PROP_SZ:
if (!ulp_operand_read(fld->result_operand,
(uint8_t *)&idx, sizeof(uint16_t))) {
BNXT_TF_DBG(ERR, "%s operand read failed\n", name);
val_size = ULP_BYTE_2_BITS(val_size);
ulp_blob_push_encap(blob, val, val_size);
break;
- case BNXT_ULP_RESULT_OPC_SET_TO_REGFILE:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_REGFILE:
if (!ulp_operand_read(fld->result_operand,
(uint8_t *)&idx, sizeof(uint16_t))) {
BNXT_TF_DBG(ERR, "%s operand read failed\n", name);
return -EINVAL;
}
break;
- case BNXT_ULP_RESULT_OPC_SET_TO_GLB_REGFILE:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_GLB_REGFILE:
if (!ulp_operand_read(fld->result_operand,
(uint8_t *)&idx,
sizeof(uint16_t))) {
return -EINVAL;
}
break;
- case BNXT_ULP_RESULT_OPC_SET_TO_COMP_FIELD:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_COMP_FIELD:
if (!ulp_operand_read(fld->result_operand,
(uint8_t *)&idx,
sizeof(uint16_t))) {
BNXT_TF_DBG(ERR, "%s push to key blob failed\n", name);
return -EINVAL;
}
+ break;
+ case BNXT_ULP_MAPPER_OPC_SET_TO_ZERO:
+ if (ulp_blob_pad_push(blob, fld->field_bit_size) < 0) {
+ BNXT_TF_DBG(ERR, "%s too large for blob\n", name);
+ return -EINVAL;
+ }
+
break;
default:
return -EINVAL;
bitlen = fld->field_bit_size;
switch (opcode) {
- case BNXT_ULP_SPEC_OPC_SET_TO_CONSTANT:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_CONSTANT:
val = operand;
if (!ulp_blob_push(blob, val, bitlen)) {
BNXT_TF_DBG(ERR, "%s push to key blob failed\n", name);
return -EINVAL;
}
break;
- case BNXT_ULP_SPEC_OPC_ADD_PAD:
- if (!ulp_blob_pad_push(blob, bitlen)) {
+ case BNXT_ULP_MAPPER_OPC_SET_TO_ZERO:
+ if (ulp_blob_pad_push(blob, bitlen) < 0) {
BNXT_TF_DBG(ERR, "%s pad too large for blob\n", name);
return -EINVAL;
}
break;
- case BNXT_ULP_SPEC_OPC_SET_TO_HDR_FIELD:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_HDR_FIELD:
if (!ulp_operand_read(operand, (uint8_t *)&idx,
sizeof(uint16_t))) {
BNXT_TF_DBG(ERR, "%s key operand read failed.\n", name);
return -EINVAL;
}
break;
- case BNXT_ULP_SPEC_OPC_SET_TO_COMP_FIELD:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_COMP_FIELD:
if (!ulp_operand_read(operand, (uint8_t *)&idx,
sizeof(uint16_t))) {
BNXT_TF_DBG(ERR, "%s key operand read failed.\n", name);
return -EINVAL;
}
break;
- case BNXT_ULP_SPEC_OPC_SET_TO_REGFILE:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_REGFILE:
if (!ulp_operand_read(operand, (uint8_t *)&idx,
sizeof(uint16_t))) {
BNXT_TF_DBG(ERR, "%s key operand read failed.\n", name);
return -EINVAL;
}
break;
- case BNXT_ULP_SPEC_OPC_SET_TO_GLB_REGFILE:
+ case BNXT_ULP_MAPPER_OPC_SET_TO_GLB_REGFILE:
if (!ulp_operand_read(operand, (uint8_t *)&idx,
sizeof(uint16_t))) {
BNXT_TF_DBG(ERR, "%s key operand read failed.\n", name);
struct bnxt_ulp_mapper_tbl_info *tbl,
uint64_t flow_id)
{
+ enum bnxt_ulp_mark_db_opcode mark_op = tbl->mark_db_opcode;
struct ulp_flow_db_res_params fid_parms;
uint32_t mark, gfid, mark_flag;
int32_t rc = 0;
- if (!(tbl->mark_enable &&
+ if (mark_op == BNXT_ULP_MARK_DB_OPCODE_NOP ||
+ !(mark_op == BNXT_ULP_MARK_DB_OPCODE_SET_IF_MARK_ACTION &&
ULP_BITMAP_ISSET(parms->act_bitmap->bits,
- BNXT_ULP_ACTION_BIT_MARK)))
+ BNXT_ULP_ACTION_BIT_MARK)))
return rc; /* no need to perform gfid process */
/* Get the mark id details from action property */
ulp_mapper_mark_act_ptr_process(struct bnxt_ulp_mapper_parms *parms,
struct bnxt_ulp_mapper_tbl_info *tbl)
{
+ enum bnxt_ulp_mark_db_opcode mark_op = tbl->mark_db_opcode;
struct ulp_flow_db_res_params fid_parms;
uint32_t act_idx, mark, mark_flag;
uint64_t val64;
int32_t rc = 0;
- if (!(tbl->mark_enable &&
+ if (mark_op == BNXT_ULP_MARK_DB_OPCODE_NOP ||
+ !(mark_op == BNXT_ULP_MARK_DB_OPCODE_SET_IF_MARK_ACTION &&
ULP_BITMAP_ISSET(parms->act_bitmap->bits,
- BNXT_ULP_ACTION_BIT_MARK)))
+ BNXT_ULP_ACTION_BIT_MARK)))
return rc; /* no need to perform mark action process */
/* Get the mark id details from action property */
return rc;
}
+static int32_t
+ulp_mapper_mark_vfr_idx_process(struct bnxt_ulp_mapper_parms *parms,
+ struct bnxt_ulp_mapper_tbl_info *tbl)
+{
+ struct ulp_flow_db_res_params fid_parms;
+ uint32_t act_idx, mark, mark_flag;
+ uint64_t val64;
+ enum bnxt_ulp_mark_db_opcode mark_op = tbl->mark_db_opcode;
+ int32_t rc = 0;
+
+ if (mark_op == BNXT_ULP_MARK_DB_OPCODE_NOP ||
+ mark_op == BNXT_ULP_MARK_DB_OPCODE_SET_IF_MARK_ACTION)
+ return rc; /* no need to perform mark action process */
+
+ /* Get the mark id details from the computed field of dev port id */
+ mark = ULP_COMP_FLD_IDX_RD(parms, BNXT_ULP_CF_IDX_DEV_PORT_ID);
+
+ /* Get the main action pointer */
+ if (!ulp_regfile_read(parms->regfile,
+ BNXT_ULP_REGFILE_INDEX_MAIN_ACTION_PTR,
+ &val64)) {
+ BNXT_TF_DBG(ERR, "read action ptr main failed\n");
+ return -EINVAL;
+ }
+ act_idx = tfp_be_to_cpu_64(val64);
+
+ /* Set the mark flag to local fid and vfr flag */
+ mark_flag = BNXT_ULP_MARK_LOCAL_HW_FID | BNXT_ULP_MARK_VFR_ID;
+
+ rc = ulp_mark_db_mark_add(parms->ulp_ctx, mark_flag,
+ act_idx, mark);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Failed to add mark to flow\n");
+ return rc;
+ }
+ fid_parms.direction = tbl->direction;
+ fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_HW_FID;
+ fid_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
+ fid_parms.resource_type = mark_flag;
+ fid_parms.resource_hndl = act_idx;
+ rc = ulp_flow_db_resource_add(parms->ulp_ctx,
+ parms->tbl_idx,
+ parms->fid,
+ &fid_parms);
+ if (rc)
+ BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc);
+ return rc;
+}
+
static int32_t
ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms,
struct bnxt_ulp_mapper_tbl_info *tbl)
return -EINVAL;
}
- if (!ulp_blob_init(&key, tbl->key_bit_size, parms->order) ||
- !ulp_blob_init(&mask, tbl->key_bit_size, parms->order) ||
- !ulp_blob_init(&data, tbl->result_bit_size, parms->order)) {
+ if (!ulp_blob_init(&key, tbl->key_bit_size,
+ parms->device_params->byte_order) ||
+ !ulp_blob_init(&mask, tbl->key_bit_size,
+ parms->device_params->byte_order) ||
+ !ulp_blob_init(&data, tbl->result_bit_size,
+ parms->device_params->byte_order)) {
BNXT_TF_DBG(ERR, "blob inits failed.\n");
return -EINVAL;
}
parms->cache_ptr->tcam_idx = aparms.idx;
}
+ /* Mark action */
+ rc = ulp_mapper_mark_act_ptr_process(parms, tbl);
+ if (rc)
+ goto error;
+
} else {
BNXT_TF_DBG(ERR, "Not supporting search before alloc now\n");
rc = -EINVAL;
struct tf_insert_em_entry_parms iparms = { 0 };
struct tf_delete_em_entry_parms free_parms = { 0 };
int32_t trc;
+ enum bnxt_ulp_flow_mem_type mtype = parms->device_params->flow_mem_type;
int32_t rc = 0;
kflds = ulp_mapper_key_fields_get(tbl, &num_kflds);
}
/* Initialize the key/result blobs */
- if (!ulp_blob_init(&key, tbl->blob_key_bit_size, parms->order) ||
- !ulp_blob_init(&data, tbl->result_bit_size, parms->order)) {
+ if (!ulp_blob_init(&key, tbl->blob_key_bit_size,
+ parms->device_params->byte_order) ||
+ !ulp_blob_init(&data, tbl->result_bit_size,
+ parms->device_params->byte_order)) {
BNXT_TF_DBG(ERR, "blob inits failed.\n");
return -EINVAL;
}
return rc;
}
}
+#ifdef RTE_LIBRTE_BNXT_TRUFLOW_DEBUG
+ ulp_mapper_result_dump("EEM Result", tbl, &data);
+#endif
+
+ /* do the transpose for the internal EM keys */
+ if (tbl->resource_type == TF_MEM_INTERNAL)
+ ulp_blob_perform_byte_reverse(&key);
rc = bnxt_ulp_cntxt_tbl_scope_id_get(parms->ulp_ctx,
&iparms.tbl_scope_id);
}
/* Mark action process */
- if (parms->device_params->global_fid_enable &&
+ if (mtype == BNXT_ULP_FLOW_MEM_TYPE_EXT &&
tbl->resource_type == TF_MEM_EXTERNAL)
rc = ulp_mapper_mark_gfid_process(parms, tbl, iparms.flow_id);
- else if (!parms->device_params->global_fid_enable &&
+ else if (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT &&
tbl->resource_type == TF_MEM_INTERNAL)
rc = ulp_mapper_mark_act_ptr_process(parms, tbl);
if (rc) {
goto error;
}
+ /* Perform the VF rep action */
+ rc = ulp_mapper_mark_vfr_idx_process(parms, tbl);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Failed to add vfr mark rc = %d\n", rc);
+ goto error;
+ }
return rc;
error:
/*
BNXT_TF_DBG(ERR, "Failed to get key fields\n");
return -EINVAL;
}
- if (!ulp_blob_init(&key, tbl->key_bit_size, parms->order)) {
+ if (!ulp_blob_init(&key, tbl->key_bit_size,
+ parms->device_params->byte_order)) {
BNXT_TF_DBG(ERR, "Failed to alloc blob\n");
return -EINVAL;
}
struct bnxt_ulp_mapper_create_parms *cparms,
uint32_t *flowid)
{
- struct bnxt_ulp_device_params *device_params;
struct bnxt_ulp_mapper_parms parms;
struct ulp_regfile regfile;
int32_t rc, trc;
return -EINVAL;
}
- /* Get the byte order for the further processing from device params */
- device_params = bnxt_ulp_device_params_get(parms.dev_id);
- if (!device_params) {
+ /* Get the device params, it will be used in later processing */
+ parms.device_params = bnxt_ulp_device_params_get(parms.dev_id);
+ if (!parms.device_params) {
BNXT_TF_DBG(ERR, "No class tables for %d:%d\n",
parms.dev_id, parms.class_tid);
return -EINVAL;
}
- parms.order = device_params->byte_order;
- parms.encap_byte_swap = device_params->encap_byte_swap;
/* initialize the registry file for further processing */
if (!ulp_regfile_init(parms.regfile)) {