X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Ftf_ulp%2Fulp_rte_parser.c;h=39f801b2f0f68d659e24ce55fc77b89816352533;hb=4182be0dcb847f488bc9f2e5d63ea045d4c50019;hp=4339032a78cb2c2b7f5e9fbda440c0e67d69d4c6;hpb=a7420bd934633ad4eeab961b3ad2e26aa244005a;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 4339032a78..39f801b2f0 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c +++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c @@ -4,31 +4,19 @@ */ #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 @@ -45,39 +33,81 @@ ulp_rte_item_skip_void(const struct rte_flow_item **item, uint32_t increment) 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; } @@ -86,8 +116,7 @@ bnxt_ulp_rte_parser_hdr_parse(const struct rte_flow_item pattern[], 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); } /* @@ -96,8 +125,7 @@ bnxt_ulp_rte_parser_hdr_parse(const struct rte_flow_item pattern[], */ 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; @@ -117,8 +145,7 @@ bnxt_ulp_rte_parser_act_parse(const struct rte_flow_action actions[], /* 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; } @@ -126,234 +153,471 @@ bnxt_ulp_rte_parser_act_parse(const struct rte_flow_action actions[], } 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; + enum bnxt_ulp_direction_type dir; + + /* get the direction details */ + dir = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_DIRECTION); + + if (dir == BNXT_ULP_DIR_INGRESS) { + /* 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; + } + /* 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; + } + /* Parif needs to be reset to a free partition */ + parif += BNXT_ULP_FREE_PARIF_BASE; + ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_PHY_PORT_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); - 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); + /* 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 = 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_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_SVIF)) + 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 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); + /* 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; + } - return ulp_rte_parser_svif_set(hdr_bitmap, hdr_field, - RTE_FLOW_ITEM_TYPE_PORT_ID, - dir, port_id, svif_mask); + /* Update the SVIF details */ + rc = ulp_rte_parser_svif_set(params, ifindex, svif_mask); + return rc; +} + +/* 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; + + /* 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, - 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); + + /* 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; + } - return ulp_rte_parser_svif_set(hdr_bitmap, hdr_field, - item->type, 0, svif, mask); + /* 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; } @@ -361,23 +625,18 @@ ulp_rte_eth_hdr_handler(const struct rte_flow_item *item, /* 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 @@ -385,117 +644,159 @@ 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); - 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; } @@ -504,169 +805,259 @@ ulp_rte_ipv4_hdr_handler(const struct rte_flow_item *item, * 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; } @@ -676,64 +1067,73 @@ ulp_rte_udp_hdr_handler(const struct rte_flow_item *item, * 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; } @@ -742,132 +1142,151 @@ ulp_rte_tcp_hdr_handler(const struct rte_flow_item *item, * 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; } @@ -875,8 +1294,7 @@ ulp_rte_void_hdr_handler(const struct rte_flow_item *item __rte_unused, /* 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; } @@ -884,16 +1302,16 @@ ulp_rte_void_act_handler(const struct rte_flow_action *action_item __rte_unused, /* 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 */ @@ -907,15 +1325,13 @@ ulp_rte_mark_act_handler(const struct rte_flow_action *action_item, /* 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"); @@ -925,8 +1341,7 @@ ulp_rte_rss_act_handler(const struct rte_flow_action *action_item, /* 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; @@ -939,8 +1354,10 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_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) { @@ -968,6 +1385,11 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, 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; @@ -1024,15 +1446,15 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, 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 + @@ -1041,6 +1463,11 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, (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], @@ -1051,6 +1478,10 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, 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) { @@ -1071,6 +1502,10 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, 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 { @@ -1106,7 +1541,7 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, 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; } @@ -1115,33 +1550,32 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, 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) { @@ -1156,107 +1590,389 @@ ulp_rte_count_act_handler(const struct rte_flow_action *action_item, } /* 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; }