drivers/net/bnxt/bnxt_filter.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) Broadcom Limited.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Broadcom Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <sys/queue.h>
  35
  36 #include <rte_log.h>
  37 #include <rte_malloc.h>
  38 #include <rte_flow.h>
  39 #include <rte_flow_driver.h>
  40 #include <rte_tailq.h>
  41
  42 #include "bnxt.h"
  43 #include "bnxt_filter.h"
  44 #include "bnxt_hwrm.h"
  45 #include "bnxt_vnic.h"
  46 #include "hsi_struct_def_dpdk.h"
  47
  48 /*
  49  * Filter Functions
  50  */
  51
  52 struct bnxt_filter_info *bnxt_alloc_filter(struct bnxt *bp)
  53 {
  54         struct bnxt_filter_info *filter;
  55
  56         /* Find the 1st unused filter from the free_filter_list pool*/
  57         filter = STAILQ_FIRST(&bp->free_filter_list);
  58         if (!filter) {
  59                 PMD_DRV_LOG(ERR, "No more free filter resources\n");
  60                 return NULL;
  61         }
  62         STAILQ_REMOVE_HEAD(&bp->free_filter_list, next);
  63
  64         /* Default to L2 MAC Addr filter */
  65         filter->flags = HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_PATH_RX;
  66         filter->enables = HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR |
  67                         HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR_MASK;
  68         memcpy(filter->l2_addr, bp->eth_dev->data->mac_addrs->addr_bytes,
  69                ETHER_ADDR_LEN);
  70         memset(filter->l2_addr_mask, 0xff, ETHER_ADDR_LEN);
  71         return filter;
  72 }
  73
  74 struct bnxt_filter_info *bnxt_alloc_vf_filter(struct bnxt *bp, uint16_t vf)
  75 {
  76         struct bnxt_filter_info *filter;
  77
  78         filter = rte_zmalloc("bnxt_vf_filter_info", sizeof(*filter), 0);
  79         if (!filter) {
  80                 PMD_DRV_LOG(ERR, "Failed to alloc memory for VF %hu filters\n",
  81                         vf);
  82                 return NULL;
  83         }
  84
  85         filter->fw_l2_filter_id = UINT64_MAX;
  86         STAILQ_INSERT_TAIL(&bp->pf.vf_info[vf].filter, filter, next);
  87         return filter;
  88 }
  89
  90 void bnxt_init_filters(struct bnxt *bp)
  91 {
  92         struct bnxt_filter_info *filter;
  93         int i, max_filters;
  94
  95         max_filters = bp->max_l2_ctx;
  96         STAILQ_INIT(&bp->free_filter_list);
  97         for (i = 0; i < max_filters; i++) {
  98                 filter = &bp->filter_info[i];
  99                 filter->fw_l2_filter_id = -1;
 100                 filter->fw_em_filter_id = -1;
 101                 filter->fw_ntuple_filter_id = -1;
 102                 STAILQ_INSERT_TAIL(&bp->free_filter_list, filter, next);
 103         }
 104 }
 105
 106 void bnxt_free_all_filters(struct bnxt *bp)
 107 {
 108         struct bnxt_vnic_info *vnic;
 109         struct bnxt_filter_info *filter, *temp_filter;
 110         int i;
 111
 112         for (i = 0; i < MAX_FF_POOLS; i++) {
 113                 STAILQ_FOREACH(vnic, &bp->ff_pool[i], next) {
 114                         filter = STAILQ_FIRST(&vnic->filter);
 115                         while (filter) {
 116                                 temp_filter = STAILQ_NEXT(filter, next);
 117                                 STAILQ_REMOVE(&vnic->filter, filter,
 118                                               bnxt_filter_info, next);
 119                                 STAILQ_INSERT_TAIL(&bp->free_filter_list,
 120                                                    filter, next);
 121                                 filter = temp_filter;
 122                         }
 123                         STAILQ_INIT(&vnic->filter);
 124                 }
 125         }
 126
 127         for (i = 0; i < bp->pf.max_vfs; i++) {
 128                 STAILQ_FOREACH(filter, &bp->pf.vf_info[i].filter, next) {
 129                         bnxt_hwrm_clear_l2_filter(bp, filter);
 130                 }
 131         }
 132 }
 133
 134 void bnxt_free_filter_mem(struct bnxt *bp)
 135 {
 136         struct bnxt_filter_info *filter;
 137         uint16_t max_filters, i;
 138         int rc = 0;
 139
 140         if (bp->filter_info == NULL)
 141                 return;
 142
 143         /* Ensure that all filters are freed */
 144         max_filters = bp->max_l2_ctx;
 145         for (i = 0; i < max_filters; i++) {
 146                 filter = &bp->filter_info[i];
 147                 if (filter->fw_l2_filter_id != ((uint64_t)-1)) {
 148                         PMD_DRV_LOG(ERR, "HWRM filter is not freed??\n");
 149                         /* Call HWRM to try to free filter again */
 150                         rc = bnxt_hwrm_clear_l2_filter(bp, filter);
 151                         if (rc)
 152                                 PMD_DRV_LOG(ERR,
 153                                        "HWRM filter cannot be freed rc = %d\n",
 154                                         rc);
 155                 }
 156                 filter->fw_l2_filter_id = UINT64_MAX;
 157         }
 158         STAILQ_INIT(&bp->free_filter_list);
 159
 160         rte_free(bp->filter_info);
 161         bp->filter_info = NULL;
 162 }
 163
 164 int bnxt_alloc_filter_mem(struct bnxt *bp)
 165 {
 166         struct bnxt_filter_info *filter_mem;
 167         uint16_t max_filters;
 168
 169         max_filters = bp->max_l2_ctx;
 170         /* Allocate memory for VNIC pool and filter pool */
 171         filter_mem = rte_zmalloc("bnxt_filter_info",
 172                                  max_filters * sizeof(struct bnxt_filter_info),
 173                                  0);
 174         if (filter_mem == NULL) {
 175                 PMD_DRV_LOG(ERR, "Failed to alloc memory for %d filters",
 176                         max_filters);
 177                 return -ENOMEM;
 178         }
 179         bp->filter_info = filter_mem;
 180         return 0;
 181 }
 182
 183 struct bnxt_filter_info *bnxt_get_unused_filter(struct bnxt *bp)
 184 {
 185         struct bnxt_filter_info *filter;
 186
 187         /* Find the 1st unused filter from the free_filter_list pool*/
 188         filter = STAILQ_FIRST(&bp->free_filter_list);
 189         if (!filter) {
 190                 PMD_DRV_LOG(ERR, "No more free filter resources\n");
 191                 return NULL;
 192         }
 193         STAILQ_REMOVE_HEAD(&bp->free_filter_list, next);
 194
 195         return filter;
 196 }
 197
 198 void bnxt_free_filter(struct bnxt *bp, struct bnxt_filter_info *filter)
 199 {
 200         STAILQ_INSERT_TAIL(&bp->free_filter_list, filter, next);
 201 }
 202
 203 static int
 204 bnxt_flow_agrs_validate(const struct rte_flow_attr *attr,
 205                         const struct rte_flow_item pattern[],
 206                         const struct rte_flow_action actions[],
 207                         struct rte_flow_error *error)
 208 {
 209         if (!pattern) {
 210                 rte_flow_error_set(error, EINVAL,
 211                         RTE_FLOW_ERROR_TYPE_ITEM_NUM,
 212                         NULL, "NULL pattern.");
 213                 return -rte_errno;
 214         }
 215
 216         if (!actions) {
 217                 rte_flow_error_set(error, EINVAL,
 218                                    RTE_FLOW_ERROR_TYPE_ACTION_NUM,
 219                                    NULL, "NULL action.");
 220                 return -rte_errno;
 221         }
 222
 223         if (!attr) {
 224                 rte_flow_error_set(error, EINVAL,
 225                                    RTE_FLOW_ERROR_TYPE_ATTR,
 226                                    NULL, "NULL attribute.");
 227                 return -rte_errno;
 228         }
 229
 230         return 0;
 231 }
 232
 233 static const struct rte_flow_item *
 234 nxt_non_void_pattern(const struct rte_flow_item *cur)
 235 {
 236         while (1) {
 237                 if (cur->type != RTE_FLOW_ITEM_TYPE_VOID)
 238                         return cur;
 239                 cur++;
 240         }
 241 }
 242
 243 static const struct rte_flow_action *
 244 nxt_non_void_action(const struct rte_flow_action *cur)
 245 {
 246         while (1) {
 247                 if (cur->type != RTE_FLOW_ACTION_TYPE_VOID)
 248                         return cur;
 249                 cur++;
 250         }
 251 }
 252
 253 int check_zero_bytes(const uint8_t *bytes, int len)
 254 {
 255         int i;
 256         for (i = 0; i < len; i++)
 257                 if (bytes[i] != 0x00)
 258                         return 0;
 259         return 1;
 260 }
 261
 262 static int
 263 bnxt_filter_type_check(const struct rte_flow_item pattern[],
 264                        struct rte_flow_error *error __rte_unused)
 265 {
 266         const struct rte_flow_item *item = nxt_non_void_pattern(pattern);
 267         int use_ntuple = 1;
 268
 269         while (item->type != RTE_FLOW_ITEM_TYPE_END) {
 270                 switch (item->type) {
 271                 case RTE_FLOW_ITEM_TYPE_ETH:
 272                         use_ntuple = 1;
 273                         break;
 274                 case RTE_FLOW_ITEM_TYPE_VLAN:
 275                         use_ntuple = 0;
 276                         break;
 277                 case RTE_FLOW_ITEM_TYPE_IPV4:
 278                 case RTE_FLOW_ITEM_TYPE_IPV6:
 279                 case RTE_FLOW_ITEM_TYPE_TCP:
 280                 case RTE_FLOW_ITEM_TYPE_UDP:
 281                         /* FALLTHROUGH */
 282                         /* need ntuple match, reset exact match */
 283                         if (!use_ntuple) {
 284                                 PMD_DRV_LOG(ERR,
 285                                         "VLAN flow cannot use NTUPLE filter\n");
 286                                 rte_flow_error_set(error, EINVAL,
 287                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 288                                                    item,
 289                                                    "Cannot use VLAN with NTUPLE");
 290                                 return -rte_errno;
 291                         }
 292                         use_ntuple |= 1;
 293                         break;
 294                 default:
 295                         PMD_DRV_LOG(ERR, "Unknown Flow type");
 296                         use_ntuple |= 1;
 297                 }
 298                 item++;
 299         }
 300         return use_ntuple;
 301 }
 302
 303 static int
 304 bnxt_validate_and_parse_flow_type(struct bnxt *bp,
 305                                   const struct rte_flow_item pattern[],
 306                                   struct rte_flow_error *error,
 307                                   struct bnxt_filter_info *filter)
 308 {
 309         const struct rte_flow_item *item = nxt_non_void_pattern(pattern);
 310         const struct rte_flow_item_vlan *vlan_spec, *vlan_mask;
 311         const struct rte_flow_item_ipv4 *ipv4_spec, *ipv4_mask;
 312         const struct rte_flow_item_ipv6 *ipv6_spec, *ipv6_mask;
 313         const struct rte_flow_item_tcp *tcp_spec, *tcp_mask;
 314         const struct rte_flow_item_udp *udp_spec, *udp_mask;
 315         const struct rte_flow_item_eth *eth_spec, *eth_mask;
 316         const struct rte_flow_item_nvgre *nvgre_spec;
 317         const struct rte_flow_item_nvgre *nvgre_mask;
 318         const struct rte_flow_item_vxlan *vxlan_spec;
 319         const struct rte_flow_item_vxlan *vxlan_mask;
 320         uint8_t vni_mask[] = {0xFF, 0xFF, 0xFF};
 321         uint8_t tni_mask[] = {0xFF, 0xFF, 0xFF};
 322         const struct rte_flow_item_vf *vf_spec;
 323         uint32_t tenant_id_be = 0;
 324         bool vni_masked = 0;
 325         bool tni_masked = 0;
 326         uint32_t vf = 0;
 327         int use_ntuple;
 328         uint32_t en = 0;
 329         int dflt_vnic;
 330
 331         use_ntuple = bnxt_filter_type_check(pattern, error);
 332         PMD_DRV_LOG(DEBUG, "Use NTUPLE %d\n", use_ntuple);
 333         if (use_ntuple < 0)
 334                 return use_ntuple;
 335
 336         filter->filter_type = use_ntuple ?
 337                 HWRM_CFA_NTUPLE_FILTER : HWRM_CFA_EM_FILTER;
 338
 339         while (item->type != RTE_FLOW_ITEM_TYPE_END) {
 340                 if (item->last) {
 341                         /* last or range is NOT supported as match criteria */
 342                         rte_flow_error_set(error, EINVAL,
 343                                            RTE_FLOW_ERROR_TYPE_ITEM,
 344                                            item,
 345                                            "No support for range");
 346                         return -rte_errno;
 347                 }
 348                 if (!item->spec || !item->mask) {
 349                         rte_flow_error_set(error, EINVAL,
 350                                            RTE_FLOW_ERROR_TYPE_ITEM,
 351                                            item,
 352                                            "spec/mask is NULL");
 353                         return -rte_errno;
 354                 }
 355                 switch (item->type) {
 356                 case RTE_FLOW_ITEM_TYPE_ETH:
 357                         eth_spec = item->spec;
 358                         eth_mask = item->mask;
 359
 360                         /* Source MAC address mask cannot be partially set.
 361                          * Should be All 0's or all 1's.
 362                          * Destination MAC address mask must not be partially
 363                          * set. Should be all 1's or all 0's.
 364                          */
 365                         if ((!is_zero_ether_addr(&eth_mask->src) &&
 366                              !is_broadcast_ether_addr(&eth_mask->src)) ||
 367                             (!is_zero_ether_addr(&eth_mask->dst) &&
 368                              !is_broadcast_ether_addr(&eth_mask->dst))) {
 369                                 rte_flow_error_set(error, EINVAL,
 370                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 371                                                    item,
 372                                                    "MAC_addr mask not valid");
 373                                 return -rte_errno;
 374                         }
 375
 376                         /* Mask is not allowed. Only exact matches are */
 377                         if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) {
 378                                 rte_flow_error_set(error, EINVAL,
 379                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 380                                                    item,
 381                                                    "ethertype mask not valid");
 382                                 return -rte_errno;
 383                         }
 384
 385                         if (is_broadcast_ether_addr(&eth_mask->dst)) {
 386                                 rte_memcpy(filter->dst_macaddr,
 387                                            &eth_spec->dst, 6);
 388                                 en |= use_ntuple ?
 389                                         NTUPLE_FLTR_ALLOC_INPUT_EN_DST_MACADDR :
 390                                         EM_FLOW_ALLOC_INPUT_EN_DST_MACADDR;
 391                         }
 392                         if (is_broadcast_ether_addr(&eth_mask->src)) {
 393                                 rte_memcpy(filter->src_macaddr,
 394                                            &eth_spec->src, 6);
 395                                 en |= use_ntuple ?
 396                                         NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_MACADDR :
 397                                         EM_FLOW_ALLOC_INPUT_EN_SRC_MACADDR;
 398                         } /*
 399                            * else {
 400                            *  RTE_LOG(ERR, PMD, "Handle this condition\n");
 401                            * }
 402                            */
 403                         if (eth_spec->type) {
 404                                 filter->ethertype =
 405                                         rte_be_to_cpu_16(eth_spec->type);
 406                                 en |= use_ntuple ?
 407                                         NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE :
 408                                         EM_FLOW_ALLOC_INPUT_EN_ETHERTYPE;
 409                         }
 410
 411                         break;
 412                 case RTE_FLOW_ITEM_TYPE_VLAN:
 413                         vlan_spec = item->spec;
 414                         vlan_mask = item->mask;
 415                         if (vlan_mask->tci & 0xFFFF && !vlan_mask->tpid) {
 416                                 /* Only the VLAN ID can be matched. */
 417                                 filter->l2_ovlan =
 418                                         rte_be_to_cpu_16(vlan_spec->tci &
 419                                                          0xFFF);
 420                                 en |= EM_FLOW_ALLOC_INPUT_EN_OVLAN_VID;
 421                         } else {
 422                                 rte_flow_error_set(error, EINVAL,
 423                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 424                                                    item,
 425                                                    "VLAN mask is invalid");
 426                                 return -rte_errno;
 427                         }
 428
 429                         break;
 430                 case RTE_FLOW_ITEM_TYPE_IPV4:
 431                         /* If mask is not involved, we could use EM filters. */
 432                         ipv4_spec = item->spec;
 433                         ipv4_mask = item->mask;
 434                         /* Only IP DST and SRC fields are maskable. */
 435                         if (ipv4_mask->hdr.version_ihl ||
 436                             ipv4_mask->hdr.type_of_service ||
 437                             ipv4_mask->hdr.total_length ||
 438                             ipv4_mask->hdr.packet_id ||
 439                             ipv4_mask->hdr.fragment_offset ||
 440                             ipv4_mask->hdr.time_to_live ||
 441                             ipv4_mask->hdr.next_proto_id ||
 442                             ipv4_mask->hdr.hdr_checksum) {
 443                                 rte_flow_error_set(error, EINVAL,
 444                                            RTE_FLOW_ERROR_TYPE_ITEM,
 445                                            item,
 446                                            "Invalid IPv4 mask.");
 447                                 return -rte_errno;
 448                         }
 449                         filter->dst_ipaddr[0] = ipv4_spec->hdr.dst_addr;
 450                         filter->src_ipaddr[0] = ipv4_spec->hdr.src_addr;
 451                         if (use_ntuple)
 452                                 en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR |
 453                                         NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR;
 454                         else
 455                                 en |= EM_FLOW_ALLOC_INPUT_EN_SRC_IPADDR |
 456                                         EM_FLOW_ALLOC_INPUT_EN_DST_IPADDR;
 457                         if (ipv4_mask->hdr.src_addr) {
 458                                 filter->src_ipaddr_mask[0] =
 459                                         ipv4_mask->hdr.src_addr;
 460                                 en |= !use_ntuple ? 0 :
 461                                      NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR_MASK;
 462                         }
 463                         if (ipv4_mask->hdr.dst_addr) {
 464                                 filter->dst_ipaddr_mask[0] =
 465                                         ipv4_mask->hdr.dst_addr;
 466                                 en |= !use_ntuple ? 0 :
 467                                      NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR_MASK;
 468                         }
 469                         filter->ip_addr_type = use_ntuple ?
 470                          HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_IP_ADDR_TYPE_IPV4 :
 471                          HWRM_CFA_EM_FLOW_ALLOC_INPUT_IP_ADDR_TYPE_IPV4;
 472                         if (ipv4_spec->hdr.next_proto_id) {
 473                                 filter->ip_protocol =
 474                                         ipv4_spec->hdr.next_proto_id;
 475                                 if (use_ntuple)
 476                                         en |= NTUPLE_FLTR_ALLOC_IN_EN_IP_PROTO;
 477                                 else
 478                                         en |= EM_FLOW_ALLOC_INPUT_EN_IP_PROTO;
 479                         }
 480                         break;
 481                 case RTE_FLOW_ITEM_TYPE_IPV6:
 482                         ipv6_spec = item->spec;
 483                         ipv6_mask = item->mask;
 484
 485                         /* Only IP DST and SRC fields are maskable. */
 486                         if (ipv6_mask->hdr.vtc_flow ||
 487                             ipv6_mask->hdr.payload_len ||
 488                             ipv6_mask->hdr.proto ||
 489                             ipv6_mask->hdr.hop_limits) {
 490                                 rte_flow_error_set(error, EINVAL,
 491                                            RTE_FLOW_ERROR_TYPE_ITEM,
 492                                            item,
 493                                            "Invalid IPv6 mask.");
 494                                 return -rte_errno;
 495                         }
 496
 497                         if (use_ntuple)
 498                                 en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR |
 499                                         NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR;
 500                         else
 501                                 en |= EM_FLOW_ALLOC_INPUT_EN_SRC_IPADDR |
 502                                         EM_FLOW_ALLOC_INPUT_EN_DST_IPADDR;
 503                         rte_memcpy(filter->src_ipaddr,
 504                                    ipv6_spec->hdr.src_addr, 16);
 505                         rte_memcpy(filter->dst_ipaddr,
 506                                    ipv6_spec->hdr.dst_addr, 16);
 507                         if (!check_zero_bytes(ipv6_mask->hdr.src_addr, 16)) {
 508                                 rte_memcpy(filter->src_ipaddr_mask,
 509                                            ipv6_mask->hdr.src_addr, 16);
 510                                 en |= !use_ntuple ? 0 :
 511                                     NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR_MASK;
 512                         }
 513                         if (!check_zero_bytes(ipv6_mask->hdr.dst_addr, 16)) {
 514                                 rte_memcpy(filter->dst_ipaddr_mask,
 515                                            ipv6_mask->hdr.dst_addr, 16);
 516                                 en |= !use_ntuple ? 0 :
 517                                      NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR_MASK;
 518                         }
 519                         filter->ip_addr_type = use_ntuple ?
 520                                 NTUPLE_FLTR_ALLOC_INPUT_IP_ADDR_TYPE_IPV6 :
 521                                 EM_FLOW_ALLOC_INPUT_IP_ADDR_TYPE_IPV6;
 522                         break;
 523                 case RTE_FLOW_ITEM_TYPE_TCP:
 524                         tcp_spec = item->spec;
 525                         tcp_mask = item->mask;
 526
 527                         /* Check TCP mask. Only DST & SRC ports are maskable */
 528                         if (tcp_mask->hdr.sent_seq ||
 529                             tcp_mask->hdr.recv_ack ||
 530                             tcp_mask->hdr.data_off ||
 531                             tcp_mask->hdr.tcp_flags ||
 532                             tcp_mask->hdr.rx_win ||
 533                             tcp_mask->hdr.cksum ||
 534                             tcp_mask->hdr.tcp_urp) {
 535                                 rte_flow_error_set(error, EINVAL,
 536                                            RTE_FLOW_ERROR_TYPE_ITEM,
 537                                            item,
 538                                            "Invalid TCP mask");
 539                                 return -rte_errno;
 540                         }
 541                         filter->src_port = tcp_spec->hdr.src_port;
 542                         filter->dst_port = tcp_spec->hdr.dst_port;
 543                         if (use_ntuple)
 544                                 en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT |
 545                                         NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT;
 546                         else
 547                                 en |= EM_FLOW_ALLOC_INPUT_EN_SRC_PORT |
 548                                         EM_FLOW_ALLOC_INPUT_EN_DST_PORT;
 549                         if (tcp_mask->hdr.dst_port) {
 550                                 filter->dst_port_mask = tcp_mask->hdr.dst_port;
 551                                 en |= !use_ntuple ? 0 :
 552                                   NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT_MASK;
 553                         }
 554                         if (tcp_mask->hdr.src_port) {
 555                                 filter->src_port_mask = tcp_mask->hdr.src_port;
 556                                 en |= !use_ntuple ? 0 :
 557                                   NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT_MASK;
 558                         }
 559                         break;
 560                 case RTE_FLOW_ITEM_TYPE_UDP:
 561                         udp_spec = item->spec;
 562                         udp_mask = item->mask;
 563
 564                         if (udp_mask->hdr.dgram_len ||
 565                             udp_mask->hdr.dgram_cksum) {
 566                                 rte_flow_error_set(error, EINVAL,
 567                                            RTE_FLOW_ERROR_TYPE_ITEM,
 568                                            item,
 569                                            "Invalid UDP mask");
 570                                 return -rte_errno;
 571                         }
 572
 573                         filter->src_port = udp_spec->hdr.src_port;
 574                         filter->dst_port = udp_spec->hdr.dst_port;
 575                         if (use_ntuple)
 576                                 en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT |
 577                                         NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT;
 578                         else
 579                                 en |= EM_FLOW_ALLOC_INPUT_EN_SRC_PORT |
 580                                         EM_FLOW_ALLOC_INPUT_EN_DST_PORT;
 581
 582                         if (udp_mask->hdr.dst_port) {
 583                                 filter->dst_port_mask = udp_mask->hdr.dst_port;
 584                                 en |= !use_ntuple ? 0 :
 585                                   NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT_MASK;
 586                         }
 587                         if (udp_mask->hdr.src_port) {
 588                                 filter->src_port_mask = udp_mask->hdr.src_port;
 589                                 en |= !use_ntuple ? 0 :
 590                                   NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT_MASK;
 591                         }
 592                         break;
 593                 case RTE_FLOW_ITEM_TYPE_VXLAN:
 594                         vxlan_spec = item->spec;
 595                         vxlan_mask = item->mask;
 596                         /* Check if VXLAN item is used to describe protocol.
 597                          * If yes, both spec and mask should be NULL.
 598                          * If no, both spec and mask shouldn't be NULL.
 599                          */
 600                         if ((!vxlan_spec && vxlan_mask) ||
 601                             (vxlan_spec && !vxlan_mask)) {
 602                                 rte_flow_error_set(error, EINVAL,
 603                                            RTE_FLOW_ERROR_TYPE_ITEM,
 604                                            item,
 605                                            "Invalid VXLAN item");
 606                                 return -rte_errno;
 607                         }
 608
 609                         if (vxlan_spec->rsvd1 || vxlan_spec->rsvd0[0] ||
 610                             vxlan_spec->rsvd0[1] || vxlan_spec->rsvd0[2] ||
 611                             vxlan_spec->flags != 0x8) {
 612                                 rte_flow_error_set(error, EINVAL,
 613                                            RTE_FLOW_ERROR_TYPE_ITEM,
 614                                            item,
 615                                            "Invalid VXLAN item");
 616                                 return -rte_errno;
 617                         }
 618
 619                         /* Check if VNI is masked. */
 620                         if (vxlan_spec && vxlan_mask) {
 621                                 vni_masked =
 622                                         !!memcmp(vxlan_mask->vni, vni_mask,
 623                                                  RTE_DIM(vni_mask));
 624                                 if (vni_masked) {
 625                                         rte_flow_error_set(error, EINVAL,
 626                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 627                                                    item,
 628                                                    "Invalid VNI mask");
 629                                         return -rte_errno;
 630                                 }
 631
 632                                 rte_memcpy(((uint8_t *)&tenant_id_be + 1),
 633                                            vxlan_spec->vni, 3);
 634                                 filter->vni =
 635                                         rte_be_to_cpu_32(tenant_id_be);
 636                                 filter->tunnel_type =
 637                                  CFA_NTUPLE_FILTER_ALLOC_REQ_TUNNEL_TYPE_VXLAN;
 638                         }
 639                         break;
 640                 case RTE_FLOW_ITEM_TYPE_NVGRE:
 641                         nvgre_spec = item->spec;
 642                         nvgre_mask = item->mask;
 643                         /* Check if NVGRE item is used to describe protocol.
 644                          * If yes, both spec and mask should be NULL.
 645                          * If no, both spec and mask shouldn't be NULL.
 646                          */
 647                         if ((!nvgre_spec && nvgre_mask) ||
 648                             (nvgre_spec && !nvgre_mask)) {
 649                                 rte_flow_error_set(error, EINVAL,
 650                                            RTE_FLOW_ERROR_TYPE_ITEM,
 651                                            item,
 652                                            "Invalid NVGRE item");
 653                                 return -rte_errno;
 654                         }
 655
 656                         if (nvgre_spec->c_k_s_rsvd0_ver != 0x2000 ||
 657                             nvgre_spec->protocol != 0x6558) {
 658                                 rte_flow_error_set(error, EINVAL,
 659                                            RTE_FLOW_ERROR_TYPE_ITEM,
 660                                            item,
 661                                            "Invalid NVGRE item");
 662                                 return -rte_errno;
 663                         }
 664
 665                         if (nvgre_spec && nvgre_mask) {
 666                                 tni_masked =
 667                                         !!memcmp(nvgre_mask->tni, tni_mask,
 668                                                  RTE_DIM(tni_mask));
 669                                 if (tni_masked) {
 670                                         rte_flow_error_set(error, EINVAL,
 671                                                        RTE_FLOW_ERROR_TYPE_ITEM,
 672                                                        item,
 673                                                        "Invalid TNI mask");
 674                                         return -rte_errno;
 675                                 }
 676                                 rte_memcpy(((uint8_t *)&tenant_id_be + 1),
 677                                            nvgre_spec->tni, 3);
 678                                 filter->vni =
 679                                         rte_be_to_cpu_32(tenant_id_be);
 680                                 filter->tunnel_type =
 681                                  CFA_NTUPLE_FILTER_ALLOC_REQ_TUNNEL_TYPE_NVGRE;
 682                         }
 683                         break;
 684                 case RTE_FLOW_ITEM_TYPE_VF:
 685                         vf_spec = item->spec;
 686                         vf = vf_spec->id;
 687                         if (!BNXT_PF(bp)) {
 688                                 rte_flow_error_set(error, EINVAL,
 689                                            RTE_FLOW_ERROR_TYPE_ITEM,
 690                                            item,
 691                                            "Configuring on a VF!");
 692                                 return -rte_errno;
 693                         }
 694
 695                         if (vf >= bp->pdev->max_vfs) {
 696                                 rte_flow_error_set(error, EINVAL,
 697                                            RTE_FLOW_ERROR_TYPE_ITEM,
 698                                            item,
 699                                            "Incorrect VF id!");
 700                                 return -rte_errno;
 701                         }
 702
 703                         filter->mirror_vnic_id =
 704                         dflt_vnic = bnxt_hwrm_func_qcfg_vf_dflt_vnic_id(bp, vf);
 705                         if (dflt_vnic < 0) {
 706                                 /* This simply indicates there's no driver
 707                                  * loaded. This is not an error.
 708                                  */
 709                                 rte_flow_error_set(error, EINVAL,
 710                                            RTE_FLOW_ERROR_TYPE_ITEM,
 711                                            item,
 712                                            "Unable to get default VNIC for VF");
 713                                 return -rte_errno;
 714                         }
 715                         filter->mirror_vnic_id = dflt_vnic;
 716                         en |= NTUPLE_FLTR_ALLOC_INPUT_EN_MIRROR_VNIC_ID;
 717                         break;
 718                 default:
 719                         break;
 720                 }
 721                 item++;
 722         }
 723         filter->enables = en;
 724
 725         return 0;
 726 }
 727
 728 /* Parse attributes */
 729 static int
 730 bnxt_flow_parse_attr(const struct rte_flow_attr *attr,
 731                      struct rte_flow_error *error)
 732 {
 733         /* Must be input direction */
 734         if (!attr->ingress) {
 735                 rte_flow_error_set(error, EINVAL,
 736                                    RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
 737                                    attr, "Only support ingress.");
 738                 return -rte_errno;
 739         }
 740
 741         /* Not supported */
 742         if (attr->egress) {
 743                 rte_flow_error_set(error, EINVAL,
 744                                    RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
 745                                    attr, "No support for egress.");
 746                 return -rte_errno;
 747         }
 748
 749         /* Not supported */
 750         if (attr->priority) {
 751                 rte_flow_error_set(error, EINVAL,
 752                                    RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
 753                                    attr, "No support for priority.");
 754                 return -rte_errno;
 755         }
 756
 757         /* Not supported */
 758         if (attr->group) {
 759                 rte_flow_error_set(error, EINVAL,
 760                                    RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
 761                                    attr, "No support for group.");
 762                 return -rte_errno;
 763         }
 764
 765         return 0;
 766 }
 767
 768 struct bnxt_filter_info *
 769 bnxt_get_l2_filter(struct bnxt *bp, struct bnxt_filter_info *nf,
 770                    struct bnxt_vnic_info *vnic)
 771 {
 772         struct bnxt_filter_info *filter1, *f0;
 773         struct bnxt_vnic_info *vnic0;
 774         int rc;
 775
 776         vnic0 = STAILQ_FIRST(&bp->ff_pool[0]);
 777         f0 = STAILQ_FIRST(&vnic0->filter);
 778
 779         //This flow has same DST MAC as the port/l2 filter.
 780         if (memcmp(f0->l2_addr, nf->dst_macaddr, ETHER_ADDR_LEN) == 0)
 781                 return f0;
 782
 783         //This flow needs DST MAC which is not same as port/l2
 784         PMD_DRV_LOG(DEBUG, "Create L2 filter for DST MAC\n");
 785         filter1 = bnxt_get_unused_filter(bp);
 786         if (filter1 == NULL)
 787                 return NULL;
 788         filter1->flags = HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_PATH_RX;
 789         filter1->enables = HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR |
 790                         L2_FILTER_ALLOC_INPUT_EN_L2_ADDR_MASK;
 791         memcpy(filter1->l2_addr, nf->dst_macaddr, ETHER_ADDR_LEN);
 792         memset(filter1->l2_addr_mask, 0xff, ETHER_ADDR_LEN);
 793         rc = bnxt_hwrm_set_l2_filter(bp, vnic->fw_vnic_id,
 794                                      filter1);
 795         if (rc) {
 796                 bnxt_free_filter(bp, filter1);
 797                 return NULL;
 798         }
 799         return filter1;
 800 }
 801
 802 static int
 803 bnxt_validate_and_parse_flow(struct rte_eth_dev *dev,
 804                              const struct rte_flow_item pattern[],
 805                              const struct rte_flow_action actions[],
 806                              const struct rte_flow_attr *attr,
 807                              struct rte_flow_error *error,
 808                              struct bnxt_filter_info *filter)
 809 {
 810         const struct rte_flow_action *act = nxt_non_void_action(actions);
 811         struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
 812         const struct rte_flow_action_queue *act_q;
 813         const struct rte_flow_action_vf *act_vf;
 814         struct bnxt_vnic_info *vnic, *vnic0;
 815         struct bnxt_filter_info *filter1;
 816         uint32_t vf = 0;
 817         int dflt_vnic;
 818         int rc;
 819
 820         if (bp->eth_dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS) {
 821                 PMD_DRV_LOG(ERR, "Cannot create flow on RSS queues\n");
 822                 rte_flow_error_set(error, EINVAL,
 823                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
 824                                    "Cannot create flow on RSS queues");
 825                 rc = -rte_errno;
 826                 goto ret;
 827         }
 828
 829         rc = bnxt_validate_and_parse_flow_type(bp, pattern, error, filter);
 830         if (rc != 0)
 831                 goto ret;
 832
 833         rc = bnxt_flow_parse_attr(attr, error);
 834         if (rc != 0)
 835                 goto ret;
 836         //Since we support ingress attribute only - right now.
 837         filter->flags = HWRM_CFA_EM_FLOW_ALLOC_INPUT_FLAGS_PATH_RX;
 838
 839         switch (act->type) {
 840         case RTE_FLOW_ACTION_TYPE_QUEUE:
 841                 /* Allow this flow. Redirect to a VNIC. */
 842                 act_q = (const struct rte_flow_action_queue *)act->conf;
 843                 if (act_q->index >= bp->rx_nr_rings) {
 844                         rte_flow_error_set(error, EINVAL,
 845                                            RTE_FLOW_ERROR_TYPE_ACTION, act,
 846                                            "Invalid queue ID.");
 847                         rc = -rte_errno;
 848                         goto ret;
 849                 }
 850                 PMD_DRV_LOG(DEBUG, "Queue index %d\n", act_q->index);
 851
 852                 vnic0 = STAILQ_FIRST(&bp->ff_pool[0]);
 853                 vnic = STAILQ_FIRST(&bp->ff_pool[act_q->index]);
 854                 if (vnic == NULL) {
 855                         rte_flow_error_set(error, EINVAL,
 856                                            RTE_FLOW_ERROR_TYPE_ACTION, act,
 857                                            "No matching VNIC for queue ID.");
 858                         rc = -rte_errno;
 859                         goto ret;
 860                 }
 861                 filter->dst_id = vnic->fw_vnic_id;
 862                 filter1 = bnxt_get_l2_filter(bp, filter, vnic);
 863                 if (filter1 == NULL) {
 864                         rc = -ENOSPC;
 865                         goto ret;
 866                 }
 867                 filter->fw_l2_filter_id = filter1->fw_l2_filter_id;
 868                 PMD_DRV_LOG(DEBUG, "VNIC found\n");
 869                 break;
 870         case RTE_FLOW_ACTION_TYPE_DROP:
 871                 vnic0 = STAILQ_FIRST(&bp->ff_pool[0]);
 872                 filter1 = bnxt_get_l2_filter(bp, filter, vnic0);
 873                 if (filter1 == NULL) {
 874                         rc = -ENOSPC;
 875                         goto ret;
 876                 }
 877                 filter->fw_l2_filter_id = filter1->fw_l2_filter_id;
 878                 if (filter->filter_type == HWRM_CFA_EM_FILTER)
 879                         filter->flags =
 880                                 HWRM_CFA_EM_FLOW_ALLOC_INPUT_FLAGS_DROP;
 881                 else
 882                         filter->flags =
 883                                 HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_FLAGS_DROP;
 884                 break;
 885         case RTE_FLOW_ACTION_TYPE_COUNT:
 886                 vnic0 = STAILQ_FIRST(&bp->ff_pool[0]);
 887                 filter1 = bnxt_get_l2_filter(bp, filter, vnic0);
 888                 if (filter1 == NULL) {
 889                         rc = -ENOSPC;
 890                         goto ret;
 891                 }
 892                 filter->fw_l2_filter_id = filter1->fw_l2_filter_id;
 893                 filter->flags = HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_FLAGS_METER;
 894                 break;
 895         case RTE_FLOW_ACTION_TYPE_VF:
 896                 act_vf = (const struct rte_flow_action_vf *)act->conf;
 897                 vf = act_vf->id;
 898                 if (!BNXT_PF(bp)) {
 899                         rte_flow_error_set(error, EINVAL,
 900                                    RTE_FLOW_ERROR_TYPE_ACTION,
 901                                    act,
 902                                    "Configuring on a VF!");
 903                         rc = -rte_errno;
 904                         goto ret;
 905                 }
 906
 907                 if (vf >= bp->pdev->max_vfs) {
 908                         rte_flow_error_set(error, EINVAL,
 909                                    RTE_FLOW_ERROR_TYPE_ACTION,
 910                                    act,
 911                                    "Incorrect VF id!");
 912                         rc = -rte_errno;
 913                         goto ret;
 914                 }
 915
 916                 filter->mirror_vnic_id =
 917                 dflt_vnic = bnxt_hwrm_func_qcfg_vf_dflt_vnic_id(bp, vf);
 918                 if (dflt_vnic < 0) {
 919                         /* This simply indicates there's no driver loaded.
 920                          * This is not an error.
 921                          */
 922                         rte_flow_error_set(error, EINVAL,
 923                                    RTE_FLOW_ERROR_TYPE_ACTION,
 924                                    act,
 925                                    "Unable to get default VNIC for VF");
 926                         rc = -rte_errno;
 927                         goto ret;
 928                 }
 929                 filter->mirror_vnic_id = dflt_vnic;
 930                 filter->enables |= NTUPLE_FLTR_ALLOC_INPUT_EN_MIRROR_VNIC_ID;
 931
 932                 vnic0 = STAILQ_FIRST(&bp->ff_pool[0]);
 933                 filter1 = bnxt_get_l2_filter(bp, filter, vnic0);
 934                 if (filter1 == NULL) {
 935                         rc = -ENOSPC;
 936                         goto ret;
 937                 }
 938                 filter->fw_l2_filter_id = filter1->fw_l2_filter_id;
 939                 break;
 940
 941         default:
 942                 rte_flow_error_set(error, EINVAL,
 943                                    RTE_FLOW_ERROR_TYPE_ACTION, act,
 944                                    "Invalid action.");
 945                 rc = -rte_errno;
 946                 goto ret;
 947         }
 948
 949         if (filter1) {
 950                 bnxt_free_filter(bp, filter1);
 951                 filter1->fw_l2_filter_id = -1;
 952         }
 953
 954         act = nxt_non_void_action(++act);
 955         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
 956                 rte_flow_error_set(error, EINVAL,
 957                                    RTE_FLOW_ERROR_TYPE_ACTION,
 958                                    act, "Invalid action.");
 959                 rc = -rte_errno;
 960                 goto ret;
 961         }
 962 ret:
 963         return rc;
 964 }
 965
 966 static int
 967 bnxt_flow_validate(struct rte_eth_dev *dev,
 968                 const struct rte_flow_attr *attr,
 969                 const struct rte_flow_item pattern[],
 970                 const struct rte_flow_action actions[],
 971                 struct rte_flow_error *error)
 972 {
 973         struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
 974         struct bnxt_filter_info *filter;
 975         int ret = 0;
 976
 977         ret = bnxt_flow_agrs_validate(attr, pattern, actions, error);
 978         if (ret != 0)
 979                 return ret;
 980
 981         filter = bnxt_get_unused_filter(bp);
 982         if (filter == NULL) {
 983                 PMD_DRV_LOG(ERR, "Not enough resources for a new flow.\n");
 984                 return -ENOMEM;
 985         }
 986
 987         ret = bnxt_validate_and_parse_flow(dev, pattern, actions, attr,
 988                                            error, filter);
 989         /* No need to hold on to this filter if we are just validating flow */
 990         filter->fw_l2_filter_id = -1;
 991         bnxt_free_filter(bp, filter);
 992
 993         return ret;
 994 }
 995
 996 static int
 997 bnxt_match_filter(struct bnxt *bp, struct bnxt_filter_info *nf)
 998 {
 999         struct bnxt_filter_info *mf;
1000         struct rte_flow *flow;
1001         int i;
1002
1003         for (i = bp->nr_vnics - 1; i >= 0; i--) {
1004                 struct bnxt_vnic_info *vnic = &bp->vnic_info[i];
1005
1006                 STAILQ_FOREACH(flow, &vnic->flow_list, next) {
1007                         mf = flow->filter;
1008
1009                         if (mf->filter_type == nf->filter_type &&
1010                             mf->flags == nf->flags &&
1011                             mf->src_port == nf->src_port &&
1012                             mf->src_port_mask == nf->src_port_mask &&
1013                             mf->dst_port == nf->dst_port &&
1014                             mf->dst_port_mask == nf->dst_port_mask &&
1015                             mf->ip_protocol == nf->ip_protocol &&
1016                             mf->ip_addr_type == nf->ip_addr_type &&
1017                             mf->ethertype == nf->ethertype &&
1018                             mf->vni == nf->vni &&
1019                             mf->tunnel_type == nf->tunnel_type &&
1020                             mf->l2_ovlan == nf->l2_ovlan &&
1021                             mf->l2_ovlan_mask == nf->l2_ovlan_mask &&
1022                             mf->l2_ivlan == nf->l2_ivlan &&
1023                             mf->l2_ivlan_mask == nf->l2_ivlan_mask &&
1024                             !memcmp(mf->l2_addr, nf->l2_addr, ETHER_ADDR_LEN) &&
1025                             !memcmp(mf->l2_addr_mask, nf->l2_addr_mask,
1026                                     ETHER_ADDR_LEN) &&
1027                             !memcmp(mf->src_macaddr, nf->src_macaddr,
1028                                     ETHER_ADDR_LEN) &&
1029                             !memcmp(mf->dst_macaddr, nf->dst_macaddr,
1030                                     ETHER_ADDR_LEN) &&
1031                             !memcmp(mf->src_ipaddr, nf->src_ipaddr,
1032                                     sizeof(nf->src_ipaddr)) &&
1033                             !memcmp(mf->src_ipaddr_mask, nf->src_ipaddr_mask,
1034                                     sizeof(nf->src_ipaddr_mask)) &&
1035                             !memcmp(mf->dst_ipaddr, nf->dst_ipaddr,
1036                                     sizeof(nf->dst_ipaddr)) &&
1037                             !memcmp(mf->dst_ipaddr_mask, nf->dst_ipaddr_mask,
1038                                     sizeof(nf->dst_ipaddr_mask))) {
1039                                 if (mf->dst_id == nf->dst_id)
1040                                         return -EEXIST;
1041                                 /* Same Flow, Different queue
1042                                  * Clear the old ntuple filter
1043                                  */
1044                                 if (nf->filter_type == HWRM_CFA_EM_FILTER)
1045                                         bnxt_hwrm_clear_em_filter(bp, mf);
1046                                 if (nf->filter_type == HWRM_CFA_NTUPLE_FILTER)
1047                                         bnxt_hwrm_clear_ntuple_filter(bp, mf);
1048                                 /* Free the old filter, update flow
1049                                  * with new filter
1050                                  */
1051                                 bnxt_free_filter(bp, mf);
1052                                 flow->filter = nf;
1053                                 return -EXDEV;
1054                         }
1055                 }
1056         }
1057         return 0;
1058 }
1059
1060 static struct rte_flow *
1061 bnxt_flow_create(struct rte_eth_dev *dev,
1062                   const struct rte_flow_attr *attr,
1063                   const struct rte_flow_item pattern[],
1064                   const struct rte_flow_action actions[],
1065                   struct rte_flow_error *error)
1066 {
1067         struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
1068         struct bnxt_filter_info *filter;
1069         struct bnxt_vnic_info *vnic = NULL;
1070         bool update_flow = false;
1071         struct rte_flow *flow;
1072         unsigned int i;
1073         int ret = 0;
1074
1075         flow = rte_zmalloc("bnxt_flow", sizeof(struct rte_flow), 0);
1076         if (!flow) {
1077                 rte_flow_error_set(error, ENOMEM,
1078                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1079                                    "Failed to allocate memory");
1080                 return flow;
1081         }
1082
1083         ret = bnxt_flow_agrs_validate(attr, pattern, actions, error);
1084         if (ret != 0) {
1085                 PMD_DRV_LOG(ERR, "Not a validate flow.\n");
1086                 goto free_flow;
1087         }
1088
1089         filter = bnxt_get_unused_filter(bp);
1090         if (filter == NULL) {
1091                 PMD_DRV_LOG(ERR, "Not enough resources for a new flow.\n");
1092                 goto free_flow;
1093         }
1094
1095         ret = bnxt_validate_and_parse_flow(dev, pattern, actions, attr,
1096                                            error, filter);
1097         if (ret != 0)
1098                 goto free_filter;
1099
1100         ret = bnxt_match_filter(bp, filter);
1101         if (ret == -EEXIST) {
1102                 PMD_DRV_LOG(DEBUG, "Flow already exists.\n");
1103                 /* Clear the filter that was created as part of
1104                  * validate_and_parse_flow() above
1105                  */
1106                 bnxt_hwrm_clear_l2_filter(bp, filter);
1107                 goto free_filter;
1108         } else if (ret == -EXDEV) {
1109                 PMD_DRV_LOG(DEBUG, "Flow with same pattern exists");
1110                 PMD_DRV_LOG(DEBUG, "Updating with different destination\n");
1111                 update_flow = true;
1112         }
1113
1114         if (filter->filter_type == HWRM_CFA_EM_FILTER) {
1115                 filter->enables |=
1116                         HWRM_CFA_EM_FLOW_ALLOC_INPUT_ENABLES_L2_FILTER_ID;
1117                 ret = bnxt_hwrm_set_em_filter(bp, filter->dst_id, filter);
1118         }
1119         if (filter->filter_type == HWRM_CFA_NTUPLE_FILTER) {
1120                 filter->enables |=
1121                         HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_ENABLES_L2_FILTER_ID;
1122                 ret = bnxt_hwrm_set_ntuple_filter(bp, filter->dst_id, filter);
1123         }
1124
1125         for (i = 0; i < bp->nr_vnics; i++) {
1126                 vnic = &bp->vnic_info[i];
1127                 if (filter->dst_id == vnic->fw_vnic_id)
1128                         break;
1129         }
1130
1131         if (!ret) {
1132                 flow->filter = filter;
1133                 flow->vnic = vnic;
1134                 if (update_flow) {
1135                         ret = -EXDEV;
1136                         goto free_flow;
1137                 }
1138                 PMD_DRV_LOG(ERR, "Successfully created flow.\n");
1139                 STAILQ_INSERT_TAIL(&vnic->flow_list, flow, next);
1140                 return flow;
1141         }
1142 free_filter:
1143         bnxt_free_filter(bp, filter);
1144 free_flow:
1145         if (ret == -EEXIST)
1146                 rte_flow_error_set(error, ret,
1147                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1148                                    "Matching Flow exists.");
1149         else if (ret == -EXDEV)
1150                 rte_flow_error_set(error, ret,
1151                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1152                                    "Flow with pattern exists, updating destination queue");
1153         else
1154                 rte_flow_error_set(error, -ret,
1155                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1156                                    "Failed to create flow.");
1157         rte_free(flow);
1158         flow = NULL;
1159         return flow;
1160 }
1161
1162 static int
1163 bnxt_flow_destroy(struct rte_eth_dev *dev,
1164                   struct rte_flow *flow,
1165                   struct rte_flow_error *error)
1166 {
1167         struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
1168         struct bnxt_filter_info *filter = flow->filter;
1169         struct bnxt_vnic_info *vnic = flow->vnic;
1170         int ret = 0;
1171
1172         ret = bnxt_match_filter(bp, filter);
1173         if (ret == 0)
1174                 PMD_DRV_LOG(ERR, "Could not find matching flow\n");
1175         if (filter->filter_type == HWRM_CFA_EM_FILTER)
1176                 ret = bnxt_hwrm_clear_em_filter(bp, filter);
1177         if (filter->filter_type == HWRM_CFA_NTUPLE_FILTER)
1178                 ret = bnxt_hwrm_clear_ntuple_filter(bp, filter);
1179
1180         bnxt_hwrm_clear_l2_filter(bp, filter);
1181         if (!ret) {
1182                 STAILQ_REMOVE(&vnic->flow_list, flow, rte_flow, next);
1183                 rte_free(flow);
1184         } else {
1185                 rte_flow_error_set(error, -ret,
1186                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1187                                    "Failed to destroy flow.");
1188         }
1189
1190         return ret;
1191 }
1192
1193 static int
1194 bnxt_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
1195 {
1196         struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
1197         struct bnxt_vnic_info *vnic;
1198         struct rte_flow *flow;
1199         unsigned int i;
1200         int ret = 0;
1201
1202         for (i = 0; i < bp->nr_vnics; i++) {
1203                 vnic = &bp->vnic_info[i];
1204                 STAILQ_FOREACH(flow, &vnic->flow_list, next) {
1205                         struct bnxt_filter_info *filter = flow->filter;
1206
1207                         if (filter->filter_type == HWRM_CFA_EM_FILTER)
1208                                 ret = bnxt_hwrm_clear_em_filter(bp, filter);
1209                         if (filter->filter_type == HWRM_CFA_NTUPLE_FILTER)
1210                                 ret = bnxt_hwrm_clear_ntuple_filter(bp, filter);
1211
1212                         if (ret) {
1213                                 rte_flow_error_set(error, -ret,
1214                                                    RTE_FLOW_ERROR_TYPE_HANDLE,
1215                                                    NULL,
1216                                                    "Failed to flush flow in HW.");
1217                                 return -rte_errno;
1218                         }
1219
1220                         STAILQ_REMOVE(&vnic->flow_list, flow,
1221                                       rte_flow, next);
1222                         rte_free(flow);
1223                 }
1224         }
1225
1226         return ret;
1227 }
1228
1229 const struct rte_flow_ops bnxt_flow_ops = {
1230         .validate = bnxt_flow_validate,
1231         .create = bnxt_flow_create,
1232         .destroy = bnxt_flow_destroy,
1233         .flush = bnxt_flow_flush,
1234 };