*/
#include "bnxt.h"
-#include "ulp_template_db.h"
+#include "ulp_template_db_enum.h"
#include "ulp_template_struct.h"
#include "bnxt_tf_common.h"
#include "ulp_rte_parser.h"
#include "ulp_utils.h"
#include "tfp.h"
+#include "ulp_port_db.h"
-/* Inline Func to read integer that is stored in big endian format */
-static inline void ulp_util_field_int_read(uint8_t *buffer,
- uint32_t *val)
-{
- uint32_t temp_val;
-
- memcpy(&temp_val, buffer, sizeof(uint32_t));
- *val = rte_be_to_cpu_32(temp_val);
-}
-
-/* Inline Func to write integer that is stored in big endian format */
-static inline void ulp_util_field_int_write(uint8_t *buffer,
- uint32_t val)
-{
- uint32_t temp_val = rte_cpu_to_be_32(val);
-
- memcpy(buffer, &temp_val, sizeof(uint32_t));
-}
+/* Local defines for the parsing functions */
+#define ULP_VLAN_PRIORITY_SHIFT 13 /* First 3 bits */
+#define ULP_VLAN_PRIORITY_MASK 0x700
+#define ULP_VLAN_TAG_MASK 0xFFF /* Last 12 bits*/
+#define ULP_UDP_PORT_VXLAN 4789
/* Utility function to skip the void items. */
static inline int32_t
return 0;
}
+/* Utility function to update the field_bitmap */
+static void
+ulp_rte_parser_field_bitmap_update(struct ulp_rte_parser_params *params,
+ uint32_t idx)
+{
+ struct ulp_rte_hdr_field *field;
+
+ field = ¶ms->hdr_field[idx];
+ if (ulp_bitmap_notzero(field->mask, field->size)) {
+ ULP_INDEX_BITMAP_SET(params->fld_bitmap.bits, idx);
+ /* Not exact match */
+ if (!ulp_bitmap_is_ones(field->mask, field->size))
+ ULP_BITMAP_SET(params->fld_bitmap.bits,
+ BNXT_ULP_MATCH_TYPE_BITMASK_WM);
+ } else {
+ ULP_INDEX_BITMAP_RESET(params->fld_bitmap.bits, idx);
+ }
+}
+
+/* Utility function to copy field spec items */
+static struct ulp_rte_hdr_field *
+ulp_rte_parser_fld_copy(struct ulp_rte_hdr_field *field,
+ const void *buffer,
+ uint32_t size)
+{
+ field->size = size;
+ memcpy(field->spec, buffer, field->size);
+ field++;
+ return field;
+}
+
+/* Utility function to copy field masks items */
+static void
+ulp_rte_prsr_mask_copy(struct ulp_rte_parser_params *params,
+ uint32_t *idx,
+ const void *buffer,
+ uint32_t size)
+{
+ struct ulp_rte_hdr_field *field = ¶ms->hdr_field[*idx];
+
+ memcpy(field->mask, buffer, size);
+ ulp_rte_parser_field_bitmap_update(params, *idx);
+ *idx = *idx + 1;
+}
+
/*
* Function to handle the parsing of RTE Flows and placing
* the RTE flow items into the ulp structures.
*/
int32_t
bnxt_ulp_rte_parser_hdr_parse(const struct rte_flow_item pattern[],
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field)
+ struct ulp_rte_parser_params *params)
{
const struct rte_flow_item *item = pattern;
- uint32_t field_idx = BNXT_ULP_HDR_FIELD_LAST;
- uint32_t vlan_idx = 0;
struct bnxt_ulp_rte_hdr_info *hdr_info;
+ params->field_idx = BNXT_ULP_PROTO_HDR_SVIF_NUM;
+
+ /* Set the computed flags for no vlan tags before parsing */
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_NO_VTAG, 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_NO_VTAG, 1);
+
/* Parse all the items in the pattern */
while (item && item->type != RTE_FLOW_ITEM_TYPE_END) {
/* get the header information from the flow_hdr_info table */
hdr_info = &ulp_hdr_info[item->type];
- if (hdr_info->hdr_type ==
- BNXT_ULP_HDR_TYPE_NOT_SUPPORTED) {
+ if (hdr_info->hdr_type == BNXT_ULP_HDR_TYPE_NOT_SUPPORTED) {
BNXT_TF_DBG(ERR,
"Truflow parser does not support type %d\n",
item->type);
return BNXT_TF_RC_PARSE_ERR;
- } else if (hdr_info->hdr_type ==
- BNXT_ULP_HDR_TYPE_SUPPORTED) {
+ } else if (hdr_info->hdr_type == BNXT_ULP_HDR_TYPE_SUPPORTED) {
/* call the registered callback handler */
if (hdr_info->proto_hdr_func) {
- if (hdr_info->proto_hdr_func(item,
- hdr_bitmap,
- hdr_field,
- &field_idx,
- &vlan_idx) !=
+ if (hdr_info->proto_hdr_func(item, params) !=
BNXT_TF_RC_SUCCESS) {
return BNXT_TF_RC_ERROR;
}
item++;
}
/* update the implied SVIF */
- (void)ulp_rte_parser_svif_process(hdr_bitmap, hdr_field);
- return BNXT_TF_RC_SUCCESS;
+ return ulp_rte_parser_implicit_match_port_process(params);
}
/*
*/
int32_t
bnxt_ulp_rte_parser_act_parse(const struct rte_flow_action actions[],
- struct ulp_rte_act_bitmap *act_bitmap,
- struct ulp_rte_act_prop *act_prop)
+ struct ulp_rte_parser_params *params)
{
const struct rte_flow_action *action_item = actions;
struct bnxt_ulp_rte_act_info *hdr_info;
/* call the registered callback handler */
if (hdr_info->proto_act_func) {
if (hdr_info->proto_act_func(action_item,
- act_bitmap,
- act_prop) !=
+ params) !=
BNXT_TF_RC_SUCCESS) {
return BNXT_TF_RC_ERROR;
}
}
action_item++;
}
+ /* update the implied port details */
+ ulp_rte_parser_implicit_act_port_process(params);
return BNXT_TF_RC_SUCCESS;
}
+/*
+ * Function to handle the post processing of the computed
+ * fields for the interface.
+ */
+static void
+bnxt_ulp_comp_fld_intf_update(struct ulp_rte_parser_params *params)
+{
+ uint32_t ifindex;
+ uint16_t port_id, parif;
+ uint32_t mtype;
+ enum bnxt_ulp_direction_type dir;
+
+ /* get the direction details */
+ dir = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_DIRECTION);
+
+ /* read the port id details */
+ port_id = ULP_COMP_FLD_IDX_RD(params,
+ BNXT_ULP_CF_IDX_INCOMING_IF);
+ if (ulp_port_db_dev_port_to_ulp_index(params->ulp_ctx,
+ port_id,
+ &ifindex)) {
+ BNXT_TF_DBG(ERR, "ParseErr:Portid is not valid\n");
+ return;
+ }
+
+ if (dir == BNXT_ULP_DIR_INGRESS) {
+ /* Set port PARIF */
+ if (ulp_port_db_parif_get(params->ulp_ctx, ifindex,
+ BNXT_ULP_PHY_PORT_PARIF, &parif)) {
+ BNXT_TF_DBG(ERR, "ParseErr:ifindex is not valid\n");
+ return;
+ }
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_PHY_PORT_PARIF,
+ parif);
+ } else {
+ /* Get the match port type */
+ mtype = ULP_COMP_FLD_IDX_RD(params,
+ BNXT_ULP_CF_IDX_MATCH_PORT_TYPE);
+ if (mtype == BNXT_ULP_INTF_TYPE_VF_REP) {
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_MATCH_PORT_IS_VFREP,
+ 1);
+ /* Set VF func PARIF */
+ if (ulp_port_db_parif_get(params->ulp_ctx, ifindex,
+ BNXT_ULP_VF_FUNC_PARIF,
+ &parif)) {
+ BNXT_TF_DBG(ERR,
+ "ParseErr:ifindex is not valid\n");
+ return;
+ }
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_VF_FUNC_PARIF,
+ parif);
+ } else {
+ /* Set DRV func PARIF */
+ if (ulp_port_db_parif_get(params->ulp_ctx, ifindex,
+ BNXT_ULP_DRV_FUNC_PARIF,
+ &parif)) {
+ BNXT_TF_DBG(ERR,
+ "ParseErr:ifindex is not valid\n");
+ return;
+ }
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_DRV_FUNC_PARIF,
+ parif);
+ }
+ }
+}
+
+/*
+ * Function to handle the post processing of the parsing details
+ */
+int32_t
+bnxt_ulp_rte_parser_post_process(struct ulp_rte_parser_params *params)
+{
+ enum bnxt_ulp_direction_type dir;
+ enum bnxt_ulp_intf_type match_port_type, act_port_type;
+ uint32_t act_port_set;
+
+ /* Get the computed details */
+ dir = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_DIRECTION);
+ match_port_type = ULP_COMP_FLD_IDX_RD(params,
+ BNXT_ULP_CF_IDX_MATCH_PORT_TYPE);
+ act_port_type = ULP_COMP_FLD_IDX_RD(params,
+ BNXT_ULP_CF_IDX_ACT_PORT_TYPE);
+ act_port_set = ULP_COMP_FLD_IDX_RD(params,
+ BNXT_ULP_CF_IDX_ACT_PORT_IS_SET);
+
+ /* set the flow direction in the proto and action header */
+ if (dir == BNXT_ULP_DIR_EGRESS) {
+ ULP_BITMAP_SET(params->hdr_bitmap.bits,
+ BNXT_ULP_FLOW_DIR_BITMASK_EGR);
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_FLOW_DIR_BITMASK_EGR);
+ }
+
+ /* calculate the VF to VF flag */
+ if (act_port_set && act_port_type == BNXT_ULP_INTF_TYPE_VF_REP &&
+ match_port_type == BNXT_ULP_INTF_TYPE_VF_REP)
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_VF_TO_VF, 1);
+
+ /* Update the decrement ttl computational fields */
+ if (ULP_BITMAP_ISSET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_DEC_TTL)) {
+ /*
+ * Check that vxlan proto is included and vxlan decap
+ * action is not set then decrement tunnel ttl.
+ * Similarly add GRE and NVGRE in future.
+ */
+ if ((ULP_BITMAP_ISSET(params->hdr_bitmap.bits,
+ BNXT_ULP_HDR_BIT_T_VXLAN) &&
+ !ULP_BITMAP_ISSET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_VXLAN_DECAP))) {
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_ACT_T_DEC_TTL, 1);
+ } else {
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_ACT_DEC_TTL, 1);
+ }
+ }
+
+ /* Merge the hdr_fp_bit into the proto header bit */
+ params->hdr_bitmap.bits |= params->hdr_fp_bit.bits;
+
+ /* Update the computed interface parameters */
+ bnxt_ulp_comp_fld_intf_update(params);
+
+ /* TBD: Handle the flow rejection scenarios */
+ return 0;
+}
+
+/*
+ * Function to compute the flow direction based on the match port details
+ */
+static void
+bnxt_ulp_rte_parser_direction_compute(struct ulp_rte_parser_params *params)
+{
+ enum bnxt_ulp_intf_type match_port_type;
+
+ /* Get the match port type */
+ match_port_type = ULP_COMP_FLD_IDX_RD(params,
+ BNXT_ULP_CF_IDX_MATCH_PORT_TYPE);
+
+ /* If ingress flow and matchport is vf rep then dir is egress*/
+ if ((params->dir_attr & BNXT_ULP_FLOW_ATTR_INGRESS) &&
+ match_port_type == BNXT_ULP_INTF_TYPE_VF_REP) {
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_DIRECTION,
+ BNXT_ULP_DIR_EGRESS);
+ } else {
+ /* Assign the input direction */
+ if (params->dir_attr & BNXT_ULP_FLOW_ATTR_INGRESS)
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_DIRECTION,
+ BNXT_ULP_DIR_INGRESS);
+ else
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_DIRECTION,
+ BNXT_ULP_DIR_EGRESS);
+ }
+}
+
/* Function to handle the parsing of RTE Flow item PF Header. */
static int32_t
-ulp_rte_parser_svif_set(struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- enum rte_flow_item_type proto,
- uint32_t dir,
- uint16_t svif,
+ulp_rte_parser_svif_set(struct ulp_rte_parser_params *params,
+ uint32_t ifindex,
uint16_t mask)
{
- uint16_t port_id = svif;
-
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_SVIF)) {
+ uint16_t svif;
+ enum bnxt_ulp_direction_type dir;
+ struct ulp_rte_hdr_field *hdr_field;
+ enum bnxt_ulp_svif_type svif_type;
+ enum bnxt_ulp_intf_type port_type;
+
+ if (ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_SVIF_FLAG) !=
+ BNXT_ULP_INVALID_SVIF_VAL) {
BNXT_TF_DBG(ERR,
- "SVIF already set,"
- " multiple sources not supported\n");
+ "SVIF already set,multiple source not support'd\n");
return BNXT_TF_RC_ERROR;
}
- /* Update the hdr_bitmap with BNXT_ULP_HDR_PROTO_SVIF. */
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_SVIF);
+ /* Get port type details */
+ port_type = ulp_port_db_port_type_get(params->ulp_ctx, ifindex);
+ if (port_type == BNXT_ULP_INTF_TYPE_INVALID) {
+ BNXT_TF_DBG(ERR, "Invalid port type\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ /* Update the match port type */
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_MATCH_PORT_TYPE, port_type);
+
+ /* compute the direction */
+ bnxt_ulp_rte_parser_direction_compute(params);
- if (proto == RTE_FLOW_ITEM_TYPE_PORT_ID) {
- /* perform the conversion from dpdk port to svif */
- if (dir == ULP_DIR_EGRESS)
- svif = bnxt_get_svif(port_id, true);
+ /* Get the computed direction */
+ dir = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_DIRECTION);
+ if (dir == BNXT_ULP_DIR_INGRESS) {
+ svif_type = BNXT_ULP_PHY_PORT_SVIF;
+ } else {
+ if (port_type == BNXT_ULP_INTF_TYPE_VF_REP)
+ svif_type = BNXT_ULP_VF_FUNC_SVIF;
else
- svif = bnxt_get_svif(port_id, false);
+ svif_type = BNXT_ULP_DRV_FUNC_SVIF;
}
-
- memcpy(hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].spec,
- &svif, sizeof(svif));
- memcpy(hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].mask,
- &mask, sizeof(mask));
- hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].size = sizeof(svif);
+ ulp_port_db_svif_get(params->ulp_ctx, ifindex, svif_type,
+ &svif);
+ svif = rte_cpu_to_be_16(svif);
+ hdr_field = ¶ms->hdr_field[BNXT_ULP_PROTO_HDR_FIELD_SVIF_IDX];
+ memcpy(hdr_field->spec, &svif, sizeof(svif));
+ memcpy(hdr_field->mask, &mask, sizeof(mask));
+ hdr_field->size = sizeof(svif);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_SVIF_FLAG,
+ rte_be_to_cpu_16(svif));
return BNXT_TF_RC_SUCCESS;
}
-/* Function to handle the parsing of the RTE port id
- */
+/* Function to handle the parsing of the RTE port id */
int32_t
-ulp_rte_parser_svif_process(struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field)
+ulp_rte_parser_implicit_match_port_process(struct ulp_rte_parser_params *params)
{
uint16_t port_id = 0;
- uint32_t dir = 0;
- uint8_t *buffer;
uint16_t svif_mask = 0xFFFF;
+ uint32_t ifindex;
+ int32_t rc = BNXT_TF_RC_ERROR;
+
+ if (ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_SVIF_FLAG) !=
+ BNXT_ULP_INVALID_SVIF_VAL)
+ return BNXT_TF_RC_SUCCESS;
+
+ /* SVIF not set. So get the port id */
+ port_id = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF);
+
+ if (ulp_port_db_dev_port_to_ulp_index(params->ulp_ctx,
+ port_id,
+ &ifindex)) {
+ BNXT_TF_DBG(ERR, "ParseErr:Portid is not valid\n");
+ return rc;
+ }
+
+ /* Update the SVIF details */
+ rc = ulp_rte_parser_svif_set(params, ifindex, svif_mask);
+ return rc;
+}
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_SVIF))
+/* Function to handle the implicit action port id */
+int32_t
+ulp_rte_parser_implicit_act_port_process(struct ulp_rte_parser_params *params)
+{
+ struct rte_flow_action action_item = {0};
+ struct rte_flow_action_port_id port_id = {0};
+
+ /* Read the action port set bit */
+ if (ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_ACT_PORT_IS_SET)) {
+ /* Already set, so just exit */
return BNXT_TF_RC_SUCCESS;
+ }
+ port_id.id = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF);
+ action_item.conf = &port_id;
- /* SVIF not set. So get the port id and direction */
- buffer = hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].spec;
- memcpy(&port_id, buffer, sizeof(port_id));
- memcpy(&dir, buffer + sizeof(port_id), sizeof(dir));
- memset(hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].spec, 0,
- RTE_PARSER_FLOW_HDR_FIELD_SIZE);
+ /* Update the action port based on incoming port */
+ ulp_rte_port_id_act_handler(&action_item, params);
- return ulp_rte_parser_svif_set(hdr_bitmap, hdr_field,
- RTE_FLOW_ITEM_TYPE_PORT_ID,
- dir, port_id, svif_mask);
+ /* Reset the action port set bit */
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_ACT_PORT_IS_SET, 0);
+ return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow item PF Header. */
int32_t
-ulp_rte_pf_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx __rte_unused,
- uint32_t *vlan_idx __rte_unused)
+ulp_rte_pf_hdr_handler(const struct rte_flow_item *item __rte_unused,
+ struct ulp_rte_parser_params *params)
{
uint16_t port_id = 0;
- uint32_t dir = 0;
- uint8_t *buffer;
uint16_t svif_mask = 0xFFFF;
+ uint32_t ifindex;
- buffer = hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].spec;
- memcpy(&port_id, buffer, sizeof(port_id));
- memcpy(&dir, buffer + sizeof(port_id), sizeof(dir));
- memset(hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].spec, 0,
- RTE_PARSER_FLOW_HDR_FIELD_SIZE);
+ /* Get the implicit port id */
+ port_id = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF);
- return ulp_rte_parser_svif_set(hdr_bitmap, hdr_field,
- item->type,
- dir, port_id, svif_mask);
+ /* perform the conversion from dpdk port to bnxt ifindex */
+ if (ulp_port_db_dev_port_to_ulp_index(params->ulp_ctx,
+ port_id,
+ &ifindex)) {
+ BNXT_TF_DBG(ERR, "ParseErr:Portid is not valid\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ /* Update the SVIF details */
+ return ulp_rte_parser_svif_set(params, ifindex, svif_mask);
}
/* Function to handle the parsing of RTE Flow item VF Header. */
int32_t
ulp_rte_vf_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx __rte_unused,
- uint32_t *vlan_idx __rte_unused)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_vf *vf_spec, *vf_mask;
- uint16_t svif = 0, mask = 0;
-
- vf_spec = item->spec;
- vf_mask = item->mask;
-
- /*
- * Copy the rte_flow_item for eth into hdr_field using ethernet
- * header fields.
- */
- if (vf_spec)
- svif = (uint16_t)vf_spec->id;
- if (vf_mask)
- mask = (uint16_t)vf_mask->id;
-
- return ulp_rte_parser_svif_set(hdr_bitmap, hdr_field,
- item->type, 0, svif, mask);
+ const struct rte_flow_item_vf *vf_spec = item->spec;
+ const struct rte_flow_item_vf *vf_mask = item->mask;
+ uint16_t mask = 0;
+ uint32_t ifindex;
+ int32_t rc = BNXT_TF_RC_PARSE_ERR;
+
+ /* Get VF rte_flow_item for Port details */
+ if (!vf_spec) {
+ BNXT_TF_DBG(ERR, "ParseErr:VF id is not valid\n");
+ return rc;
+ }
+ if (!vf_mask) {
+ BNXT_TF_DBG(ERR, "ParseErr:VF mask is not valid\n");
+ return rc;
+ }
+ mask = vf_mask->id;
+
+ /* perform the conversion from VF Func id to bnxt ifindex */
+ if (ulp_port_db_dev_func_id_to_ulp_index(params->ulp_ctx,
+ vf_spec->id,
+ &ifindex)) {
+ BNXT_TF_DBG(ERR, "ParseErr:Portid is not valid\n");
+ return rc;
+ }
+ /* Update the SVIF details */
+ return ulp_rte_parser_svif_set(params, ifindex, mask);
}
/* Function to handle the parsing of RTE Flow item port id Header. */
int32_t
ulp_rte_port_id_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx __rte_unused,
- uint32_t *vlan_idx __rte_unused)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_port_id *port_spec, *port_mask;
- uint16_t svif = 0, mask = 0;
- uint32_t dir;
- uint8_t *buffer;
-
- port_spec = item->spec;
- port_mask = item->mask;
-
- /*
- * Copy the rte_flow_item for Port into hdr_field using port id
- * header fields.
- */
- if (port_spec)
- svif = (uint16_t)port_spec->id;
- if (port_mask)
- mask = (uint16_t)port_mask->id;
-
- buffer = hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].spec;
- memcpy(&dir, buffer + sizeof(uint16_t), sizeof(uint16_t));
-
- return ulp_rte_parser_svif_set(hdr_bitmap, hdr_field,
- item->type, dir, svif, mask);
+ const struct rte_flow_item_port_id *port_spec = item->spec;
+ const struct rte_flow_item_port_id *port_mask = item->mask;
+ uint16_t mask = 0;
+ int32_t rc = BNXT_TF_RC_PARSE_ERR;
+ uint32_t ifindex;
+
+ if (!port_spec) {
+ BNXT_TF_DBG(ERR, "ParseErr:Port id is not valid\n");
+ return rc;
+ }
+ if (!port_mask) {
+ BNXT_TF_DBG(ERR, "ParseErr:Phy Port mask is not valid\n");
+ return rc;
+ }
+ mask = port_mask->id;
+
+ /* perform the conversion from dpdk port to bnxt ifindex */
+ if (ulp_port_db_dev_port_to_ulp_index(params->ulp_ctx,
+ port_spec->id,
+ &ifindex)) {
+ BNXT_TF_DBG(ERR, "ParseErr:Portid is not valid\n");
+ return rc;
+ }
+ /* Update the SVIF details */
+ return ulp_rte_parser_svif_set(params, ifindex, mask);
}
/* Function to handle the parsing of RTE Flow item phy port Header. */
int32_t
ulp_rte_phy_port_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx __rte_unused,
- uint32_t *vlan_idx __rte_unused)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_phy_port *port_spec, *port_mask;
- uint32_t svif = 0, mask = 0;
-
- port_spec = item->spec;
- port_mask = item->mask;
+ const struct rte_flow_item_phy_port *port_spec = item->spec;
+ const struct rte_flow_item_phy_port *port_mask = item->mask;
+ uint16_t mask = 0;
+ int32_t rc = BNXT_TF_RC_ERROR;
+ uint16_t svif;
+ enum bnxt_ulp_direction_type dir;
+ struct ulp_rte_hdr_field *hdr_field;
/* Copy the rte_flow_item for phy port into hdr_field */
- if (port_spec)
- svif = port_spec->index;
- if (port_mask)
- mask = port_mask->index;
+ if (!port_spec) {
+ BNXT_TF_DBG(ERR, "ParseErr:Phy Port id is not valid\n");
+ return rc;
+ }
+ if (!port_mask) {
+ BNXT_TF_DBG(ERR, "ParseErr:Phy Port mask is not valid\n");
+ return rc;
+ }
+ mask = port_mask->index;
+
+ /* Update the match port type */
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_MATCH_PORT_TYPE,
+ BNXT_ULP_INTF_TYPE_PHY_PORT);
+
+ /* Compute the Hw direction */
+ bnxt_ulp_rte_parser_direction_compute(params);
- return ulp_rte_parser_svif_set(hdr_bitmap, hdr_field,
- item->type, 0, svif, mask);
+ /* Direction validation */
+ dir = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_DIRECTION);
+ if (dir == BNXT_ULP_DIR_EGRESS) {
+ BNXT_TF_DBG(ERR,
+ "Parse Err:Phy ports are valid only for ingress\n");
+ return BNXT_TF_RC_PARSE_ERR;
+ }
+
+ /* Get the physical port details from port db */
+ rc = ulp_port_db_phy_port_svif_get(params->ulp_ctx, port_spec->index,
+ &svif);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Failed to get port details\n");
+ return BNXT_TF_RC_PARSE_ERR;
+ }
+
+ /* Update the SVIF details */
+ svif = rte_cpu_to_be_16(svif);
+ hdr_field = ¶ms->hdr_field[BNXT_ULP_PROTO_HDR_FIELD_SVIF_IDX];
+ memcpy(hdr_field->spec, &svif, sizeof(svif));
+ memcpy(hdr_field->mask, &mask, sizeof(mask));
+ hdr_field->size = sizeof(svif);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_SVIF_FLAG,
+ rte_be_to_cpu_16(svif));
+ return BNXT_TF_RC_SUCCESS;
+}
+
+/* Function to handle the update of proto header based on field values */
+static void
+ulp_rte_l2_proto_type_update(struct ulp_rte_parser_params *param,
+ uint16_t type, uint32_t in_flag)
+{
+ if (type == tfp_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
+ if (in_flag) {
+ ULP_BITMAP_SET(param->hdr_fp_bit.bits,
+ BNXT_ULP_HDR_BIT_I_IPV4);
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_I_L3, 1);
+ } else {
+ ULP_BITMAP_SET(param->hdr_fp_bit.bits,
+ BNXT_ULP_HDR_BIT_O_IPV4);
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_O_L3, 1);
+ }
+ } else if (type == tfp_cpu_to_be_16(RTE_ETHER_TYPE_IPV6)) {
+ if (in_flag) {
+ ULP_BITMAP_SET(param->hdr_fp_bit.bits,
+ BNXT_ULP_HDR_BIT_I_IPV6);
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_I_L3, 1);
+ } else {
+ ULP_BITMAP_SET(param->hdr_fp_bit.bits,
+ BNXT_ULP_HDR_BIT_O_IPV6);
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_O_L3, 1);
+ }
+ }
}
/* Function to handle the parsing of RTE Flow item Ethernet Header. */
int32_t
ulp_rte_eth_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx,
- uint32_t *vlan_idx)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_eth *eth_spec, *eth_mask;
- uint32_t idx = *field_idx;
- uint32_t mdx = *field_idx;
- uint64_t set_flag = 0;
-
- eth_spec = item->spec;
- eth_mask = item->mask;
+ const struct rte_flow_item_eth *eth_spec = item->spec;
+ const struct rte_flow_item_eth *eth_mask = item->mask;
+ struct ulp_rte_hdr_field *field;
+ uint32_t idx = params->field_idx;
+ uint32_t size;
+ uint16_t eth_type = 0;
+ uint32_t inner_flag = 0;
/*
* Copy the rte_flow_item for eth into hdr_field using ethernet
* header fields
*/
if (eth_spec) {
- hdr_field[idx].size = sizeof(eth_spec->dst.addr_bytes);
- memcpy(hdr_field[idx++].spec, eth_spec->dst.addr_bytes,
- sizeof(eth_spec->dst.addr_bytes));
- hdr_field[idx].size = sizeof(eth_spec->src.addr_bytes);
- memcpy(hdr_field[idx++].spec, eth_spec->src.addr_bytes,
- sizeof(eth_spec->src.addr_bytes));
- hdr_field[idx].size = sizeof(eth_spec->type);
- memcpy(hdr_field[idx++].spec, ð_spec->type,
- sizeof(eth_spec->type));
- } else {
- idx += BNXT_ULP_PROTO_HDR_ETH_NUM;
+ size = sizeof(eth_spec->dst.addr_bytes);
+ field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
+ eth_spec->dst.addr_bytes,
+ size);
+ size = sizeof(eth_spec->src.addr_bytes);
+ field = ulp_rte_parser_fld_copy(field,
+ eth_spec->src.addr_bytes,
+ size);
+ field = ulp_rte_parser_fld_copy(field,
+ ð_spec->type,
+ sizeof(eth_spec->type));
+ eth_type = eth_spec->type;
}
-
if (eth_mask) {
- memcpy(hdr_field[mdx++].mask, eth_mask->dst.addr_bytes,
- sizeof(eth_mask->dst.addr_bytes));
- memcpy(hdr_field[mdx++].mask, eth_mask->src.addr_bytes,
- sizeof(eth_mask->src.addr_bytes));
- memcpy(hdr_field[mdx++].mask, ð_mask->type,
- sizeof(eth_mask->type));
+ ulp_rte_prsr_mask_copy(params, &idx, eth_mask->dst.addr_bytes,
+ sizeof(eth_mask->dst.addr_bytes));
+ ulp_rte_prsr_mask_copy(params, &idx, eth_mask->src.addr_bytes,
+ sizeof(eth_mask->src.addr_bytes));
+ ulp_rte_prsr_mask_copy(params, &idx, ð_mask->type,
+ sizeof(eth_mask->type));
}
/* Add number of vlan header elements */
- *field_idx = idx + BNXT_ULP_PROTO_HDR_VLAN_NUM;
- *vlan_idx = idx;
-
- /* Update the hdr_bitmap with BNXT_ULP_HDR_PROTO_I_ETH */
- set_flag = ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_ETH);
- if (set_flag)
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_ETH);
- else
- ULP_BITMAP_RESET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_ETH);
-
- /* update the hdr_bitmap with BNXT_ULP_HDR_PROTO_O_ETH */
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_ETH);
+ params->field_idx += BNXT_ULP_PROTO_HDR_ETH_NUM;
+ params->vlan_idx = params->field_idx;
+ params->field_idx += BNXT_ULP_PROTO_HDR_VLAN_NUM;
+
+ /* Update the protocol hdr bitmap */
+ if (ULP_BITMAP_ISSET(params->hdr_bitmap.bits, BNXT_ULP_HDR_BIT_O_ETH)) {
+ ULP_BITMAP_SET(params->hdr_bitmap.bits, BNXT_ULP_HDR_BIT_I_ETH);
+ inner_flag = 1;
+ } else {
+ ULP_BITMAP_SET(params->hdr_bitmap.bits, BNXT_ULP_HDR_BIT_O_ETH);
+ }
+ /* Update the field protocol hdr bitmap */
+ ulp_rte_l2_proto_type_update(params, eth_type, inner_flag);
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow item Vlan Header. */
int32_t
ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx __rte_unused,
- uint32_t *vlan_idx)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_vlan *vlan_spec, *vlan_mask;
- uint32_t idx = *vlan_idx;
- uint32_t mdx = *vlan_idx;
+ const struct rte_flow_item_vlan *vlan_spec = item->spec;
+ const struct rte_flow_item_vlan *vlan_mask = item->mask;
+ struct ulp_rte_hdr_field *field;
+ struct ulp_rte_hdr_bitmap *hdr_bit;
+ uint32_t idx = params->vlan_idx;
uint16_t vlan_tag, priority;
- uint32_t outer_vtag_num = 0, inner_vtag_num = 0;
- uint8_t *outer_tag_buffer;
- uint8_t *inner_tag_buffer;
-
- vlan_spec = item->spec;
- vlan_mask = item->mask;
- outer_tag_buffer = hdr_field[BNXT_ULP_HDR_FIELD_O_VTAG_NUM].spec;
- inner_tag_buffer = hdr_field[BNXT_ULP_HDR_FIELD_I_VTAG_NUM].spec;
+ uint32_t outer_vtag_num;
+ uint32_t inner_vtag_num;
+ uint16_t eth_type = 0;
+ uint32_t inner_flag = 0;
/*
* Copy the rte_flow_item for vlan into hdr_field using Vlan
*/
if (vlan_spec) {
vlan_tag = ntohs(vlan_spec->tci);
- priority = htons(vlan_tag >> 13);
- vlan_tag &= 0xfff;
+ priority = htons(vlan_tag >> ULP_VLAN_PRIORITY_SHIFT);
+ vlan_tag &= ULP_VLAN_TAG_MASK;
vlan_tag = htons(vlan_tag);
- hdr_field[idx].size = sizeof(priority);
- memcpy(hdr_field[idx++].spec, &priority, sizeof(priority));
- hdr_field[idx].size = sizeof(vlan_tag);
- memcpy(hdr_field[idx++].spec, &vlan_tag, sizeof(vlan_tag));
- hdr_field[idx].size = sizeof(vlan_spec->inner_type);
- memcpy(hdr_field[idx++].spec, &vlan_spec->inner_type,
- sizeof(vlan_spec->inner_type));
- } else {
- idx += BNXT_ULP_PROTO_HDR_S_VLAN_NUM;
+ field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
+ &priority,
+ sizeof(priority));
+ field = ulp_rte_parser_fld_copy(field,
+ &vlan_tag,
+ sizeof(vlan_tag));
+ field = ulp_rte_parser_fld_copy(field,
+ &vlan_spec->inner_type,
+ sizeof(vlan_spec->inner_type));
+ eth_type = vlan_spec->inner_type;
}
if (vlan_mask) {
vlan_tag = ntohs(vlan_mask->tci);
- priority = htons(vlan_tag >> 13);
+ priority = htons(vlan_tag >> ULP_VLAN_PRIORITY_SHIFT);
vlan_tag &= 0xfff;
+
+ /*
+ * the storage for priority and vlan tag is 2 bytes
+ * The mask of priority which is 3 bits if it is all 1's
+ * then make the rest bits 13 bits as 1's
+ * so that it is matched as exact match.
+ */
+ if (priority == ULP_VLAN_PRIORITY_MASK)
+ priority |= ~ULP_VLAN_PRIORITY_MASK;
+ if (vlan_tag == ULP_VLAN_TAG_MASK)
+ vlan_tag |= ~ULP_VLAN_TAG_MASK;
vlan_tag = htons(vlan_tag);
- memcpy(hdr_field[mdx++].mask, &priority, sizeof(priority));
- memcpy(hdr_field[mdx++].mask, &vlan_tag, sizeof(vlan_tag));
- memcpy(hdr_field[mdx++].mask, &vlan_mask->inner_type,
- sizeof(vlan_mask->inner_type));
+ ulp_rte_prsr_mask_copy(params, &idx, &priority,
+ sizeof(priority));
+ ulp_rte_prsr_mask_copy(params, &idx, &vlan_tag,
+ sizeof(vlan_tag));
+ ulp_rte_prsr_mask_copy(params, &idx, &vlan_mask->inner_type,
+ sizeof(vlan_mask->inner_type));
}
/* Set the vlan index to new incremented value */
- *vlan_idx = idx;
+ params->vlan_idx += BNXT_ULP_PROTO_HDR_S_VLAN_NUM;
/* Get the outer tag and inner tag counts */
- ulp_util_field_int_read(outer_tag_buffer, &outer_vtag_num);
- ulp_util_field_int_read(inner_tag_buffer, &inner_vtag_num);
+ outer_vtag_num = ULP_COMP_FLD_IDX_RD(params,
+ BNXT_ULP_CF_IDX_O_VTAG_NUM);
+ inner_vtag_num = ULP_COMP_FLD_IDX_RD(params,
+ BNXT_ULP_CF_IDX_I_VTAG_NUM);
/* Update the hdr_bitmap of the vlans */
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
- !ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_OO_VLAN)) {
- /* Set the outer vlan bit and update the vlan tag num */
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_OO_VLAN);
+ hdr_bit = ¶ms->hdr_bitmap;
+ if (ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
+ !ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_I_ETH) &&
+ !outer_vtag_num) {
+ /* Update the vlan tag num */
outer_vtag_num++;
- ulp_util_field_int_write(outer_tag_buffer, outer_vtag_num);
- hdr_field[BNXT_ULP_HDR_FIELD_O_VTAG_NUM].size =
- sizeof(uint32_t);
- } else if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
- ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_OO_VLAN) &&
- !ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_OI_VLAN)) {
- /* Set the outer vlan bit and update the vlan tag num */
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_OI_VLAN);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_VTAG_NUM,
+ outer_vtag_num);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_NO_VTAG, 0);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_ONE_VTAG, 1);
+ ULP_BITMAP_SET(params->hdr_bitmap.bits,
+ BNXT_ULP_HDR_BIT_OO_VLAN);
+ } else if (ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
+ !ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_I_ETH) &&
+ outer_vtag_num == 1) {
+ /* update the vlan tag num */
outer_vtag_num++;
- ulp_util_field_int_write(outer_tag_buffer, outer_vtag_num);
- hdr_field[BNXT_ULP_HDR_FIELD_O_VTAG_NUM].size =
- sizeof(uint32_t);
- } else if (ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_O_ETH) &&
- ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_OO_VLAN) &&
- ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_OI_VLAN) &&
- ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_I_ETH) &&
- !ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_IO_VLAN)) {
- /* Set the inner vlan bit and update the vlan tag num */
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_IO_VLAN);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_VTAG_NUM,
+ outer_vtag_num);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_TWO_VTAGS, 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_ONE_VTAG, 0);
+ ULP_BITMAP_SET(params->hdr_bitmap.bits,
+ BNXT_ULP_HDR_BIT_OI_VLAN);
+ } else if (ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
+ ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_I_ETH) &&
+ !inner_vtag_num) {
+ /* update the vlan tag num */
inner_vtag_num++;
- ulp_util_field_int_write(inner_tag_buffer, inner_vtag_num);
- hdr_field[BNXT_ULP_HDR_FIELD_I_VTAG_NUM].size =
- sizeof(uint32_t);
- } else if (ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_O_ETH) &&
- ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_OO_VLAN) &&
- ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_OI_VLAN) &&
- ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_I_ETH) &&
- ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_IO_VLAN) &&
- !ULP_BITMAP_ISSET(hdr_bitmap->bits,
- BNXT_ULP_HDR_BIT_II_VLAN)) {
- /* Set the inner vlan bit and update the vlan tag num */
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_II_VLAN);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_VTAG_NUM,
+ inner_vtag_num);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_NO_VTAG, 0);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_ONE_VTAG, 1);
+ ULP_BITMAP_SET(params->hdr_bitmap.bits,
+ BNXT_ULP_HDR_BIT_IO_VLAN);
+ inner_flag = 1;
+ } else if (ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
+ ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_I_ETH) &&
+ inner_vtag_num == 1) {
+ /* update the vlan tag num */
inner_vtag_num++;
- ulp_util_field_int_write(inner_tag_buffer, inner_vtag_num);
- hdr_field[BNXT_ULP_HDR_FIELD_I_VTAG_NUM].size =
- sizeof(uint32_t);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_VTAG_NUM,
+ inner_vtag_num);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_TWO_VTAGS, 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_ONE_VTAG, 0);
+ ULP_BITMAP_SET(params->hdr_bitmap.bits,
+ BNXT_ULP_HDR_BIT_II_VLAN);
+ inner_flag = 1;
} else {
BNXT_TF_DBG(ERR, "Error Parsing:Vlan hdr found withtout eth\n");
return BNXT_TF_RC_ERROR;
}
+ /* Update the field protocol hdr bitmap */
+ ulp_rte_l2_proto_type_update(params, eth_type, inner_flag);
return BNXT_TF_RC_SUCCESS;
}
+/* Function to handle the update of proto header based on field values */
+static void
+ulp_rte_l3_proto_type_update(struct ulp_rte_parser_params *param,
+ uint8_t proto, uint32_t in_flag)
+{
+ if (proto == IPPROTO_UDP) {
+ if (in_flag) {
+ ULP_BITMAP_SET(param->hdr_fp_bit.bits,
+ BNXT_ULP_HDR_BIT_I_UDP);
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_I_L4, 1);
+ } else {
+ ULP_BITMAP_SET(param->hdr_fp_bit.bits,
+ BNXT_ULP_HDR_BIT_O_UDP);
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_O_L4, 1);
+ }
+ } else if (proto == IPPROTO_TCP) {
+ if (in_flag) {
+ ULP_BITMAP_SET(param->hdr_fp_bit.bits,
+ BNXT_ULP_HDR_BIT_I_TCP);
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_I_L4, 1);
+ } else {
+ ULP_BITMAP_SET(param->hdr_fp_bit.bits,
+ BNXT_ULP_HDR_BIT_O_TCP);
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_O_L4, 1);
+ }
+ }
+}
+
/* Function to handle the parsing of RTE Flow item IPV4 Header. */
int32_t
ulp_rte_ipv4_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx,
- uint32_t *vlan_idx __rte_unused)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_ipv4 *ipv4_spec, *ipv4_mask;
- uint32_t idx = *field_idx;
- uint32_t mdx = *field_idx;
-
- ipv4_spec = item->spec;
- ipv4_mask = item->mask;
-
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_L3)) {
- BNXT_TF_DBG(ERR, "Parse Error:Third L3 header not supported\n");
+ const struct rte_flow_item_ipv4 *ipv4_spec = item->spec;
+ const struct rte_flow_item_ipv4 *ipv4_mask = item->mask;
+ struct ulp_rte_hdr_field *field;
+ struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
+ uint32_t idx = params->field_idx;
+ uint32_t size;
+ uint8_t proto = 0;
+ uint32_t inner_flag = 0;
+ uint32_t cnt;
+
+ /* validate there are no 3rd L3 header */
+ cnt = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_L3_HDR_CNT);
+ if (cnt == 2) {
+ BNXT_TF_DBG(ERR, "Parse Err:Third L3 header not supported\n");
return BNXT_TF_RC_ERROR;
}
* header fields
*/
if (ipv4_spec) {
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.version_ihl);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.version_ihl,
- sizeof(ipv4_spec->hdr.version_ihl));
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.type_of_service);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.type_of_service,
- sizeof(ipv4_spec->hdr.type_of_service));
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.total_length);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.total_length,
- sizeof(ipv4_spec->hdr.total_length));
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.packet_id);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.packet_id,
- sizeof(ipv4_spec->hdr.packet_id));
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.fragment_offset);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.fragment_offset,
- sizeof(ipv4_spec->hdr.fragment_offset));
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.time_to_live);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.time_to_live,
- sizeof(ipv4_spec->hdr.time_to_live));
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.next_proto_id);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.next_proto_id,
- sizeof(ipv4_spec->hdr.next_proto_id));
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.hdr_checksum);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.hdr_checksum,
- sizeof(ipv4_spec->hdr.hdr_checksum));
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.src_addr);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.src_addr,
- sizeof(ipv4_spec->hdr.src_addr));
- hdr_field[idx].size = sizeof(ipv4_spec->hdr.dst_addr);
- memcpy(hdr_field[idx++].spec, &ipv4_spec->hdr.dst_addr,
- sizeof(ipv4_spec->hdr.dst_addr));
- } else {
- idx += BNXT_ULP_PROTO_HDR_IPV4_NUM;
+ size = sizeof(ipv4_spec->hdr.version_ihl);
+ field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
+ &ipv4_spec->hdr.version_ihl,
+ size);
+ size = sizeof(ipv4_spec->hdr.type_of_service);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv4_spec->hdr.type_of_service,
+ size);
+ size = sizeof(ipv4_spec->hdr.total_length);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv4_spec->hdr.total_length,
+ size);
+ size = sizeof(ipv4_spec->hdr.packet_id);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv4_spec->hdr.packet_id,
+ size);
+ size = sizeof(ipv4_spec->hdr.fragment_offset);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv4_spec->hdr.fragment_offset,
+ size);
+ size = sizeof(ipv4_spec->hdr.time_to_live);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv4_spec->hdr.time_to_live,
+ size);
+ size = sizeof(ipv4_spec->hdr.next_proto_id);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv4_spec->hdr.next_proto_id,
+ size);
+ proto = ipv4_spec->hdr.next_proto_id;
+ size = sizeof(ipv4_spec->hdr.hdr_checksum);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv4_spec->hdr.hdr_checksum,
+ size);
+ size = sizeof(ipv4_spec->hdr.src_addr);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv4_spec->hdr.src_addr,
+ size);
+ size = sizeof(ipv4_spec->hdr.dst_addr);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv4_spec->hdr.dst_addr,
+ size);
}
-
if (ipv4_mask) {
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.version_ihl,
- sizeof(ipv4_mask->hdr.version_ihl));
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.type_of_service,
- sizeof(ipv4_mask->hdr.type_of_service));
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.total_length,
- sizeof(ipv4_mask->hdr.total_length));
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.packet_id,
- sizeof(ipv4_mask->hdr.packet_id));
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.fragment_offset,
- sizeof(ipv4_mask->hdr.fragment_offset));
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.time_to_live,
- sizeof(ipv4_mask->hdr.time_to_live));
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.next_proto_id,
- sizeof(ipv4_mask->hdr.next_proto_id));
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.hdr_checksum,
- sizeof(ipv4_mask->hdr.hdr_checksum));
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.src_addr,
- sizeof(ipv4_mask->hdr.src_addr));
- memcpy(hdr_field[mdx++].mask, &ipv4_mask->hdr.dst_addr,
- sizeof(ipv4_mask->hdr.dst_addr));
- }
- *field_idx = idx; /* Number of ipv4 header elements */
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.version_ihl,
+ sizeof(ipv4_mask->hdr.version_ihl));
+#ifdef ULP_DONT_IGNORE_TOS
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.type_of_service,
+ sizeof(ipv4_mask->hdr.type_of_service));
+#else
+ /*
+ * The tos field is ignored since OVS is setting it as wild card
+ * match and it is not supported. This is a work around and
+ * shall be addressed in the future.
+ */
+ idx += 1;
+#endif
+
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.total_length,
+ sizeof(ipv4_mask->hdr.total_length));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.packet_id,
+ sizeof(ipv4_mask->hdr.packet_id));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.fragment_offset,
+ sizeof(ipv4_mask->hdr.fragment_offset));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.time_to_live,
+ sizeof(ipv4_mask->hdr.time_to_live));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.next_proto_id,
+ sizeof(ipv4_mask->hdr.next_proto_id));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.hdr_checksum,
+ sizeof(ipv4_mask->hdr.hdr_checksum));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.src_addr,
+ sizeof(ipv4_mask->hdr.src_addr));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv4_mask->hdr.dst_addr,
+ sizeof(ipv4_mask->hdr.dst_addr));
+ }
+ /* Add the number of ipv4 header elements */
+ params->field_idx += BNXT_ULP_PROTO_HDR_IPV4_NUM;
/* Set the ipv4 header bitmap and computed l3 header bitmaps */
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_L3) ||
- ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4) ||
+ if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4) ||
ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV6)) {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_IPV4);
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_L3);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L3, 1);
+ inner_flag = 1;
} else {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4);
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_L3);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3, 1);
}
+
+ /* Update the field protocol hdr bitmap */
+ ulp_rte_l3_proto_type_update(params, proto, inner_flag);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L3_HDR_CNT, ++cnt);
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow item IPV6 Header */
int32_t
ulp_rte_ipv6_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx,
- uint32_t *vlan_idx __rte_unused)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_ipv6 *ipv6_spec, *ipv6_mask;
- uint32_t idx = *field_idx;
- uint32_t mdx = *field_idx;
-
- ipv6_spec = item->spec;
- ipv6_mask = item->mask;
-
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_L3)) {
- BNXT_TF_DBG(ERR, "Parse Error: 3'rd L3 header not supported\n");
+ const struct rte_flow_item_ipv6 *ipv6_spec = item->spec;
+ const struct rte_flow_item_ipv6 *ipv6_mask = item->mask;
+ struct ulp_rte_hdr_field *field;
+ struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
+ uint32_t idx = params->field_idx;
+ uint32_t size;
+ uint32_t vtcf, vtcf_mask;
+ uint8_t proto = 0;
+ uint32_t inner_flag = 0;
+ uint32_t cnt;
+
+ /* validate there are no 3rd L3 header */
+ cnt = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_L3_HDR_CNT);
+ if (cnt == 2) {
+ BNXT_TF_DBG(ERR, "Parse Err:Third L3 header not supported\n");
return BNXT_TF_RC_ERROR;
}
/*
- * Copy the rte_flow_item for ipv4 into hdr_field using ipv4
+ * Copy the rte_flow_item for ipv6 into hdr_field using ipv6
* header fields
*/
if (ipv6_spec) {
- hdr_field[idx].size = sizeof(ipv6_spec->hdr.vtc_flow);
- memcpy(hdr_field[idx++].spec, &ipv6_spec->hdr.vtc_flow,
- sizeof(ipv6_spec->hdr.vtc_flow));
- hdr_field[idx].size = sizeof(ipv6_spec->hdr.payload_len);
- memcpy(hdr_field[idx++].spec, &ipv6_spec->hdr.payload_len,
- sizeof(ipv6_spec->hdr.payload_len));
- hdr_field[idx].size = sizeof(ipv6_spec->hdr.proto);
- memcpy(hdr_field[idx++].spec, &ipv6_spec->hdr.proto,
- sizeof(ipv6_spec->hdr.proto));
- hdr_field[idx].size = sizeof(ipv6_spec->hdr.hop_limits);
- memcpy(hdr_field[idx++].spec, &ipv6_spec->hdr.hop_limits,
- sizeof(ipv6_spec->hdr.hop_limits));
- hdr_field[idx].size = sizeof(ipv6_spec->hdr.src_addr);
- memcpy(hdr_field[idx++].spec, &ipv6_spec->hdr.src_addr,
- sizeof(ipv6_spec->hdr.src_addr));
- hdr_field[idx].size = sizeof(ipv6_spec->hdr.dst_addr);
- memcpy(hdr_field[idx++].spec, &ipv6_spec->hdr.dst_addr,
- sizeof(ipv6_spec->hdr.dst_addr));
- } else {
- idx += BNXT_ULP_PROTO_HDR_IPV6_NUM;
+ size = sizeof(ipv6_spec->hdr.vtc_flow);
+
+ vtcf = BNXT_ULP_GET_IPV6_VER(ipv6_spec->hdr.vtc_flow);
+ field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
+ &vtcf,
+ size);
+
+ vtcf = BNXT_ULP_GET_IPV6_TC(ipv6_spec->hdr.vtc_flow);
+ field = ulp_rte_parser_fld_copy(field,
+ &vtcf,
+ size);
+
+ vtcf = BNXT_ULP_GET_IPV6_FLOWLABEL(ipv6_spec->hdr.vtc_flow);
+ field = ulp_rte_parser_fld_copy(field,
+ &vtcf,
+ size);
+
+ size = sizeof(ipv6_spec->hdr.payload_len);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv6_spec->hdr.payload_len,
+ size);
+ size = sizeof(ipv6_spec->hdr.proto);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv6_spec->hdr.proto,
+ size);
+ proto = ipv6_spec->hdr.proto;
+ size = sizeof(ipv6_spec->hdr.hop_limits);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv6_spec->hdr.hop_limits,
+ size);
+ size = sizeof(ipv6_spec->hdr.src_addr);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv6_spec->hdr.src_addr,
+ size);
+ size = sizeof(ipv6_spec->hdr.dst_addr);
+ field = ulp_rte_parser_fld_copy(field,
+ &ipv6_spec->hdr.dst_addr,
+ size);
}
-
if (ipv6_mask) {
- memcpy(hdr_field[mdx++].mask, &ipv6_mask->hdr.vtc_flow,
- sizeof(ipv6_mask->hdr.vtc_flow));
- memcpy(hdr_field[mdx++].mask, &ipv6_mask->hdr.payload_len,
- sizeof(ipv6_mask->hdr.payload_len));
- memcpy(hdr_field[mdx++].mask, &ipv6_mask->hdr.proto,
- sizeof(ipv6_mask->hdr.proto));
- memcpy(hdr_field[mdx++].mask, &ipv6_mask->hdr.hop_limits,
- sizeof(ipv6_mask->hdr.hop_limits));
- memcpy(hdr_field[mdx++].mask, &ipv6_mask->hdr.src_addr,
- sizeof(ipv6_mask->hdr.src_addr));
- memcpy(hdr_field[mdx++].mask, &ipv6_mask->hdr.dst_addr,
- sizeof(ipv6_mask->hdr.dst_addr));
- }
- *field_idx = idx; /* add number of ipv6 header elements */
+ size = sizeof(ipv6_mask->hdr.vtc_flow);
+
+ vtcf_mask = BNXT_ULP_GET_IPV6_VER(ipv6_mask->hdr.vtc_flow);
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &vtcf_mask,
+ size);
+
+ vtcf_mask = BNXT_ULP_GET_IPV6_TC(ipv6_mask->hdr.vtc_flow);
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &vtcf_mask,
+ size);
+
+ vtcf_mask =
+ BNXT_ULP_GET_IPV6_FLOWLABEL(ipv6_mask->hdr.vtc_flow);
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &vtcf_mask,
+ size);
+
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv6_mask->hdr.payload_len,
+ sizeof(ipv6_mask->hdr.payload_len));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv6_mask->hdr.proto,
+ sizeof(ipv6_mask->hdr.proto));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv6_mask->hdr.hop_limits,
+ sizeof(ipv6_mask->hdr.hop_limits));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv6_mask->hdr.src_addr,
+ sizeof(ipv6_mask->hdr.src_addr));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &ipv6_mask->hdr.dst_addr,
+ sizeof(ipv6_mask->hdr.dst_addr));
+ }
+ /* add number of ipv6 header elements */
+ params->field_idx += BNXT_ULP_PROTO_HDR_IPV6_NUM;
/* Set the ipv6 header bitmap and computed l3 header bitmaps */
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_L3) ||
- ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4) ||
+ if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4) ||
ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV6)) {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_IPV6);
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_L3);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L3, 1);
+ inner_flag = 1;
} else {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV6);
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_L3);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3, 1);
}
+
+ /* Update the field protocol hdr bitmap */
+ ulp_rte_l3_proto_type_update(params, proto, inner_flag);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L3_HDR_CNT, ++cnt);
+
return BNXT_TF_RC_SUCCESS;
}
+/* Function to handle the update of proto header based on field values */
+static void
+ulp_rte_l4_proto_type_update(struct ulp_rte_parser_params *param,
+ uint16_t dst_port)
+{
+ if (dst_port == tfp_cpu_to_be_16(ULP_UDP_PORT_VXLAN))
+ ULP_BITMAP_SET(param->hdr_fp_bit.bits,
+ BNXT_ULP_HDR_BIT_T_VXLAN);
+}
+
/* Function to handle the parsing of RTE Flow item UDP Header. */
int32_t
ulp_rte_udp_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx,
- uint32_t *vlan_idx __rte_unused)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_udp *udp_spec, *udp_mask;
- uint32_t idx = *field_idx;
- uint32_t mdx = *field_idx;
-
- udp_spec = item->spec;
- udp_mask = item->mask;
-
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_L4)) {
+ const struct rte_flow_item_udp *udp_spec = item->spec;
+ const struct rte_flow_item_udp *udp_mask = item->mask;
+ struct ulp_rte_hdr_field *field;
+ struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
+ uint32_t idx = params->field_idx;
+ uint32_t size;
+ uint16_t dst_port = 0;
+ uint32_t cnt;
+
+ cnt = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_L4_HDR_CNT);
+ if (cnt == 2) {
BNXT_TF_DBG(ERR, "Parse Err:Third L4 header not supported\n");
return BNXT_TF_RC_ERROR;
}
* header fields
*/
if (udp_spec) {
- hdr_field[idx].size = sizeof(udp_spec->hdr.src_port);
- memcpy(hdr_field[idx++].spec, &udp_spec->hdr.src_port,
- sizeof(udp_spec->hdr.src_port));
- hdr_field[idx].size = sizeof(udp_spec->hdr.dst_port);
- memcpy(hdr_field[idx++].spec, &udp_spec->hdr.dst_port,
- sizeof(udp_spec->hdr.dst_port));
- hdr_field[idx].size = sizeof(udp_spec->hdr.dgram_len);
- memcpy(hdr_field[idx++].spec, &udp_spec->hdr.dgram_len,
- sizeof(udp_spec->hdr.dgram_len));
- hdr_field[idx].size = sizeof(udp_spec->hdr.dgram_cksum);
- memcpy(hdr_field[idx++].spec, &udp_spec->hdr.dgram_cksum,
- sizeof(udp_spec->hdr.dgram_cksum));
- } else {
- idx += BNXT_ULP_PROTO_HDR_UDP_NUM;
+ size = sizeof(udp_spec->hdr.src_port);
+ field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
+ &udp_spec->hdr.src_port,
+ size);
+ size = sizeof(udp_spec->hdr.dst_port);
+ field = ulp_rte_parser_fld_copy(field,
+ &udp_spec->hdr.dst_port,
+ size);
+ dst_port = udp_spec->hdr.dst_port;
+ size = sizeof(udp_spec->hdr.dgram_len);
+ field = ulp_rte_parser_fld_copy(field,
+ &udp_spec->hdr.dgram_len,
+ size);
+ size = sizeof(udp_spec->hdr.dgram_cksum);
+ field = ulp_rte_parser_fld_copy(field,
+ &udp_spec->hdr.dgram_cksum,
+ size);
}
-
if (udp_mask) {
- memcpy(hdr_field[mdx++].mask, &udp_mask->hdr.src_port,
- sizeof(udp_mask->hdr.src_port));
- memcpy(hdr_field[mdx++].mask, &udp_mask->hdr.dst_port,
- sizeof(udp_mask->hdr.dst_port));
- memcpy(hdr_field[mdx++].mask, &udp_mask->hdr.dgram_len,
- sizeof(udp_mask->hdr.dgram_len));
- memcpy(hdr_field[mdx++].mask, &udp_mask->hdr.dgram_cksum,
- sizeof(udp_mask->hdr.dgram_cksum));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &udp_mask->hdr.src_port,
+ sizeof(udp_mask->hdr.src_port));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &udp_mask->hdr.dst_port,
+ sizeof(udp_mask->hdr.dst_port));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &udp_mask->hdr.dgram_len,
+ sizeof(udp_mask->hdr.dgram_len));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &udp_mask->hdr.dgram_cksum,
+ sizeof(udp_mask->hdr.dgram_cksum));
}
- *field_idx = idx; /* Add number of UDP header elements */
+
+ /* Add number of UDP header elements */
+ params->field_idx += BNXT_ULP_PROTO_HDR_UDP_NUM;
/* Set the udp header bitmap and computed l4 header bitmaps */
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_L4) ||
- ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP) ||
+ if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP) ||
ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP)) {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_UDP);
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_L4);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4, 1);
} else {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP);
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_L4);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4, 1);
+ /* Update the field protocol hdr bitmap */
+ ulp_rte_l4_proto_type_update(params, dst_port);
}
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L4_HDR_CNT, ++cnt);
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow item TCP Header. */
int32_t
ulp_rte_tcp_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdr_bitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx,
- uint32_t *vlan_idx __rte_unused)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_tcp *tcp_spec, *tcp_mask;
- uint32_t idx = *field_idx;
- uint32_t mdx = *field_idx;
-
- tcp_spec = item->spec;
- tcp_mask = item->mask;
-
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_L4)) {
- BNXT_TF_DBG(ERR, "Parse Error:Third L4 header not supported\n");
+ const struct rte_flow_item_tcp *tcp_spec = item->spec;
+ const struct rte_flow_item_tcp *tcp_mask = item->mask;
+ struct ulp_rte_hdr_field *field;
+ struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
+ uint32_t idx = params->field_idx;
+ uint32_t size;
+ uint32_t cnt;
+
+ cnt = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_L4_HDR_CNT);
+ if (cnt == 2) {
+ BNXT_TF_DBG(ERR, "Parse Err:Third L4 header not supported\n");
return BNXT_TF_RC_ERROR;
}
* header fields
*/
if (tcp_spec) {
- hdr_field[idx].size = sizeof(tcp_spec->hdr.src_port);
- memcpy(hdr_field[idx++].spec, &tcp_spec->hdr.src_port,
- sizeof(tcp_spec->hdr.src_port));
- hdr_field[idx].size = sizeof(tcp_spec->hdr.dst_port);
- memcpy(hdr_field[idx++].spec, &tcp_spec->hdr.dst_port,
- sizeof(tcp_spec->hdr.dst_port));
- hdr_field[idx].size = sizeof(tcp_spec->hdr.sent_seq);
- memcpy(hdr_field[idx++].spec, &tcp_spec->hdr.sent_seq,
- sizeof(tcp_spec->hdr.sent_seq));
- hdr_field[idx].size = sizeof(tcp_spec->hdr.recv_ack);
- memcpy(hdr_field[idx++].spec, &tcp_spec->hdr.recv_ack,
- sizeof(tcp_spec->hdr.recv_ack));
- hdr_field[idx].size = sizeof(tcp_spec->hdr.data_off);
- memcpy(hdr_field[idx++].spec, &tcp_spec->hdr.data_off,
- sizeof(tcp_spec->hdr.data_off));
- hdr_field[idx].size = sizeof(tcp_spec->hdr.tcp_flags);
- memcpy(hdr_field[idx++].spec, &tcp_spec->hdr.tcp_flags,
- sizeof(tcp_spec->hdr.tcp_flags));
- hdr_field[idx].size = sizeof(tcp_spec->hdr.rx_win);
- memcpy(hdr_field[idx++].spec, &tcp_spec->hdr.rx_win,
- sizeof(tcp_spec->hdr.rx_win));
- hdr_field[idx].size = sizeof(tcp_spec->hdr.cksum);
- memcpy(hdr_field[idx++].spec, &tcp_spec->hdr.cksum,
- sizeof(tcp_spec->hdr.cksum));
- hdr_field[idx].size = sizeof(tcp_spec->hdr.tcp_urp);
- memcpy(hdr_field[idx++].spec, &tcp_spec->hdr.tcp_urp,
- sizeof(tcp_spec->hdr.tcp_urp));
+ size = sizeof(tcp_spec->hdr.src_port);
+ field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
+ &tcp_spec->hdr.src_port,
+ size);
+ size = sizeof(tcp_spec->hdr.dst_port);
+ field = ulp_rte_parser_fld_copy(field,
+ &tcp_spec->hdr.dst_port,
+ size);
+ size = sizeof(tcp_spec->hdr.sent_seq);
+ field = ulp_rte_parser_fld_copy(field,
+ &tcp_spec->hdr.sent_seq,
+ size);
+ size = sizeof(tcp_spec->hdr.recv_ack);
+ field = ulp_rte_parser_fld_copy(field,
+ &tcp_spec->hdr.recv_ack,
+ size);
+ size = sizeof(tcp_spec->hdr.data_off);
+ field = ulp_rte_parser_fld_copy(field,
+ &tcp_spec->hdr.data_off,
+ size);
+ size = sizeof(tcp_spec->hdr.tcp_flags);
+ field = ulp_rte_parser_fld_copy(field,
+ &tcp_spec->hdr.tcp_flags,
+ size);
+ size = sizeof(tcp_spec->hdr.rx_win);
+ field = ulp_rte_parser_fld_copy(field,
+ &tcp_spec->hdr.rx_win,
+ size);
+ size = sizeof(tcp_spec->hdr.cksum);
+ field = ulp_rte_parser_fld_copy(field,
+ &tcp_spec->hdr.cksum,
+ size);
+ size = sizeof(tcp_spec->hdr.tcp_urp);
+ field = ulp_rte_parser_fld_copy(field,
+ &tcp_spec->hdr.tcp_urp,
+ size);
} else {
idx += BNXT_ULP_PROTO_HDR_TCP_NUM;
}
if (tcp_mask) {
- memcpy(hdr_field[mdx++].mask, &tcp_mask->hdr.src_port,
- sizeof(tcp_mask->hdr.src_port));
- memcpy(hdr_field[mdx++].mask, &tcp_mask->hdr.dst_port,
- sizeof(tcp_mask->hdr.dst_port));
- memcpy(hdr_field[mdx++].mask, &tcp_mask->hdr.sent_seq,
- sizeof(tcp_mask->hdr.sent_seq));
- memcpy(hdr_field[mdx++].mask, &tcp_mask->hdr.recv_ack,
- sizeof(tcp_mask->hdr.recv_ack));
- memcpy(hdr_field[mdx++].mask, &tcp_mask->hdr.data_off,
- sizeof(tcp_mask->hdr.data_off));
- memcpy(hdr_field[mdx++].mask, &tcp_mask->hdr.tcp_flags,
- sizeof(tcp_mask->hdr.tcp_flags));
- memcpy(hdr_field[mdx++].mask, &tcp_mask->hdr.rx_win,
- sizeof(tcp_mask->hdr.rx_win));
- memcpy(hdr_field[mdx++].mask, &tcp_mask->hdr.cksum,
- sizeof(tcp_mask->hdr.cksum));
- memcpy(hdr_field[mdx++].mask, &tcp_mask->hdr.tcp_urp,
- sizeof(tcp_mask->hdr.tcp_urp));
- }
- *field_idx = idx; /* add number of TCP header elements */
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &tcp_mask->hdr.src_port,
+ sizeof(tcp_mask->hdr.src_port));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &tcp_mask->hdr.dst_port,
+ sizeof(tcp_mask->hdr.dst_port));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &tcp_mask->hdr.sent_seq,
+ sizeof(tcp_mask->hdr.sent_seq));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &tcp_mask->hdr.recv_ack,
+ sizeof(tcp_mask->hdr.recv_ack));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &tcp_mask->hdr.data_off,
+ sizeof(tcp_mask->hdr.data_off));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &tcp_mask->hdr.tcp_flags,
+ sizeof(tcp_mask->hdr.tcp_flags));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &tcp_mask->hdr.rx_win,
+ sizeof(tcp_mask->hdr.rx_win));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &tcp_mask->hdr.cksum,
+ sizeof(tcp_mask->hdr.cksum));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &tcp_mask->hdr.tcp_urp,
+ sizeof(tcp_mask->hdr.tcp_urp));
+ }
+ /* add number of TCP header elements */
+ params->field_idx += BNXT_ULP_PROTO_HDR_TCP_NUM;
/* Set the udp header bitmap and computed l4 header bitmaps */
- if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_L4) ||
- ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP) ||
+ if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP) ||
ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP)) {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_TCP);
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_L4);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4, 1);
} else {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP);
- ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_L4);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4, 1);
}
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L4_HDR_CNT, ++cnt);
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow item Vxlan Header. */
int32_t
ulp_rte_vxlan_hdr_handler(const struct rte_flow_item *item,
- struct ulp_rte_hdr_bitmap *hdrbitmap,
- struct ulp_rte_hdr_field *hdr_field,
- uint32_t *field_idx,
- uint32_t *vlan_idx __rte_unused)
+ struct ulp_rte_parser_params *params)
{
- const struct rte_flow_item_vxlan *vxlan_spec, *vxlan_mask;
- uint32_t idx = *field_idx;
- uint32_t mdx = *field_idx;
-
- vxlan_spec = item->spec;
- vxlan_mask = item->mask;
+ const struct rte_flow_item_vxlan *vxlan_spec = item->spec;
+ const struct rte_flow_item_vxlan *vxlan_mask = item->mask;
+ struct ulp_rte_hdr_field *field;
+ struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
+ uint32_t idx = params->field_idx;
+ uint32_t size;
/*
* Copy the rte_flow_item for vxlan into hdr_field using vxlan
* header fields
*/
if (vxlan_spec) {
- hdr_field[idx].size = sizeof(vxlan_spec->flags);
- memcpy(hdr_field[idx++].spec, &vxlan_spec->flags,
- sizeof(vxlan_spec->flags));
- hdr_field[idx].size = sizeof(vxlan_spec->rsvd0);
- memcpy(hdr_field[idx++].spec, &vxlan_spec->rsvd0,
- sizeof(vxlan_spec->rsvd0));
- hdr_field[idx].size = sizeof(vxlan_spec->vni);
- memcpy(hdr_field[idx++].spec, &vxlan_spec->vni,
- sizeof(vxlan_spec->vni));
- hdr_field[idx].size = sizeof(vxlan_spec->rsvd1);
- memcpy(hdr_field[idx++].spec, &vxlan_spec->rsvd1,
- sizeof(vxlan_spec->rsvd1));
- } else {
- idx += BNXT_ULP_PROTO_HDR_VXLAN_NUM;
+ size = sizeof(vxlan_spec->flags);
+ field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
+ &vxlan_spec->flags,
+ size);
+ size = sizeof(vxlan_spec->rsvd0);
+ field = ulp_rte_parser_fld_copy(field,
+ &vxlan_spec->rsvd0,
+ size);
+ size = sizeof(vxlan_spec->vni);
+ field = ulp_rte_parser_fld_copy(field,
+ &vxlan_spec->vni,
+ size);
+ size = sizeof(vxlan_spec->rsvd1);
+ field = ulp_rte_parser_fld_copy(field,
+ &vxlan_spec->rsvd1,
+ size);
}
-
if (vxlan_mask) {
- memcpy(hdr_field[mdx++].mask, &vxlan_mask->flags,
- sizeof(vxlan_mask->flags));
- memcpy(hdr_field[mdx++].mask, &vxlan_mask->rsvd0,
- sizeof(vxlan_mask->rsvd0));
- memcpy(hdr_field[mdx++].mask, &vxlan_mask->vni,
- sizeof(vxlan_mask->vni));
- memcpy(hdr_field[mdx++].mask, &vxlan_mask->rsvd1,
- sizeof(vxlan_mask->rsvd1));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &vxlan_mask->flags,
+ sizeof(vxlan_mask->flags));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &vxlan_mask->rsvd0,
+ sizeof(vxlan_mask->rsvd0));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &vxlan_mask->vni,
+ sizeof(vxlan_mask->vni));
+ ulp_rte_prsr_mask_copy(params, &idx,
+ &vxlan_mask->rsvd1,
+ sizeof(vxlan_mask->rsvd1));
}
- *field_idx = idx; /* Add number of vxlan header elements */
+ /* Add number of vxlan header elements */
+ params->field_idx += BNXT_ULP_PROTO_HDR_VXLAN_NUM;
/* Update the hdr_bitmap with vxlan */
- ULP_BITMAP_SET(hdrbitmap->bits, BNXT_ULP_HDR_BIT_T_VXLAN);
+ ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_T_VXLAN);
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow item void Header */
int32_t
ulp_rte_void_hdr_handler(const struct rte_flow_item *item __rte_unused,
- struct ulp_rte_hdr_bitmap *hdr_bit __rte_unused,
- struct ulp_rte_hdr_field *hdr_field __rte_unused,
- uint32_t *field_idx __rte_unused,
- uint32_t *vlan_idx __rte_unused)
+ struct ulp_rte_parser_params *params __rte_unused)
{
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow action void Header. */
int32_t
ulp_rte_void_act_handler(const struct rte_flow_action *action_item __rte_unused,
- struct ulp_rte_act_bitmap *act __rte_unused,
- struct ulp_rte_act_prop *act_prop __rte_unused)
+ struct ulp_rte_parser_params *params __rte_unused)
{
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow action Mark Header. */
int32_t
ulp_rte_mark_act_handler(const struct rte_flow_action *action_item,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *act_prop)
+ struct ulp_rte_parser_params *param)
{
const struct rte_flow_action_mark *mark;
- uint32_t mark_id = 0;
+ struct ulp_rte_act_bitmap *act = ¶m->act_bitmap;
+ uint32_t mark_id;
mark = action_item->conf;
if (mark) {
mark_id = tfp_cpu_to_be_32(mark->id);
- memcpy(&act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_MARK],
+ memcpy(¶m->act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_MARK],
&mark_id, BNXT_ULP_ACT_PROP_SZ_MARK);
/* Update the hdr_bitmap with vxlan */
/* Function to handle the parsing of RTE Flow action RSS Header. */
int32_t
ulp_rte_rss_act_handler(const struct rte_flow_action *action_item,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *act_prop __rte_unused)
+ struct ulp_rte_parser_params *param)
{
- const struct rte_flow_action_rss *rss;
+ const struct rte_flow_action_rss *rss = action_item->conf;
- rss = action_item->conf;
if (rss) {
/* Update the hdr_bitmap with vxlan */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_RSS);
+ ULP_BITMAP_SET(param->act_bitmap.bits, BNXT_ULP_ACTION_BIT_RSS);
return BNXT_TF_RC_SUCCESS;
}
BNXT_TF_DBG(ERR, "Parse Error: RSS arg is invalid\n");
/* Function to handle the parsing of RTE Flow action vxlan_encap Header. */
int32_t
ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *ap)
+ struct ulp_rte_parser_params *params)
{
const struct rte_flow_action_vxlan_encap *vxlan_encap;
const struct rte_flow_item *item;
uint32_t vxlan_size = 0;
uint8_t *buff;
/* IP header per byte - ver/hlen, TOS, ID, ID, FRAG, FRAG, TTL, PROTO */
- const uint8_t def_ipv4_hdr[] = {0x45, 0x00, 0x00, 0x01, 0x00,
+ const uint8_t def_ipv4_hdr[] = {0x45, 0x00, 0x00, 0x01, 0x00,
0x00, 0x40, 0x11};
+ struct ulp_rte_act_bitmap *act = ¶ms->act_bitmap;
+ struct ulp_rte_act_prop *ap = ¶ms->act_prop;
vxlan_encap = action_item->conf;
if (!vxlan_encap) {
eth_spec->dst.addr_bytes,
BNXT_ULP_ACT_PROP_SZ_ENCAP_L2_DMAC);
+ buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_L2_SMAC];
+ ulp_encap_buffer_copy(buff,
+ eth_spec->src.addr_bytes,
+ BNXT_ULP_ACT_PROP_SZ_ENCAP_L2_SMAC);
+
/* Goto the next item */
if (!ulp_rte_item_skip_void(&item, 1))
return BNXT_TF_RC_ERROR;
const uint8_t *tmp_buff;
buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP];
- ulp_encap_buffer_copy(buff,
- &ipv4_spec->hdr.version_ihl,
- BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS);
- buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP +
- BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS];
tmp_buff = (const uint8_t *)&ipv4_spec->hdr.packet_id;
ulp_encap_buffer_copy(buff,
tmp_buff,
BNXT_ULP_ENCAP_IPV4_ID_PROTO);
+ buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP +
+ BNXT_ULP_ENCAP_IPV4_ID_PROTO];
+ ulp_encap_buffer_copy(buff,
+ &ipv4_spec->hdr.version_ihl,
+ BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS);
}
buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP +
BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS +
(const uint8_t *)&ipv4_spec->hdr.dst_addr,
BNXT_ULP_ENCAP_IPV4_DEST_IP);
+ buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP_SRC];
+ ulp_encap_buffer_copy(buff,
+ (const uint8_t *)&ipv4_spec->hdr.src_addr,
+ BNXT_ULP_ACT_PROP_SZ_ENCAP_IP_SRC);
+
/* Update the ip size details */
ip_size = tfp_cpu_to_be_32(ip_size);
memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP_SZ],
memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_L3_TYPE],
&ip_type, sizeof(uint32_t));
+ /* update the computed field to notify it is ipv4 header */
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_ACT_ENCAP_IPV4_FLAG,
+ 1);
+
if (!ulp_rte_item_skip_void(&item, 1))
return BNXT_TF_RC_ERROR;
} else if (item->type == RTE_FLOW_ITEM_TYPE_IPV6) {
memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_L3_TYPE],
&ip_type, sizeof(uint32_t));
+ /* update the computed field to notify it is ipv6 header */
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_ACT_ENCAP_IPV6_FLAG,
+ 1);
+
if (!ulp_rte_item_skip_void(&item, 1))
return BNXT_TF_RC_ERROR;
} else {
memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_TUN_SZ],
&vxlan_size, sizeof(uint32_t));
- /*update the hdr_bitmap with vxlan */
+ /* update the hdr_bitmap with vxlan */
ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_VXLAN_ENCAP);
return BNXT_TF_RC_SUCCESS;
}
int32_t
ulp_rte_vxlan_decap_act_handler(const struct rte_flow_action *action_item
__rte_unused,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *act_prop __rte_unused)
+ struct ulp_rte_parser_params *params)
{
/* update the hdr_bitmap with vxlan */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_VXLAN_DECAP);
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_VXLAN_DECAP);
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow action drop Header. */
int32_t
ulp_rte_drop_act_handler(const struct rte_flow_action *action_item __rte_unused,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *act_prop __rte_unused)
+ struct ulp_rte_parser_params *params)
{
/* Update the hdr_bitmap with drop */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_DROP);
+ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_DROP);
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow action count. */
int32_t
ulp_rte_count_act_handler(const struct rte_flow_action *action_item,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *act_prop __rte_unused)
+ struct ulp_rte_parser_params *params)
{
const struct rte_flow_action_count *act_count;
+ struct ulp_rte_act_prop *act_prop = ¶ms->act_prop;
act_count = action_item->conf;
if (act_count) {
}
/* Update the hdr_bitmap with count */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_COUNT);
+ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_COUNT);
+ return BNXT_TF_RC_SUCCESS;
+}
+
+/* Function to handle the parsing of action ports. */
+static int32_t
+ulp_rte_parser_act_port_set(struct ulp_rte_parser_params *param,
+ uint32_t ifindex)
+{
+ enum bnxt_ulp_direction_type dir;
+ uint16_t pid_s;
+ uint32_t pid;
+ struct ulp_rte_act_prop *act = ¶m->act_prop;
+ enum bnxt_ulp_intf_type port_type;
+ uint32_t vnic_type;
+
+ /* Get the direction */
+ dir = ULP_COMP_FLD_IDX_RD(param, BNXT_ULP_CF_IDX_DIRECTION);
+ if (dir == BNXT_ULP_DIR_EGRESS) {
+ /* For egress direction, fill vport */
+ if (ulp_port_db_vport_get(param->ulp_ctx, ifindex, &pid_s))
+ return BNXT_TF_RC_ERROR;
+
+ pid = pid_s;
+ pid = rte_cpu_to_be_32(pid);
+ memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_VPORT],
+ &pid, BNXT_ULP_ACT_PROP_SZ_VPORT);
+ } else {
+ /* For ingress direction, fill vnic */
+ port_type = ULP_COMP_FLD_IDX_RD(param,
+ BNXT_ULP_CF_IDX_ACT_PORT_TYPE);
+ if (port_type == BNXT_ULP_INTF_TYPE_VF_REP)
+ vnic_type = BNXT_ULP_VF_FUNC_VNIC;
+ else
+ vnic_type = BNXT_ULP_DRV_FUNC_VNIC;
+
+ if (ulp_port_db_default_vnic_get(param->ulp_ctx, ifindex,
+ vnic_type, &pid_s))
+ return BNXT_TF_RC_ERROR;
+
+ pid = pid_s;
+ pid = rte_cpu_to_be_32(pid);
+ memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_VNIC],
+ &pid, BNXT_ULP_ACT_PROP_SZ_VNIC);
+ }
+
+ /* Update the action port set bit */
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_ACT_PORT_IS_SET, 1);
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow action PF. */
int32_t
ulp_rte_pf_act_handler(const struct rte_flow_action *action_item __rte_unused,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *act_prop)
+ struct ulp_rte_parser_params *params)
{
- uint8_t *svif_buf;
- uint8_t *vnic_buffer;
- uint32_t svif;
+ uint32_t port_id;
+ uint32_t ifindex;
+ enum bnxt_ulp_intf_type intf_type;
- /* Update the hdr_bitmap with vnic bit */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_VNIC);
+ /* Get the port id of the current device */
+ port_id = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF);
- /* copy the PF of the current device into VNIC Property */
- svif_buf = &act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_VNIC];
- ulp_util_field_int_read(svif_buf, &svif);
- svif = (uint32_t)bnxt_get_vnic_id(svif);
- svif = htonl(svif);
- vnic_buffer = &act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_VNIC];
- ulp_util_field_int_write(vnic_buffer, svif);
+ /* Get the port db ifindex */
+ if (ulp_port_db_dev_port_to_ulp_index(params->ulp_ctx, port_id,
+ &ifindex)) {
+ BNXT_TF_DBG(ERR, "Invalid port id\n");
+ return BNXT_TF_RC_ERROR;
+ }
- return BNXT_TF_RC_SUCCESS;
+ /* Check the port is PF port */
+ intf_type = ulp_port_db_port_type_get(params->ulp_ctx, ifindex);
+ if (intf_type != BNXT_ULP_INTF_TYPE_PF) {
+ BNXT_TF_DBG(ERR, "Port is not a PF port\n");
+ return BNXT_TF_RC_ERROR;
+ }
+ /* Update the action properties */
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_ACT_PORT_TYPE, intf_type);
+ return ulp_rte_parser_act_port_set(params, ifindex);
}
/* Function to handle the parsing of RTE Flow action VF. */
int32_t
ulp_rte_vf_act_handler(const struct rte_flow_action *action_item,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *act_prop)
+ struct ulp_rte_parser_params *params)
{
const struct rte_flow_action_vf *vf_action;
+ uint32_t ifindex;
+ enum bnxt_ulp_intf_type intf_type;
vf_action = action_item->conf;
- if (vf_action) {
- if (vf_action->original) {
- BNXT_TF_DBG(ERR,
- "Parse Error:VF Original not supported\n");
- return BNXT_TF_RC_PARSE_ERR;
- }
- /* TBD: Update the computed VNIC using VF conversion */
- memcpy(&act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_VNIC],
- &vf_action->id,
- BNXT_ULP_ACT_PROP_SZ_VNIC);
+ if (!vf_action) {
+ BNXT_TF_DBG(ERR, "ParseErr: Invalid Argument\n");
+ return BNXT_TF_RC_PARSE_ERR;
}
- /* Update the hdr_bitmap with count */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_VNIC);
- return BNXT_TF_RC_SUCCESS;
+ if (vf_action->original) {
+ BNXT_TF_DBG(ERR, "ParseErr:VF Original not supported\n");
+ return BNXT_TF_RC_PARSE_ERR;
+ }
+
+ /* Check the port is VF port */
+ if (ulp_port_db_dev_func_id_to_ulp_index(params->ulp_ctx, vf_action->id,
+ &ifindex)) {
+ BNXT_TF_DBG(ERR, "VF is not valid interface\n");
+ return BNXT_TF_RC_ERROR;
+ }
+ intf_type = ulp_port_db_port_type_get(params->ulp_ctx, ifindex);
+ if (intf_type != BNXT_ULP_INTF_TYPE_VF &&
+ intf_type != BNXT_ULP_INTF_TYPE_TRUSTED_VF) {
+ BNXT_TF_DBG(ERR, "Port is not a VF port\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ /* Update the action properties */
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_ACT_PORT_TYPE, intf_type);
+ return ulp_rte_parser_act_port_set(params, ifindex);
}
/* Function to handle the parsing of RTE Flow action port_id. */
int32_t
ulp_rte_port_id_act_handler(const struct rte_flow_action *act_item,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *act_prop)
+ struct ulp_rte_parser_params *param)
{
- const struct rte_flow_action_port_id *port_id;
+ const struct rte_flow_action_port_id *port_id = act_item->conf;
+ uint32_t ifindex;
+ enum bnxt_ulp_intf_type intf_type;
- port_id = act_item->conf;
- if (port_id) {
- if (port_id->original) {
- BNXT_TF_DBG(ERR,
- "ParseErr:Portid Original not supported\n");
- return BNXT_TF_RC_PARSE_ERR;
- }
- /* TBD: Update the computed VNIC using port conversion */
- memcpy(&act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_VNIC],
- &port_id->id,
- BNXT_ULP_ACT_PROP_SZ_VNIC);
+ if (!port_id) {
+ BNXT_TF_DBG(ERR,
+ "ParseErr: Invalid Argument\n");
+ return BNXT_TF_RC_PARSE_ERR;
+ }
+ if (port_id->original) {
+ BNXT_TF_DBG(ERR,
+ "ParseErr:Portid Original not supported\n");
+ return BNXT_TF_RC_PARSE_ERR;
}
- /* Update the hdr_bitmap with count */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_VNIC);
- return BNXT_TF_RC_SUCCESS;
+ /* Get the port db ifindex */
+ if (ulp_port_db_dev_port_to_ulp_index(param->ulp_ctx, port_id->id,
+ &ifindex)) {
+ BNXT_TF_DBG(ERR, "Invalid port id\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ /* Get the intf type */
+ intf_type = ulp_port_db_port_type_get(param->ulp_ctx, ifindex);
+ if (!intf_type) {
+ BNXT_TF_DBG(ERR, "Invalid port type\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ /* Set the action port */
+ ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_ACT_PORT_TYPE, intf_type);
+ return ulp_rte_parser_act_port_set(param, ifindex);
}
/* Function to handle the parsing of RTE Flow action phy_port. */
int32_t
ulp_rte_phy_port_act_handler(const struct rte_flow_action *action_item,
- struct ulp_rte_act_bitmap *act,
- struct ulp_rte_act_prop *act_prop)
+ struct ulp_rte_parser_params *prm)
{
const struct rte_flow_action_phy_port *phy_port;
+ uint32_t pid;
+ int32_t rc;
+ uint16_t pid_s;
+ enum bnxt_ulp_direction_type dir;
phy_port = action_item->conf;
- if (phy_port) {
- if (phy_port->original) {
+ if (!phy_port) {
+ BNXT_TF_DBG(ERR,
+ "ParseErr: Invalid Argument\n");
+ return BNXT_TF_RC_PARSE_ERR;
+ }
+
+ if (phy_port->original) {
+ BNXT_TF_DBG(ERR,
+ "Parse Err:Port Original not supported\n");
+ return BNXT_TF_RC_PARSE_ERR;
+ }
+ dir = ULP_COMP_FLD_IDX_RD(prm, BNXT_ULP_CF_IDX_DIRECTION);
+ if (dir != BNXT_ULP_DIR_EGRESS) {
+ BNXT_TF_DBG(ERR,
+ "Parse Err:Phy ports are valid only for egress\n");
+ return BNXT_TF_RC_PARSE_ERR;
+ }
+ /* Get the physical port details from port db */
+ rc = ulp_port_db_phy_port_vport_get(prm->ulp_ctx, phy_port->index,
+ &pid_s);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Failed to get port details\n");
+ return -EINVAL;
+ }
+
+ pid = pid_s;
+ pid = rte_cpu_to_be_32(pid);
+ memcpy(&prm->act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VPORT],
+ &pid, BNXT_ULP_ACT_PROP_SZ_VPORT);
+
+ /* Update the action port set bit */
+ ULP_COMP_FLD_IDX_WR(prm, BNXT_ULP_CF_IDX_ACT_PORT_IS_SET, 1);
+ ULP_COMP_FLD_IDX_WR(prm, BNXT_ULP_CF_IDX_ACT_PORT_TYPE,
+ BNXT_ULP_INTF_TYPE_PHY_PORT);
+ return BNXT_TF_RC_SUCCESS;
+}
+
+/* Function to handle the parsing of RTE Flow action pop vlan. */
+int32_t
+ulp_rte_of_pop_vlan_act_handler(const struct rte_flow_action *a __rte_unused,
+ struct ulp_rte_parser_params *params)
+{
+ /* Update the act_bitmap with pop */
+ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_POP_VLAN);
+ return BNXT_TF_RC_SUCCESS;
+}
+
+/* Function to handle the parsing of RTE Flow action push vlan. */
+int32_t
+ulp_rte_of_push_vlan_act_handler(const struct rte_flow_action *action_item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_action_of_push_vlan *push_vlan;
+ uint16_t ethertype;
+ struct ulp_rte_act_prop *act = ¶ms->act_prop;
+
+ push_vlan = action_item->conf;
+ if (push_vlan) {
+ ethertype = push_vlan->ethertype;
+ if (tfp_cpu_to_be_16(ethertype) != RTE_ETHER_TYPE_VLAN) {
BNXT_TF_DBG(ERR,
- "Parse Err:Port Original not supported\n");
+ "Parse Err: Ethertype not supported\n");
return BNXT_TF_RC_PARSE_ERR;
}
- memcpy(&act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_VPORT],
- &phy_port->index,
- BNXT_ULP_ACT_PROP_SZ_VPORT);
+ memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_PUSH_VLAN],
+ ðertype, BNXT_ULP_ACT_PROP_SZ_PUSH_VLAN);
+ /* Update the hdr_bitmap with push vlan */
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_PUSH_VLAN);
+ return BNXT_TF_RC_SUCCESS;
}
+ BNXT_TF_DBG(ERR, "Parse Error: Push vlan arg is invalid\n");
+ return BNXT_TF_RC_ERROR;
+}
- /* Update the hdr_bitmap with count */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_VPORT);
+/* Function to handle the parsing of RTE Flow action set vlan id. */
+int32_t
+ulp_rte_of_set_vlan_vid_act_handler(const struct rte_flow_action *action_item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_action_of_set_vlan_vid *vlan_vid;
+ uint32_t vid;
+ struct ulp_rte_act_prop *act = ¶ms->act_prop;
+
+ vlan_vid = action_item->conf;
+ if (vlan_vid && vlan_vid->vlan_vid) {
+ vid = vlan_vid->vlan_vid;
+ memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_SET_VLAN_VID],
+ &vid, BNXT_ULP_ACT_PROP_SZ_SET_VLAN_VID);
+ /* Update the hdr_bitmap with vlan vid */
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_SET_VLAN_VID);
+ return BNXT_TF_RC_SUCCESS;
+ }
+ BNXT_TF_DBG(ERR, "Parse Error: Vlan vid arg is invalid\n");
+ return BNXT_TF_RC_ERROR;
+}
+
+/* Function to handle the parsing of RTE Flow action set vlan pcp. */
+int32_t
+ulp_rte_of_set_vlan_pcp_act_handler(const struct rte_flow_action *action_item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_action_of_set_vlan_pcp *vlan_pcp;
+ uint8_t pcp;
+ struct ulp_rte_act_prop *act = ¶ms->act_prop;
+
+ vlan_pcp = action_item->conf;
+ if (vlan_pcp) {
+ pcp = vlan_pcp->vlan_pcp;
+ memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_SET_VLAN_PCP],
+ &pcp, BNXT_ULP_ACT_PROP_SZ_SET_VLAN_PCP);
+ /* Update the hdr_bitmap with vlan vid */
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_SET_VLAN_PCP);
+ return BNXT_TF_RC_SUCCESS;
+ }
+ BNXT_TF_DBG(ERR, "Parse Error: Vlan pcp arg is invalid\n");
+ return BNXT_TF_RC_ERROR;
+}
+
+/* Function to handle the parsing of RTE Flow action set ipv4 src.*/
+int32_t
+ulp_rte_set_ipv4_src_act_handler(const struct rte_flow_action *action_item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_action_set_ipv4 *set_ipv4;
+ struct ulp_rte_act_prop *act = ¶ms->act_prop;
+
+ set_ipv4 = action_item->conf;
+ if (set_ipv4) {
+ memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_SET_IPV4_SRC],
+ &set_ipv4->ipv4_addr, BNXT_ULP_ACT_PROP_SZ_SET_IPV4_SRC);
+ /* Update the hdr_bitmap with set ipv4 src */
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_SET_IPV4_SRC);
+ return BNXT_TF_RC_SUCCESS;
+ }
+ BNXT_TF_DBG(ERR, "Parse Error: set ipv4 src arg is invalid\n");
+ return BNXT_TF_RC_ERROR;
+}
+
+/* Function to handle the parsing of RTE Flow action set ipv4 dst.*/
+int32_t
+ulp_rte_set_ipv4_dst_act_handler(const struct rte_flow_action *action_item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_action_set_ipv4 *set_ipv4;
+ struct ulp_rte_act_prop *act = ¶ms->act_prop;
+
+ set_ipv4 = action_item->conf;
+ if (set_ipv4) {
+ memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_SET_IPV4_DST],
+ &set_ipv4->ipv4_addr, BNXT_ULP_ACT_PROP_SZ_SET_IPV4_DST);
+ /* Update the hdr_bitmap with set ipv4 dst */
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_SET_IPV4_DST);
+ return BNXT_TF_RC_SUCCESS;
+ }
+ BNXT_TF_DBG(ERR, "Parse Error: set ipv4 dst arg is invalid\n");
+ return BNXT_TF_RC_ERROR;
+}
+
+/* Function to handle the parsing of RTE Flow action set tp src.*/
+int32_t
+ulp_rte_set_tp_src_act_handler(const struct rte_flow_action *action_item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_action_set_tp *set_tp;
+ struct ulp_rte_act_prop *act = ¶ms->act_prop;
+
+ set_tp = action_item->conf;
+ if (set_tp) {
+ memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_SET_TP_SRC],
+ &set_tp->port, BNXT_ULP_ACT_PROP_SZ_SET_TP_SRC);
+ /* Update the hdr_bitmap with set tp src */
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_SET_TP_SRC);
+ return BNXT_TF_RC_SUCCESS;
+ }
+
+ BNXT_TF_DBG(ERR, "Parse Error: set tp src arg is invalid\n");
+ return BNXT_TF_RC_ERROR;
+}
+
+/* Function to handle the parsing of RTE Flow action set tp dst.*/
+int32_t
+ulp_rte_set_tp_dst_act_handler(const struct rte_flow_action *action_item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_action_set_tp *set_tp;
+ struct ulp_rte_act_prop *act = ¶ms->act_prop;
+
+ set_tp = action_item->conf;
+ if (set_tp) {
+ memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_SET_TP_DST],
+ &set_tp->port, BNXT_ULP_ACT_PROP_SZ_SET_TP_DST);
+ /* Update the hdr_bitmap with set tp dst */
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_ACTION_BIT_SET_TP_DST);
+ return BNXT_TF_RC_SUCCESS;
+ }
+
+ BNXT_TF_DBG(ERR, "Parse Error: set tp src arg is invalid\n");
+ return BNXT_TF_RC_ERROR;
+}
+
+/* Function to handle the parsing of RTE Flow action dec ttl.*/
+int32_t
+ulp_rte_dec_ttl_act_handler(const struct rte_flow_action *act __rte_unused,
+ struct ulp_rte_parser_params *params)
+{
+ /* Update the act_bitmap with dec ttl */
+ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_DEC_TTL);
return BNXT_TF_RC_SUCCESS;
}
git.droids-corp.org / dpdk.git / blobdiff