drivers/net/i40e/i40e_flow.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (c) 2016-2017 Intel Corporation. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above copyright
  13  *       notice, this list of conditions and the following disclaimer in
  14  *       the documentation and/or other materials provided with the
  15  *       distribution.
  16  *     * Neither the name of Intel Corporation nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/queue.h>
  34 #include <stdio.h>
  35 #include <errno.h>
  36 #include <stdint.h>
  37 #include <string.h>
  38 #include <unistd.h>
  39 #include <stdarg.h>
  40
  41 #include <rte_ether.h>
  42 #include <rte_ethdev.h>
  43 #include <rte_log.h>
  44 #include <rte_memzone.h>
  45 #include <rte_malloc.h>
  46 #include <rte_eth_ctrl.h>
  47 #include <rte_tailq.h>
  48 #include <rte_flow_driver.h>
  49
  50 #include "i40e_logs.h"
  51 #include "base/i40e_type.h"
  52 #include "base/i40e_prototype.h"
  53 #include "i40e_ethdev.h"
  54
  55 #define I40E_IPV4_TC_SHIFT      4
  56 #define I40E_IPV6_TC_MASK       (0x00FF << I40E_IPV4_TC_SHIFT)
  57 #define I40E_IPV6_FRAG_HEADER   44
  58 #define I40E_TENANT_ARRAY_NUM   3
  59 #define I40E_TCI_MASK           0xFFFF
  60
  61 static int i40e_flow_validate(struct rte_eth_dev *dev,
  62                               const struct rte_flow_attr *attr,
  63                               const struct rte_flow_item pattern[],
  64                               const struct rte_flow_action actions[],
  65                               struct rte_flow_error *error);
  66 static struct rte_flow *i40e_flow_create(struct rte_eth_dev *dev,
  67                                          const struct rte_flow_attr *attr,
  68                                          const struct rte_flow_item pattern[],
  69                                          const struct rte_flow_action actions[],
  70                                          struct rte_flow_error *error);
  71 static int i40e_flow_destroy(struct rte_eth_dev *dev,
  72                              struct rte_flow *flow,
  73                              struct rte_flow_error *error);
  74 static int i40e_flow_flush(struct rte_eth_dev *dev,
  75                            struct rte_flow_error *error);
  76 static int
  77 i40e_flow_parse_ethertype_pattern(struct rte_eth_dev *dev,
  78                                   const struct rte_flow_item *pattern,
  79                                   struct rte_flow_error *error,
  80                                   struct rte_eth_ethertype_filter *filter);
  81 static int i40e_flow_parse_ethertype_action(struct rte_eth_dev *dev,
  82                                     const struct rte_flow_action *actions,
  83                                     struct rte_flow_error *error,
  84                                     struct rte_eth_ethertype_filter *filter);
  85 static int i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev,
  86                                         const struct rte_flow_item *pattern,
  87                                         struct rte_flow_error *error,
  88                                         struct rte_eth_fdir_filter *filter);
  89 static int i40e_flow_parse_fdir_action(struct rte_eth_dev *dev,
  90                                        const struct rte_flow_action *actions,
  91                                        struct rte_flow_error *error,
  92                                        struct rte_eth_fdir_filter *filter);
  93 static int i40e_flow_parse_tunnel_action(struct rte_eth_dev *dev,
  94                                  const struct rte_flow_action *actions,
  95                                  struct rte_flow_error *error,
  96                                  struct i40e_tunnel_filter_conf *filter);
  97 static int i40e_flow_parse_attr(const struct rte_flow_attr *attr,
  98                                 struct rte_flow_error *error);
  99 static int i40e_flow_parse_ethertype_filter(struct rte_eth_dev *dev,
 100                                     const struct rte_flow_attr *attr,
 101                                     const struct rte_flow_item pattern[],
 102                                     const struct rte_flow_action actions[],
 103                                     struct rte_flow_error *error,
 104                                     union i40e_filter_t *filter);
 105 static int i40e_flow_parse_fdir_filter(struct rte_eth_dev *dev,
 106                                        const struct rte_flow_attr *attr,
 107                                        const struct rte_flow_item pattern[],
 108                                        const struct rte_flow_action actions[],
 109                                        struct rte_flow_error *error,
 110                                        union i40e_filter_t *filter);
 111 static int i40e_flow_parse_vxlan_filter(struct rte_eth_dev *dev,
 112                                         const struct rte_flow_attr *attr,
 113                                         const struct rte_flow_item pattern[],
 114                                         const struct rte_flow_action actions[],
 115                                         struct rte_flow_error *error,
 116                                         union i40e_filter_t *filter);
 117 static int i40e_flow_parse_mpls_filter(struct rte_eth_dev *dev,
 118                                        const struct rte_flow_attr *attr,
 119                                        const struct rte_flow_item pattern[],
 120                                        const struct rte_flow_action actions[],
 121                                        struct rte_flow_error *error,
 122                                        union i40e_filter_t *filter);
 123 static int i40e_flow_destroy_ethertype_filter(struct i40e_pf *pf,
 124                                       struct i40e_ethertype_filter *filter);
 125 static int i40e_flow_destroy_tunnel_filter(struct i40e_pf *pf,
 126                                            struct i40e_tunnel_filter *filter);
 127 static int i40e_flow_flush_fdir_filter(struct i40e_pf *pf);
 128 static int i40e_flow_flush_ethertype_filter(struct i40e_pf *pf);
 129 static int i40e_flow_flush_tunnel_filter(struct i40e_pf *pf);
 130 static int
 131 i40e_flow_parse_qinq_filter(struct rte_eth_dev *dev,
 132                               const struct rte_flow_attr *attr,
 133                               const struct rte_flow_item pattern[],
 134                               const struct rte_flow_action actions[],
 135                               struct rte_flow_error *error,
 136                               union i40e_filter_t *filter);
 137 static int
 138 i40e_flow_parse_qinq_pattern(struct rte_eth_dev *dev,
 139                               const struct rte_flow_item *pattern,
 140                               struct rte_flow_error *error,
 141                               struct i40e_tunnel_filter_conf *filter);
 142
 143 const struct rte_flow_ops i40e_flow_ops = {
 144         .validate = i40e_flow_validate,
 145         .create = i40e_flow_create,
 146         .destroy = i40e_flow_destroy,
 147         .flush = i40e_flow_flush,
 148 };
 149
 150 union i40e_filter_t cons_filter;
 151 enum rte_filter_type cons_filter_type = RTE_ETH_FILTER_NONE;
 152
 153 /* Pattern matched ethertype filter */
 154 static enum rte_flow_item_type pattern_ethertype[] = {
 155         RTE_FLOW_ITEM_TYPE_ETH,
 156         RTE_FLOW_ITEM_TYPE_END,
 157 };
 158
 159 /* Pattern matched flow director filter */
 160 static enum rte_flow_item_type pattern_fdir_ipv4[] = {
 161         RTE_FLOW_ITEM_TYPE_IPV4,
 162         RTE_FLOW_ITEM_TYPE_END,
 163 };
 164
 165 static enum rte_flow_item_type pattern_fdir_ipv4_ext[] = {
 166         RTE_FLOW_ITEM_TYPE_ETH,
 167         RTE_FLOW_ITEM_TYPE_IPV4,
 168         RTE_FLOW_ITEM_TYPE_END,
 169 };
 170
 171 static enum rte_flow_item_type pattern_fdir_ipv4_udp[] = {
 172         RTE_FLOW_ITEM_TYPE_IPV4,
 173         RTE_FLOW_ITEM_TYPE_UDP,
 174         RTE_FLOW_ITEM_TYPE_END,
 175 };
 176
 177 static enum rte_flow_item_type pattern_fdir_ipv4_udp_ext[] = {
 178         RTE_FLOW_ITEM_TYPE_ETH,
 179         RTE_FLOW_ITEM_TYPE_IPV4,
 180         RTE_FLOW_ITEM_TYPE_UDP,
 181         RTE_FLOW_ITEM_TYPE_END,
 182 };
 183
 184 static enum rte_flow_item_type pattern_fdir_ipv4_tcp[] = {
 185         RTE_FLOW_ITEM_TYPE_IPV4,
 186         RTE_FLOW_ITEM_TYPE_TCP,
 187         RTE_FLOW_ITEM_TYPE_END,
 188 };
 189
 190 static enum rte_flow_item_type pattern_fdir_ipv4_tcp_ext[] = {
 191         RTE_FLOW_ITEM_TYPE_ETH,
 192         RTE_FLOW_ITEM_TYPE_IPV4,
 193         RTE_FLOW_ITEM_TYPE_TCP,
 194         RTE_FLOW_ITEM_TYPE_END,
 195 };
 196
 197 static enum rte_flow_item_type pattern_fdir_ipv4_sctp[] = {
 198         RTE_FLOW_ITEM_TYPE_IPV4,
 199         RTE_FLOW_ITEM_TYPE_SCTP,
 200         RTE_FLOW_ITEM_TYPE_END,
 201 };
 202
 203 static enum rte_flow_item_type pattern_fdir_ipv4_sctp_ext[] = {
 204         RTE_FLOW_ITEM_TYPE_ETH,
 205         RTE_FLOW_ITEM_TYPE_IPV4,
 206         RTE_FLOW_ITEM_TYPE_SCTP,
 207         RTE_FLOW_ITEM_TYPE_END,
 208 };
 209
 210 static enum rte_flow_item_type pattern_fdir_ipv6[] = {
 211         RTE_FLOW_ITEM_TYPE_IPV6,
 212         RTE_FLOW_ITEM_TYPE_END,
 213 };
 214
 215 static enum rte_flow_item_type pattern_fdir_ipv6_ext[] = {
 216         RTE_FLOW_ITEM_TYPE_ETH,
 217         RTE_FLOW_ITEM_TYPE_IPV6,
 218         RTE_FLOW_ITEM_TYPE_END,
 219 };
 220
 221 static enum rte_flow_item_type pattern_fdir_ipv6_udp[] = {
 222         RTE_FLOW_ITEM_TYPE_IPV6,
 223         RTE_FLOW_ITEM_TYPE_UDP,
 224         RTE_FLOW_ITEM_TYPE_END,
 225 };
 226
 227 static enum rte_flow_item_type pattern_fdir_ipv6_udp_ext[] = {
 228         RTE_FLOW_ITEM_TYPE_ETH,
 229         RTE_FLOW_ITEM_TYPE_IPV6,
 230         RTE_FLOW_ITEM_TYPE_UDP,
 231         RTE_FLOW_ITEM_TYPE_END,
 232 };
 233
 234 static enum rte_flow_item_type pattern_fdir_ipv6_tcp[] = {
 235         RTE_FLOW_ITEM_TYPE_IPV6,
 236         RTE_FLOW_ITEM_TYPE_TCP,
 237         RTE_FLOW_ITEM_TYPE_END,
 238 };
 239
 240 static enum rte_flow_item_type pattern_fdir_ipv6_tcp_ext[] = {
 241         RTE_FLOW_ITEM_TYPE_ETH,
 242         RTE_FLOW_ITEM_TYPE_IPV6,
 243         RTE_FLOW_ITEM_TYPE_TCP,
 244         RTE_FLOW_ITEM_TYPE_END,
 245 };
 246
 247 static enum rte_flow_item_type pattern_fdir_ipv6_sctp[] = {
 248         RTE_FLOW_ITEM_TYPE_IPV6,
 249         RTE_FLOW_ITEM_TYPE_SCTP,
 250         RTE_FLOW_ITEM_TYPE_END,
 251 };
 252
 253 static enum rte_flow_item_type pattern_fdir_ipv6_sctp_ext[] = {
 254         RTE_FLOW_ITEM_TYPE_ETH,
 255         RTE_FLOW_ITEM_TYPE_IPV6,
 256         RTE_FLOW_ITEM_TYPE_SCTP,
 257         RTE_FLOW_ITEM_TYPE_END,
 258 };
 259
 260 /* Pattern matched tunnel filter */
 261 static enum rte_flow_item_type pattern_vxlan_1[] = {
 262         RTE_FLOW_ITEM_TYPE_ETH,
 263         RTE_FLOW_ITEM_TYPE_IPV4,
 264         RTE_FLOW_ITEM_TYPE_UDP,
 265         RTE_FLOW_ITEM_TYPE_VXLAN,
 266         RTE_FLOW_ITEM_TYPE_ETH,
 267         RTE_FLOW_ITEM_TYPE_END,
 268 };
 269
 270 static enum rte_flow_item_type pattern_vxlan_2[] = {
 271         RTE_FLOW_ITEM_TYPE_ETH,
 272         RTE_FLOW_ITEM_TYPE_IPV6,
 273         RTE_FLOW_ITEM_TYPE_UDP,
 274         RTE_FLOW_ITEM_TYPE_VXLAN,
 275         RTE_FLOW_ITEM_TYPE_ETH,
 276         RTE_FLOW_ITEM_TYPE_END,
 277 };
 278
 279 static enum rte_flow_item_type pattern_vxlan_3[] = {
 280         RTE_FLOW_ITEM_TYPE_ETH,
 281         RTE_FLOW_ITEM_TYPE_IPV4,
 282         RTE_FLOW_ITEM_TYPE_UDP,
 283         RTE_FLOW_ITEM_TYPE_VXLAN,
 284         RTE_FLOW_ITEM_TYPE_ETH,
 285         RTE_FLOW_ITEM_TYPE_VLAN,
 286         RTE_FLOW_ITEM_TYPE_END,
 287 };
 288
 289 static enum rte_flow_item_type pattern_vxlan_4[] = {
 290         RTE_FLOW_ITEM_TYPE_ETH,
 291         RTE_FLOW_ITEM_TYPE_IPV6,
 292         RTE_FLOW_ITEM_TYPE_UDP,
 293         RTE_FLOW_ITEM_TYPE_VXLAN,
 294         RTE_FLOW_ITEM_TYPE_ETH,
 295         RTE_FLOW_ITEM_TYPE_VLAN,
 296         RTE_FLOW_ITEM_TYPE_END,
 297 };
 298
 299 /* Pattern matched MPLS */
 300 static enum rte_flow_item_type pattern_mpls_1[] = {
 301         RTE_FLOW_ITEM_TYPE_ETH,
 302         RTE_FLOW_ITEM_TYPE_IPV4,
 303         RTE_FLOW_ITEM_TYPE_UDP,
 304         RTE_FLOW_ITEM_TYPE_MPLS,
 305         RTE_FLOW_ITEM_TYPE_END,
 306 };
 307
 308 static enum rte_flow_item_type pattern_mpls_2[] = {
 309         RTE_FLOW_ITEM_TYPE_ETH,
 310         RTE_FLOW_ITEM_TYPE_IPV6,
 311         RTE_FLOW_ITEM_TYPE_UDP,
 312         RTE_FLOW_ITEM_TYPE_MPLS,
 313         RTE_FLOW_ITEM_TYPE_END,
 314 };
 315
 316 static enum rte_flow_item_type pattern_mpls_3[] = {
 317         RTE_FLOW_ITEM_TYPE_ETH,
 318         RTE_FLOW_ITEM_TYPE_IPV4,
 319         RTE_FLOW_ITEM_TYPE_GRE,
 320         RTE_FLOW_ITEM_TYPE_MPLS,
 321         RTE_FLOW_ITEM_TYPE_END,
 322 };
 323
 324 static enum rte_flow_item_type pattern_mpls_4[] = {
 325         RTE_FLOW_ITEM_TYPE_ETH,
 326         RTE_FLOW_ITEM_TYPE_IPV6,
 327         RTE_FLOW_ITEM_TYPE_GRE,
 328         RTE_FLOW_ITEM_TYPE_MPLS,
 329         RTE_FLOW_ITEM_TYPE_END,
 330 };
 331
 332 /* Pattern matched QINQ */
 333 static enum rte_flow_item_type pattern_qinq_1[] = {
 334         RTE_FLOW_ITEM_TYPE_ETH,
 335         RTE_FLOW_ITEM_TYPE_VLAN,
 336         RTE_FLOW_ITEM_TYPE_VLAN,
 337         RTE_FLOW_ITEM_TYPE_END,
 338 };
 339
 340 static struct i40e_valid_pattern i40e_supported_patterns[] = {
 341         /* Ethertype */
 342         { pattern_ethertype, i40e_flow_parse_ethertype_filter },
 343         /* FDIR */
 344         { pattern_fdir_ipv4, i40e_flow_parse_fdir_filter },
 345         { pattern_fdir_ipv4_ext, i40e_flow_parse_fdir_filter },
 346         { pattern_fdir_ipv4_udp, i40e_flow_parse_fdir_filter },
 347         { pattern_fdir_ipv4_udp_ext, i40e_flow_parse_fdir_filter },
 348         { pattern_fdir_ipv4_tcp, i40e_flow_parse_fdir_filter },
 349         { pattern_fdir_ipv4_tcp_ext, i40e_flow_parse_fdir_filter },
 350         { pattern_fdir_ipv4_sctp, i40e_flow_parse_fdir_filter },
 351         { pattern_fdir_ipv4_sctp_ext, i40e_flow_parse_fdir_filter },
 352         { pattern_fdir_ipv6, i40e_flow_parse_fdir_filter },
 353         { pattern_fdir_ipv6_ext, i40e_flow_parse_fdir_filter },
 354         { pattern_fdir_ipv6_udp, i40e_flow_parse_fdir_filter },
 355         { pattern_fdir_ipv6_udp_ext, i40e_flow_parse_fdir_filter },
 356         { pattern_fdir_ipv6_tcp, i40e_flow_parse_fdir_filter },
 357         { pattern_fdir_ipv6_tcp_ext, i40e_flow_parse_fdir_filter },
 358         { pattern_fdir_ipv6_sctp, i40e_flow_parse_fdir_filter },
 359         { pattern_fdir_ipv6_sctp_ext, i40e_flow_parse_fdir_filter },
 360         /* VXLAN */
 361         { pattern_vxlan_1, i40e_flow_parse_vxlan_filter },
 362         { pattern_vxlan_2, i40e_flow_parse_vxlan_filter },
 363         { pattern_vxlan_3, i40e_flow_parse_vxlan_filter },
 364         { pattern_vxlan_4, i40e_flow_parse_vxlan_filter },
 365         /* MPLSoUDP & MPLSoGRE */
 366         { pattern_mpls_1, i40e_flow_parse_mpls_filter },
 367         { pattern_mpls_2, i40e_flow_parse_mpls_filter },
 368         { pattern_mpls_3, i40e_flow_parse_mpls_filter },
 369         { pattern_mpls_4, i40e_flow_parse_mpls_filter },
 370         /* QINQ */
 371         { pattern_qinq_1, i40e_flow_parse_qinq_filter },
 372 };
 373
 374 #define NEXT_ITEM_OF_ACTION(act, actions, index)                        \
 375         do {                                                            \
 376                 act = actions + index;                                  \
 377                 while (act->type == RTE_FLOW_ACTION_TYPE_VOID) {        \
 378                         index++;                                        \
 379                         act = actions + index;                          \
 380                 }                                                       \
 381         } while (0)
 382
 383 /* Find the first VOID or non-VOID item pointer */
 384 static const struct rte_flow_item *
 385 i40e_find_first_item(const struct rte_flow_item *item, bool is_void)
 386 {
 387         bool is_find;
 388
 389         while (item->type != RTE_FLOW_ITEM_TYPE_END) {
 390                 if (is_void)
 391                         is_find = item->type == RTE_FLOW_ITEM_TYPE_VOID;
 392                 else
 393                         is_find = item->type != RTE_FLOW_ITEM_TYPE_VOID;
 394                 if (is_find)
 395                         break;
 396                 item++;
 397         }
 398         return item;
 399 }
 400
 401 /* Skip all VOID items of the pattern */
 402 static void
 403 i40e_pattern_skip_void_item(struct rte_flow_item *items,
 404                             const struct rte_flow_item *pattern)
 405 {
 406         uint32_t cpy_count = 0;
 407         const struct rte_flow_item *pb = pattern, *pe = pattern;
 408
 409         for (;;) {
 410                 /* Find a non-void item first */
 411                 pb = i40e_find_first_item(pb, false);
 412                 if (pb->type == RTE_FLOW_ITEM_TYPE_END) {
 413                         pe = pb;
 414                         break;
 415                 }
 416
 417                 /* Find a void item */
 418                 pe = i40e_find_first_item(pb + 1, true);
 419
 420                 cpy_count = pe - pb;
 421                 rte_memcpy(items, pb, sizeof(struct rte_flow_item) * cpy_count);
 422
 423                 items += cpy_count;
 424
 425                 if (pe->type == RTE_FLOW_ITEM_TYPE_END) {
 426                         pb = pe;
 427                         break;
 428                 }
 429
 430                 pb = pe + 1;
 431         }
 432         /* Copy the END item. */
 433         rte_memcpy(items, pe, sizeof(struct rte_flow_item));
 434 }
 435
 436 /* Check if the pattern matches a supported item type array */
 437 static bool
 438 i40e_match_pattern(enum rte_flow_item_type *item_array,
 439                    struct rte_flow_item *pattern)
 440 {
 441         struct rte_flow_item *item = pattern;
 442
 443         while ((*item_array == item->type) &&
 444                (*item_array != RTE_FLOW_ITEM_TYPE_END)) {
 445                 item_array++;
 446                 item++;
 447         }
 448
 449         return (*item_array == RTE_FLOW_ITEM_TYPE_END &&
 450                 item->type == RTE_FLOW_ITEM_TYPE_END);
 451 }
 452
 453 /* Find if there's parse filter function matched */
 454 static parse_filter_t
 455 i40e_find_parse_filter_func(struct rte_flow_item *pattern)
 456 {
 457         parse_filter_t parse_filter = NULL;
 458         uint8_t i = 0;
 459
 460         for (; i < RTE_DIM(i40e_supported_patterns); i++) {
 461                 if (i40e_match_pattern(i40e_supported_patterns[i].items,
 462                                         pattern)) {
 463                         parse_filter = i40e_supported_patterns[i].parse_filter;
 464                         break;
 465                 }
 466         }
 467
 468         return parse_filter;
 469 }
 470
 471 /* Parse attributes */
 472 static int
 473 i40e_flow_parse_attr(const struct rte_flow_attr *attr,
 474                      struct rte_flow_error *error)
 475 {
 476         /* Must be input direction */
 477         if (!attr->ingress) {
 478                 rte_flow_error_set(error, EINVAL,
 479                                    RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
 480                                    attr, "Only support ingress.");
 481                 return -rte_errno;
 482         }
 483
 484         /* Not supported */
 485         if (attr->egress) {
 486                 rte_flow_error_set(error, EINVAL,
 487                                    RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
 488                                    attr, "Not support egress.");
 489                 return -rte_errno;
 490         }
 491
 492         /* Not supported */
 493         if (attr->priority) {
 494                 rte_flow_error_set(error, EINVAL,
 495                                    RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
 496                                    attr, "Not support priority.");
 497                 return -rte_errno;
 498         }
 499
 500         /* Not supported */
 501         if (attr->group) {
 502                 rte_flow_error_set(error, EINVAL,
 503                                    RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
 504                                    attr, "Not support group.");
 505                 return -rte_errno;
 506         }
 507
 508         return 0;
 509 }
 510
 511 static uint16_t
 512 i40e_get_outer_vlan(struct rte_eth_dev *dev)
 513 {
 514         struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 515         int qinq = dev->data->dev_conf.rxmode.hw_vlan_extend;
 516         uint64_t reg_r = 0;
 517         uint16_t reg_id;
 518         uint16_t tpid;
 519
 520         if (qinq)
 521                 reg_id = 2;
 522         else
 523                 reg_id = 3;
 524
 525         i40e_aq_debug_read_register(hw, I40E_GL_SWT_L2TAGCTRL(reg_id),
 526                                     &reg_r, NULL);
 527
 528         tpid = (reg_r >> I40E_GL_SWT_L2TAGCTRL_ETHERTYPE_SHIFT) & 0xFFFF;
 529
 530         return tpid;
 531 }
 532
 533 /* 1. Last in item should be NULL as range is not supported.
 534  * 2. Supported filter types: MAC_ETHTYPE and ETHTYPE.
 535  * 3. SRC mac_addr mask should be 00:00:00:00:00:00.
 536  * 4. DST mac_addr mask should be 00:00:00:00:00:00 or
 537  *    FF:FF:FF:FF:FF:FF
 538  * 5. Ether_type mask should be 0xFFFF.
 539  */
 540 static int
 541 i40e_flow_parse_ethertype_pattern(struct rte_eth_dev *dev,
 542                                   const struct rte_flow_item *pattern,
 543                                   struct rte_flow_error *error,
 544                                   struct rte_eth_ethertype_filter *filter)
 545 {
 546         const struct rte_flow_item *item = pattern;
 547         const struct rte_flow_item_eth *eth_spec;
 548         const struct rte_flow_item_eth *eth_mask;
 549         enum rte_flow_item_type item_type;
 550         uint16_t outer_tpid;
 551
 552         outer_tpid = i40e_get_outer_vlan(dev);
 553
 554         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
 555                 if (item->last) {
 556                         rte_flow_error_set(error, EINVAL,
 557                                            RTE_FLOW_ERROR_TYPE_ITEM,
 558                                            item,
 559                                            "Not support range");
 560                         return -rte_errno;
 561                 }
 562                 item_type = item->type;
 563                 switch (item_type) {
 564                 case RTE_FLOW_ITEM_TYPE_ETH:
 565                         eth_spec = (const struct rte_flow_item_eth *)item->spec;
 566                         eth_mask = (const struct rte_flow_item_eth *)item->mask;
 567                         /* Get the MAC info. */
 568                         if (!eth_spec || !eth_mask) {
 569                                 rte_flow_error_set(error, EINVAL,
 570                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 571                                                    item,
 572                                                    "NULL ETH spec/mask");
 573                                 return -rte_errno;
 574                         }
 575
 576                         /* Mask bits of source MAC address must be full of 0.
 577                          * Mask bits of destination MAC address must be full
 578                          * of 1 or full of 0.
 579                          */
 580                         if (!is_zero_ether_addr(&eth_mask->src) ||
 581                             (!is_zero_ether_addr(&eth_mask->dst) &&
 582                              !is_broadcast_ether_addr(&eth_mask->dst))) {
 583                                 rte_flow_error_set(error, EINVAL,
 584                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 585                                                    item,
 586                                                    "Invalid MAC_addr mask");
 587                                 return -rte_errno;
 588                         }
 589
 590                         if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) {
 591                                 rte_flow_error_set(error, EINVAL,
 592                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 593                                                    item,
 594                                                    "Invalid ethertype mask");
 595                                 return -rte_errno;
 596                         }
 597
 598                         /* If mask bits of destination MAC address
 599                          * are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
 600                          */
 601                         if (is_broadcast_ether_addr(&eth_mask->dst)) {
 602                                 filter->mac_addr = eth_spec->dst;
 603                                 filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
 604                         } else {
 605                                 filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC;
 606                         }
 607                         filter->ether_type = rte_be_to_cpu_16(eth_spec->type);
 608
 609                         if (filter->ether_type == ETHER_TYPE_IPv4 ||
 610                             filter->ether_type == ETHER_TYPE_IPv6 ||
 611                             filter->ether_type == ETHER_TYPE_LLDP ||
 612                             filter->ether_type == outer_tpid) {
 613                                 rte_flow_error_set(error, EINVAL,
 614                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 615                                                    item,
 616                                                    "Unsupported ether_type in"
 617                                                    " control packet filter.");
 618                                 return -rte_errno;
 619                         }
 620                         break;
 621                 default:
 622                         break;
 623                 }
 624         }
 625
 626         return 0;
 627 }
 628
 629 /* Ethertype action only supports QUEUE or DROP. */
 630 static int
 631 i40e_flow_parse_ethertype_action(struct rte_eth_dev *dev,
 632                                  const struct rte_flow_action *actions,
 633                                  struct rte_flow_error *error,
 634                                  struct rte_eth_ethertype_filter *filter)
 635 {
 636         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
 637         const struct rte_flow_action *act;
 638         const struct rte_flow_action_queue *act_q;
 639         uint32_t index = 0;
 640
 641         /* Check if the first non-void action is QUEUE or DROP. */
 642         NEXT_ITEM_OF_ACTION(act, actions, index);
 643         if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
 644             act->type != RTE_FLOW_ACTION_TYPE_DROP) {
 645                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
 646                                    act, "Not supported action.");
 647                 return -rte_errno;
 648         }
 649
 650         if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
 651                 act_q = (const struct rte_flow_action_queue *)act->conf;
 652                 filter->queue = act_q->index;
 653                 if (filter->queue >= pf->dev_data->nb_rx_queues) {
 654                         rte_flow_error_set(error, EINVAL,
 655                                            RTE_FLOW_ERROR_TYPE_ACTION,
 656                                            act, "Invalid queue ID for"
 657                                            " ethertype_filter.");
 658                         return -rte_errno;
 659                 }
 660         } else {
 661                 filter->flags |= RTE_ETHTYPE_FLAGS_DROP;
 662         }
 663
 664         /* Check if the next non-void item is END */
 665         index++;
 666         NEXT_ITEM_OF_ACTION(act, actions, index);
 667         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
 668                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
 669                                    act, "Not supported action.");
 670                 return -rte_errno;
 671         }
 672
 673         return 0;
 674 }
 675
 676 static int
 677 i40e_flow_parse_ethertype_filter(struct rte_eth_dev *dev,
 678                                  const struct rte_flow_attr *attr,
 679                                  const struct rte_flow_item pattern[],
 680                                  const struct rte_flow_action actions[],
 681                                  struct rte_flow_error *error,
 682                                  union i40e_filter_t *filter)
 683 {
 684         struct rte_eth_ethertype_filter *ethertype_filter =
 685                 &filter->ethertype_filter;
 686         int ret;
 687
 688         ret = i40e_flow_parse_ethertype_pattern(dev, pattern, error,
 689                                                 ethertype_filter);
 690         if (ret)
 691                 return ret;
 692
 693         ret = i40e_flow_parse_ethertype_action(dev, actions, error,
 694                                                ethertype_filter);
 695         if (ret)
 696                 return ret;
 697
 698         ret = i40e_flow_parse_attr(attr, error);
 699         if (ret)
 700                 return ret;
 701
 702         cons_filter_type = RTE_ETH_FILTER_ETHERTYPE;
 703
 704         return ret;
 705 }
 706
 707 /* 1. Last in item should be NULL as range is not supported.
 708  * 2. Supported flow type and input set: refer to array
 709  *    default_inset_table in i40e_ethdev.c.
 710  * 3. Mask of fields which need to be matched should be
 711  *    filled with 1.
 712  * 4. Mask of fields which needn't to be matched should be
 713  *    filled with 0.
 714  */
 715 static int
 716 i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev,
 717                              const struct rte_flow_item *pattern,
 718                              struct rte_flow_error *error,
 719                              struct rte_eth_fdir_filter *filter)
 720 {
 721         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
 722         const struct rte_flow_item *item = pattern;
 723         const struct rte_flow_item_eth *eth_spec, *eth_mask;
 724         const struct rte_flow_item_ipv4 *ipv4_spec, *ipv4_mask;
 725         const struct rte_flow_item_ipv6 *ipv6_spec, *ipv6_mask;
 726         const struct rte_flow_item_tcp *tcp_spec, *tcp_mask;
 727         const struct rte_flow_item_udp *udp_spec, *udp_mask;
 728         const struct rte_flow_item_sctp *sctp_spec, *sctp_mask;
 729         const struct rte_flow_item_vf *vf_spec;
 730         uint32_t flow_type = RTE_ETH_FLOW_UNKNOWN;
 731         enum i40e_filter_pctype pctype;
 732         uint64_t input_set = I40E_INSET_NONE;
 733         uint16_t flag_offset;
 734         enum rte_flow_item_type item_type;
 735         enum rte_flow_item_type l3 = RTE_FLOW_ITEM_TYPE_END;
 736         uint32_t j;
 737
 738         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
 739                 if (item->last) {
 740                         rte_flow_error_set(error, EINVAL,
 741                                            RTE_FLOW_ERROR_TYPE_ITEM,
 742                                            item,
 743                                            "Not support range");
 744                         return -rte_errno;
 745                 }
 746                 item_type = item->type;
 747                 switch (item_type) {
 748                 case RTE_FLOW_ITEM_TYPE_ETH:
 749                         eth_spec = (const struct rte_flow_item_eth *)item->spec;
 750                         eth_mask = (const struct rte_flow_item_eth *)item->mask;
 751                         if (eth_spec || eth_mask) {
 752                                 rte_flow_error_set(error, EINVAL,
 753                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 754                                                    item,
 755                                                    "Invalid ETH spec/mask");
 756                                 return -rte_errno;
 757                         }
 758                         break;
 759                 case RTE_FLOW_ITEM_TYPE_IPV4:
 760                         l3 = RTE_FLOW_ITEM_TYPE_IPV4;
 761                         ipv4_spec =
 762                                 (const struct rte_flow_item_ipv4 *)item->spec;
 763                         ipv4_mask =
 764                                 (const struct rte_flow_item_ipv4 *)item->mask;
 765                         if (!ipv4_spec || !ipv4_mask) {
 766                                 rte_flow_error_set(error, EINVAL,
 767                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 768                                                    item,
 769                                                    "NULL IPv4 spec/mask");
 770                                 return -rte_errno;
 771                         }
 772
 773                         /* Check IPv4 mask and update input set */
 774                         if (ipv4_mask->hdr.version_ihl ||
 775                             ipv4_mask->hdr.total_length ||
 776                             ipv4_mask->hdr.packet_id ||
 777                             ipv4_mask->hdr.fragment_offset ||
 778                             ipv4_mask->hdr.hdr_checksum) {
 779                                 rte_flow_error_set(error, EINVAL,
 780                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 781                                                    item,
 782                                                    "Invalid IPv4 mask.");
 783                                 return -rte_errno;
 784                         }
 785
 786                         if (ipv4_mask->hdr.src_addr == UINT32_MAX)
 787                                 input_set |= I40E_INSET_IPV4_SRC;
 788                         if (ipv4_mask->hdr.dst_addr == UINT32_MAX)
 789                                 input_set |= I40E_INSET_IPV4_DST;
 790                         if (ipv4_mask->hdr.type_of_service == UINT8_MAX)
 791                                 input_set |= I40E_INSET_IPV4_TOS;
 792                         if (ipv4_mask->hdr.time_to_live == UINT8_MAX)
 793                                 input_set |= I40E_INSET_IPV4_TTL;
 794                         if (ipv4_mask->hdr.next_proto_id == UINT8_MAX)
 795                                 input_set |= I40E_INSET_IPV4_PROTO;
 796
 797                         /* Get filter info */
 798                         flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_OTHER;
 799                         /* Check if it is fragment. */
 800                         flag_offset =
 801                               rte_be_to_cpu_16(ipv4_spec->hdr.fragment_offset);
 802                         if (flag_offset & IPV4_HDR_OFFSET_MASK ||
 803                             flag_offset & IPV4_HDR_MF_FLAG)
 804                                 flow_type = RTE_ETH_FLOW_FRAG_IPV4;
 805
 806                         /* Get the filter info */
 807                         filter->input.flow.ip4_flow.proto =
 808                                 ipv4_spec->hdr.next_proto_id;
 809                         filter->input.flow.ip4_flow.tos =
 810                                 ipv4_spec->hdr.type_of_service;
 811                         filter->input.flow.ip4_flow.ttl =
 812                                 ipv4_spec->hdr.time_to_live;
 813                         filter->input.flow.ip4_flow.src_ip =
 814                                 ipv4_spec->hdr.src_addr;
 815                         filter->input.flow.ip4_flow.dst_ip =
 816                                 ipv4_spec->hdr.dst_addr;
 817
 818                         break;
 819                 case RTE_FLOW_ITEM_TYPE_IPV6:
 820                         l3 = RTE_FLOW_ITEM_TYPE_IPV6;
 821                         ipv6_spec =
 822                                 (const struct rte_flow_item_ipv6 *)item->spec;
 823                         ipv6_mask =
 824                                 (const struct rte_flow_item_ipv6 *)item->mask;
 825                         if (!ipv6_spec || !ipv6_mask) {
 826                                 rte_flow_error_set(error, EINVAL,
 827                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 828                                                    item,
 829                                                    "NULL IPv6 spec/mask");
 830                                 return -rte_errno;
 831                         }
 832
 833                         /* Check IPv6 mask and update input set */
 834                         if (ipv6_mask->hdr.payload_len) {
 835                                 rte_flow_error_set(error, EINVAL,
 836                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 837                                                    item,
 838                                                    "Invalid IPv6 mask");
 839                                 return -rte_errno;
 840                         }
 841
 842                         /* SCR and DST address of IPv6 shouldn't be masked */
 843                         for (j = 0; j < RTE_DIM(ipv6_mask->hdr.src_addr); j++) {
 844                                 if (ipv6_mask->hdr.src_addr[j] != UINT8_MAX ||
 845                                     ipv6_mask->hdr.dst_addr[j] != UINT8_MAX) {
 846                                         rte_flow_error_set(error, EINVAL,
 847                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 848                                                    item,
 849                                                    "Invalid IPv6 mask");
 850                                         return -rte_errno;
 851                                 }
 852                         }
 853
 854                         input_set |= I40E_INSET_IPV6_SRC;
 855                         input_set |= I40E_INSET_IPV6_DST;
 856
 857                         if ((ipv6_mask->hdr.vtc_flow &
 858                              rte_cpu_to_be_16(I40E_IPV6_TC_MASK))
 859                             == rte_cpu_to_be_16(I40E_IPV6_TC_MASK))
 860                                 input_set |= I40E_INSET_IPV6_TC;
 861                         if (ipv6_mask->hdr.proto == UINT8_MAX)
 862                                 input_set |= I40E_INSET_IPV6_NEXT_HDR;
 863                         if (ipv6_mask->hdr.hop_limits == UINT8_MAX)
 864                                 input_set |= I40E_INSET_IPV6_HOP_LIMIT;
 865
 866                         /* Get filter info */
 867                         filter->input.flow.ipv6_flow.tc =
 868                                 (uint8_t)(ipv6_spec->hdr.vtc_flow <<
 869                                           I40E_IPV4_TC_SHIFT);
 870                         filter->input.flow.ipv6_flow.proto =
 871                                 ipv6_spec->hdr.proto;
 872                         filter->input.flow.ipv6_flow.hop_limits =
 873                                 ipv6_spec->hdr.hop_limits;
 874
 875                         rte_memcpy(filter->input.flow.ipv6_flow.src_ip,
 876                                    ipv6_spec->hdr.src_addr, 16);
 877                         rte_memcpy(filter->input.flow.ipv6_flow.dst_ip,
 878                                    ipv6_spec->hdr.dst_addr, 16);
 879
 880                         /* Check if it is fragment. */
 881                         if (ipv6_spec->hdr.proto == I40E_IPV6_FRAG_HEADER)
 882                                 flow_type = RTE_ETH_FLOW_FRAG_IPV6;
 883                         else
 884                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_OTHER;
 885                         break;
 886                 case RTE_FLOW_ITEM_TYPE_TCP:
 887                         tcp_spec = (const struct rte_flow_item_tcp *)item->spec;
 888                         tcp_mask = (const struct rte_flow_item_tcp *)item->mask;
 889                         if (!tcp_spec || !tcp_mask) {
 890                                 rte_flow_error_set(error, EINVAL,
 891                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 892                                                    item,
 893                                                    "NULL TCP spec/mask");
 894                                 return -rte_errno;
 895                         }
 896
 897                         /* Check TCP mask and update input set */
 898                         if (tcp_mask->hdr.sent_seq ||
 899                             tcp_mask->hdr.recv_ack ||
 900                             tcp_mask->hdr.data_off ||
 901                             tcp_mask->hdr.tcp_flags ||
 902                             tcp_mask->hdr.rx_win ||
 903                             tcp_mask->hdr.cksum ||
 904                             tcp_mask->hdr.tcp_urp) {
 905                                 rte_flow_error_set(error, EINVAL,
 906                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 907                                                    item,
 908                                                    "Invalid TCP mask");
 909                                 return -rte_errno;
 910                         }
 911
 912                         if (tcp_mask->hdr.src_port != UINT16_MAX ||
 913                             tcp_mask->hdr.dst_port != UINT16_MAX) {
 914                                 rte_flow_error_set(error, EINVAL,
 915                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 916                                                    item,
 917                                                    "Invalid TCP mask");
 918                                 return -rte_errno;
 919                         }
 920
 921                         input_set |= I40E_INSET_SRC_PORT;
 922                         input_set |= I40E_INSET_DST_PORT;
 923
 924                         /* Get filter info */
 925                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
 926                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_TCP;
 927                         else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
 928                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_TCP;
 929
 930                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4) {
 931                                 filter->input.flow.tcp4_flow.src_port =
 932                                         tcp_spec->hdr.src_port;
 933                                 filter->input.flow.tcp4_flow.dst_port =
 934                                         tcp_spec->hdr.dst_port;
 935                         } else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6) {
 936                                 filter->input.flow.tcp6_flow.src_port =
 937                                         tcp_spec->hdr.src_port;
 938                                 filter->input.flow.tcp6_flow.dst_port =
 939                                         tcp_spec->hdr.dst_port;
 940                         }
 941                         break;
 942                 case RTE_FLOW_ITEM_TYPE_UDP:
 943                         udp_spec = (const struct rte_flow_item_udp *)item->spec;
 944                         udp_mask = (const struct rte_flow_item_udp *)item->mask;
 945                         if (!udp_spec || !udp_mask) {
 946                                 rte_flow_error_set(error, EINVAL,
 947                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 948                                                    item,
 949                                                    "NULL UDP spec/mask");
 950                                 return -rte_errno;
 951                         }
 952
 953                         /* Check UDP mask and update input set*/
 954                         if (udp_mask->hdr.dgram_len ||
 955                             udp_mask->hdr.dgram_cksum) {
 956                                 rte_flow_error_set(error, EINVAL,
 957                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 958                                                    item,
 959                                                    "Invalid UDP mask");
 960                                 return -rte_errno;
 961                         }
 962
 963                         if (udp_mask->hdr.src_port != UINT16_MAX ||
 964                             udp_mask->hdr.dst_port != UINT16_MAX) {
 965                                 rte_flow_error_set(error, EINVAL,
 966                                                    RTE_FLOW_ERROR_TYPE_ITEM,
 967                                                    item,
 968                                                    "Invalid UDP mask");
 969                                 return -rte_errno;
 970                         }
 971
 972                         input_set |= I40E_INSET_SRC_PORT;
 973                         input_set |= I40E_INSET_DST_PORT;
 974
 975                         /* Get filter info */
 976                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
 977                                 flow_type =
 978                                         RTE_ETH_FLOW_NONFRAG_IPV4_UDP;
 979                         else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
 980                                 flow_type =
 981                                         RTE_ETH_FLOW_NONFRAG_IPV6_UDP;
 982
 983                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4) {
 984                                 filter->input.flow.udp4_flow.src_port =
 985                                         udp_spec->hdr.src_port;
 986                                 filter->input.flow.udp4_flow.dst_port =
 987                                         udp_spec->hdr.dst_port;
 988                         } else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6) {
 989                                 filter->input.flow.udp6_flow.src_port =
 990                                         udp_spec->hdr.src_port;
 991                                 filter->input.flow.udp6_flow.dst_port =
 992                                         udp_spec->hdr.dst_port;
 993                         }
 994                         break;
 995                 case RTE_FLOW_ITEM_TYPE_SCTP:
 996                         sctp_spec =
 997                                 (const struct rte_flow_item_sctp *)item->spec;
 998                         sctp_mask =
 999                                 (const struct rte_flow_item_sctp *)item->mask;
1000                         if (!sctp_spec || !sctp_mask) {
1001                                 rte_flow_error_set(error, EINVAL,
1002                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1003                                                    item,
1004                                                    "NULL SCTP spec/mask");
1005                                 return -rte_errno;
1006                         }
1007
1008                         /* Check SCTP mask and update input set */
1009                         if (sctp_mask->hdr.cksum) {
1010                                 rte_flow_error_set(error, EINVAL,
1011                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1012                                                    item,
1013                                                    "Invalid UDP mask");
1014                                 return -rte_errno;
1015                         }
1016
1017                         if (sctp_mask->hdr.src_port != UINT16_MAX ||
1018                             sctp_mask->hdr.dst_port != UINT16_MAX ||
1019                             sctp_mask->hdr.tag != UINT32_MAX) {
1020                                 rte_flow_error_set(error, EINVAL,
1021                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1022                                                    item,
1023                                                    "Invalid UDP mask");
1024                                 return -rte_errno;
1025                         }
1026                         input_set |= I40E_INSET_SRC_PORT;
1027                         input_set |= I40E_INSET_DST_PORT;
1028                         input_set |= I40E_INSET_SCTP_VT;
1029
1030                         /* Get filter info */
1031                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
1032                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_SCTP;
1033                         else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
1034                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_SCTP;
1035
1036                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4) {
1037                                 filter->input.flow.sctp4_flow.src_port =
1038                                         sctp_spec->hdr.src_port;
1039                                 filter->input.flow.sctp4_flow.dst_port =
1040                                         sctp_spec->hdr.dst_port;
1041                                 filter->input.flow.sctp4_flow.verify_tag =
1042                                         sctp_spec->hdr.tag;
1043                         } else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6) {
1044                                 filter->input.flow.sctp6_flow.src_port =
1045                                         sctp_spec->hdr.src_port;
1046                                 filter->input.flow.sctp6_flow.dst_port =
1047                                         sctp_spec->hdr.dst_port;
1048                                 filter->input.flow.sctp6_flow.verify_tag =
1049                                         sctp_spec->hdr.tag;
1050                         }
1051                         break;
1052                 case RTE_FLOW_ITEM_TYPE_VF:
1053                         vf_spec = (const struct rte_flow_item_vf *)item->spec;
1054                         filter->input.flow_ext.is_vf = 1;
1055                         filter->input.flow_ext.dst_id = vf_spec->id;
1056                         if (filter->input.flow_ext.is_vf &&
1057                             filter->input.flow_ext.dst_id >= pf->vf_num) {
1058                                 rte_flow_error_set(error, EINVAL,
1059                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1060                                                    item,
1061                                                    "Invalid VF ID for FDIR.");
1062                                 return -rte_errno;
1063                         }
1064                         break;
1065                 default:
1066                         break;
1067                 }
1068         }
1069
1070         pctype = i40e_flowtype_to_pctype(flow_type);
1071         if (pctype == 0 || pctype > I40E_FILTER_PCTYPE_L2_PAYLOAD) {
1072                 rte_flow_error_set(error, EINVAL,
1073                                    RTE_FLOW_ERROR_TYPE_ITEM, item,
1074                                    "Unsupported flow type");
1075                 return -rte_errno;
1076         }
1077
1078         if (input_set != i40e_get_default_input_set(pctype)) {
1079                 rte_flow_error_set(error, EINVAL,
1080                                    RTE_FLOW_ERROR_TYPE_ITEM, item,
1081                                    "Invalid input set.");
1082                 return -rte_errno;
1083         }
1084         filter->input.flow_type = flow_type;
1085
1086         return 0;
1087 }
1088
1089 /* Parse to get the action info of a FDIR filter.
1090  * FDIR action supports QUEUE or (QUEUE + MARK).
1091  */
1092 static int
1093 i40e_flow_parse_fdir_action(struct rte_eth_dev *dev,
1094                             const struct rte_flow_action *actions,
1095                             struct rte_flow_error *error,
1096                             struct rte_eth_fdir_filter *filter)
1097 {
1098         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
1099         const struct rte_flow_action *act;
1100         const struct rte_flow_action_queue *act_q;
1101         const struct rte_flow_action_mark *mark_spec;
1102         uint32_t index = 0;
1103
1104         /* Check if the first non-void action is QUEUE or DROP or PASSTHRU. */
1105         NEXT_ITEM_OF_ACTION(act, actions, index);
1106         switch (act->type) {
1107         case RTE_FLOW_ACTION_TYPE_QUEUE:
1108                 act_q = (const struct rte_flow_action_queue *)act->conf;
1109                 filter->action.rx_queue = act_q->index;
1110                 if (filter->action.rx_queue >= pf->dev_data->nb_rx_queues) {
1111                         rte_flow_error_set(error, EINVAL,
1112                                            RTE_FLOW_ERROR_TYPE_ACTION, act,
1113                                            "Invalid queue ID for FDIR.");
1114                         return -rte_errno;
1115                 }
1116                 filter->action.behavior = RTE_ETH_FDIR_ACCEPT;
1117                 break;
1118         case RTE_FLOW_ACTION_TYPE_DROP:
1119                 filter->action.behavior = RTE_ETH_FDIR_REJECT;
1120                 break;
1121         case RTE_FLOW_ACTION_TYPE_PASSTHRU:
1122                 filter->action.behavior = RTE_ETH_FDIR_PASSTHRU;
1123                 break;
1124         default:
1125                 rte_flow_error_set(error, EINVAL,
1126                                    RTE_FLOW_ERROR_TYPE_ACTION, act,
1127                                    "Invalid action.");
1128                 return -rte_errno;
1129         }
1130
1131         /* Check if the next non-void item is MARK or FLAG or END. */
1132         index++;
1133         NEXT_ITEM_OF_ACTION(act, actions, index);
1134         switch (act->type) {
1135         case RTE_FLOW_ACTION_TYPE_MARK:
1136                 mark_spec = (const struct rte_flow_action_mark *)act->conf;
1137                 filter->action.report_status = RTE_ETH_FDIR_REPORT_ID;
1138                 filter->soft_id = mark_spec->id;
1139                 break;
1140         case RTE_FLOW_ACTION_TYPE_FLAG:
1141                 filter->action.report_status = RTE_ETH_FDIR_NO_REPORT_STATUS;
1142                 break;
1143         case RTE_FLOW_ACTION_TYPE_END:
1144                 return 0;
1145         default:
1146                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1147                                    act, "Invalid action.");
1148                 return -rte_errno;
1149         }
1150
1151         /* Check if the next non-void item is END */
1152         index++;
1153         NEXT_ITEM_OF_ACTION(act, actions, index);
1154         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1155                 rte_flow_error_set(error, EINVAL,
1156                                    RTE_FLOW_ERROR_TYPE_ACTION,
1157                                    act, "Invalid action.");
1158                 return -rte_errno;
1159         }
1160
1161         return 0;
1162 }
1163
1164 static int
1165 i40e_flow_parse_fdir_filter(struct rte_eth_dev *dev,
1166                             const struct rte_flow_attr *attr,
1167                             const struct rte_flow_item pattern[],
1168                             const struct rte_flow_action actions[],
1169                             struct rte_flow_error *error,
1170                             union i40e_filter_t *filter)
1171 {
1172         struct rte_eth_fdir_filter *fdir_filter =
1173                 &filter->fdir_filter;
1174         int ret;
1175
1176         ret = i40e_flow_parse_fdir_pattern(dev, pattern, error, fdir_filter);
1177         if (ret)
1178                 return ret;
1179
1180         ret = i40e_flow_parse_fdir_action(dev, actions, error, fdir_filter);
1181         if (ret)
1182                 return ret;
1183
1184         ret = i40e_flow_parse_attr(attr, error);
1185         if (ret)
1186                 return ret;
1187
1188         cons_filter_type = RTE_ETH_FILTER_FDIR;
1189
1190         if (dev->data->dev_conf.fdir_conf.mode !=
1191             RTE_FDIR_MODE_PERFECT) {
1192                 rte_flow_error_set(error, ENOTSUP,
1193                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1194                                    NULL,
1195                                    "Check the mode in fdir_conf.");
1196                 return -rte_errno;
1197         }
1198
1199         return 0;
1200 }
1201
1202 /* Parse to get the action info of a tunnel filter
1203  * Tunnel action only supports PF, VF and QUEUE.
1204  */
1205 static int
1206 i40e_flow_parse_tunnel_action(struct rte_eth_dev *dev,
1207                               const struct rte_flow_action *actions,
1208                               struct rte_flow_error *error,
1209                               struct i40e_tunnel_filter_conf *filter)
1210 {
1211         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
1212         const struct rte_flow_action *act;
1213         const struct rte_flow_action_queue *act_q;
1214         const struct rte_flow_action_vf *act_vf;
1215         uint32_t index = 0;
1216
1217         /* Check if the first non-void action is PF or VF. */
1218         NEXT_ITEM_OF_ACTION(act, actions, index);
1219         if (act->type != RTE_FLOW_ACTION_TYPE_PF &&
1220             act->type != RTE_FLOW_ACTION_TYPE_VF) {
1221                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1222                                    act, "Not supported action.");
1223                 return -rte_errno;
1224         }
1225
1226         if (act->type == RTE_FLOW_ACTION_TYPE_VF) {
1227                 act_vf = (const struct rte_flow_action_vf *)act->conf;
1228                 filter->vf_id = act_vf->id;
1229                 filter->is_to_vf = 1;
1230                 if (filter->vf_id >= pf->vf_num) {
1231                         rte_flow_error_set(error, EINVAL,
1232                                    RTE_FLOW_ERROR_TYPE_ACTION,
1233                                    act, "Invalid VF ID for tunnel filter");
1234                         return -rte_errno;
1235                 }
1236         }
1237
1238         /* Check if the next non-void item is QUEUE */
1239         index++;
1240         NEXT_ITEM_OF_ACTION(act, actions, index);
1241         if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
1242                 act_q = (const struct rte_flow_action_queue *)act->conf;
1243                 filter->queue_id = act_q->index;
1244                 if ((!filter->is_to_vf) &&
1245                     (filter->queue_id >= pf->dev_data->nb_rx_queues)) {
1246                         rte_flow_error_set(error, EINVAL,
1247                                    RTE_FLOW_ERROR_TYPE_ACTION,
1248                                    act, "Invalid queue ID for tunnel filter");
1249                         return -rte_errno;
1250                 } else if (filter->is_to_vf &&
1251                            (filter->queue_id >= pf->vf_nb_qps)) {
1252                         rte_flow_error_set(error, EINVAL,
1253                                    RTE_FLOW_ERROR_TYPE_ACTION,
1254                                    act, "Invalid queue ID for tunnel filter");
1255                         return -rte_errno;
1256                 }
1257         }
1258
1259         /* Check if the next non-void item is END */
1260         index++;
1261         NEXT_ITEM_OF_ACTION(act, actions, index);
1262         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1263                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1264                                    act, "Not supported action.");
1265                 return -rte_errno;
1266         }
1267
1268         return 0;
1269 }
1270
1271 static uint16_t i40e_supported_tunnel_filter_types[] = {
1272         ETH_TUNNEL_FILTER_IMAC | ETH_TUNNEL_FILTER_TENID |
1273         ETH_TUNNEL_FILTER_IVLAN,
1274         ETH_TUNNEL_FILTER_IMAC | ETH_TUNNEL_FILTER_IVLAN,
1275         ETH_TUNNEL_FILTER_IMAC | ETH_TUNNEL_FILTER_TENID,
1276         ETH_TUNNEL_FILTER_OMAC | ETH_TUNNEL_FILTER_TENID |
1277         ETH_TUNNEL_FILTER_IMAC,
1278         ETH_TUNNEL_FILTER_IMAC,
1279 };
1280
1281 static int
1282 i40e_check_tunnel_filter_type(uint8_t filter_type)
1283 {
1284         uint8_t i;
1285
1286         for (i = 0; i < RTE_DIM(i40e_supported_tunnel_filter_types); i++) {
1287                 if (filter_type == i40e_supported_tunnel_filter_types[i])
1288                         return 0;
1289         }
1290
1291         return -1;
1292 }
1293
1294 /* 1. Last in item should be NULL as range is not supported.
1295  * 2. Supported filter types: IMAC_IVLAN_TENID, IMAC_IVLAN,
1296  *    IMAC_TENID, OMAC_TENID_IMAC and IMAC.
1297  * 3. Mask of fields which need to be matched should be
1298  *    filled with 1.
1299  * 4. Mask of fields which needn't to be matched should be
1300  *    filled with 0.
1301  */
1302 static int
1303 i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev,
1304                               const struct rte_flow_item *pattern,
1305                               struct rte_flow_error *error,
1306                               struct i40e_tunnel_filter_conf *filter)
1307 {
1308         const struct rte_flow_item *item = pattern;
1309         const struct rte_flow_item_eth *eth_spec;
1310         const struct rte_flow_item_eth *eth_mask;
1311         const struct rte_flow_item_vxlan *vxlan_spec;
1312         const struct rte_flow_item_vxlan *vxlan_mask;
1313         const struct rte_flow_item_vlan *vlan_spec;
1314         const struct rte_flow_item_vlan *vlan_mask;
1315         uint8_t filter_type = 0;
1316         bool is_vni_masked = 0;
1317         uint8_t vni_mask[] = {0xFF, 0xFF, 0xFF};
1318         enum rte_flow_item_type item_type;
1319         bool vxlan_flag = 0;
1320         uint32_t tenant_id_be = 0;
1321         int ret;
1322
1323         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
1324                 if (item->last) {
1325                         rte_flow_error_set(error, EINVAL,
1326                                            RTE_FLOW_ERROR_TYPE_ITEM,
1327                                            item,
1328                                            "Not support range");
1329                         return -rte_errno;
1330                 }
1331                 item_type = item->type;
1332                 switch (item_type) {
1333                 case RTE_FLOW_ITEM_TYPE_ETH:
1334                         eth_spec = (const struct rte_flow_item_eth *)item->spec;
1335                         eth_mask = (const struct rte_flow_item_eth *)item->mask;
1336
1337                         /* Check if ETH item is used for place holder.
1338                          * If yes, both spec and mask should be NULL.
1339                          * If no, both spec and mask shouldn't be NULL.
1340                          */
1341                         if ((!eth_spec && eth_mask) ||
1342                             (eth_spec && !eth_mask)) {
1343                                 rte_flow_error_set(error, EINVAL,
1344                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1345                                                    item,
1346                                                    "Invalid ether spec/mask");
1347                                 return -rte_errno;
1348                         }
1349
1350                         if (eth_spec && eth_mask) {
1351                                 /* DST address of inner MAC shouldn't be masked.
1352                                  * SRC address of Inner MAC should be masked.
1353                                  */
1354                                 if (!is_broadcast_ether_addr(&eth_mask->dst) ||
1355                                     !is_zero_ether_addr(&eth_mask->src) ||
1356                                     eth_mask->type) {
1357                                         rte_flow_error_set(error, EINVAL,
1358                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1359                                                    item,
1360                                                    "Invalid ether spec/mask");
1361                                         return -rte_errno;
1362                                 }
1363
1364                                 if (!vxlan_flag) {
1365                                         rte_memcpy(&filter->outer_mac,
1366                                                    &eth_spec->dst,
1367                                                    ETHER_ADDR_LEN);
1368                                         filter_type |= ETH_TUNNEL_FILTER_OMAC;
1369                                 } else {
1370                                         rte_memcpy(&filter->inner_mac,
1371                                                    &eth_spec->dst,
1372                                                    ETHER_ADDR_LEN);
1373                                         filter_type |= ETH_TUNNEL_FILTER_IMAC;
1374                                 }
1375                         }
1376                         break;
1377                 case RTE_FLOW_ITEM_TYPE_VLAN:
1378                         vlan_spec =
1379                                 (const struct rte_flow_item_vlan *)item->spec;
1380                         vlan_mask =
1381                                 (const struct rte_flow_item_vlan *)item->mask;
1382                         if (!(vlan_spec && vlan_mask)) {
1383                                 rte_flow_error_set(error, EINVAL,
1384                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1385                                                    item,
1386                                                    "Invalid vlan item");
1387                                 return -rte_errno;
1388                         }
1389
1390                         if (vlan_spec && vlan_mask) {
1391                                 if (vlan_mask->tci ==
1392                                     rte_cpu_to_be_16(I40E_TCI_MASK))
1393                                         filter->inner_vlan =
1394                                               rte_be_to_cpu_16(vlan_spec->tci) &
1395                                               I40E_TCI_MASK;
1396                                 filter_type |= ETH_TUNNEL_FILTER_IVLAN;
1397                         }
1398                         break;
1399                 case RTE_FLOW_ITEM_TYPE_IPV4:
1400                         filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
1401                         /* IPv4 is used to describe protocol,
1402                          * spec and mask should be NULL.
1403                          */
1404                         if (item->spec || item->mask) {
1405                                 rte_flow_error_set(error, EINVAL,
1406                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1407                                                    item,
1408                                                    "Invalid IPv4 item");
1409                                 return -rte_errno;
1410                         }
1411                         break;
1412                 case RTE_FLOW_ITEM_TYPE_IPV6:
1413                         filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
1414                         /* IPv6 is used to describe protocol,
1415                          * spec and mask should be NULL.
1416                          */
1417                         if (item->spec || item->mask) {
1418                                 rte_flow_error_set(error, EINVAL,
1419                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1420                                                    item,
1421                                                    "Invalid IPv6 item");
1422                                 return -rte_errno;
1423                         }
1424                         break;
1425                 case RTE_FLOW_ITEM_TYPE_UDP:
1426                         /* UDP is used to describe protocol,
1427                          * spec and mask should be NULL.
1428                          */
1429                         if (item->spec || item->mask) {
1430                                 rte_flow_error_set(error, EINVAL,
1431                                            RTE_FLOW_ERROR_TYPE_ITEM,
1432                                            item,
1433                                            "Invalid UDP item");
1434                                 return -rte_errno;
1435                         }
1436                         break;
1437                 case RTE_FLOW_ITEM_TYPE_VXLAN:
1438                         vxlan_spec =
1439                                 (const struct rte_flow_item_vxlan *)item->spec;
1440                         vxlan_mask =
1441                                 (const struct rte_flow_item_vxlan *)item->mask;
1442                         /* Check if VXLAN item is used to describe protocol.
1443                          * If yes, both spec and mask should be NULL.
1444                          * If no, both spec and mask shouldn't be NULL.
1445                          */
1446                         if ((!vxlan_spec && vxlan_mask) ||
1447                             (vxlan_spec && !vxlan_mask)) {
1448                                 rte_flow_error_set(error, EINVAL,
1449                                            RTE_FLOW_ERROR_TYPE_ITEM,
1450                                            item,
1451                                            "Invalid VXLAN item");
1452                                 return -rte_errno;
1453                         }
1454
1455                         /* Check if VNI is masked. */
1456                         if (vxlan_spec && vxlan_mask) {
1457                                 is_vni_masked =
1458                                         !!memcmp(vxlan_mask->vni, vni_mask,
1459                                                  RTE_DIM(vni_mask));
1460                                 if (is_vni_masked) {
1461                                         rte_flow_error_set(error, EINVAL,
1462                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1463                                                    item,
1464                                                    "Invalid VNI mask");
1465                                         return -rte_errno;
1466                                 }
1467
1468                                 rte_memcpy(((uint8_t *)&tenant_id_be + 1),
1469                                            vxlan_spec->vni, 3);
1470                                 filter->tenant_id =
1471                                         rte_be_to_cpu_32(tenant_id_be);
1472                                 filter_type |= ETH_TUNNEL_FILTER_TENID;
1473                         }
1474
1475                         vxlan_flag = 1;
1476                         break;
1477                 default:
1478                         break;
1479                 }
1480         }
1481
1482         ret = i40e_check_tunnel_filter_type(filter_type);
1483         if (ret < 0) {
1484                 rte_flow_error_set(error, EINVAL,
1485                                    RTE_FLOW_ERROR_TYPE_ITEM,
1486                                    NULL,
1487                                    "Invalid filter type");
1488                 return -rte_errno;
1489         }
1490         filter->filter_type = filter_type;
1491
1492         filter->tunnel_type = I40E_TUNNEL_TYPE_VXLAN;
1493
1494         return 0;
1495 }
1496
1497 static int
1498 i40e_flow_parse_vxlan_filter(struct rte_eth_dev *dev,
1499                              const struct rte_flow_attr *attr,
1500                              const struct rte_flow_item pattern[],
1501                              const struct rte_flow_action actions[],
1502                              struct rte_flow_error *error,
1503                              union i40e_filter_t *filter)
1504 {
1505         struct i40e_tunnel_filter_conf *tunnel_filter =
1506                 &filter->consistent_tunnel_filter;
1507         int ret;
1508
1509         ret = i40e_flow_parse_vxlan_pattern(dev, pattern,
1510                                             error, tunnel_filter);
1511         if (ret)
1512                 return ret;
1513
1514         ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
1515         if (ret)
1516                 return ret;
1517
1518         ret = i40e_flow_parse_attr(attr, error);
1519         if (ret)
1520                 return ret;
1521
1522         cons_filter_type = RTE_ETH_FILTER_TUNNEL;
1523
1524         return ret;
1525 }
1526
1527 /* 1. Last in item should be NULL as range is not supported.
1528  * 2. Supported filter types: MPLS label.
1529  * 3. Mask of fields which need to be matched should be
1530  *    filled with 1.
1531  * 4. Mask of fields which needn't to be matched should be
1532  *    filled with 0.
1533  */
1534 static int
1535 i40e_flow_parse_mpls_pattern(__rte_unused struct rte_eth_dev *dev,
1536                              const struct rte_flow_item *pattern,
1537                              struct rte_flow_error *error,
1538                              struct i40e_tunnel_filter_conf *filter)
1539 {
1540         const struct rte_flow_item *item = pattern;
1541         const struct rte_flow_item_mpls *mpls_spec;
1542         const struct rte_flow_item_mpls *mpls_mask;
1543         enum rte_flow_item_type item_type;
1544         bool is_mplsoudp = 0; /* 1 - MPLSoUDP, 0 - MPLSoGRE */
1545         const uint8_t label_mask[3] = {0xFF, 0xFF, 0xF0};
1546         uint32_t label_be = 0;
1547
1548         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
1549                 if (item->last) {
1550                         rte_flow_error_set(error, EINVAL,
1551                                            RTE_FLOW_ERROR_TYPE_ITEM,
1552                                            item,
1553                                            "Not support range");
1554                         return -rte_errno;
1555                 }
1556                 item_type = item->type;
1557                 switch (item_type) {
1558                 case RTE_FLOW_ITEM_TYPE_ETH:
1559                         if (item->spec || item->mask) {
1560                                 rte_flow_error_set(error, EINVAL,
1561                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1562                                                    item,
1563                                                    "Invalid ETH item");
1564                                 return -rte_errno;
1565                         }
1566                         break;
1567                 case RTE_FLOW_ITEM_TYPE_IPV4:
1568                         filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
1569                         /* IPv4 is used to describe protocol,
1570                          * spec and mask should be NULL.
1571                          */
1572                         if (item->spec || item->mask) {
1573                                 rte_flow_error_set(error, EINVAL,
1574                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1575                                                    item,
1576                                                    "Invalid IPv4 item");
1577                                 return -rte_errno;
1578                         }
1579                         break;
1580                 case RTE_FLOW_ITEM_TYPE_IPV6:
1581                         filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
1582                         /* IPv6 is used to describe protocol,
1583                          * spec and mask should be NULL.
1584                          */
1585                         if (item->spec || item->mask) {
1586                                 rte_flow_error_set(error, EINVAL,
1587                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1588                                                    item,
1589                                                    "Invalid IPv6 item");
1590                                 return -rte_errno;
1591                         }
1592                         break;
1593                 case RTE_FLOW_ITEM_TYPE_UDP:
1594                         /* UDP is used to describe protocol,
1595                          * spec and mask should be NULL.
1596                          */
1597                         if (item->spec || item->mask) {
1598                                 rte_flow_error_set(error, EINVAL,
1599                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1600                                                    item,
1601                                                    "Invalid UDP item");
1602                                 return -rte_errno;
1603                         }
1604                         is_mplsoudp = 1;
1605                         break;
1606                 case RTE_FLOW_ITEM_TYPE_GRE:
1607                         /* GRE is used to describe protocol,
1608                          * spec and mask should be NULL.
1609                          */
1610                         if (item->spec || item->mask) {
1611                                 rte_flow_error_set(error, EINVAL,
1612                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1613                                                    item,
1614                                                    "Invalid GRE item");
1615                                 return -rte_errno;
1616                         }
1617                         break;
1618                 case RTE_FLOW_ITEM_TYPE_MPLS:
1619                         mpls_spec =
1620                                 (const struct rte_flow_item_mpls *)item->spec;
1621                         mpls_mask =
1622                                 (const struct rte_flow_item_mpls *)item->mask;
1623
1624                         if (!mpls_spec || !mpls_mask) {
1625                                 rte_flow_error_set(error, EINVAL,
1626                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1627                                                    item,
1628                                                    "Invalid MPLS item");
1629                                 return -rte_errno;
1630                         }
1631
1632                         if (memcmp(mpls_mask->label_tc_s, label_mask, 3)) {
1633                                 rte_flow_error_set(error, EINVAL,
1634                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1635                                                    item,
1636                                                    "Invalid MPLS label mask");
1637                                 return -rte_errno;
1638                         }
1639                         rte_memcpy(((uint8_t *)&label_be + 1),
1640                                    mpls_spec->label_tc_s, 3);
1641                         filter->tenant_id = rte_be_to_cpu_32(label_be) >> 4;
1642                         break;
1643                 default:
1644                         break;
1645                 }
1646         }
1647
1648         if (is_mplsoudp)
1649                 filter->tunnel_type = I40E_TUNNEL_TYPE_MPLSoUDP;
1650         else
1651                 filter->tunnel_type = I40E_TUNNEL_TYPE_MPLSoGRE;
1652
1653         return 0;
1654 }
1655
1656 static int
1657 i40e_flow_parse_mpls_filter(struct rte_eth_dev *dev,
1658                             const struct rte_flow_attr *attr,
1659                             const struct rte_flow_item pattern[],
1660                             const struct rte_flow_action actions[],
1661                             struct rte_flow_error *error,
1662                             union i40e_filter_t *filter)
1663 {
1664         struct i40e_tunnel_filter_conf *tunnel_filter =
1665                 &filter->consistent_tunnel_filter;
1666         int ret;
1667
1668         ret = i40e_flow_parse_mpls_pattern(dev, pattern,
1669                                            error, tunnel_filter);
1670         if (ret)
1671                 return ret;
1672
1673         ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
1674         if (ret)
1675                 return ret;
1676
1677         ret = i40e_flow_parse_attr(attr, error);
1678         if (ret)
1679                 return ret;
1680
1681         cons_filter_type = RTE_ETH_FILTER_TUNNEL;
1682
1683         return ret;
1684 }
1685
1686 /* 1. Last in item should be NULL as range is not supported.
1687  * 2. Supported filter types: QINQ.
1688  * 3. Mask of fields which need to be matched should be
1689  *    filled with 1.
1690  * 4. Mask of fields which needn't to be matched should be
1691  *    filled with 0.
1692  */
1693 static int
1694 i40e_flow_parse_qinq_pattern(__rte_unused struct rte_eth_dev *dev,
1695                               const struct rte_flow_item *pattern,
1696                               struct rte_flow_error *error,
1697                               struct i40e_tunnel_filter_conf *filter)
1698 {
1699         const struct rte_flow_item *item = pattern;
1700         const struct rte_flow_item_vlan *vlan_spec = NULL;
1701         const struct rte_flow_item_vlan *vlan_mask = NULL;
1702         const struct rte_flow_item_vlan *i_vlan_spec = NULL;
1703         const struct rte_flow_item_vlan *i_vlan_mask = NULL;
1704         const struct rte_flow_item_vlan *o_vlan_spec = NULL;
1705         const struct rte_flow_item_vlan *o_vlan_mask = NULL;
1706
1707         enum rte_flow_item_type item_type;
1708         bool vlan_flag = 0;
1709
1710         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
1711                 if (item->last) {
1712                         rte_flow_error_set(error, EINVAL,
1713                                            RTE_FLOW_ERROR_TYPE_ITEM,
1714                                            item,
1715                                            "Not support range");
1716                         return -rte_errno;
1717                 }
1718                 item_type = item->type;
1719                 switch (item_type) {
1720                 case RTE_FLOW_ITEM_TYPE_ETH:
1721                         if (item->spec || item->mask) {
1722                                 rte_flow_error_set(error, EINVAL,
1723                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1724                                                    item,
1725                                                    "Invalid ETH item");
1726                                 return -rte_errno;
1727                         }
1728                         break;
1729                 case RTE_FLOW_ITEM_TYPE_VLAN:
1730                         vlan_spec =
1731                                 (const struct rte_flow_item_vlan *)item->spec;
1732                         vlan_mask =
1733                                 (const struct rte_flow_item_vlan *)item->mask;
1734
1735                         if (!(vlan_spec && vlan_mask)) {
1736                                 rte_flow_error_set(error, EINVAL,
1737                                            RTE_FLOW_ERROR_TYPE_ITEM,
1738                                            item,
1739                                            "Invalid vlan item");
1740                                 return -rte_errno;
1741                         }
1742
1743                         if (!vlan_flag) {
1744                                 o_vlan_spec = vlan_spec;
1745                                 o_vlan_mask = vlan_mask;
1746                                 vlan_flag = 1;
1747                         } else {
1748                                 i_vlan_spec = vlan_spec;
1749                                 i_vlan_mask = vlan_mask;
1750                                 vlan_flag = 0;
1751                         }
1752                         break;
1753
1754                 default:
1755                         break;
1756                 }
1757         }
1758
1759         /* Get filter specification */
1760         if ((o_vlan_mask->tci == rte_cpu_to_be_16(I40E_TCI_MASK)) &&
1761             (i_vlan_mask->tci == rte_cpu_to_be_16(I40E_TCI_MASK))) {
1762                 filter->outer_vlan = rte_be_to_cpu_16(o_vlan_spec->tci)
1763                         & I40E_TCI_MASK;
1764                 filter->inner_vlan = rte_be_to_cpu_16(i_vlan_spec->tci)
1765                         & I40E_TCI_MASK;
1766         } else {
1767                         rte_flow_error_set(error, EINVAL,
1768                                            RTE_FLOW_ERROR_TYPE_ITEM,
1769                                            NULL,
1770                                            "Invalid filter type");
1771                         return -rte_errno;
1772         }
1773
1774         filter->tunnel_type = I40E_TUNNEL_TYPE_QINQ;
1775         return 0;
1776 }
1777
1778 static int
1779 i40e_flow_parse_qinq_filter(struct rte_eth_dev *dev,
1780                               const struct rte_flow_attr *attr,
1781                               const struct rte_flow_item pattern[],
1782                               const struct rte_flow_action actions[],
1783                               struct rte_flow_error *error,
1784                               union i40e_filter_t *filter)
1785 {
1786         struct i40e_tunnel_filter_conf *tunnel_filter =
1787                 &filter->consistent_tunnel_filter;
1788         int ret;
1789
1790         ret = i40e_flow_parse_qinq_pattern(dev, pattern,
1791                                              error, tunnel_filter);
1792         if (ret)
1793                 return ret;
1794
1795         ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
1796         if (ret)
1797                 return ret;
1798
1799         ret = i40e_flow_parse_attr(attr, error);
1800         if (ret)
1801                 return ret;
1802
1803         cons_filter_type = RTE_ETH_FILTER_TUNNEL;
1804
1805         return ret;
1806 }
1807
1808 static int
1809 i40e_flow_validate(struct rte_eth_dev *dev,
1810                    const struct rte_flow_attr *attr,
1811                    const struct rte_flow_item pattern[],
1812                    const struct rte_flow_action actions[],
1813                    struct rte_flow_error *error)
1814 {
1815         struct rte_flow_item *items; /* internal pattern w/o VOID items */
1816         parse_filter_t parse_filter;
1817         uint32_t item_num = 0; /* non-void item number of pattern*/
1818         uint32_t i = 0;
1819         int ret;
1820
1821         if (!pattern) {
1822                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1823                                    NULL, "NULL pattern.");
1824                 return -rte_errno;
1825         }
1826
1827         if (!actions) {
1828                 rte_flow_error_set(error, EINVAL,
1829                                    RTE_FLOW_ERROR_TYPE_ACTION_NUM,
1830                                    NULL, "NULL action.");
1831                 return -rte_errno;
1832         }
1833
1834         if (!attr) {
1835                 rte_flow_error_set(error, EINVAL,
1836                                    RTE_FLOW_ERROR_TYPE_ATTR,
1837                                    NULL, "NULL attribute.");
1838                 return -rte_errno;
1839         }
1840
1841         memset(&cons_filter, 0, sizeof(cons_filter));
1842
1843         /* Get the non-void item number of pattern */
1844         while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) {
1845                 if ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_VOID)
1846                         item_num++;
1847                 i++;
1848         }
1849         item_num++;
1850
1851         items = rte_zmalloc("i40e_pattern",
1852                             item_num * sizeof(struct rte_flow_item), 0);
1853         if (!items) {
1854                 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1855                                    NULL, "No memory for PMD internal items.");
1856                 return -ENOMEM;
1857         }
1858
1859         i40e_pattern_skip_void_item(items, pattern);
1860
1861         /* Find if there's matched parse filter function */
1862         parse_filter = i40e_find_parse_filter_func(items);
1863         if (!parse_filter) {
1864                 rte_flow_error_set(error, EINVAL,
1865                                    RTE_FLOW_ERROR_TYPE_ITEM,
1866                                    pattern, "Unsupported pattern");
1867                 return -rte_errno;
1868         }
1869
1870         ret = parse_filter(dev, attr, items, actions, error, &cons_filter);
1871
1872         rte_free(items);
1873
1874         return ret;
1875 }
1876
1877 static struct rte_flow *
1878 i40e_flow_create(struct rte_eth_dev *dev,
1879                  const struct rte_flow_attr *attr,
1880                  const struct rte_flow_item pattern[],
1881                  const struct rte_flow_action actions[],
1882                  struct rte_flow_error *error)
1883 {
1884         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
1885         struct rte_flow *flow;
1886         int ret;
1887
1888         flow = rte_zmalloc("i40e_flow", sizeof(struct rte_flow), 0);
1889         if (!flow) {
1890                 rte_flow_error_set(error, ENOMEM,
1891                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1892                                    "Failed to allocate memory");
1893                 return flow;
1894         }
1895
1896         ret = i40e_flow_validate(dev, attr, pattern, actions, error);
1897         if (ret < 0)
1898                 return NULL;
1899
1900         switch (cons_filter_type) {
1901         case RTE_ETH_FILTER_ETHERTYPE:
1902                 ret = i40e_ethertype_filter_set(pf,
1903                                         &cons_filter.ethertype_filter, 1);
1904                 if (ret)
1905                         goto free_flow;
1906                 flow->rule = TAILQ_LAST(&pf->ethertype.ethertype_list,
1907                                         i40e_ethertype_filter_list);
1908                 break;
1909         case RTE_ETH_FILTER_FDIR:
1910                 ret = i40e_add_del_fdir_filter(dev,
1911                                        &cons_filter.fdir_filter, 1);
1912                 if (ret)
1913                         goto free_flow;
1914                 flow->rule = TAILQ_LAST(&pf->fdir.fdir_list,
1915                                         i40e_fdir_filter_list);
1916                 break;
1917         case RTE_ETH_FILTER_TUNNEL:
1918                 ret = i40e_dev_consistent_tunnel_filter_set(pf,
1919                             &cons_filter.consistent_tunnel_filter, 1);
1920                 if (ret)
1921                         goto free_flow;
1922                 flow->rule = TAILQ_LAST(&pf->tunnel.tunnel_list,
1923                                         i40e_tunnel_filter_list);
1924                 break;
1925         default:
1926                 goto free_flow;
1927         }
1928
1929         flow->filter_type = cons_filter_type;
1930         TAILQ_INSERT_TAIL(&pf->flow_list, flow, node);
1931         return flow;
1932
1933 free_flow:
1934         rte_flow_error_set(error, -ret,
1935                            RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1936                            "Failed to create flow.");
1937         rte_free(flow);
1938         return NULL;
1939 }
1940
1941 static int
1942 i40e_flow_destroy(struct rte_eth_dev *dev,
1943                   struct rte_flow *flow,
1944                   struct rte_flow_error *error)
1945 {
1946         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
1947         enum rte_filter_type filter_type = flow->filter_type;
1948         int ret = 0;
1949
1950         switch (filter_type) {
1951         case RTE_ETH_FILTER_ETHERTYPE:
1952                 ret = i40e_flow_destroy_ethertype_filter(pf,
1953                          (struct i40e_ethertype_filter *)flow->rule);
1954                 break;
1955         case RTE_ETH_FILTER_TUNNEL:
1956                 ret = i40e_flow_destroy_tunnel_filter(pf,
1957                               (struct i40e_tunnel_filter *)flow->rule);
1958                 break;
1959         case RTE_ETH_FILTER_FDIR:
1960                 ret = i40e_add_del_fdir_filter(dev,
1961                        &((struct i40e_fdir_filter *)flow->rule)->fdir, 0);
1962                 break;
1963         default:
1964                 PMD_DRV_LOG(WARNING, "Filter type (%d) not supported",
1965                             filter_type);
1966                 ret = -EINVAL;
1967                 break;
1968         }
1969
1970         if (!ret) {
1971                 TAILQ_REMOVE(&pf->flow_list, flow, node);
1972                 rte_free(flow);
1973         } else
1974                 rte_flow_error_set(error, -ret,
1975                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1976                                    "Failed to destroy flow.");
1977
1978         return ret;
1979 }
1980
1981 static int
1982 i40e_flow_destroy_ethertype_filter(struct i40e_pf *pf,
1983                                    struct i40e_ethertype_filter *filter)
1984 {
1985         struct i40e_hw *hw = I40E_PF_TO_HW(pf);
1986         struct i40e_ethertype_rule *ethertype_rule = &pf->ethertype;
1987         struct i40e_ethertype_filter *node;
1988         struct i40e_control_filter_stats stats;
1989         uint16_t flags = 0;
1990         int ret = 0;
1991
1992         if (!(filter->flags & RTE_ETHTYPE_FLAGS_MAC))
1993                 flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_IGNORE_MAC;
1994         if (filter->flags & RTE_ETHTYPE_FLAGS_DROP)
1995                 flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_DROP;
1996         flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TO_QUEUE;
1997
1998         memset(&stats, 0, sizeof(stats));
1999         ret = i40e_aq_add_rem_control_packet_filter(hw,
2000                                     filter->input.mac_addr.addr_bytes,
2001                                     filter->input.ether_type,
2002                                     flags, pf->main_vsi->seid,
2003                                     filter->queue, 0, &stats, NULL);
2004         if (ret < 0)
2005                 return ret;
2006
2007         node = i40e_sw_ethertype_filter_lookup(ethertype_rule, &filter->input);
2008         if (!node)
2009                 return -EINVAL;
2010
2011         ret = i40e_sw_ethertype_filter_del(pf, &node->input);
2012
2013         return ret;
2014 }
2015
2016 static int
2017 i40e_flow_destroy_tunnel_filter(struct i40e_pf *pf,
2018                                 struct i40e_tunnel_filter *filter)
2019 {
2020         struct i40e_hw *hw = I40E_PF_TO_HW(pf);
2021         struct i40e_vsi *vsi;
2022         struct i40e_pf_vf *vf;
2023         struct i40e_aqc_add_rm_cloud_filt_elem_ext cld_filter;
2024         struct i40e_tunnel_rule *tunnel_rule = &pf->tunnel;
2025         struct i40e_tunnel_filter *node;
2026         bool big_buffer = 0;
2027         int ret = 0;
2028
2029         memset(&cld_filter, 0, sizeof(cld_filter));
2030         ether_addr_copy((struct ether_addr *)&filter->input.outer_mac,
2031                         (struct ether_addr *)&cld_filter.element.outer_mac);
2032         ether_addr_copy((struct ether_addr *)&filter->input.inner_mac,
2033                         (struct ether_addr *)&cld_filter.element.inner_mac);
2034         cld_filter.element.inner_vlan = filter->input.inner_vlan;
2035         cld_filter.element.flags = filter->input.flags;
2036         cld_filter.element.tenant_id = filter->input.tenant_id;
2037         cld_filter.element.queue_number = filter->queue;
2038         rte_memcpy(cld_filter.general_fields,
2039                    filter->input.general_fields,
2040                    sizeof(cld_filter.general_fields));
2041
2042         if (!filter->is_to_vf)
2043                 vsi = pf->main_vsi;
2044         else {
2045                 vf = &pf->vfs[filter->vf_id];
2046                 vsi = vf->vsi;
2047         }
2048
2049         if (((filter->input.flags & I40E_AQC_ADD_CLOUD_FILTER_TEID_MPLSoUDP) ==
2050             I40E_AQC_ADD_CLOUD_FILTER_TEID_MPLSoUDP) ||
2051             ((filter->input.flags & I40E_AQC_ADD_CLOUD_FILTER_TEID_MPLSoGRE) ==
2052             I40E_AQC_ADD_CLOUD_FILTER_TEID_MPLSoGRE) ||
2053             ((filter->input.flags & I40E_AQC_ADD_CLOUD_FILTER_CUSTOM_QINQ) ==
2054             I40E_AQC_ADD_CLOUD_FILTER_CUSTOM_QINQ))
2055                 big_buffer = 1;
2056
2057         if (big_buffer)
2058                 ret = i40e_aq_remove_cloud_filters_big_buffer(hw, vsi->seid,
2059                                                               &cld_filter, 1);
2060         else
2061                 ret = i40e_aq_remove_cloud_filters(hw, vsi->seid,
2062                                                    &cld_filter.element, 1);
2063         if (ret < 0)
2064                 return -ENOTSUP;
2065
2066         node = i40e_sw_tunnel_filter_lookup(tunnel_rule, &filter->input);
2067         if (!node)
2068                 return -EINVAL;
2069
2070         ret = i40e_sw_tunnel_filter_del(pf, &node->input);
2071
2072         return ret;
2073 }
2074
2075 static int
2076 i40e_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
2077 {
2078         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
2079         int ret;
2080
2081         ret = i40e_flow_flush_fdir_filter(pf);
2082         if (ret) {
2083                 rte_flow_error_set(error, -ret,
2084                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
2085                                    "Failed to flush FDIR flows.");
2086                 return -rte_errno;
2087         }
2088
2089         ret = i40e_flow_flush_ethertype_filter(pf);
2090         if (ret) {
2091                 rte_flow_error_set(error, -ret,
2092                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
2093                                    "Failed to ethertype flush flows.");
2094                 return -rte_errno;
2095         }
2096
2097         ret = i40e_flow_flush_tunnel_filter(pf);
2098         if (ret) {
2099                 rte_flow_error_set(error, -ret,
2100                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
2101                                    "Failed to flush tunnel flows.");
2102                 return -rte_errno;
2103         }
2104
2105         return ret;
2106 }
2107
2108 static int
2109 i40e_flow_flush_fdir_filter(struct i40e_pf *pf)
2110 {
2111         struct rte_eth_dev *dev = pf->adapter->eth_dev;
2112         struct i40e_fdir_info *fdir_info = &pf->fdir;
2113         struct i40e_fdir_filter *fdir_filter;
2114         struct rte_flow *flow;
2115         void *temp;
2116         int ret;
2117
2118         ret = i40e_fdir_flush(dev);
2119         if (!ret) {
2120                 /* Delete FDIR filters in FDIR list. */
2121                 while ((fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list))) {
2122                         ret = i40e_sw_fdir_filter_del(pf,
2123                                                       &fdir_filter->fdir.input);
2124                         if (ret < 0)
2125                                 return ret;
2126                 }
2127
2128                 /* Delete FDIR flows in flow list. */
2129                 TAILQ_FOREACH_SAFE(flow, &pf->flow_list, node, temp) {
2130                         if (flow->filter_type == RTE_ETH_FILTER_FDIR) {
2131                                 TAILQ_REMOVE(&pf->flow_list, flow, node);
2132                                 rte_free(flow);
2133                         }
2134                 }
2135         }
2136
2137         return ret;
2138 }
2139
2140 /* Flush all ethertype filters */
2141 static int
2142 i40e_flow_flush_ethertype_filter(struct i40e_pf *pf)
2143 {
2144         struct i40e_ethertype_filter_list
2145                 *ethertype_list = &pf->ethertype.ethertype_list;
2146         struct i40e_ethertype_filter *filter;
2147         struct rte_flow *flow;
2148         void *temp;
2149         int ret = 0;
2150
2151         while ((filter = TAILQ_FIRST(ethertype_list))) {
2152                 ret = i40e_flow_destroy_ethertype_filter(pf, filter);
2153                 if (ret)
2154                         return ret;
2155         }
2156
2157         /* Delete ethertype flows in flow list. */
2158         TAILQ_FOREACH_SAFE(flow, &pf->flow_list, node, temp) {
2159                 if (flow->filter_type == RTE_ETH_FILTER_ETHERTYPE) {
2160                         TAILQ_REMOVE(&pf->flow_list, flow, node);
2161                         rte_free(flow);
2162                 }
2163         }
2164
2165         return ret;
2166 }
2167
2168 /* Flush all tunnel filters */
2169 static int
2170 i40e_flow_flush_tunnel_filter(struct i40e_pf *pf)
2171 {
2172         struct i40e_tunnel_filter_list
2173                 *tunnel_list = &pf->tunnel.tunnel_list;
2174         struct i40e_tunnel_filter *filter;
2175         struct rte_flow *flow;
2176         void *temp;
2177         int ret = 0;
2178
2179         while ((filter = TAILQ_FIRST(tunnel_list))) {
2180                 ret = i40e_flow_destroy_tunnel_filter(pf, filter);
2181                 if (ret)
2182                         return ret;
2183         }
2184
2185         /* Delete tunnel flows in flow list. */
2186         TAILQ_FOREACH_SAFE(flow, &pf->flow_list, node, temp) {
2187                 if (flow->filter_type == RTE_ETH_FILTER_TUNNEL) {
2188                         TAILQ_REMOVE(&pf->flow_list, flow, node);
2189                         rte_free(flow);
2190                 }
2191         }
2192
2193         return ret;
2194 }