X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Ftf_ulp%2Fulp_rte_parser.c;h=a54c55c5f5572cfe96086f3a9740845a549d1e5e;hb=fcf681890a31a7396df2b85b2888074c5b939535;hp=b4bf431549930801c21e4215d63a5d402df1884e;hpb=3c334fcd9e565258667ec052550ab023d0fc9adb;p=dpdk.git diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c index b4bf431549..a54c55c5f5 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c +++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c @@ -6,11 +6,22 @@ #include "bnxt.h" #include "ulp_template_db_enum.h" #include "ulp_template_struct.h" +#include "bnxt_ulp.h" #include "bnxt_tf_common.h" #include "ulp_rte_parser.h" +#include "ulp_matcher.h" #include "ulp_utils.h" #include "tfp.h" #include "ulp_port_db.h" +#include "ulp_flow_db.h" +#include "ulp_mapper.h" +#include "ulp_tun.h" + +/* 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 @@ -72,6 +83,16 @@ ulp_rte_prsr_mask_copy(struct ulp_rte_parser_params *params, *idx = *idx + 1; } +/* Utility function to ignore field masks items */ +static void +ulp_rte_prsr_mask_ignore(struct ulp_rte_parser_params *params __rte_unused, + uint32_t *idx, + const void *buffer __rte_unused, + uint32_t size __rte_unused) +{ + *idx = *idx + 1; +} + /* * Function to handle the parsing of RTE Flows and placing * the RTE flow items into the ulp structures. @@ -84,9 +105,10 @@ bnxt_ulp_rte_parser_hdr_parse(const struct rte_flow_item pattern[], struct bnxt_ulp_rte_hdr_info *hdr_info; params->field_idx = BNXT_ULP_PROTO_HDR_SVIF_NUM; - if (params->dir == ULP_DIR_EGRESS) - ULP_BITMAP_SET(params->hdr_bitmap.bits, - BNXT_ULP_FLOW_DIR_BITMASK_EGR); + + /* 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) { @@ -109,8 +131,7 @@ bnxt_ulp_rte_parser_hdr_parse(const struct rte_flow_item pattern[], item++; } /* update the implied SVIF */ - (void)ulp_rte_parser_svif_process(params); - return BNXT_TF_RC_SUCCESS; + return ulp_rte_parser_implicit_match_port_process(params); } /* @@ -124,10 +145,6 @@ bnxt_ulp_rte_parser_act_parse(const struct rte_flow_action actions[], const struct rte_flow_action *action_item = actions; struct bnxt_ulp_rte_act_info *hdr_info; - if (params->dir == ULP_DIR_EGRESS) - ULP_BITMAP_SET(params->act_bitmap.bits, - BNXT_ULP_FLOW_DIR_BITMASK_EGR); - /* Parse all the items in the pattern */ while (action_item && action_item->type != RTE_FLOW_ACTION_TYPE_END) { /* get the header information from the flow_hdr_info table */ @@ -151,25 +168,194 @@ bnxt_ulp_rte_parser_act_parse(const struct rte_flow_action actions[], } action_item++; } - /* update the implied VNIC */ - ulp_rte_parser_vnic_process(params); + /* 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); + + /* populate the loopback parif */ + ULP_COMP_FLD_IDX_WR(params, + BNXT_ULP_CF_IDX_LOOPBACK_PARIF, + BNXT_ULP_SYM_VF_FUNC_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); + } + } +} + +static int32_t +ulp_post_process_normal_flow(struct ulp_rte_parser_params *params) +{ + enum bnxt_ulp_intf_type match_port_type, act_port_type; + enum bnxt_ulp_direction_type dir; + 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 handle the post processing of the parsing details + */ +int32_t +bnxt_ulp_rte_parser_post_process(struct ulp_rte_parser_params *params) +{ + ulp_post_process_normal_flow(params); + return ulp_post_process_tun_flow(params); +} + +/* + * 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_parser_params *params, - enum rte_flow_item_type proto, - uint16_t svif, + uint32_t ifindex, uint16_t mask) { - uint16_t port_id = svif; - uint32_t dir = 0; + 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 if_type; - uint32_t ifindex; - int32_t rc; + 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) { @@ -178,31 +364,32 @@ ulp_rte_parser_svif_set(struct ulp_rte_parser_params *params, return BNXT_TF_RC_ERROR; } - if (proto == RTE_FLOW_ITEM_TYPE_PORT_ID) { - dir = ULP_COMP_FLD_IDX_RD(params, - BNXT_ULP_CF_IDX_DIRECTION); - /* perform the conversion from dpdk port to bnxt svif */ - rc = ulp_port_db_dev_port_to_ulp_index(params->ulp_ctx, port_id, - &ifindex); - if (rc) { - BNXT_TF_DBG(ERR, - "Invalid port id\n"); - return BNXT_TF_RC_ERROR; - } + /* 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; + } - if (dir == ULP_DIR_INGRESS) { - svif_type = BNXT_ULP_PHY_PORT_SVIF; - } else { - if_type = bnxt_get_interface_type(port_id); - if (if_type == BNXT_ULP_INTF_TYPE_VF_REP) - svif_type = BNXT_ULP_VF_FUNC_SVIF; - else - svif_type = BNXT_ULP_DRV_FUNC_SVIF; - } - ulp_port_db_svif_get(params->ulp_ctx, ifindex, svif_type, - &svif); - svif = rte_cpu_to_be_16(svif); + /* 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); + + /* 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_type = BNXT_ULP_DRV_FUNC_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)); @@ -214,10 +401,12 @@ ulp_rte_parser_svif_set(struct ulp_rte_parser_params *params, /* Function to handle the parsing of the RTE port id */ int32_t -ulp_rte_parser_svif_process(struct ulp_rte_parser_params *params) +ulp_rte_parser_implicit_match_port_process(struct ulp_rte_parser_params *params) { uint16_t port_id = 0; 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) @@ -226,53 +415,63 @@ ulp_rte_parser_svif_process(struct ulp_rte_parser_params *params) /* 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 */ - return ulp_rte_parser_svif_set(params, RTE_FLOW_ITEM_TYPE_PORT_ID, - port_id, svif_mask); + rc = ulp_rte_parser_svif_set(params, ifindex, svif_mask); + return rc; } -/* Function to handle the implicit VNIC RTE port id */ +/* Function to handle the implicit action port id */ int32_t -ulp_rte_parser_vnic_process(struct ulp_rte_parser_params *params) +ulp_rte_parser_implicit_act_port_process(struct ulp_rte_parser_params *params) { - struct ulp_rte_act_bitmap *act = ¶ms->act_bitmap; + struct rte_flow_action action_item = {0}; + struct rte_flow_action_port_id port_id = {0}; - if (ULP_BITMAP_ISSET(act->bits, BNXT_ULP_ACTION_BIT_VNIC) || - ULP_BITMAP_ISSET(act->bits, BNXT_ULP_ACTION_BIT_VPORT)) { - /* - * Reset the vnic/vport action bitmaps - * it is not required for match - */ - ULP_BITMAP_RESET(params->act_bitmap.bits, - BNXT_ULP_ACTION_BIT_VNIC); - ULP_BITMAP_RESET(params->act_bitmap.bits, - BNXT_ULP_ACTION_BIT_VPORT); + /* 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; - /* Update the vnic details */ - ulp_rte_pf_act_handler(NULL, params); - /* Reset the hdr_bitmap with vnic bit */ - ULP_BITMAP_RESET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_VNIC); + /* Update the action port based on incoming port */ + ulp_rte_port_id_act_handler(&action_item, params); + /* 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, +ulp_rte_pf_hdr_handler(const struct rte_flow_item *item __rte_unused, struct ulp_rte_parser_params *params) { uint16_t port_id = 0; uint16_t svif_mask = 0xFFFF; + uint32_t ifindex; - /* Get the port id */ + /* Get the implicit port id */ port_id = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF); + /* 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, - item->type, - port_id, svif_mask); + return ulp_rte_parser_svif_set(params, ifindex, svif_mask); } /* Function to handle the parsing of RTE Flow item VF Header. */ @@ -282,15 +481,30 @@ ulp_rte_vf_hdr_handler(const struct rte_flow_item *item, { const struct rte_flow_item_vf *vf_spec = item->spec; const struct rte_flow_item_vf *vf_mask = item->mask; - uint16_t svif = 0, mask = 0; + 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) - svif = (uint16_t)vf_spec->id; - if (vf_mask) - mask = (uint16_t)vf_mask->id; - - return ulp_rte_parser_svif_set(params, item->type, svif, mask); + 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. */ @@ -300,24 +514,29 @@ ulp_rte_port_id_hdr_handler(const struct rte_flow_item *item, { const struct rte_flow_item_port_id *port_spec = item->spec; const struct rte_flow_item_port_id *port_mask = item->mask; - uint16_t svif = 0, mask = 0; + uint16_t mask = 0; + int32_t rc = BNXT_TF_RC_PARSE_ERR; + uint32_t ifindex; - /* - * 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 (svif >= RTE_MAX_ETHPORTS) { - BNXT_TF_DBG(ERR, "ParseErr:Portid is not valid\n"); - return BNXT_TF_RC_PARSE_ERR; - } + 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; } - if (port_mask) - mask = (uint16_t)port_mask->id; - /* Update the SVIF details */ - return ulp_rte_parser_svif_set(params, item->type, svif, mask); + return ulp_rte_parser_svif_set(params, ifindex, mask); } /* Function to handle the parsing of RTE Flow item phy port Header. */ @@ -327,34 +546,96 @@ ulp_rte_phy_port_hdr_handler(const struct rte_flow_item *item, { const struct rte_flow_item_phy_port *port_spec = item->spec; const struct rte_flow_item_phy_port *port_mask = item->mask; - uint32_t svif = 0, mask = 0; - struct bnxt_ulp_device_params *dparms; - uint32_t dev_id; + 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 (bnxt_ulp_cntxt_dev_id_get(params->ulp_ctx, &dev_id)) { - BNXT_TF_DBG(DEBUG, "Failed to get device id\n"); - return -EINVAL; + 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; - dparms = bnxt_ulp_device_params_get(dev_id); - if (!dparms) { - BNXT_TF_DBG(DEBUG, "Failed to get device parms\n"); - return -EINVAL; + /* 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); + + /* 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; } - if (svif > dparms->num_phy_ports) { - BNXT_TF_DBG(ERR, "ParseErr:Phy Port is not valid\n"); + /* 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 */ - return ulp_rte_parser_svif_set(params, item->type, svif, mask); + 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); + } + } +} + +/* Internal Function to identify broadcast or multicast packets */ +static int32_t +ulp_rte_parser_is_bcmc_addr(const struct rte_ether_addr *eth_addr) +{ + if (rte_is_multicast_ether_addr(eth_addr) || + rte_is_broadcast_ether_addr(eth_addr)) { + BNXT_TF_DBG(DEBUG, + "No support for bcast or mcast addr offload\n"); + return 1; + } + return 0; } /* Function to handle the parsing of RTE Flow item Ethernet Header. */ @@ -366,8 +647,9 @@ ulp_rte_eth_hdr_handler(const struct rte_flow_item *item, const struct rte_flow_item_eth *eth_mask = item->mask; struct ulp_rte_hdr_field *field; uint32_t idx = params->field_idx; - uint64_t set_flag = 0; 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 @@ -378,13 +660,22 @@ ulp_rte_eth_hdr_handler(const struct rte_flow_item *item, field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx], eth_spec->dst.addr_bytes, size); + /* Todo: work around to avoid multicast and broadcast addr */ + if (ulp_rte_parser_is_bcmc_addr(ð_spec->dst)) + return BNXT_TF_RC_PARSE_ERR; + size = sizeof(eth_spec->src.addr_bytes); field = ulp_rte_parser_fld_copy(field, eth_spec->src.addr_bytes, size); + /* Todo: work around to avoid multicast and broadcast addr */ + if (ulp_rte_parser_is_bcmc_addr(ð_spec->src)) + return BNXT_TF_RC_PARSE_ERR; + field = ulp_rte_parser_fld_copy(field, ð_spec->type, sizeof(eth_spec->type)); + eth_type = eth_spec->type; } if (eth_mask) { ulp_rte_prsr_mask_copy(params, &idx, eth_mask->dst.addr_bytes, @@ -399,17 +690,24 @@ ulp_rte_eth_hdr_handler(const struct rte_flow_item *item, params->vlan_idx = params->field_idx; params->field_idx += BNXT_ULP_PROTO_HDR_VLAN_NUM; - /* Update the hdr_bitmap with BNXT_ULP_HDR_PROTO_I_ETH */ - set_flag = ULP_BITMAP_ISSET(params->hdr_bitmap.bits, - BNXT_ULP_HDR_BIT_O_ETH); - if (set_flag) + /* Update the protocol hdr bitmap */ + if (ULP_BITMAP_ISSET(params->hdr_bitmap.bits, + BNXT_ULP_HDR_BIT_O_ETH) || + ULP_BITMAP_ISSET(params->hdr_bitmap.bits, + BNXT_ULP_HDR_BIT_O_IPV4) || + ULP_BITMAP_ISSET(params->hdr_bitmap.bits, + BNXT_ULP_HDR_BIT_O_IPV6) || + ULP_BITMAP_ISSET(params->hdr_bitmap.bits, + BNXT_ULP_HDR_BIT_O_UDP) || + ULP_BITMAP_ISSET(params->hdr_bitmap.bits, + BNXT_ULP_HDR_BIT_O_TCP)) { ULP_BITMAP_SET(params->hdr_bitmap.bits, BNXT_ULP_HDR_BIT_I_ETH); - else - ULP_BITMAP_RESET(params->hdr_bitmap.bits, - BNXT_ULP_HDR_BIT_I_ETH); - - /* update the hdr_bitmap with BNXT_ULP_HDR_PROTO_O_ETH */ - ULP_BITMAP_SET(params->hdr_bitmap.bits, BNXT_ULP_HDR_BIT_O_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; } @@ -427,6 +725,8 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, uint16_t vlan_tag, priority; 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 @@ -434,8 +734,8 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, */ 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); field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx], @@ -447,20 +747,38 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, 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); - field = ¶ms->hdr_field[idx]; - memcpy(field->mask, &priority, field->size); - field++; - memcpy(field->mask, &vlan_tag, field->size); - field++; - memcpy(field->mask, &vlan_mask->inner_type, field->size); + /* + * The priority 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. + */ + ulp_rte_prsr_mask_ignore(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 */ params->vlan_idx += BNXT_ULP_PROTO_HDR_S_VLAN_NUM; @@ -480,6 +798,8 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, outer_vtag_num++; 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) && @@ -490,6 +810,7 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, 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) && @@ -499,8 +820,11 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, inner_vtag_num++; 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) { @@ -509,15 +833,47 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, 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, @@ -529,14 +885,33 @@ ulp_rte_ipv4_hdr_handler(const struct rte_flow_item *item, struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap; uint32_t idx = params->field_idx; uint32_t size; - uint32_t inner_l3, outer_l3; - - inner_l3 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_I_L3); - if (inner_l3) { - BNXT_TF_DBG(ERR, "Parse Error:Third L3 header not supported\n"); + 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; } + if (!ULP_BITMAP_ISSET(params->hdr_bitmap.bits, + BNXT_ULP_HDR_BIT_O_ETH) && + !ULP_BITMAP_ISSET(params->hdr_bitmap.bits, + BNXT_ULP_HDR_BIT_I_ETH)) { + /* Since F2 flow does not include eth item, when parser detects + * IPv4/IPv6 item list and it belongs to the outer header; i.e., + * o_ipv4/o_ipv6, check if O_ETH and I_ETH is set. If not set, + * then add offset sizeof(o_eth/oo_vlan/oi_vlan) to the index. + * This will allow the parser post processor to update the + * t_dmac in hdr_field[o_eth.dmac] + */ + idx += (BNXT_ULP_PROTO_HDR_ETH_NUM + + BNXT_ULP_PROTO_HDR_VLAN_NUM); + params->field_idx = idx; + } + /* * Copy the rte_flow_item for ipv4 into hdr_field using ipv4 * header fields @@ -570,6 +945,7 @@ ulp_rte_ipv4_hdr_handler(const struct rte_flow_item *item, 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, @@ -587,9 +963,16 @@ ulp_rte_ipv4_hdr_handler(const struct rte_flow_item *item, ulp_rte_prsr_mask_copy(params, &idx, &ipv4_mask->hdr.version_ihl, sizeof(ipv4_mask->hdr.version_ihl)); - ulp_rte_prsr_mask_copy(params, &idx, - &ipv4_mask->hdr.type_of_service, - sizeof(ipv4_mask->hdr.type_of_service)); + /* + * 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. + */ + ulp_rte_prsr_mask_ignore(params, &idx, + &ipv4_mask->hdr.type_of_service, + sizeof(ipv4_mask->hdr.type_of_service) + ); + ulp_rte_prsr_mask_copy(params, &idx, &ipv4_mask->hdr.total_length, sizeof(ipv4_mask->hdr.total_length)); @@ -619,18 +1002,26 @@ ulp_rte_ipv4_hdr_handler(const struct rte_flow_item *item, params->field_idx += BNXT_ULP_PROTO_HDR_IPV4_NUM; /* Set the ipv4 header bitmap and computed l3 header bitmaps */ - outer_l3 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_O_L3); - if (outer_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); - inner_l3++; - ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L3, inner_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); - outer_l3++; - ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3, outer_l3); + ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3, 1); } + + /* Some of the PMD applications may set the protocol field + * in the IPv4 spec but don't set the mask. So, consider + * the mask in the proto value calculation. + */ + if (ipv4_mask) + proto &= ipv4_mask->hdr.next_proto_id; + + /* 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; } @@ -645,15 +1036,34 @@ ulp_rte_ipv6_hdr_handler(const struct rte_flow_item *item, struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap; uint32_t idx = params->field_idx; uint32_t size; - uint32_t inner_l3, outer_l3; uint32_t vtcf, vtcf_mask; - - inner_l3 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_I_L3); - if (inner_l3) { - BNXT_TF_DBG(ERR, "Parse Error: 3'rd L3 header not supported\n"); + 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; } + if (!ULP_BITMAP_ISSET(params->hdr_bitmap.bits, + BNXT_ULP_HDR_BIT_O_ETH) && + !ULP_BITMAP_ISSET(params->hdr_bitmap.bits, + BNXT_ULP_HDR_BIT_I_ETH)) { + /* Since F2 flow does not include eth item, when parser detects + * IPv4/IPv6 item list and it belongs to the outer header; i.e., + * o_ipv4/o_ipv6, check if O_ETH and I_ETH is set. If not set, + * then add offset sizeof(o_eth/oo_vlan/oi_vlan) to the index. + * This will allow the parser post processor to update the + * t_dmac in hdr_field[o_eth.dmac] + */ + idx += (BNXT_ULP_PROTO_HDR_ETH_NUM + + BNXT_ULP_PROTO_HDR_VLAN_NUM); + params->field_idx = idx; + } + /* * Copy the rte_flow_item for ipv6 into hdr_field using ipv6 * header fields @@ -684,6 +1094,7 @@ ulp_rte_ipv6_hdr_handler(const struct rte_flow_item *item, 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, @@ -704,17 +1115,17 @@ ulp_rte_ipv6_hdr_handler(const struct rte_flow_item *item, ulp_rte_prsr_mask_copy(params, &idx, &vtcf_mask, size); - + /* + * The TC and flow label field are ignored since OVS is + * setting it for match and it is not supported. + * This is a work around and + * shall be addressed in the future. + */ vtcf_mask = BNXT_ULP_GET_IPV6_TC(ipv6_mask->hdr.vtc_flow); - ulp_rte_prsr_mask_copy(params, &idx, - &vtcf_mask, - size); - + ulp_rte_prsr_mask_ignore(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_ignore(params, &idx, &vtcf_mask, size); ulp_rte_prsr_mask_copy(params, &idx, &ipv6_mask->hdr.payload_len, @@ -736,19 +1147,42 @@ ulp_rte_ipv6_hdr_handler(const struct rte_flow_item *item, params->field_idx += BNXT_ULP_PROTO_HDR_IPV6_NUM; /* Set the ipv6 header bitmap and computed l3 header bitmaps */ - outer_l3 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_O_L3); - if (outer_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_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_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3, 1); } + + /* Some of the PMD applications may set the protocol field + * in the IPv6 spec but don't set the mask. So, consider + * the mask in proto value calculation. + */ + if (ipv6_mask) + proto &= ipv6_mask->hdr.proto; + + /* 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); + ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_L3_TUN, 1); + } +} + /* Function to handle the parsing of RTE Flow item UDP Header. */ int32_t ulp_rte_udp_hdr_handler(const struct rte_flow_item *item, @@ -760,10 +1194,11 @@ ulp_rte_udp_hdr_handler(const struct rte_flow_item *item, struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap; uint32_t idx = params->field_idx; uint32_t size; - uint32_t inner_l4, outer_l4; + uint16_t dst_port = 0; + uint32_t cnt; - inner_l4 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_I_L4); - if (inner_l4) { + 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; } @@ -777,10 +1212,12 @@ ulp_rte_udp_hdr_handler(const struct rte_flow_item *item, 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, @@ -809,16 +1246,17 @@ ulp_rte_udp_hdr_handler(const struct rte_flow_item *item, params->field_idx += BNXT_ULP_PROTO_HDR_UDP_NUM; /* Set the udp header bitmap and computed l4 header bitmaps */ - outer_l4 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_O_L4); - if (outer_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_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_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; } @@ -833,11 +1271,11 @@ ulp_rte_tcp_hdr_handler(const struct rte_flow_item *item, struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap; uint32_t idx = params->field_idx; uint32_t size; - uint32_t inner_l4, outer_l4; + uint32_t cnt; - inner_l4 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_I_L4); - if (inner_l4) { - BNXT_TF_DBG(ERR, "Parse Error:Third L4 header not supported\n"); + 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; } @@ -919,9 +1357,7 @@ ulp_rte_tcp_hdr_handler(const struct rte_flow_item *item, params->field_idx += BNXT_ULP_PROTO_HDR_TCP_NUM; /* Set the udp header bitmap and computed l4 header bitmaps */ - outer_l4 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_O_L4); - if (outer_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_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4, 1); @@ -929,6 +1365,7 @@ ulp_rte_tcp_hdr_handler(const struct rte_flow_item *item, ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP); 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; } @@ -1061,8 +1498,12 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, /* IP header per byte - ver/hlen, TOS, ID, ID, FRAG, FRAG, TTL, PROTO */ const uint8_t def_ipv4_hdr[] = {0x45, 0x00, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11}; + /* IPv6 header per byte - vtc-flow,flow,zero,nexthdr-ttl */ + const uint8_t def_ipv6_hdr[] = {0x60, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x11, 0xf6}; struct ulp_rte_act_bitmap *act = ¶ms->act_bitmap; struct ulp_rte_act_prop *ap = ¶ms->act_prop; + const uint8_t *tmp_buff; vxlan_encap = action_item->conf; if (!vxlan_encap) { @@ -1088,12 +1529,14 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_L2_DMAC]; ulp_encap_buffer_copy(buff, eth_spec->dst.addr_bytes, - BNXT_ULP_ACT_PROP_SZ_ENCAP_L2_DMAC); + BNXT_ULP_ACT_PROP_SZ_ENCAP_L2_DMAC, + ULP_BUFFER_ALIGN_8_BYTE); 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); + BNXT_ULP_ACT_PROP_SZ_ENCAP_L2_SMAC, + ULP_BUFFER_ALIGN_8_BYTE); /* Goto the next item */ if (!ulp_rte_item_skip_void(&item, 1)) @@ -1105,7 +1548,8 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_VTAG]; ulp_encap_buffer_copy(buff, item->spec, - sizeof(struct rte_flow_item_vlan)); + sizeof(struct rte_flow_item_vlan), + ULP_BUFFER_ALIGN_8_BYTE); if (!ulp_rte_item_skip_void(&item, 1)) return BNXT_TF_RC_ERROR; @@ -1146,32 +1590,41 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, ulp_encap_buffer_copy(buff, def_ipv4_hdr, BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS + - BNXT_ULP_ENCAP_IPV4_ID_PROTO); + BNXT_ULP_ENCAP_IPV4_ID_PROTO, + ULP_BUFFER_ALIGN_8_BYTE); } else { - const uint8_t *tmp_buff; - + /* Total length being ignored in the ip hdr. */ 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); + BNXT_ULP_ENCAP_IPV4_ID_PROTO, + ULP_BUFFER_ALIGN_8_BYTE); + 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, + ULP_BUFFER_ALIGN_8_BYTE); } + + /* Update the dst ip address in ip encap buffer */ buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP + BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS + BNXT_ULP_ENCAP_IPV4_ID_PROTO]; ulp_encap_buffer_copy(buff, (const uint8_t *)&ipv4_spec->hdr.dst_addr, - BNXT_ULP_ENCAP_IPV4_DEST_IP); + sizeof(ipv4_spec->hdr.dst_addr), + ULP_BUFFER_ALIGN_8_BYTE); - buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP_SRC]; + /* Update the src ip address */ + buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP_SRC + + BNXT_ULP_ACT_PROP_SZ_ENCAP_IP_SRC - + sizeof(ipv4_spec->hdr.src_addr)]; ulp_encap_buffer_copy(buff, (const uint8_t *)&ipv4_spec->hdr.src_addr, - BNXT_ULP_ACT_PROP_SZ_ENCAP_IP_SRC); + sizeof(ipv4_spec->hdr.src_addr), + ULP_BUFFER_ALIGN_8_BYTE); /* Update the ip size details */ ip_size = tfp_cpu_to_be_32(ip_size); @@ -1193,9 +1646,46 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, ipv6_spec = item->spec; ip_size = BNXT_ULP_ENCAP_IPV6_SIZE; - /* copy the ipv4 details */ - memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP], - ipv6_spec, BNXT_ULP_ENCAP_IPV6_SIZE); + /* copy the ipv6 details */ + tmp_buff = (const uint8_t *)&ipv6_spec->hdr.vtc_flow; + if (ulp_buffer_is_empty(tmp_buff, + BNXT_ULP_ENCAP_IPV6_VTC_FLOW)) { + buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP]; + ulp_encap_buffer_copy(buff, + def_ipv6_hdr, + sizeof(def_ipv6_hdr), + ULP_BUFFER_ALIGN_8_BYTE); + } else { + /* The payload length being ignored in the ip hdr. */ + buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP]; + tmp_buff = (const uint8_t *)&ipv6_spec->hdr.proto; + ulp_encap_buffer_copy(buff, + tmp_buff, + BNXT_ULP_ENCAP_IPV6_PROTO_TTL, + ULP_BUFFER_ALIGN_8_BYTE); + buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP + + BNXT_ULP_ENCAP_IPV6_PROTO_TTL + + BNXT_ULP_ENCAP_IPV6_DO]; + tmp_buff = (const uint8_t *)&ipv6_spec->hdr.vtc_flow; + ulp_encap_buffer_copy(buff, + tmp_buff, + BNXT_ULP_ENCAP_IPV6_VTC_FLOW, + ULP_BUFFER_ALIGN_8_BYTE); + } + /* Update the dst ip address in ip encap buffer */ + buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP + + sizeof(def_ipv6_hdr)]; + ulp_encap_buffer_copy(buff, + (const uint8_t *)ipv6_spec->hdr.dst_addr, + sizeof(ipv6_spec->hdr.dst_addr), + ULP_BUFFER_ALIGN_8_BYTE); + + /* Update the src ip address */ + buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP_SRC]; + ulp_encap_buffer_copy(buff, + (const uint8_t *)ipv6_spec->hdr.src_addr, + sizeof(ipv6_spec->hdr.src_addr), + ULP_BUFFER_ALIGN_16_BYTE); /* Update the ip size details */ ip_size = tfp_cpu_to_be_32(ip_size); @@ -1225,7 +1715,8 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, } /* copy the udp details */ ulp_encap_buffer_copy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_UDP], - item->spec, BNXT_ULP_ENCAP_UDP_SIZE); + item->spec, BNXT_ULP_ENCAP_UDP_SIZE, + ULP_BUFFER_ALIGN_8_BYTE); if (!ulp_rte_item_skip_void(&item, 1)) return BNXT_TF_RC_ERROR; @@ -1239,14 +1730,22 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, /* copy the vxlan details */ memcpy(&vxlan_spec, item->spec, vxlan_size); vxlan_spec.flags = 0x08; - ulp_encap_buffer_copy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_TUN], - (const uint8_t *)&vxlan_spec, - vxlan_size); + buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_TUN]; + if (ip_type == rte_cpu_to_be_32(BNXT_ULP_ETH_IPV4)) { + ulp_encap_buffer_copy(buff, (const uint8_t *)&vxlan_spec, + vxlan_size, ULP_BUFFER_ALIGN_8_BYTE); + } else { + ulp_encap_buffer_copy(buff, (const uint8_t *)&vxlan_spec, + vxlan_size / 2, ULP_BUFFER_ALIGN_8_BYTE); + ulp_encap_buffer_copy(buff + (vxlan_size / 2), + (const uint8_t *)&vxlan_spec.vni, + vxlan_size / 2, ULP_BUFFER_ALIGN_8_BYTE); + } vxlan_size = tfp_cpu_to_be_32(vxlan_size); 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; } @@ -1260,6 +1759,9 @@ ulp_rte_vxlan_decap_act_handler(const struct rte_flow_action *action_item /* update the hdr_bitmap with vxlan */ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_VXLAN_DECAP); + /* Update computational field with tunnel decap info */ + ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L3_TUN_DECAP, 1); + ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L3_TUN, 1); return BNXT_TF_RC_SUCCESS; } @@ -1299,52 +1801,119 @@ ulp_rte_count_act_handler(const struct rte_flow_action *action_item, 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_parser_params *params) { - 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(params->act_bitmap.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 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF); - svif = bnxt_get_vnic_id(svif, BNXT_ULP_INTF_TYPE_INVALID); - svif = rte_cpu_to_be_32(svif); - memcpy(¶ms->act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VNIC], - &svif, BNXT_ULP_ACT_PROP_SZ_VNIC); + /* 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_parser_params *param) + struct ulp_rte_parser_params *params) { const struct rte_flow_action_vf *vf_action; - uint32_t pid; + 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 */ - pid = bnxt_get_vnic_id(vf_action->id, - BNXT_ULP_INTF_TYPE_INVALID); - pid = rte_cpu_to_be_32(pid); - memcpy(¶m->act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VNIC], - &pid, 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(param->act_bitmap.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. */ @@ -1352,14 +1921,10 @@ int32_t ulp_rte_port_id_act_handler(const struct rte_flow_action *act_item, struct ulp_rte_parser_params *param) { - const struct rte_flow_action_port_id *port_id; - struct ulp_rte_act_prop *act; - uint32_t pid; - int32_t rc; + const struct rte_flow_action_port_id *port_id = act_item->conf; uint32_t ifindex; - uint16_t pid_s; + enum bnxt_ulp_intf_type intf_type; - port_id = act_item->conf; if (!port_id) { BNXT_TF_DBG(ERR, "ParseErr: Invalid Argument\n"); @@ -1372,42 +1937,22 @@ ulp_rte_port_id_act_handler(const struct rte_flow_action *act_item, } /* Get the port db ifindex */ - rc = ulp_port_db_dev_port_to_ulp_index(param->ulp_ctx, - port_id->id, - &ifindex); - if (rc) { + 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; } - act = ¶m->act_prop; - if (param->dir == ULP_DIR_EGRESS) { - rc = ulp_port_db_vport_get(param->ulp_ctx, - ifindex, &pid_s); - if (rc) - 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 { - rc = ulp_port_db_default_vnic_get(param->ulp_ctx, - ifindex, - BNXT_ULP_DRV_FUNC_VNIC, - &pid_s); - if (rc) - 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); + /* 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; } - /*Update the hdr_bitmap with vnic */ - ULP_BITMAP_SET(param->act_bitmap.bits, BNXT_ULP_ACTION_BIT_VNIC); - return BNXT_TF_RC_SUCCESS; + /* 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. */ @@ -1419,6 +1964,7 @@ ulp_rte_phy_port_act_handler(const struct rte_flow_action *action_item, uint32_t pid; int32_t rc; uint16_t pid_s; + enum bnxt_ulp_direction_type dir; phy_port = action_item->conf; if (!phy_port) { @@ -1432,7 +1978,8 @@ ulp_rte_phy_port_act_handler(const struct rte_flow_action *action_item, "Parse Err:Port Original not supported\n"); return BNXT_TF_RC_PARSE_ERR; } - if (prm->dir != ULP_DIR_EGRESS) { + 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; @@ -1441,7 +1988,7 @@ ulp_rte_phy_port_act_handler(const struct rte_flow_action *action_item, rc = ulp_port_db_phy_port_vport_get(prm->ulp_ctx, phy_port->index, &pid_s); if (rc) { - BNXT_TF_DBG(DEBUG, "Failed to get port details\n"); + BNXT_TF_DBG(ERR, "Failed to get port details\n"); return -EINVAL; } @@ -1450,8 +1997,10 @@ ulp_rte_phy_port_act_handler(const struct rte_flow_action *action_item, memcpy(&prm->act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VPORT], &pid, BNXT_ULP_ACT_PROP_SZ_VPORT); - /* update the hdr_bitmap with vport */ - ULP_BITMAP_SET(prm->act_bitmap.bits, BNXT_ULP_ACTION_BIT_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; } @@ -1538,3 +2087,109 @@ ulp_rte_of_set_vlan_pcp_act_handler(const struct rte_flow_action *action_item, 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; +} + +/* Function to handle the parsing of RTE Flow action JUMP */ +int32_t +ulp_rte_jump_act_handler(const struct rte_flow_action *action_item __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_JUMP); + return BNXT_TF_RC_SUCCESS; +}