drivers/net/bnxt/tf_ulp/ulp_rte_parser.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2014-2020 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #include "bnxt.h"
   7 #include "ulp_template_db_enum.h"
   8 #include "ulp_template_struct.h"
   9 #include "bnxt_tf_common.h"
  10 #include "ulp_rte_parser.h"
  11 #include "ulp_utils.h"
  12 #include "tfp.h"
  13 #include "ulp_port_db.h"
  14
  15 /* Utility function to skip the void items. */
  16 static inline int32_t
  17 ulp_rte_item_skip_void(const struct rte_flow_item **item, uint32_t increment)
  18 {
  19         if (!*item)
  20                 return 0;
  21         if (increment)
  22                 (*item)++;
  23         while ((*item) && (*item)->type == RTE_FLOW_ITEM_TYPE_VOID)
  24                 (*item)++;
  25         if (*item)
  26                 return 1;
  27         return 0;
  28 }
  29
  30 /* Utility function to update the field_bitmap */
  31 static void
  32 ulp_rte_parser_field_bitmap_update(struct ulp_rte_parser_params *params,
  33                                    uint32_t idx)
  34 {
  35         struct ulp_rte_hdr_field *field;
  36
  37         field = &params->hdr_field[idx];
  38         if (ulp_bitmap_notzero(field->mask, field->size)) {
  39                 ULP_INDEX_BITMAP_SET(params->fld_bitmap.bits, idx);
  40                 /* Not exact match */
  41                 if (!ulp_bitmap_is_ones(field->mask, field->size))
  42                         ULP_BITMAP_SET(params->fld_bitmap.bits,
  43                                        BNXT_ULP_MATCH_TYPE_BITMASK_WM);
  44         } else {
  45                 ULP_INDEX_BITMAP_RESET(params->fld_bitmap.bits, idx);
  46         }
  47 }
  48
  49 /* Utility function to copy field spec items */
  50 static struct ulp_rte_hdr_field *
  51 ulp_rte_parser_fld_copy(struct ulp_rte_hdr_field *field,
  52                         const void *buffer,
  53                         uint32_t size)
  54 {
  55         field->size = size;
  56         memcpy(field->spec, buffer, field->size);
  57         field++;
  58         return field;
  59 }
  60
  61 /* Utility function to copy field masks items */
  62 static void
  63 ulp_rte_prsr_mask_copy(struct ulp_rte_parser_params *params,
  64                        uint32_t *idx,
  65                        const void *buffer,
  66                        uint32_t size)
  67 {
  68         struct ulp_rte_hdr_field *field = &params->hdr_field[*idx];
  69
  70         memcpy(field->mask, buffer, size);
  71         ulp_rte_parser_field_bitmap_update(params, *idx);
  72         *idx = *idx + 1;
  73 }
  74
  75 /*
  76  * Function to handle the parsing of RTE Flows and placing
  77  * the RTE flow items into the ulp structures.
  78  */
  79 int32_t
  80 bnxt_ulp_rte_parser_hdr_parse(const struct rte_flow_item pattern[],
  81                               struct ulp_rte_parser_params *params)
  82 {
  83         const struct rte_flow_item *item = pattern;
  84         struct bnxt_ulp_rte_hdr_info *hdr_info;
  85
  86         params->field_idx = BNXT_ULP_PROTO_HDR_SVIF_NUM;
  87         if (params->dir == ULP_DIR_EGRESS)
  88                 ULP_BITMAP_SET(params->hdr_bitmap.bits,
  89                                BNXT_ULP_FLOW_DIR_BITMASK_EGR);
  90
  91         /* Parse all the items in the pattern */
  92         while (item && item->type != RTE_FLOW_ITEM_TYPE_END) {
  93                 /* get the header information from the flow_hdr_info table */
  94                 hdr_info = &ulp_hdr_info[item->type];
  95                 if (hdr_info->hdr_type == BNXT_ULP_HDR_TYPE_NOT_SUPPORTED) {
  96                         BNXT_TF_DBG(ERR,
  97                                     "Truflow parser does not support type %d\n",
  98                                     item->type);
  99                         return BNXT_TF_RC_PARSE_ERR;
 100                 } else if (hdr_info->hdr_type == BNXT_ULP_HDR_TYPE_SUPPORTED) {
 101                         /* call the registered callback handler */
 102                         if (hdr_info->proto_hdr_func) {
 103                                 if (hdr_info->proto_hdr_func(item, params) !=
 104                                     BNXT_TF_RC_SUCCESS) {
 105                                         return BNXT_TF_RC_ERROR;
 106                                 }
 107                         }
 108                 }
 109                 item++;
 110         }
 111         /* update the implied SVIF */
 112         (void)ulp_rte_parser_svif_process(params);
 113         return BNXT_TF_RC_SUCCESS;
 114 }
 115
 116 /*
 117  * Function to handle the parsing of RTE Flows and placing
 118  * the RTE flow actions into the ulp structures.
 119  */
 120 int32_t
 121 bnxt_ulp_rte_parser_act_parse(const struct rte_flow_action actions[],
 122                               struct ulp_rte_parser_params *params)
 123 {
 124         const struct rte_flow_action *action_item = actions;
 125         struct bnxt_ulp_rte_act_info *hdr_info;
 126
 127         if (params->dir == ULP_DIR_EGRESS)
 128                 ULP_BITMAP_SET(params->act_bitmap.bits,
 129                                BNXT_ULP_FLOW_DIR_BITMASK_EGR);
 130
 131         /* Parse all the items in the pattern */
 132         while (action_item && action_item->type != RTE_FLOW_ACTION_TYPE_END) {
 133                 /* get the header information from the flow_hdr_info table */
 134                 hdr_info = &ulp_act_info[action_item->type];
 135                 if (hdr_info->act_type ==
 136                     BNXT_ULP_ACT_TYPE_NOT_SUPPORTED) {
 137                         BNXT_TF_DBG(ERR,
 138                                     "Truflow parser does not support act %u\n",
 139                                     action_item->type);
 140                         return BNXT_TF_RC_ERROR;
 141                 } else if (hdr_info->act_type ==
 142                     BNXT_ULP_ACT_TYPE_SUPPORTED) {
 143                         /* call the registered callback handler */
 144                         if (hdr_info->proto_act_func) {
 145                                 if (hdr_info->proto_act_func(action_item,
 146                                                              params) !=
 147                                     BNXT_TF_RC_SUCCESS) {
 148                                         return BNXT_TF_RC_ERROR;
 149                                 }
 150                         }
 151                 }
 152                 action_item++;
 153         }
 154         /* update the implied VNIC */
 155         ulp_rte_parser_vnic_process(params);
 156         return BNXT_TF_RC_SUCCESS;
 157 }
 158
 159 /* Function to handle the parsing of RTE Flow item PF Header. */
 160 static int32_t
 161 ulp_rte_parser_svif_set(struct ulp_rte_parser_params *params,
 162                         enum rte_flow_item_type proto,
 163                         uint16_t svif,
 164                         uint16_t mask)
 165 {
 166         uint16_t port_id = svif;
 167         uint32_t dir = 0;
 168         struct ulp_rte_hdr_field *hdr_field;
 169         enum bnxt_ulp_svif_type svif_type;
 170         enum bnxt_ulp_intf_type if_type;
 171         uint32_t ifindex;
 172         int32_t rc;
 173
 174         if (ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_SVIF_FLAG) !=
 175             BNXT_ULP_INVALID_SVIF_VAL) {
 176                 BNXT_TF_DBG(ERR,
 177                             "SVIF already set,multiple source not support'd\n");
 178                 return BNXT_TF_RC_ERROR;
 179         }
 180
 181         if (proto == RTE_FLOW_ITEM_TYPE_PORT_ID) {
 182                 dir = ULP_COMP_FLD_IDX_RD(params,
 183                                           BNXT_ULP_CF_IDX_DIRECTION);
 184                 /* perform the conversion from dpdk port to bnxt svif */
 185                 rc = ulp_port_db_dev_port_to_ulp_index(params->ulp_ctx, port_id,
 186                                                        &ifindex);
 187                 if (rc) {
 188                         BNXT_TF_DBG(ERR,
 189                                     "Invalid port id\n");
 190                         return BNXT_TF_RC_ERROR;
 191                 }
 192
 193                 if (dir == ULP_DIR_INGRESS) {
 194                         svif_type = BNXT_ULP_PHY_PORT_SVIF;
 195                 } else {
 196                         if_type = bnxt_get_interface_type(port_id);
 197                         if (if_type == BNXT_ULP_INTF_TYPE_VF_REP)
 198                                 svif_type = BNXT_ULP_VF_FUNC_SVIF;
 199                         else
 200                                 svif_type = BNXT_ULP_DRV_FUNC_SVIF;
 201                 }
 202                 ulp_port_db_svif_get(params->ulp_ctx, ifindex, svif_type,
 203                                      &svif);
 204                 svif = rte_cpu_to_be_16(svif);
 205         }
 206         hdr_field = &params->hdr_field[BNXT_ULP_PROTO_HDR_FIELD_SVIF_IDX];
 207         memcpy(hdr_field->spec, &svif, sizeof(svif));
 208         memcpy(hdr_field->mask, &mask, sizeof(mask));
 209         hdr_field->size = sizeof(svif);
 210         ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_SVIF_FLAG,
 211                             rte_be_to_cpu_16(svif));
 212         return BNXT_TF_RC_SUCCESS;
 213 }
 214
 215 /* Function to handle the parsing of the RTE port id */
 216 int32_t
 217 ulp_rte_parser_svif_process(struct ulp_rte_parser_params *params)
 218 {
 219         uint16_t port_id = 0;
 220         uint16_t svif_mask = 0xFFFF;
 221
 222         if (ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_SVIF_FLAG) !=
 223             BNXT_ULP_INVALID_SVIF_VAL)
 224                 return BNXT_TF_RC_SUCCESS;
 225
 226         /* SVIF not set. So get the port id */
 227         port_id = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF);
 228
 229         /* Update the SVIF details */
 230         return ulp_rte_parser_svif_set(params, RTE_FLOW_ITEM_TYPE_PORT_ID,
 231                                        port_id, svif_mask);
 232 }
 233
 234 /* Function to handle the implicit VNIC RTE port id */
 235 int32_t
 236 ulp_rte_parser_vnic_process(struct ulp_rte_parser_params *params)
 237 {
 238         struct ulp_rte_act_bitmap *act = &params->act_bitmap;
 239
 240         if (ULP_BITMAP_ISSET(act->bits, BNXT_ULP_ACTION_BIT_VNIC) ||
 241             ULP_BITMAP_ISSET(act->bits, BNXT_ULP_ACTION_BIT_VPORT)) {
 242                 /*
 243                  * Reset the vnic/vport action bitmaps
 244                  * it is not required for match
 245                  */
 246                 ULP_BITMAP_RESET(params->act_bitmap.bits,
 247                                  BNXT_ULP_ACTION_BIT_VNIC);
 248                 ULP_BITMAP_RESET(params->act_bitmap.bits,
 249                                  BNXT_ULP_ACTION_BIT_VPORT);
 250                 return BNXT_TF_RC_SUCCESS;
 251         }
 252
 253         /* Update the vnic details */
 254         ulp_rte_pf_act_handler(NULL, params);
 255         /* Reset the hdr_bitmap with vnic bit */
 256         ULP_BITMAP_RESET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_VNIC);
 257
 258         return BNXT_TF_RC_SUCCESS;
 259 }
 260
 261 /* Function to handle the parsing of RTE Flow item PF Header. */
 262 int32_t
 263 ulp_rte_pf_hdr_handler(const struct rte_flow_item *item,
 264                        struct ulp_rte_parser_params *params)
 265 {
 266         uint16_t port_id = 0;
 267         uint16_t svif_mask = 0xFFFF;
 268
 269         /* Get the port id */
 270         port_id = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF);
 271
 272         /* Update the SVIF details */
 273         return ulp_rte_parser_svif_set(params,
 274                                        item->type,
 275                                        port_id, svif_mask);
 276 }
 277
 278 /* Function to handle the parsing of RTE Flow item VF Header. */
 279 int32_t
 280 ulp_rte_vf_hdr_handler(const struct rte_flow_item *item,
 281                        struct ulp_rte_parser_params *params)
 282 {
 283         const struct rte_flow_item_vf *vf_spec = item->spec;
 284         const struct rte_flow_item_vf *vf_mask = item->mask;
 285         uint16_t svif = 0, mask = 0;
 286
 287         /* Get VF rte_flow_item for Port details */
 288         if (vf_spec)
 289                 svif = (uint16_t)vf_spec->id;
 290         if (vf_mask)
 291                 mask = (uint16_t)vf_mask->id;
 292
 293         return ulp_rte_parser_svif_set(params, item->type, svif, mask);
 294 }
 295
 296 /* Function to handle the parsing of RTE Flow item port id  Header. */
 297 int32_t
 298 ulp_rte_port_id_hdr_handler(const struct rte_flow_item *item,
 299                             struct ulp_rte_parser_params *params)
 300 {
 301         const struct rte_flow_item_port_id *port_spec = item->spec;
 302         const struct rte_flow_item_port_id *port_mask = item->mask;
 303         uint16_t svif = 0, mask = 0;
 304
 305         /*
 306          * Copy the rte_flow_item for Port into hdr_field using port id
 307          * header fields.
 308          */
 309         if (port_spec) {
 310                 svif = (uint16_t)port_spec->id;
 311                 if (svif >= RTE_MAX_ETHPORTS) {
 312                         BNXT_TF_DBG(ERR, "ParseErr:Portid is not valid\n");
 313                         return BNXT_TF_RC_PARSE_ERR;
 314                 }
 315         }
 316         if (port_mask)
 317                 mask = (uint16_t)port_mask->id;
 318
 319         /* Update the SVIF details */
 320         return ulp_rte_parser_svif_set(params, item->type, svif, mask);
 321 }
 322
 323 /* Function to handle the parsing of RTE Flow item phy port Header. */
 324 int32_t
 325 ulp_rte_phy_port_hdr_handler(const struct rte_flow_item *item,
 326                              struct ulp_rte_parser_params *params)
 327 {
 328         const struct rte_flow_item_phy_port *port_spec = item->spec;
 329         const struct rte_flow_item_phy_port *port_mask = item->mask;
 330         uint32_t svif = 0, mask = 0;
 331         struct bnxt_ulp_device_params *dparms;
 332         uint32_t dev_id;
 333
 334         /* Copy the rte_flow_item for phy port into hdr_field */
 335         if (port_spec)
 336                 svif = port_spec->index;
 337         if (port_mask)
 338                 mask = port_mask->index;
 339
 340         if (bnxt_ulp_cntxt_dev_id_get(params->ulp_ctx, &dev_id)) {
 341                 BNXT_TF_DBG(DEBUG, "Failed to get device id\n");
 342                 return -EINVAL;
 343         }
 344
 345         dparms = bnxt_ulp_device_params_get(dev_id);
 346         if (!dparms) {
 347                 BNXT_TF_DBG(DEBUG, "Failed to get device parms\n");
 348                 return -EINVAL;
 349         }
 350
 351         if (svif > dparms->num_phy_ports) {
 352                 BNXT_TF_DBG(ERR, "ParseErr:Phy Port is not valid\n");
 353                 return BNXT_TF_RC_PARSE_ERR;
 354         }
 355
 356         /* Update the SVIF details */
 357         return ulp_rte_parser_svif_set(params, item->type, svif, mask);
 358 }
 359
 360 /* Function to handle the parsing of RTE Flow item Ethernet Header. */
 361 int32_t
 362 ulp_rte_eth_hdr_handler(const struct rte_flow_item *item,
 363                         struct ulp_rte_parser_params *params)
 364 {
 365         const struct rte_flow_item_eth *eth_spec = item->spec;
 366         const struct rte_flow_item_eth *eth_mask = item->mask;
 367         struct ulp_rte_hdr_field *field;
 368         uint32_t idx = params->field_idx;
 369         uint64_t set_flag = 0;
 370         uint32_t size;
 371
 372         /*
 373          * Copy the rte_flow_item for eth into hdr_field using ethernet
 374          * header fields
 375          */
 376         if (eth_spec) {
 377                 size = sizeof(eth_spec->dst.addr_bytes);
 378                 field = ulp_rte_parser_fld_copy(&params->hdr_field[idx],
 379                                                 eth_spec->dst.addr_bytes,
 380                                                 size);
 381                 size = sizeof(eth_spec->src.addr_bytes);
 382                 field = ulp_rte_parser_fld_copy(field,
 383                                                 eth_spec->src.addr_bytes,
 384                                                 size);
 385                 field = ulp_rte_parser_fld_copy(field,
 386                                                 &eth_spec->type,
 387                                                 sizeof(eth_spec->type));
 388         }
 389         if (eth_mask) {
 390                 ulp_rte_prsr_mask_copy(params, &idx, eth_mask->dst.addr_bytes,
 391                                        sizeof(eth_mask->dst.addr_bytes));
 392                 ulp_rte_prsr_mask_copy(params, &idx, eth_mask->src.addr_bytes,
 393                                        sizeof(eth_mask->src.addr_bytes));
 394                 ulp_rte_prsr_mask_copy(params, &idx, &eth_mask->type,
 395                                        sizeof(eth_mask->type));
 396         }
 397         /* Add number of vlan header elements */
 398         params->field_idx += BNXT_ULP_PROTO_HDR_ETH_NUM;
 399         params->vlan_idx = params->field_idx;
 400         params->field_idx += BNXT_ULP_PROTO_HDR_VLAN_NUM;
 401
 402         /* Update the hdr_bitmap with BNXT_ULP_HDR_PROTO_I_ETH */
 403         set_flag = ULP_BITMAP_ISSET(params->hdr_bitmap.bits,
 404                                     BNXT_ULP_HDR_BIT_O_ETH);
 405         if (set_flag)
 406                 ULP_BITMAP_SET(params->hdr_bitmap.bits, BNXT_ULP_HDR_BIT_I_ETH);
 407         else
 408                 ULP_BITMAP_RESET(params->hdr_bitmap.bits,
 409                                  BNXT_ULP_HDR_BIT_I_ETH);
 410
 411         /* update the hdr_bitmap with BNXT_ULP_HDR_PROTO_O_ETH */
 412         ULP_BITMAP_SET(params->hdr_bitmap.bits, BNXT_ULP_HDR_BIT_O_ETH);
 413
 414         return BNXT_TF_RC_SUCCESS;
 415 }
 416
 417 /* Function to handle the parsing of RTE Flow item Vlan Header. */
 418 int32_t
 419 ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item,
 420                          struct ulp_rte_parser_params *params)
 421 {
 422         const struct rte_flow_item_vlan *vlan_spec = item->spec;
 423         const struct rte_flow_item_vlan *vlan_mask = item->mask;
 424         struct ulp_rte_hdr_field *field;
 425         struct ulp_rte_hdr_bitmap       *hdr_bit;
 426         uint32_t idx = params->vlan_idx;
 427         uint16_t vlan_tag, priority;
 428         uint32_t outer_vtag_num;
 429         uint32_t inner_vtag_num;
 430
 431         /*
 432          * Copy the rte_flow_item for vlan into hdr_field using Vlan
 433          * header fields
 434          */
 435         if (vlan_spec) {
 436                 vlan_tag = ntohs(vlan_spec->tci);
 437                 priority = htons(vlan_tag >> 13);
 438                 vlan_tag &= 0xfff;
 439                 vlan_tag = htons(vlan_tag);
 440
 441                 field = ulp_rte_parser_fld_copy(&params->hdr_field[idx],
 442                                                 &priority,
 443                                                 sizeof(priority));
 444                 field = ulp_rte_parser_fld_copy(field,
 445                                                 &vlan_tag,
 446                                                 sizeof(vlan_tag));
 447                 field = ulp_rte_parser_fld_copy(field,
 448                                                 &vlan_spec->inner_type,
 449                                                 sizeof(vlan_spec->inner_type));
 450         }
 451
 452         if (vlan_mask) {
 453                 vlan_tag = ntohs(vlan_mask->tci);
 454                 priority = htons(vlan_tag >> 13);
 455                 vlan_tag &= 0xfff;
 456                 vlan_tag = htons(vlan_tag);
 457
 458                 field = &params->hdr_field[idx];
 459                 memcpy(field->mask, &priority, field->size);
 460                 field++;
 461                 memcpy(field->mask, &vlan_tag, field->size);
 462                 field++;
 463                 memcpy(field->mask, &vlan_mask->inner_type, field->size);
 464         }
 465         /* Set the vlan index to new incremented value */
 466         params->vlan_idx += BNXT_ULP_PROTO_HDR_S_VLAN_NUM;
 467
 468         /* Get the outer tag and inner tag counts */
 469         outer_vtag_num = ULP_COMP_FLD_IDX_RD(params,
 470                                              BNXT_ULP_CF_IDX_O_VTAG_NUM);
 471         inner_vtag_num = ULP_COMP_FLD_IDX_RD(params,
 472                                              BNXT_ULP_CF_IDX_I_VTAG_NUM);
 473
 474         /* Update the hdr_bitmap of the vlans */
 475         hdr_bit = &params->hdr_bitmap;
 476         if (ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
 477             !ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_I_ETH) &&
 478             !outer_vtag_num) {
 479                 /* Update the vlan tag num */
 480                 outer_vtag_num++;
 481                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_VTAG_NUM,
 482                                     outer_vtag_num);
 483                 ULP_BITMAP_SET(params->hdr_bitmap.bits,
 484                                BNXT_ULP_HDR_BIT_OO_VLAN);
 485         } else if (ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
 486                    !ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_I_ETH) &&
 487                    outer_vtag_num == 1) {
 488                 /* update the vlan tag num */
 489                 outer_vtag_num++;
 490                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_VTAG_NUM,
 491                                     outer_vtag_num);
 492                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_TWO_VTAGS, 1);
 493                 ULP_BITMAP_SET(params->hdr_bitmap.bits,
 494                                BNXT_ULP_HDR_BIT_OI_VLAN);
 495         } else if (ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
 496                    ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_I_ETH) &&
 497                    !inner_vtag_num) {
 498                 /* update the vlan tag num */
 499                 inner_vtag_num++;
 500                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_VTAG_NUM,
 501                                     inner_vtag_num);
 502                 ULP_BITMAP_SET(params->hdr_bitmap.bits,
 503                                BNXT_ULP_HDR_BIT_IO_VLAN);
 504         } else if (ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_O_ETH) &&
 505                    ULP_BITMAP_ISSET(hdr_bit->bits, BNXT_ULP_HDR_BIT_I_ETH) &&
 506                    inner_vtag_num == 1) {
 507                 /* update the vlan tag num */
 508                 inner_vtag_num++;
 509                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_VTAG_NUM,
 510                                     inner_vtag_num);
 511                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_TWO_VTAGS, 1);
 512                 ULP_BITMAP_SET(params->hdr_bitmap.bits,
 513                                BNXT_ULP_HDR_BIT_II_VLAN);
 514         } else {
 515                 BNXT_TF_DBG(ERR, "Error Parsing:Vlan hdr found withtout eth\n");
 516                 return BNXT_TF_RC_ERROR;
 517         }
 518         return BNXT_TF_RC_SUCCESS;
 519 }
 520
 521 /* Function to handle the parsing of RTE Flow item IPV4 Header. */
 522 int32_t
 523 ulp_rte_ipv4_hdr_handler(const struct rte_flow_item *item,
 524                          struct ulp_rte_parser_params *params)
 525 {
 526         const struct rte_flow_item_ipv4 *ipv4_spec = item->spec;
 527         const struct rte_flow_item_ipv4 *ipv4_mask = item->mask;
 528         struct ulp_rte_hdr_field *field;
 529         struct ulp_rte_hdr_bitmap *hdr_bitmap = &params->hdr_bitmap;
 530         uint32_t idx = params->field_idx;
 531         uint32_t size;
 532         uint32_t inner_l3, outer_l3;
 533
 534         inner_l3 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_I_L3);
 535         if (inner_l3) {
 536                 BNXT_TF_DBG(ERR, "Parse Error:Third L3 header not supported\n");
 537                 return BNXT_TF_RC_ERROR;
 538         }
 539
 540         /*
 541          * Copy the rte_flow_item for ipv4 into hdr_field using ipv4
 542          * header fields
 543          */
 544         if (ipv4_spec) {
 545                 size = sizeof(ipv4_spec->hdr.version_ihl);
 546                 field = ulp_rte_parser_fld_copy(&params->hdr_field[idx],
 547                                                 &ipv4_spec->hdr.version_ihl,
 548                                                 size);
 549                 size = sizeof(ipv4_spec->hdr.type_of_service);
 550                 field = ulp_rte_parser_fld_copy(field,
 551                                                 &ipv4_spec->hdr.type_of_service,
 552                                                 size);
 553                 size = sizeof(ipv4_spec->hdr.total_length);
 554                 field = ulp_rte_parser_fld_copy(field,
 555                                                 &ipv4_spec->hdr.total_length,
 556                                                 size);
 557                 size = sizeof(ipv4_spec->hdr.packet_id);
 558                 field = ulp_rte_parser_fld_copy(field,
 559                                                 &ipv4_spec->hdr.packet_id,
 560                                                 size);
 561                 size = sizeof(ipv4_spec->hdr.fragment_offset);
 562                 field = ulp_rte_parser_fld_copy(field,
 563                                                 &ipv4_spec->hdr.fragment_offset,
 564                                                 size);
 565                 size = sizeof(ipv4_spec->hdr.time_to_live);
 566                 field = ulp_rte_parser_fld_copy(field,
 567                                                 &ipv4_spec->hdr.time_to_live,
 568                                                 size);
 569                 size = sizeof(ipv4_spec->hdr.next_proto_id);
 570                 field = ulp_rte_parser_fld_copy(field,
 571                                                 &ipv4_spec->hdr.next_proto_id,
 572                                                 size);
 573                 size = sizeof(ipv4_spec->hdr.hdr_checksum);
 574                 field = ulp_rte_parser_fld_copy(field,
 575                                                 &ipv4_spec->hdr.hdr_checksum,
 576                                                 size);
 577                 size = sizeof(ipv4_spec->hdr.src_addr);
 578                 field = ulp_rte_parser_fld_copy(field,
 579                                                 &ipv4_spec->hdr.src_addr,
 580                                                 size);
 581                 size = sizeof(ipv4_spec->hdr.dst_addr);
 582                 field = ulp_rte_parser_fld_copy(field,
 583                                                 &ipv4_spec->hdr.dst_addr,
 584                                                 size);
 585         }
 586         if (ipv4_mask) {
 587                 ulp_rte_prsr_mask_copy(params, &idx,
 588                                        &ipv4_mask->hdr.version_ihl,
 589                                        sizeof(ipv4_mask->hdr.version_ihl));
 590                 ulp_rte_prsr_mask_copy(params, &idx,
 591                                        &ipv4_mask->hdr.type_of_service,
 592                                        sizeof(ipv4_mask->hdr.type_of_service));
 593                 ulp_rte_prsr_mask_copy(params, &idx,
 594                                        &ipv4_mask->hdr.total_length,
 595                                        sizeof(ipv4_mask->hdr.total_length));
 596                 ulp_rte_prsr_mask_copy(params, &idx,
 597                                        &ipv4_mask->hdr.packet_id,
 598                                        sizeof(ipv4_mask->hdr.packet_id));
 599                 ulp_rte_prsr_mask_copy(params, &idx,
 600                                        &ipv4_mask->hdr.fragment_offset,
 601                                        sizeof(ipv4_mask->hdr.fragment_offset));
 602                 ulp_rte_prsr_mask_copy(params, &idx,
 603                                        &ipv4_mask->hdr.time_to_live,
 604                                        sizeof(ipv4_mask->hdr.time_to_live));
 605                 ulp_rte_prsr_mask_copy(params, &idx,
 606                                        &ipv4_mask->hdr.next_proto_id,
 607                                        sizeof(ipv4_mask->hdr.next_proto_id));
 608                 ulp_rte_prsr_mask_copy(params, &idx,
 609                                        &ipv4_mask->hdr.hdr_checksum,
 610                                        sizeof(ipv4_mask->hdr.hdr_checksum));
 611                 ulp_rte_prsr_mask_copy(params, &idx,
 612                                        &ipv4_mask->hdr.src_addr,
 613                                        sizeof(ipv4_mask->hdr.src_addr));
 614                 ulp_rte_prsr_mask_copy(params, &idx,
 615                                        &ipv4_mask->hdr.dst_addr,
 616                                        sizeof(ipv4_mask->hdr.dst_addr));
 617         }
 618         /* Add the number of ipv4 header elements */
 619         params->field_idx += BNXT_ULP_PROTO_HDR_IPV4_NUM;
 620
 621         /* Set the ipv4 header bitmap and computed l3 header bitmaps */
 622         outer_l3 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_O_L3);
 623         if (outer_l3 ||
 624             ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4) ||
 625             ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV6)) {
 626                 ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_IPV4);
 627                 inner_l3++;
 628                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L3, inner_l3);
 629         } else {
 630                 ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4);
 631                 outer_l3++;
 632                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3, outer_l3);
 633         }
 634         return BNXT_TF_RC_SUCCESS;
 635 }
 636
 637 /* Function to handle the parsing of RTE Flow item IPV6 Header */
 638 int32_t
 639 ulp_rte_ipv6_hdr_handler(const struct rte_flow_item *item,
 640                          struct ulp_rte_parser_params *params)
 641 {
 642         const struct rte_flow_item_ipv6 *ipv6_spec = item->spec;
 643         const struct rte_flow_item_ipv6 *ipv6_mask = item->mask;
 644         struct ulp_rte_hdr_field *field;
 645         struct ulp_rte_hdr_bitmap *hdr_bitmap = &params->hdr_bitmap;
 646         uint32_t idx = params->field_idx;
 647         uint32_t size;
 648         uint32_t inner_l3, outer_l3;
 649         uint32_t vtcf, vtcf_mask;
 650
 651         inner_l3 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_I_L3);
 652         if (inner_l3) {
 653                 BNXT_TF_DBG(ERR, "Parse Error: 3'rd L3 header not supported\n");
 654                 return BNXT_TF_RC_ERROR;
 655         }
 656
 657         /*
 658          * Copy the rte_flow_item for ipv6 into hdr_field using ipv6
 659          * header fields
 660          */
 661         if (ipv6_spec) {
 662                 size = sizeof(ipv6_spec->hdr.vtc_flow);
 663
 664                 vtcf = BNXT_ULP_GET_IPV6_VER(ipv6_spec->hdr.vtc_flow);
 665                 field = ulp_rte_parser_fld_copy(&params->hdr_field[idx],
 666                                                 &vtcf,
 667                                                 size);
 668
 669                 vtcf = BNXT_ULP_GET_IPV6_TC(ipv6_spec->hdr.vtc_flow);
 670                 field = ulp_rte_parser_fld_copy(field,
 671                                                 &vtcf,
 672                                                 size);
 673
 674                 vtcf = BNXT_ULP_GET_IPV6_FLOWLABEL(ipv6_spec->hdr.vtc_flow);
 675                 field = ulp_rte_parser_fld_copy(field,
 676                                                 &vtcf,
 677                                                 size);
 678
 679                 size = sizeof(ipv6_spec->hdr.payload_len);
 680                 field = ulp_rte_parser_fld_copy(field,
 681                                                 &ipv6_spec->hdr.payload_len,
 682                                                 size);
 683                 size = sizeof(ipv6_spec->hdr.proto);
 684                 field = ulp_rte_parser_fld_copy(field,
 685                                                 &ipv6_spec->hdr.proto,
 686                                                 size);
 687                 size = sizeof(ipv6_spec->hdr.hop_limits);
 688                 field = ulp_rte_parser_fld_copy(field,
 689                                                 &ipv6_spec->hdr.hop_limits,
 690                                                 size);
 691                 size = sizeof(ipv6_spec->hdr.src_addr);
 692                 field = ulp_rte_parser_fld_copy(field,
 693                                                 &ipv6_spec->hdr.src_addr,
 694                                                 size);
 695                 size = sizeof(ipv6_spec->hdr.dst_addr);
 696                 field = ulp_rte_parser_fld_copy(field,
 697                                                 &ipv6_spec->hdr.dst_addr,
 698                                                 size);
 699         }
 700         if (ipv6_mask) {
 701                 size = sizeof(ipv6_mask->hdr.vtc_flow);
 702
 703                 vtcf_mask = BNXT_ULP_GET_IPV6_VER(ipv6_mask->hdr.vtc_flow);
 704                 ulp_rte_prsr_mask_copy(params, &idx,
 705                                        &vtcf_mask,
 706                                        size);
 707
 708                 vtcf_mask = BNXT_ULP_GET_IPV6_TC(ipv6_mask->hdr.vtc_flow);
 709                 ulp_rte_prsr_mask_copy(params, &idx,
 710                                        &vtcf_mask,
 711                                        size);
 712
 713                 vtcf_mask =
 714                         BNXT_ULP_GET_IPV6_FLOWLABEL(ipv6_mask->hdr.vtc_flow);
 715                 ulp_rte_prsr_mask_copy(params, &idx,
 716                                        &vtcf_mask,
 717                                        size);
 718
 719                 ulp_rte_prsr_mask_copy(params, &idx,
 720                                        &ipv6_mask->hdr.payload_len,
 721                                        sizeof(ipv6_mask->hdr.payload_len));
 722                 ulp_rte_prsr_mask_copy(params, &idx,
 723                                        &ipv6_mask->hdr.proto,
 724                                        sizeof(ipv6_mask->hdr.proto));
 725                 ulp_rte_prsr_mask_copy(params, &idx,
 726                                        &ipv6_mask->hdr.hop_limits,
 727                                        sizeof(ipv6_mask->hdr.hop_limits));
 728                 ulp_rte_prsr_mask_copy(params, &idx,
 729                                        &ipv6_mask->hdr.src_addr,
 730                                        sizeof(ipv6_mask->hdr.src_addr));
 731                 ulp_rte_prsr_mask_copy(params, &idx,
 732                                        &ipv6_mask->hdr.dst_addr,
 733                                        sizeof(ipv6_mask->hdr.dst_addr));
 734         }
 735         /* add number of ipv6 header elements */
 736         params->field_idx += BNXT_ULP_PROTO_HDR_IPV6_NUM;
 737
 738         /* Set the ipv6 header bitmap and computed l3 header bitmaps */
 739         outer_l3 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_O_L3);
 740         if (outer_l3 ||
 741             ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4) ||
 742             ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV6)) {
 743                 ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_IPV6);
 744                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L3, 1);
 745         } else {
 746                 ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV6);
 747                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3, 1);
 748         }
 749         return BNXT_TF_RC_SUCCESS;
 750 }
 751
 752 /* Function to handle the parsing of RTE Flow item UDP Header. */
 753 int32_t
 754 ulp_rte_udp_hdr_handler(const struct rte_flow_item *item,
 755                         struct ulp_rte_parser_params *params)
 756 {
 757         const struct rte_flow_item_udp *udp_spec = item->spec;
 758         const struct rte_flow_item_udp *udp_mask = item->mask;
 759         struct ulp_rte_hdr_field *field;
 760         struct ulp_rte_hdr_bitmap *hdr_bitmap = &params->hdr_bitmap;
 761         uint32_t idx = params->field_idx;
 762         uint32_t size;
 763         uint32_t inner_l4, outer_l4;
 764
 765         inner_l4 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_I_L4);
 766         if (inner_l4) {
 767                 BNXT_TF_DBG(ERR, "Parse Err:Third L4 header not supported\n");
 768                 return BNXT_TF_RC_ERROR;
 769         }
 770
 771         /*
 772          * Copy the rte_flow_item for ipv4 into hdr_field using ipv4
 773          * header fields
 774          */
 775         if (udp_spec) {
 776                 size = sizeof(udp_spec->hdr.src_port);
 777                 field = ulp_rte_parser_fld_copy(&params->hdr_field[idx],
 778                                                 &udp_spec->hdr.src_port,
 779                                                 size);
 780                 size = sizeof(udp_spec->hdr.dst_port);
 781                 field = ulp_rte_parser_fld_copy(field,
 782                                                 &udp_spec->hdr.dst_port,
 783                                                 size);
 784                 size = sizeof(udp_spec->hdr.dgram_len);
 785                 field = ulp_rte_parser_fld_copy(field,
 786                                                 &udp_spec->hdr.dgram_len,
 787                                                 size);
 788                 size = sizeof(udp_spec->hdr.dgram_cksum);
 789                 field = ulp_rte_parser_fld_copy(field,
 790                                                 &udp_spec->hdr.dgram_cksum,
 791                                                 size);
 792         }
 793         if (udp_mask) {
 794                 ulp_rte_prsr_mask_copy(params, &idx,
 795                                        &udp_mask->hdr.src_port,
 796                                        sizeof(udp_mask->hdr.src_port));
 797                 ulp_rte_prsr_mask_copy(params, &idx,
 798                                        &udp_mask->hdr.dst_port,
 799                                        sizeof(udp_mask->hdr.dst_port));
 800                 ulp_rte_prsr_mask_copy(params, &idx,
 801                                        &udp_mask->hdr.dgram_len,
 802                                        sizeof(udp_mask->hdr.dgram_len));
 803                 ulp_rte_prsr_mask_copy(params, &idx,
 804                                        &udp_mask->hdr.dgram_cksum,
 805                                        sizeof(udp_mask->hdr.dgram_cksum));
 806         }
 807
 808         /* Add number of UDP header elements */
 809         params->field_idx += BNXT_ULP_PROTO_HDR_UDP_NUM;
 810
 811         /* Set the udp header bitmap and computed l4 header bitmaps */
 812         outer_l4 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_O_L4);
 813         if (outer_l4 ||
 814             ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP) ||
 815             ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP)) {
 816                 ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_UDP);
 817                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4, 1);
 818         } else {
 819                 ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP);
 820                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4, 1);
 821         }
 822         return BNXT_TF_RC_SUCCESS;
 823 }
 824
 825 /* Function to handle the parsing of RTE Flow item TCP Header. */
 826 int32_t
 827 ulp_rte_tcp_hdr_handler(const struct rte_flow_item *item,
 828                         struct ulp_rte_parser_params *params)
 829 {
 830         const struct rte_flow_item_tcp *tcp_spec = item->spec;
 831         const struct rte_flow_item_tcp *tcp_mask = item->mask;
 832         struct ulp_rte_hdr_field *field;
 833         struct ulp_rte_hdr_bitmap *hdr_bitmap = &params->hdr_bitmap;
 834         uint32_t idx = params->field_idx;
 835         uint32_t size;
 836         uint32_t inner_l4, outer_l4;
 837
 838         inner_l4 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_I_L4);
 839         if (inner_l4) {
 840                 BNXT_TF_DBG(ERR, "Parse Error:Third L4 header not supported\n");
 841                 return BNXT_TF_RC_ERROR;
 842         }
 843
 844         /*
 845          * Copy the rte_flow_item for ipv4 into hdr_field using ipv4
 846          * header fields
 847          */
 848         if (tcp_spec) {
 849                 size = sizeof(tcp_spec->hdr.src_port);
 850                 field = ulp_rte_parser_fld_copy(&params->hdr_field[idx],
 851                                                 &tcp_spec->hdr.src_port,
 852                                                 size);
 853                 size = sizeof(tcp_spec->hdr.dst_port);
 854                 field = ulp_rte_parser_fld_copy(field,
 855                                                 &tcp_spec->hdr.dst_port,
 856                                                 size);
 857                 size = sizeof(tcp_spec->hdr.sent_seq);
 858                 field = ulp_rte_parser_fld_copy(field,
 859                                                 &tcp_spec->hdr.sent_seq,
 860                                                 size);
 861                 size = sizeof(tcp_spec->hdr.recv_ack);
 862                 field = ulp_rte_parser_fld_copy(field,
 863                                                 &tcp_spec->hdr.recv_ack,
 864                                                 size);
 865                 size = sizeof(tcp_spec->hdr.data_off);
 866                 field = ulp_rte_parser_fld_copy(field,
 867                                                 &tcp_spec->hdr.data_off,
 868                                                 size);
 869                 size = sizeof(tcp_spec->hdr.tcp_flags);
 870                 field = ulp_rte_parser_fld_copy(field,
 871                                                 &tcp_spec->hdr.tcp_flags,
 872                                                 size);
 873                 size = sizeof(tcp_spec->hdr.rx_win);
 874                 field = ulp_rte_parser_fld_copy(field,
 875                                                 &tcp_spec->hdr.rx_win,
 876                                                 size);
 877                 size = sizeof(tcp_spec->hdr.cksum);
 878                 field = ulp_rte_parser_fld_copy(field,
 879                                                 &tcp_spec->hdr.cksum,
 880                                                 size);
 881                 size = sizeof(tcp_spec->hdr.tcp_urp);
 882                 field = ulp_rte_parser_fld_copy(field,
 883                                                 &tcp_spec->hdr.tcp_urp,
 884                                                 size);
 885         } else {
 886                 idx += BNXT_ULP_PROTO_HDR_TCP_NUM;
 887         }
 888
 889         if (tcp_mask) {
 890                 ulp_rte_prsr_mask_copy(params, &idx,
 891                                        &tcp_mask->hdr.src_port,
 892                                        sizeof(tcp_mask->hdr.src_port));
 893                 ulp_rte_prsr_mask_copy(params, &idx,
 894                                        &tcp_mask->hdr.dst_port,
 895                                        sizeof(tcp_mask->hdr.dst_port));
 896                 ulp_rte_prsr_mask_copy(params, &idx,
 897                                        &tcp_mask->hdr.sent_seq,
 898                                        sizeof(tcp_mask->hdr.sent_seq));
 899                 ulp_rte_prsr_mask_copy(params, &idx,
 900                                        &tcp_mask->hdr.recv_ack,
 901                                        sizeof(tcp_mask->hdr.recv_ack));
 902                 ulp_rte_prsr_mask_copy(params, &idx,
 903                                        &tcp_mask->hdr.data_off,
 904                                        sizeof(tcp_mask->hdr.data_off));
 905                 ulp_rte_prsr_mask_copy(params, &idx,
 906                                        &tcp_mask->hdr.tcp_flags,
 907                                        sizeof(tcp_mask->hdr.tcp_flags));
 908                 ulp_rte_prsr_mask_copy(params, &idx,
 909                                        &tcp_mask->hdr.rx_win,
 910                                        sizeof(tcp_mask->hdr.rx_win));
 911                 ulp_rte_prsr_mask_copy(params, &idx,
 912                                        &tcp_mask->hdr.cksum,
 913                                        sizeof(tcp_mask->hdr.cksum));
 914                 ulp_rte_prsr_mask_copy(params, &idx,
 915                                        &tcp_mask->hdr.tcp_urp,
 916                                        sizeof(tcp_mask->hdr.tcp_urp));
 917         }
 918         /* add number of TCP header elements */
 919         params->field_idx += BNXT_ULP_PROTO_HDR_TCP_NUM;
 920
 921         /* Set the udp header bitmap and computed l4 header bitmaps */
 922         outer_l4 = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_O_L4);
 923         if (outer_l4 ||
 924             ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP) ||
 925             ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP)) {
 926                 ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_TCP);
 927                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4, 1);
 928         } else {
 929                 ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP);
 930                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4, 1);
 931         }
 932         return BNXT_TF_RC_SUCCESS;
 933 }
 934
 935 /* Function to handle the parsing of RTE Flow item Vxlan Header. */
 936 int32_t
 937 ulp_rte_vxlan_hdr_handler(const struct rte_flow_item *item,
 938                           struct ulp_rte_parser_params *params)
 939 {
 940         const struct rte_flow_item_vxlan *vxlan_spec = item->spec;
 941         const struct rte_flow_item_vxlan *vxlan_mask = item->mask;
 942         struct ulp_rte_hdr_field *field;
 943         struct ulp_rte_hdr_bitmap *hdr_bitmap = &params->hdr_bitmap;
 944         uint32_t idx = params->field_idx;
 945         uint32_t size;
 946
 947         /*
 948          * Copy the rte_flow_item for vxlan into hdr_field using vxlan
 949          * header fields
 950          */
 951         if (vxlan_spec) {
 952                 size = sizeof(vxlan_spec->flags);
 953                 field = ulp_rte_parser_fld_copy(&params->hdr_field[idx],
 954                                                 &vxlan_spec->flags,
 955                                                 size);
 956                 size = sizeof(vxlan_spec->rsvd0);
 957                 field = ulp_rte_parser_fld_copy(field,
 958                                                 &vxlan_spec->rsvd0,
 959                                                 size);
 960                 size = sizeof(vxlan_spec->vni);
 961                 field = ulp_rte_parser_fld_copy(field,
 962                                                 &vxlan_spec->vni,
 963                                                 size);
 964                 size = sizeof(vxlan_spec->rsvd1);
 965                 field = ulp_rte_parser_fld_copy(field,
 966                                                 &vxlan_spec->rsvd1,
 967                                                 size);
 968         }
 969         if (vxlan_mask) {
 970                 ulp_rte_prsr_mask_copy(params, &idx,
 971                                        &vxlan_mask->flags,
 972                                        sizeof(vxlan_mask->flags));
 973                 ulp_rte_prsr_mask_copy(params, &idx,
 974                                        &vxlan_mask->rsvd0,
 975                                        sizeof(vxlan_mask->rsvd0));
 976                 ulp_rte_prsr_mask_copy(params, &idx,
 977                                        &vxlan_mask->vni,
 978                                        sizeof(vxlan_mask->vni));
 979                 ulp_rte_prsr_mask_copy(params, &idx,
 980                                        &vxlan_mask->rsvd1,
 981                                        sizeof(vxlan_mask->rsvd1));
 982         }
 983         /* Add number of vxlan header elements */
 984         params->field_idx += BNXT_ULP_PROTO_HDR_VXLAN_NUM;
 985
 986         /* Update the hdr_bitmap with vxlan */
 987         ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_T_VXLAN);
 988         return BNXT_TF_RC_SUCCESS;
 989 }
 990
 991 /* Function to handle the parsing of RTE Flow item void Header */
 992 int32_t
 993 ulp_rte_void_hdr_handler(const struct rte_flow_item *item __rte_unused,
 994                          struct ulp_rte_parser_params *params __rte_unused)
 995 {
 996         return BNXT_TF_RC_SUCCESS;
 997 }
 998
 999 /* Function to handle the parsing of RTE Flow action void Header. */
1000 int32_t
1001 ulp_rte_void_act_handler(const struct rte_flow_action *action_item __rte_unused,
1002                          struct ulp_rte_parser_params *params __rte_unused)
1003 {
1004         return BNXT_TF_RC_SUCCESS;
1005 }
1006
1007 /* Function to handle the parsing of RTE Flow action Mark Header. */
1008 int32_t
1009 ulp_rte_mark_act_handler(const struct rte_flow_action *action_item,
1010                          struct ulp_rte_parser_params *param)
1011 {
1012         const struct rte_flow_action_mark *mark;
1013         struct ulp_rte_act_bitmap *act = &param->act_bitmap;
1014         uint32_t mark_id;
1015
1016         mark = action_item->conf;
1017         if (mark) {
1018                 mark_id = tfp_cpu_to_be_32(mark->id);
1019                 memcpy(&param->act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_MARK],
1020                        &mark_id, BNXT_ULP_ACT_PROP_SZ_MARK);
1021
1022                 /* Update the hdr_bitmap with vxlan */
1023                 ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_MARK);
1024                 return BNXT_TF_RC_SUCCESS;
1025         }
1026         BNXT_TF_DBG(ERR, "Parse Error: Mark arg is invalid\n");
1027         return BNXT_TF_RC_ERROR;
1028 }
1029
1030 /* Function to handle the parsing of RTE Flow action RSS Header. */
1031 int32_t
1032 ulp_rte_rss_act_handler(const struct rte_flow_action *action_item,
1033                         struct ulp_rte_parser_params *param)
1034 {
1035         const struct rte_flow_action_rss *rss = action_item->conf;
1036
1037         if (rss) {
1038                 /* Update the hdr_bitmap with vxlan */
1039                 ULP_BITMAP_SET(param->act_bitmap.bits, BNXT_ULP_ACTION_BIT_RSS);
1040                 return BNXT_TF_RC_SUCCESS;
1041         }
1042         BNXT_TF_DBG(ERR, "Parse Error: RSS arg is invalid\n");
1043         return BNXT_TF_RC_ERROR;
1044 }
1045
1046 /* Function to handle the parsing of RTE Flow action vxlan_encap Header. */
1047 int32_t
1048 ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item,
1049                                 struct ulp_rte_parser_params *params)
1050 {
1051         const struct rte_flow_action_vxlan_encap *vxlan_encap;
1052         const struct rte_flow_item *item;
1053         const struct rte_flow_item_eth *eth_spec;
1054         const struct rte_flow_item_ipv4 *ipv4_spec;
1055         const struct rte_flow_item_ipv6 *ipv6_spec;
1056         struct rte_flow_item_vxlan vxlan_spec;
1057         uint32_t vlan_num = 0, vlan_size = 0;
1058         uint32_t ip_size = 0, ip_type = 0;
1059         uint32_t vxlan_size = 0;
1060         uint8_t *buff;
1061         /* IP header per byte - ver/hlen, TOS, ID, ID, FRAG, FRAG, TTL, PROTO */
1062         const uint8_t def_ipv4_hdr[] = {0x45, 0x00, 0x00, 0x01, 0x00,
1063                                     0x00, 0x40, 0x11};
1064         struct ulp_rte_act_bitmap *act = &params->act_bitmap;
1065         struct ulp_rte_act_prop *ap = &params->act_prop;
1066
1067         vxlan_encap = action_item->conf;
1068         if (!vxlan_encap) {
1069                 BNXT_TF_DBG(ERR, "Parse Error: Vxlan_encap arg is invalid\n");
1070                 return BNXT_TF_RC_ERROR;
1071         }
1072
1073         item = vxlan_encap->definition;
1074         if (!item) {
1075                 BNXT_TF_DBG(ERR, "Parse Error: definition arg is invalid\n");
1076                 return BNXT_TF_RC_ERROR;
1077         }
1078
1079         if (!ulp_rte_item_skip_void(&item, 0))
1080                 return BNXT_TF_RC_ERROR;
1081
1082         /* must have ethernet header */
1083         if (item->type != RTE_FLOW_ITEM_TYPE_ETH) {
1084                 BNXT_TF_DBG(ERR, "Parse Error:vxlan encap does not have eth\n");
1085                 return BNXT_TF_RC_ERROR;
1086         }
1087         eth_spec = item->spec;
1088         buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_L2_DMAC];
1089         ulp_encap_buffer_copy(buff,
1090                               eth_spec->dst.addr_bytes,
1091                               BNXT_ULP_ACT_PROP_SZ_ENCAP_L2_DMAC);
1092
1093         buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_L2_SMAC];
1094         ulp_encap_buffer_copy(buff,
1095                               eth_spec->src.addr_bytes,
1096                               BNXT_ULP_ACT_PROP_SZ_ENCAP_L2_SMAC);
1097
1098         /* Goto the next item */
1099         if (!ulp_rte_item_skip_void(&item, 1))
1100                 return BNXT_TF_RC_ERROR;
1101
1102         /* May have vlan header */
1103         if (item->type == RTE_FLOW_ITEM_TYPE_VLAN) {
1104                 vlan_num++;
1105                 buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_VTAG];
1106                 ulp_encap_buffer_copy(buff,
1107                                       item->spec,
1108                                       sizeof(struct rte_flow_item_vlan));
1109
1110                 if (!ulp_rte_item_skip_void(&item, 1))
1111                         return BNXT_TF_RC_ERROR;
1112         }
1113
1114         /* may have two vlan headers */
1115         if (item->type == RTE_FLOW_ITEM_TYPE_VLAN) {
1116                 vlan_num++;
1117                 memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_VTAG +
1118                        sizeof(struct rte_flow_item_vlan)],
1119                        item->spec,
1120                        sizeof(struct rte_flow_item_vlan));
1121                 if (!ulp_rte_item_skip_void(&item, 1))
1122                         return BNXT_TF_RC_ERROR;
1123         }
1124         /* Update the vlan count and size of more than one */
1125         if (vlan_num) {
1126                 vlan_size = vlan_num * sizeof(struct rte_flow_item_vlan);
1127                 vlan_num = tfp_cpu_to_be_32(vlan_num);
1128                 memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_VTAG_NUM],
1129                        &vlan_num,
1130                        sizeof(uint32_t));
1131                 vlan_size = tfp_cpu_to_be_32(vlan_size);
1132                 memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_VTAG_SZ],
1133                        &vlan_size,
1134                        sizeof(uint32_t));
1135         }
1136
1137         /* L3 must be IPv4, IPv6 */
1138         if (item->type == RTE_FLOW_ITEM_TYPE_IPV4) {
1139                 ipv4_spec = item->spec;
1140                 ip_size = BNXT_ULP_ENCAP_IPV4_SIZE;
1141
1142                 /* copy the ipv4 details */
1143                 if (ulp_buffer_is_empty(&ipv4_spec->hdr.version_ihl,
1144                                         BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS)) {
1145                         buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP];
1146                         ulp_encap_buffer_copy(buff,
1147                                               def_ipv4_hdr,
1148                                               BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS +
1149                                               BNXT_ULP_ENCAP_IPV4_ID_PROTO);
1150                 } else {
1151                         const uint8_t *tmp_buff;
1152
1153                         buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP];
1154                         tmp_buff = (const uint8_t *)&ipv4_spec->hdr.packet_id;
1155                         ulp_encap_buffer_copy(buff,
1156                                               tmp_buff,
1157                                               BNXT_ULP_ENCAP_IPV4_ID_PROTO);
1158                         buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP +
1159                              BNXT_ULP_ENCAP_IPV4_ID_PROTO];
1160                         ulp_encap_buffer_copy(buff,
1161                                               &ipv4_spec->hdr.version_ihl,
1162                                               BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS);
1163                 }
1164                 buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP +
1165                     BNXT_ULP_ENCAP_IPV4_VER_HLEN_TOS +
1166                     BNXT_ULP_ENCAP_IPV4_ID_PROTO];
1167                 ulp_encap_buffer_copy(buff,
1168                                       (const uint8_t *)&ipv4_spec->hdr.dst_addr,
1169                                       BNXT_ULP_ENCAP_IPV4_DEST_IP);
1170
1171                 buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP_SRC];
1172                 ulp_encap_buffer_copy(buff,
1173                                       (const uint8_t *)&ipv4_spec->hdr.src_addr,
1174                                       BNXT_ULP_ACT_PROP_SZ_ENCAP_IP_SRC);
1175
1176                 /* Update the ip size details */
1177                 ip_size = tfp_cpu_to_be_32(ip_size);
1178                 memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP_SZ],
1179                        &ip_size, sizeof(uint32_t));
1180
1181                 /* update the ip type */
1182                 ip_type = rte_cpu_to_be_32(BNXT_ULP_ETH_IPV4);
1183                 memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_L3_TYPE],
1184                        &ip_type, sizeof(uint32_t));
1185
1186                 /* update the computed field to notify it is ipv4 header */
1187                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_ACT_ENCAP_IPV4_FLAG,
1188                                     1);
1189
1190                 if (!ulp_rte_item_skip_void(&item, 1))
1191                         return BNXT_TF_RC_ERROR;
1192         } else if (item->type == RTE_FLOW_ITEM_TYPE_IPV6) {
1193                 ipv6_spec = item->spec;
1194                 ip_size = BNXT_ULP_ENCAP_IPV6_SIZE;
1195
1196                 /* copy the ipv4 details */
1197                 memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP],
1198                        ipv6_spec, BNXT_ULP_ENCAP_IPV6_SIZE);
1199
1200                 /* Update the ip size details */
1201                 ip_size = tfp_cpu_to_be_32(ip_size);
1202                 memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_IP_SZ],
1203                        &ip_size, sizeof(uint32_t));
1204
1205                  /* update the ip type */
1206                 ip_type = rte_cpu_to_be_32(BNXT_ULP_ETH_IPV6);
1207                 memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_L3_TYPE],
1208                        &ip_type, sizeof(uint32_t));
1209
1210                 /* update the computed field to notify it is ipv6 header */
1211                 ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_ACT_ENCAP_IPV6_FLAG,
1212                                     1);
1213
1214                 if (!ulp_rte_item_skip_void(&item, 1))
1215                         return BNXT_TF_RC_ERROR;
1216         } else {
1217                 BNXT_TF_DBG(ERR, "Parse Error: Vxlan Encap expects L3 hdr\n");
1218                 return BNXT_TF_RC_ERROR;
1219         }
1220
1221         /* L4 is UDP */
1222         if (item->type != RTE_FLOW_ITEM_TYPE_UDP) {
1223                 BNXT_TF_DBG(ERR, "vxlan encap does not have udp\n");
1224                 return BNXT_TF_RC_ERROR;
1225         }
1226         /* copy the udp details */
1227         ulp_encap_buffer_copy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_UDP],
1228                               item->spec, BNXT_ULP_ENCAP_UDP_SIZE);
1229
1230         if (!ulp_rte_item_skip_void(&item, 1))
1231                 return BNXT_TF_RC_ERROR;
1232
1233         /* Finally VXLAN */
1234         if (item->type != RTE_FLOW_ITEM_TYPE_VXLAN) {
1235                 BNXT_TF_DBG(ERR, "vxlan encap does not have vni\n");
1236                 return BNXT_TF_RC_ERROR;
1237         }
1238         vxlan_size = sizeof(struct rte_flow_item_vxlan);
1239         /* copy the vxlan details */
1240         memcpy(&vxlan_spec, item->spec, vxlan_size);
1241         vxlan_spec.flags = 0x08;
1242         ulp_encap_buffer_copy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_TUN],
1243                               (const uint8_t *)&vxlan_spec,
1244                               vxlan_size);
1245         vxlan_size = tfp_cpu_to_be_32(vxlan_size);
1246         memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_TUN_SZ],
1247                &vxlan_size, sizeof(uint32_t));
1248
1249         /*update the hdr_bitmap with vxlan */
1250         ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_VXLAN_ENCAP);
1251         return BNXT_TF_RC_SUCCESS;
1252 }
1253
1254 /* Function to handle the parsing of RTE Flow action vxlan_encap Header */
1255 int32_t
1256 ulp_rte_vxlan_decap_act_handler(const struct rte_flow_action *action_item
1257                                 __rte_unused,
1258                                 struct ulp_rte_parser_params *params)
1259 {
1260         /* update the hdr_bitmap with vxlan */
1261         ULP_BITMAP_SET(params->act_bitmap.bits,
1262                        BNXT_ULP_ACTION_BIT_VXLAN_DECAP);
1263         return BNXT_TF_RC_SUCCESS;
1264 }
1265
1266 /* Function to handle the parsing of RTE Flow action drop Header. */
1267 int32_t
1268 ulp_rte_drop_act_handler(const struct rte_flow_action *action_item __rte_unused,
1269                          struct ulp_rte_parser_params *params)
1270 {
1271         /* Update the hdr_bitmap with drop */
1272         ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_DROP);
1273         return BNXT_TF_RC_SUCCESS;
1274 }
1275
1276 /* Function to handle the parsing of RTE Flow action count. */
1277 int32_t
1278 ulp_rte_count_act_handler(const struct rte_flow_action *action_item,
1279                           struct ulp_rte_parser_params *params)
1280
1281 {
1282         const struct rte_flow_action_count *act_count;
1283         struct ulp_rte_act_prop *act_prop = &params->act_prop;
1284
1285         act_count = action_item->conf;
1286         if (act_count) {
1287                 if (act_count->shared) {
1288                         BNXT_TF_DBG(ERR,
1289                                     "Parse Error:Shared count not supported\n");
1290                         return BNXT_TF_RC_PARSE_ERR;
1291                 }
1292                 memcpy(&act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_COUNT],
1293                        &act_count->id,
1294                        BNXT_ULP_ACT_PROP_SZ_COUNT);
1295         }
1296
1297         /* Update the hdr_bitmap with count */
1298         ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_COUNT);
1299         return BNXT_TF_RC_SUCCESS;
1300 }
1301
1302 /* Function to handle the parsing of RTE Flow action PF. */
1303 int32_t
1304 ulp_rte_pf_act_handler(const struct rte_flow_action *action_item __rte_unused,
1305                        struct ulp_rte_parser_params *params)
1306 {
1307         uint32_t svif;
1308
1309         /* Update the hdr_bitmap with vnic bit */
1310         ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_VNIC);
1311
1312         /* copy the PF of the current device into VNIC Property */
1313         svif = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF);
1314         svif = bnxt_get_vnic_id(svif, BNXT_ULP_INTF_TYPE_INVALID);
1315         svif = rte_cpu_to_be_32(svif);
1316         memcpy(&params->act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VNIC],
1317                &svif, BNXT_ULP_ACT_PROP_SZ_VNIC);
1318
1319         return BNXT_TF_RC_SUCCESS;
1320 }
1321
1322 /* Function to handle the parsing of RTE Flow action VF. */
1323 int32_t
1324 ulp_rte_vf_act_handler(const struct rte_flow_action *action_item,
1325                        struct ulp_rte_parser_params *param)
1326 {
1327         const struct rte_flow_action_vf *vf_action;
1328         uint32_t pid;
1329
1330         vf_action = action_item->conf;
1331         if (vf_action) {
1332                 if (vf_action->original) {
1333                         BNXT_TF_DBG(ERR,
1334                                     "Parse Error:VF Original not supported\n");
1335                         return BNXT_TF_RC_PARSE_ERR;
1336                 }
1337                 /* TBD: Update the computed VNIC using VF conversion */
1338                 pid = bnxt_get_vnic_id(vf_action->id,
1339                                        BNXT_ULP_INTF_TYPE_INVALID);
1340                 pid = rte_cpu_to_be_32(pid);
1341                 memcpy(&param->act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VNIC],
1342                        &pid, BNXT_ULP_ACT_PROP_SZ_VNIC);
1343         }
1344
1345         /* Update the hdr_bitmap with count */
1346         ULP_BITMAP_SET(param->act_bitmap.bits, BNXT_ULP_ACTION_BIT_VNIC);
1347         return BNXT_TF_RC_SUCCESS;
1348 }
1349
1350 /* Function to handle the parsing of RTE Flow action port_id. */
1351 int32_t
1352 ulp_rte_port_id_act_handler(const struct rte_flow_action *act_item,
1353                             struct ulp_rte_parser_params *param)
1354 {
1355         const struct rte_flow_action_port_id *port_id;
1356         struct ulp_rte_act_prop *act;
1357         uint32_t pid;
1358         int32_t rc;
1359         uint32_t ifindex;
1360         uint16_t pid_s;
1361
1362         port_id = act_item->conf;
1363         if (!port_id) {
1364                 BNXT_TF_DBG(ERR,
1365                             "ParseErr: Invalid Argument\n");
1366                 return BNXT_TF_RC_PARSE_ERR;
1367         }
1368         if (port_id->original) {
1369                 BNXT_TF_DBG(ERR,
1370                             "ParseErr:Portid Original not supported\n");
1371                 return BNXT_TF_RC_PARSE_ERR;
1372         }
1373
1374         /* Get the port db ifindex */
1375         rc = ulp_port_db_dev_port_to_ulp_index(param->ulp_ctx,
1376                                                port_id->id,
1377                                                &ifindex);
1378         if (rc) {
1379                 BNXT_TF_DBG(ERR, "Invalid port id\n");
1380                 return BNXT_TF_RC_ERROR;
1381         }
1382
1383         act = &param->act_prop;
1384         if (param->dir == ULP_DIR_EGRESS) {
1385                 rc = ulp_port_db_vport_get(param->ulp_ctx,
1386                                            ifindex, &pid_s);
1387                 if (rc)
1388                         return BNXT_TF_RC_ERROR;
1389
1390                 pid = pid_s;
1391                 pid = rte_cpu_to_be_32(pid);
1392                 memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_VPORT],
1393                        &pid, BNXT_ULP_ACT_PROP_SZ_VPORT);
1394         } else {
1395                 rc = ulp_port_db_default_vnic_get(param->ulp_ctx,
1396                                                   ifindex,
1397                                                   BNXT_ULP_DRV_FUNC_VNIC,
1398                                                   &pid_s);
1399                 if (rc)
1400                         return BNXT_TF_RC_ERROR;
1401
1402                 pid = pid_s;
1403                 pid = rte_cpu_to_be_32(pid);
1404                 memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_VNIC],
1405                        &pid, BNXT_ULP_ACT_PROP_SZ_VNIC);
1406         }
1407
1408         /*Update the hdr_bitmap with vnic */
1409         ULP_BITMAP_SET(param->act_bitmap.bits, BNXT_ULP_ACTION_BIT_VNIC);
1410         return BNXT_TF_RC_SUCCESS;
1411 }
1412
1413 /* Function to handle the parsing of RTE Flow action phy_port. */
1414 int32_t
1415 ulp_rte_phy_port_act_handler(const struct rte_flow_action *action_item,
1416                              struct ulp_rte_parser_params *prm)
1417 {
1418         const struct rte_flow_action_phy_port *phy_port;
1419         uint32_t pid;
1420         int32_t rc;
1421         uint16_t pid_s;
1422
1423         phy_port = action_item->conf;
1424         if (!phy_port) {
1425                 BNXT_TF_DBG(ERR,
1426                             "ParseErr: Invalid Argument\n");
1427                 return BNXT_TF_RC_PARSE_ERR;
1428         }
1429
1430         if (phy_port->original) {
1431                 BNXT_TF_DBG(ERR,
1432                             "Parse Err:Port Original not supported\n");
1433                 return BNXT_TF_RC_PARSE_ERR;
1434         }
1435         if (prm->dir != ULP_DIR_EGRESS) {
1436                 BNXT_TF_DBG(ERR,
1437                             "Parse Err:Phy ports are valid only for egress\n");
1438                 return BNXT_TF_RC_PARSE_ERR;
1439         }
1440         /* Get the physical port details from port db */
1441         rc = ulp_port_db_phy_port_vport_get(prm->ulp_ctx, phy_port->index,
1442                                             &pid_s);
1443         if (rc) {
1444                 BNXT_TF_DBG(DEBUG, "Failed to get port details\n");
1445                 return -EINVAL;
1446         }
1447
1448         pid = pid_s;
1449         pid = rte_cpu_to_be_32(pid);
1450         memcpy(&prm->act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VPORT],
1451                &pid, BNXT_ULP_ACT_PROP_SZ_VPORT);
1452
1453         /* update the hdr_bitmap with vport */
1454         ULP_BITMAP_SET(prm->act_bitmap.bits, BNXT_ULP_ACTION_BIT_VPORT);
1455         return BNXT_TF_RC_SUCCESS;
1456 }
1457
1458 /* Function to handle the parsing of RTE Flow action pop vlan. */
1459 int32_t
1460 ulp_rte_of_pop_vlan_act_handler(const struct rte_flow_action *a __rte_unused,
1461                                 struct ulp_rte_parser_params *params)
1462 {
1463         /* Update the act_bitmap with pop */
1464         ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_POP_VLAN);
1465         return BNXT_TF_RC_SUCCESS;
1466 }
1467
1468 /* Function to handle the parsing of RTE Flow action push vlan. */
1469 int32_t
1470 ulp_rte_of_push_vlan_act_handler(const struct rte_flow_action *action_item,
1471                                  struct ulp_rte_parser_params *params)
1472 {
1473         const struct rte_flow_action_of_push_vlan *push_vlan;
1474         uint16_t ethertype;
1475         struct ulp_rte_act_prop *act = &params->act_prop;
1476
1477         push_vlan = action_item->conf;
1478         if (push_vlan) {
1479                 ethertype = push_vlan->ethertype;
1480                 if (tfp_cpu_to_be_16(ethertype) != RTE_ETHER_TYPE_VLAN) {
1481                         BNXT_TF_DBG(ERR,
1482                                     "Parse Err: Ethertype not supported\n");
1483                         return BNXT_TF_RC_PARSE_ERR;
1484                 }
1485                 memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_PUSH_VLAN],
1486                        &ethertype, BNXT_ULP_ACT_PROP_SZ_PUSH_VLAN);
1487                 /* Update the hdr_bitmap with push vlan */
1488                 ULP_BITMAP_SET(params->act_bitmap.bits,
1489                                BNXT_ULP_ACTION_BIT_PUSH_VLAN);
1490                 return BNXT_TF_RC_SUCCESS;
1491         }
1492         BNXT_TF_DBG(ERR, "Parse Error: Push vlan arg is invalid\n");
1493         return BNXT_TF_RC_ERROR;
1494 }
1495
1496 /* Function to handle the parsing of RTE Flow action set vlan id. */
1497 int32_t
1498 ulp_rte_of_set_vlan_vid_act_handler(const struct rte_flow_action *action_item,
1499                                     struct ulp_rte_parser_params *params)
1500 {
1501         const struct rte_flow_action_of_set_vlan_vid *vlan_vid;
1502         uint32_t vid;
1503         struct ulp_rte_act_prop *act = &params->act_prop;
1504
1505         vlan_vid = action_item->conf;
1506         if (vlan_vid && vlan_vid->vlan_vid) {
1507                 vid = vlan_vid->vlan_vid;
1508                 memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_SET_VLAN_VID],
1509                        &vid, BNXT_ULP_ACT_PROP_SZ_SET_VLAN_VID);
1510                 /* Update the hdr_bitmap with vlan vid */
1511                 ULP_BITMAP_SET(params->act_bitmap.bits,
1512                                BNXT_ULP_ACTION_BIT_SET_VLAN_VID);
1513                 return BNXT_TF_RC_SUCCESS;
1514         }
1515         BNXT_TF_DBG(ERR, "Parse Error: Vlan vid arg is invalid\n");
1516         return BNXT_TF_RC_ERROR;
1517 }
1518
1519 /* Function to handle the parsing of RTE Flow action set vlan pcp. */
1520 int32_t
1521 ulp_rte_of_set_vlan_pcp_act_handler(const struct rte_flow_action *action_item,
1522                                     struct ulp_rte_parser_params *params)
1523 {
1524         const struct rte_flow_action_of_set_vlan_pcp *vlan_pcp;
1525         uint8_t pcp;
1526         struct ulp_rte_act_prop *act = &params->act_prop;
1527
1528         vlan_pcp = action_item->conf;
1529         if (vlan_pcp) {
1530                 pcp = vlan_pcp->vlan_pcp;
1531                 memcpy(&act->act_details[BNXT_ULP_ACT_PROP_IDX_SET_VLAN_PCP],
1532                        &pcp, BNXT_ULP_ACT_PROP_SZ_SET_VLAN_PCP);
1533                 /* Update the hdr_bitmap with vlan vid */
1534                 ULP_BITMAP_SET(params->act_bitmap.bits,
1535                                BNXT_ULP_ACTION_BIT_SET_VLAN_PCP);
1536                 return BNXT_TF_RC_SUCCESS;
1537         }
1538         BNXT_TF_DBG(ERR, "Parse Error: Vlan pcp arg is invalid\n");
1539         return BNXT_TF_RC_ERROR;
1540 }