drivers/net/iavf/iavf_hash.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2020 Intel Corporation
   3  */
   4
   5 #include <sys/queue.h>
   6 #include <stdio.h>
   7 #include <errno.h>
   8 #include <stdint.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include <stdarg.h>
  12
  13 #include <rte_debug.h>
  14 #include <rte_ether.h>
  15 #include <ethdev_driver.h>
  16 #include <rte_log.h>
  17 #include <rte_malloc.h>
  18 #include <rte_eth_ctrl.h>
  19 #include <rte_tailq.h>
  20 #include <rte_flow_driver.h>
  21
  22 #include "iavf_log.h"
  23 #include "iavf.h"
  24 #include "iavf_generic_flow.h"
  25
  26 #define IAVF_PHINT_NONE                         0
  27 #define IAVF_PHINT_GTPU                         BIT_ULL(0)
  28 #define IAVF_PHINT_GTPU_EH                      BIT_ULL(1)
  29 #define IAVF_PHINT_GTPU_EH_DWN                  BIT_ULL(2)
  30 #define IAVF_PHINT_GTPU_EH_UP                   BIT_ULL(3)
  31 #define IAVF_PHINT_OUTER_IPV4                   BIT_ULL(4)
  32 #define IAVF_PHINT_OUTER_IPV6                   BIT_ULL(5)
  33 #define IAVF_PHINT_GRE                          BIT_ULL(6)
  34 /* the second IP header of GTPoGRE */
  35 #define IAVF_PHINT_MID_IPV4                     BIT_ULL(7)
  36 #define IAVF_PHINT_MID_IPV6                     BIT_ULL(8)
  37 /* L2TPv2 */
  38 #define IAVF_PHINT_L2TPV2                       BIT_ULL(9)
  39
  40 #define IAVF_PHINT_GTPU_MSK     (IAVF_PHINT_GTPU        | \
  41                                  IAVF_PHINT_GTPU_EH     | \
  42                                  IAVF_PHINT_GTPU_EH_DWN | \
  43                                  IAVF_PHINT_GTPU_EH_UP)
  44
  45 #define IAVF_PHINT_LAYERS_MSK   (IAVF_PHINT_OUTER_IPV4  | \
  46                                  IAVF_PHINT_OUTER_IPV6)
  47
  48 #define IAVF_GTPU_EH_DWNLINK    0
  49 #define IAVF_GTPU_EH_UPLINK     1
  50
  51 struct iavf_hash_match_type {
  52         uint64_t hash_type;
  53         struct virtchnl_proto_hdrs *proto_hdrs;
  54         uint64_t pattern_hint;
  55 };
  56
  57 struct iavf_rss_meta {
  58         struct virtchnl_proto_hdrs proto_hdrs;
  59         enum virtchnl_rss_algorithm rss_algorithm;
  60 };
  61
  62 struct iavf_hash_flow_cfg {
  63         struct virtchnl_rss_cfg *rss_cfg;
  64         bool simple_xor;
  65 };
  66
  67 static int
  68 iavf_hash_init(struct iavf_adapter *ad);
  69 static int
  70 iavf_hash_create(struct iavf_adapter *ad, struct rte_flow *flow, void *meta,
  71                  struct rte_flow_error *error);
  72 static int
  73 iavf_hash_destroy(struct iavf_adapter *ad, struct rte_flow *flow,
  74                   struct rte_flow_error *error);
  75 static void
  76 iavf_hash_uninit(struct iavf_adapter *ad);
  77 static void
  78 iavf_hash_free(struct rte_flow *flow);
  79 static int
  80 iavf_hash_parse_pattern_action(struct iavf_adapter *ad,
  81                                struct iavf_pattern_match_item *array,
  82                                uint32_t array_len,
  83                                const struct rte_flow_item pattern[],
  84                                const struct rte_flow_action actions[],
  85                                void **meta,
  86                                struct rte_flow_error *error);
  87
  88 #define FIELD_SELECTOR(proto_hdr_field) \
  89                 (1UL << ((proto_hdr_field) & PROTO_HDR_FIELD_MASK))
  90 #define BUFF_NOUSED                     0
  91
  92 #define proto_hdr_eth { \
  93         VIRTCHNL_PROTO_HDR_ETH, \
  94         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ETH_SRC) | \
  95         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ETH_DST), {BUFF_NOUSED} }
  96
  97 #define proto_hdr_svlan { \
  98         VIRTCHNL_PROTO_HDR_S_VLAN, \
  99         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_S_VLAN_ID), {BUFF_NOUSED} }
 100
 101 #define proto_hdr_cvlan { \
 102         VIRTCHNL_PROTO_HDR_C_VLAN, \
 103         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_C_VLAN_ID), {BUFF_NOUSED} }
 104
 105 #define proto_hdr_ipv4 { \
 106         VIRTCHNL_PROTO_HDR_IPV4, \
 107         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) | \
 108         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST), {BUFF_NOUSED} }
 109
 110 #define proto_hdr_ipv4_with_prot { \
 111         VIRTCHNL_PROTO_HDR_IPV4, \
 112         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) | \
 113         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) | \
 114         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT), {BUFF_NOUSED} }
 115
 116 #define proto_hdr_ipv6 { \
 117         VIRTCHNL_PROTO_HDR_IPV6, \
 118         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_SRC) | \
 119         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_DST), {BUFF_NOUSED} }
 120
 121 #define proto_hdr_ipv6_frag { \
 122         VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG, \
 123         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG_PKID), {BUFF_NOUSED} }
 124
 125 #define proto_hdr_ipv6_with_prot { \
 126         VIRTCHNL_PROTO_HDR_IPV6, \
 127         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_SRC) | \
 128         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_DST) | \
 129         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PROT), {BUFF_NOUSED} }
 130
 131 #define proto_hdr_udp { \
 132         VIRTCHNL_PROTO_HDR_UDP, \
 133         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_SRC_PORT) | \
 134         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_DST_PORT), {BUFF_NOUSED} }
 135
 136 #define proto_hdr_tcp { \
 137         VIRTCHNL_PROTO_HDR_TCP, \
 138         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_SRC_PORT) | \
 139         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_DST_PORT), {BUFF_NOUSED} }
 140
 141 #define proto_hdr_sctp { \
 142         VIRTCHNL_PROTO_HDR_SCTP, \
 143         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT) | \
 144         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_DST_PORT), {BUFF_NOUSED} }
 145
 146 #define proto_hdr_esp { \
 147         VIRTCHNL_PROTO_HDR_ESP, \
 148         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ESP_SPI), {BUFF_NOUSED} }
 149
 150 #define proto_hdr_ah { \
 151         VIRTCHNL_PROTO_HDR_AH, \
 152         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_AH_SPI), {BUFF_NOUSED} }
 153
 154 #define proto_hdr_l2tpv3 { \
 155         VIRTCHNL_PROTO_HDR_L2TPV3, \
 156         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_L2TPV3_SESS_ID), {BUFF_NOUSED} }
 157
 158 #define proto_hdr_pfcp { \
 159         VIRTCHNL_PROTO_HDR_PFCP, \
 160         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_PFCP_SEID), {BUFF_NOUSED} }
 161
 162 #define proto_hdr_gtpc { \
 163         VIRTCHNL_PROTO_HDR_GTPC, 0, {BUFF_NOUSED} }
 164
 165 #define proto_hdr_ecpri { \
 166         VIRTCHNL_PROTO_HDR_ECPRI, \
 167         FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ECPRI_PC_RTC_ID), {BUFF_NOUSED} }
 168
 169 #define proto_hdr_l2tpv2 { \
 170         VIRTCHNL_PROTO_HDR_L2TPV2, 0, {BUFF_NOUSED} }
 171
 172 #define proto_hdr_ppp { \
 173         VIRTCHNL_PROTO_HDR_PPP, 0, {BUFF_NOUSED} }
 174
 175 #define TUNNEL_LEVEL_OUTER              0
 176 #define TUNNEL_LEVEL_INNER              1
 177
 178 /* proto_hdrs template */
 179 struct virtchnl_proto_hdrs outer_ipv4_tmplt = {
 180         TUNNEL_LEVEL_OUTER, 4,
 181         {proto_hdr_eth, proto_hdr_svlan, proto_hdr_cvlan, proto_hdr_ipv4}
 182 };
 183
 184 struct virtchnl_proto_hdrs outer_ipv4_udp_tmplt = {
 185         TUNNEL_LEVEL_OUTER, 5,
 186         {proto_hdr_eth, proto_hdr_svlan, proto_hdr_cvlan,
 187          proto_hdr_ipv4_with_prot,
 188          proto_hdr_udp}
 189 };
 190
 191 struct virtchnl_proto_hdrs outer_ipv4_tcp_tmplt = {
 192         TUNNEL_LEVEL_OUTER, 5,
 193         {proto_hdr_eth, proto_hdr_svlan, proto_hdr_cvlan,
 194          proto_hdr_ipv4_with_prot,
 195          proto_hdr_tcp}
 196 };
 197
 198 struct virtchnl_proto_hdrs outer_ipv4_sctp_tmplt = {
 199         TUNNEL_LEVEL_OUTER, 5,
 200         {proto_hdr_eth, proto_hdr_svlan, proto_hdr_cvlan, proto_hdr_ipv4,
 201          proto_hdr_sctp}
 202 };
 203
 204 struct virtchnl_proto_hdrs outer_ipv6_tmplt = {
 205         TUNNEL_LEVEL_OUTER, 4,
 206         {proto_hdr_eth, proto_hdr_svlan, proto_hdr_cvlan, proto_hdr_ipv6}
 207 };
 208
 209 struct virtchnl_proto_hdrs outer_ipv6_frag_tmplt = {
 210         TUNNEL_LEVEL_OUTER, 5,
 211         {proto_hdr_eth, proto_hdr_svlan, proto_hdr_cvlan,
 212          proto_hdr_ipv6, proto_hdr_ipv6_frag}
 213 };
 214
 215 struct virtchnl_proto_hdrs outer_ipv6_udp_tmplt = {
 216         TUNNEL_LEVEL_OUTER, 5,
 217         {proto_hdr_eth, proto_hdr_svlan, proto_hdr_cvlan,
 218          proto_hdr_ipv6_with_prot,
 219          proto_hdr_udp}
 220 };
 221
 222 struct virtchnl_proto_hdrs outer_ipv6_tcp_tmplt = {
 223         TUNNEL_LEVEL_OUTER, 5,
 224         {proto_hdr_eth, proto_hdr_svlan, proto_hdr_cvlan,
 225          proto_hdr_ipv6_with_prot,
 226          proto_hdr_tcp}
 227 };
 228
 229 struct virtchnl_proto_hdrs outer_ipv6_sctp_tmplt = {
 230         TUNNEL_LEVEL_OUTER, 5,
 231         {proto_hdr_eth, proto_hdr_svlan, proto_hdr_cvlan, proto_hdr_ipv6,
 232          proto_hdr_sctp}
 233 };
 234
 235 struct virtchnl_proto_hdrs inner_ipv4_tmplt = {
 236         TUNNEL_LEVEL_INNER, 1, {proto_hdr_ipv4}
 237 };
 238
 239 struct virtchnl_proto_hdrs inner_ipv4_udp_tmplt = {
 240         TUNNEL_LEVEL_INNER, 2, {proto_hdr_ipv4_with_prot, proto_hdr_udp}
 241 };
 242
 243 struct virtchnl_proto_hdrs inner_ipv4_tcp_tmplt = {
 244         TUNNEL_LEVEL_INNER, 2, {proto_hdr_ipv4_with_prot, proto_hdr_tcp}
 245 };
 246
 247 struct virtchnl_proto_hdrs second_inner_ipv4_tmplt = {
 248         2, 1, {proto_hdr_ipv4}
 249 };
 250
 251 struct virtchnl_proto_hdrs second_inner_ipv4_udp_tmplt = {
 252         2, 2, {proto_hdr_ipv4_with_prot, proto_hdr_udp}
 253 };
 254
 255 struct virtchnl_proto_hdrs second_inner_ipv4_tcp_tmplt = {
 256         2, 2, {proto_hdr_ipv4_with_prot, proto_hdr_tcp}
 257 };
 258
 259 struct virtchnl_proto_hdrs second_inner_ipv6_tmplt = {
 260         2, 1, {proto_hdr_ipv6}
 261 };
 262
 263 struct virtchnl_proto_hdrs second_inner_ipv6_udp_tmplt = {
 264         2, 2, {proto_hdr_ipv6_with_prot, proto_hdr_udp}
 265 };
 266
 267 struct virtchnl_proto_hdrs second_inner_ipv6_tcp_tmplt = {
 268         2, 2, {proto_hdr_ipv6_with_prot, proto_hdr_tcp}
 269 };
 270
 271 struct virtchnl_proto_hdrs inner_ipv4_sctp_tmplt = {
 272         TUNNEL_LEVEL_INNER, 2, {proto_hdr_ipv4, proto_hdr_sctp}
 273 };
 274
 275 struct virtchnl_proto_hdrs inner_ipv6_tmplt = {
 276         TUNNEL_LEVEL_INNER, 1, {proto_hdr_ipv6}
 277 };
 278
 279 struct virtchnl_proto_hdrs inner_ipv6_udp_tmplt = {
 280         TUNNEL_LEVEL_INNER, 2, {proto_hdr_ipv6_with_prot, proto_hdr_udp}
 281 };
 282
 283 struct virtchnl_proto_hdrs inner_ipv6_tcp_tmplt = {
 284         TUNNEL_LEVEL_INNER, 2, {proto_hdr_ipv6_with_prot, proto_hdr_tcp}
 285 };
 286
 287 struct virtchnl_proto_hdrs inner_ipv6_sctp_tmplt = {
 288         TUNNEL_LEVEL_INNER, 2, {proto_hdr_ipv6, proto_hdr_sctp}
 289 };
 290
 291 struct virtchnl_proto_hdrs ipv4_esp_tmplt = {
 292         TUNNEL_LEVEL_OUTER, 2, {proto_hdr_ipv4, proto_hdr_esp}
 293 };
 294
 295 struct virtchnl_proto_hdrs ipv4_udp_esp_tmplt = {
 296         TUNNEL_LEVEL_OUTER, 3,
 297         {proto_hdr_ipv4, proto_hdr_udp, proto_hdr_esp}
 298 };
 299
 300 struct virtchnl_proto_hdrs ipv4_ah_tmplt = {
 301         TUNNEL_LEVEL_OUTER, 2, {proto_hdr_ipv4, proto_hdr_ah}
 302 };
 303
 304 struct virtchnl_proto_hdrs ipv6_esp_tmplt = {
 305         TUNNEL_LEVEL_OUTER, 2, {proto_hdr_ipv6, proto_hdr_esp}
 306 };
 307
 308 struct virtchnl_proto_hdrs ipv6_udp_esp_tmplt = {
 309         TUNNEL_LEVEL_OUTER, 3,
 310         {proto_hdr_ipv6, proto_hdr_udp, proto_hdr_esp}
 311 };
 312
 313 struct virtchnl_proto_hdrs ipv6_ah_tmplt = {
 314         TUNNEL_LEVEL_OUTER, 2, {proto_hdr_ipv6, proto_hdr_ah}
 315 };
 316
 317 struct virtchnl_proto_hdrs ipv4_l2tpv3_tmplt = {
 318         TUNNEL_LEVEL_OUTER, 2, {proto_hdr_ipv4, proto_hdr_l2tpv3}
 319 };
 320
 321 struct virtchnl_proto_hdrs ipv6_l2tpv3_tmplt = {
 322         TUNNEL_LEVEL_OUTER, 2, {proto_hdr_ipv6, proto_hdr_l2tpv3}
 323 };
 324
 325 struct virtchnl_proto_hdrs ipv4_pfcp_tmplt = {
 326         TUNNEL_LEVEL_OUTER, 2, {proto_hdr_ipv4, proto_hdr_pfcp}
 327 };
 328
 329 struct virtchnl_proto_hdrs ipv6_pfcp_tmplt = {
 330         TUNNEL_LEVEL_OUTER, 2, {proto_hdr_ipv6, proto_hdr_pfcp}
 331 };
 332
 333 struct virtchnl_proto_hdrs ipv4_udp_gtpc_tmplt = {
 334         TUNNEL_LEVEL_OUTER, 3, {proto_hdr_ipv4, proto_hdr_udp, proto_hdr_gtpc}
 335 };
 336
 337 struct virtchnl_proto_hdrs ipv6_udp_gtpc_tmplt = {
 338         TUNNEL_LEVEL_OUTER, 3, {proto_hdr_ipv6, proto_hdr_udp, proto_hdr_gtpc}
 339 };
 340
 341 struct virtchnl_proto_hdrs eth_ecpri_tmplt = {
 342         TUNNEL_LEVEL_OUTER, 2, {proto_hdr_eth, proto_hdr_ecpri}
 343 };
 344
 345 struct virtchnl_proto_hdrs ipv4_ecpri_tmplt = {
 346         TUNNEL_LEVEL_OUTER, 3, {proto_hdr_ipv4, proto_hdr_udp, proto_hdr_ecpri}
 347 };
 348
 349 struct virtchnl_proto_hdrs udp_l2tpv2_ppp_ipv4_tmplt = {
 350         TUNNEL_LEVEL_INNER, 3,
 351         {proto_hdr_l2tpv2,
 352          proto_hdr_ppp,
 353          proto_hdr_ipv4}
 354 };
 355
 356 struct virtchnl_proto_hdrs udp_l2tpv2_ppp_ipv6_tmplt = {
 357         TUNNEL_LEVEL_INNER, 3,
 358         {proto_hdr_l2tpv2,
 359          proto_hdr_ppp,
 360          proto_hdr_ipv6}
 361 };
 362
 363 struct virtchnl_proto_hdrs udp_l2tpv2_ppp_ipv4_udp_tmplt = {
 364         TUNNEL_LEVEL_INNER, 4,
 365         {proto_hdr_l2tpv2,
 366          proto_hdr_ppp,
 367          proto_hdr_ipv4_with_prot,
 368          proto_hdr_udp}
 369 };
 370
 371 struct virtchnl_proto_hdrs udp_l2tpv2_ppp_ipv4_tcp_tmplt = {
 372         TUNNEL_LEVEL_INNER, 4,
 373         {proto_hdr_l2tpv2,
 374          proto_hdr_ppp,
 375          proto_hdr_ipv4_with_prot,
 376          proto_hdr_tcp}
 377 };
 378
 379 struct virtchnl_proto_hdrs udp_l2tpv2_ppp_ipv6_udp_tmplt = {
 380         TUNNEL_LEVEL_INNER, 4,
 381         {proto_hdr_l2tpv2,
 382          proto_hdr_ppp,
 383          proto_hdr_ipv6_with_prot,
 384          proto_hdr_udp}
 385 };
 386
 387 struct virtchnl_proto_hdrs udp_l2tpv2_ppp_ipv6_tcp_tmplt = {
 388         TUNNEL_LEVEL_INNER, 4,
 389         {proto_hdr_l2tpv2,
 390          proto_hdr_ppp,
 391          proto_hdr_ipv6_with_prot,
 392          proto_hdr_tcp}
 393 };
 394
 395 /* rss type super set */
 396
 397 /* IPv4 outer */
 398 #define IAVF_RSS_TYPE_OUTER_IPV4        (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV4 | \
 399                                          RTE_ETH_RSS_FRAG_IPV4 | \
 400                                          RTE_ETH_RSS_IPV4_CHKSUM)
 401 #define IAVF_RSS_TYPE_OUTER_IPV4_UDP    (IAVF_RSS_TYPE_OUTER_IPV4 | \
 402                                          RTE_ETH_RSS_NONFRAG_IPV4_UDP | \
 403                                          RTE_ETH_RSS_L4_CHKSUM)
 404 #define IAVF_RSS_TYPE_OUTER_IPV4_TCP    (IAVF_RSS_TYPE_OUTER_IPV4 | \
 405                                          RTE_ETH_RSS_NONFRAG_IPV4_TCP | \
 406                                          RTE_ETH_RSS_L4_CHKSUM)
 407 #define IAVF_RSS_TYPE_OUTER_IPV4_SCTP   (IAVF_RSS_TYPE_OUTER_IPV4 | \
 408                                          RTE_ETH_RSS_NONFRAG_IPV4_SCTP | \
 409                                          RTE_ETH_RSS_L4_CHKSUM)
 410 /* IPv6 outer */
 411 #define IAVF_RSS_TYPE_OUTER_IPV6        (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV6)
 412 #define IAVF_RSS_TYPE_OUTER_IPV6_FRAG   (IAVF_RSS_TYPE_OUTER_IPV6 | \
 413                                          RTE_ETH_RSS_FRAG_IPV6)
 414 #define IAVF_RSS_TYPE_OUTER_IPV6_UDP    (IAVF_RSS_TYPE_OUTER_IPV6 | \
 415                                          RTE_ETH_RSS_NONFRAG_IPV6_UDP | \
 416                                          RTE_ETH_RSS_L4_CHKSUM)
 417 #define IAVF_RSS_TYPE_OUTER_IPV6_TCP    (IAVF_RSS_TYPE_OUTER_IPV6 | \
 418                                          RTE_ETH_RSS_NONFRAG_IPV6_TCP | \
 419                                          RTE_ETH_RSS_L4_CHKSUM)
 420 #define IAVF_RSS_TYPE_OUTER_IPV6_SCTP   (IAVF_RSS_TYPE_OUTER_IPV6 | \
 421                                          RTE_ETH_RSS_NONFRAG_IPV6_SCTP | \
 422                                          RTE_ETH_RSS_L4_CHKSUM)
 423 /* VLAN IPV4 */
 424 #define IAVF_RSS_TYPE_VLAN_IPV4         (IAVF_RSS_TYPE_OUTER_IPV4 | \
 425                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 426 #define IAVF_RSS_TYPE_VLAN_IPV4_UDP     (IAVF_RSS_TYPE_OUTER_IPV4_UDP | \
 427                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 428 #define IAVF_RSS_TYPE_VLAN_IPV4_TCP     (IAVF_RSS_TYPE_OUTER_IPV4_TCP | \
 429                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 430 #define IAVF_RSS_TYPE_VLAN_IPV4_SCTP    (IAVF_RSS_TYPE_OUTER_IPV4_SCTP | \
 431                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 432 /* VLAN IPv6 */
 433 #define IAVF_RSS_TYPE_VLAN_IPV6         (IAVF_RSS_TYPE_OUTER_IPV6 | \
 434                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 435 #define IAVF_RSS_TYPE_VLAN_IPV6_FRAG    (IAVF_RSS_TYPE_OUTER_IPV6_FRAG | \
 436                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 437 #define IAVF_RSS_TYPE_VLAN_IPV6_UDP     (IAVF_RSS_TYPE_OUTER_IPV6_UDP | \
 438                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 439 #define IAVF_RSS_TYPE_VLAN_IPV6_TCP     (IAVF_RSS_TYPE_OUTER_IPV6_TCP | \
 440                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 441 #define IAVF_RSS_TYPE_VLAN_IPV6_SCTP    (IAVF_RSS_TYPE_OUTER_IPV6_SCTP | \
 442                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 443 /* IPv4 inner */
 444 #define IAVF_RSS_TYPE_INNER_IPV4        RTE_ETH_RSS_IPV4
 445 #define IAVF_RSS_TYPE_INNER_IPV4_UDP    (RTE_ETH_RSS_IPV4 | \
 446                                          RTE_ETH_RSS_NONFRAG_IPV4_UDP)
 447 #define IAVF_RSS_TYPE_INNER_IPV4_TCP    (RTE_ETH_RSS_IPV4 | \
 448                                          RTE_ETH_RSS_NONFRAG_IPV4_TCP)
 449 #define IAVF_RSS_TYPE_INNER_IPV4_SCTP   (RTE_ETH_RSS_IPV4 | \
 450                                          RTE_ETH_RSS_NONFRAG_IPV4_SCTP)
 451 /* IPv6 inner */
 452 #define IAVF_RSS_TYPE_INNER_IPV6        RTE_ETH_RSS_IPV6
 453 #define IAVF_RSS_TYPE_INNER_IPV6_UDP    (RTE_ETH_RSS_IPV6 | \
 454                                          RTE_ETH_RSS_NONFRAG_IPV6_UDP)
 455 #define IAVF_RSS_TYPE_INNER_IPV6_TCP    (RTE_ETH_RSS_IPV6 | \
 456                                          RTE_ETH_RSS_NONFRAG_IPV6_TCP)
 457 #define IAVF_RSS_TYPE_INNER_IPV6_SCTP   (RTE_ETH_RSS_IPV6 | \
 458                                          RTE_ETH_RSS_NONFRAG_IPV6_SCTP)
 459 /* GTPU IPv4 */
 460 #define IAVF_RSS_TYPE_GTPU_IPV4         (IAVF_RSS_TYPE_INNER_IPV4 | \
 461                                          RTE_ETH_RSS_GTPU)
 462 #define IAVF_RSS_TYPE_GTPU_IPV4_UDP     (IAVF_RSS_TYPE_INNER_IPV4_UDP | \
 463                                          RTE_ETH_RSS_GTPU)
 464 #define IAVF_RSS_TYPE_GTPU_IPV4_TCP     (IAVF_RSS_TYPE_INNER_IPV4_TCP | \
 465                                          RTE_ETH_RSS_GTPU)
 466 /* GTPU IPv6 */
 467 #define IAVF_RSS_TYPE_GTPU_IPV6         (IAVF_RSS_TYPE_INNER_IPV6 | \
 468                                          RTE_ETH_RSS_GTPU)
 469 #define IAVF_RSS_TYPE_GTPU_IPV6_UDP     (IAVF_RSS_TYPE_INNER_IPV6_UDP | \
 470                                          RTE_ETH_RSS_GTPU)
 471 #define IAVF_RSS_TYPE_GTPU_IPV6_TCP     (IAVF_RSS_TYPE_INNER_IPV6_TCP | \
 472                                          RTE_ETH_RSS_GTPU)
 473 /* ESP, AH, L2TPV3 and PFCP */
 474 #define IAVF_RSS_TYPE_IPV4_ESP          (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV4)
 475 #define IAVF_RSS_TYPE_IPV4_AH           (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV4)
 476 #define IAVF_RSS_TYPE_IPV6_ESP          (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV6)
 477 #define IAVF_RSS_TYPE_IPV6_AH           (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV6)
 478 #define IAVF_RSS_TYPE_IPV4_L2TPV3       (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV4)
 479 #define IAVF_RSS_TYPE_IPV6_L2TPV3       (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV6)
 480 #define IAVF_RSS_TYPE_IPV4_PFCP         (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV4)
 481 #define IAVF_RSS_TYPE_IPV6_PFCP         (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV6)
 482
 483 /**
 484  * Supported pattern for hash.
 485  * The first member is pattern item type,
 486  * the second member is input set mask,
 487  * the third member is virtchnl_proto_hdrs template
 488  */
 489 static struct iavf_pattern_match_item iavf_hash_pattern_list[] = {
 490         /* IPv4 */
 491         {iavf_pattern_eth_ipv4,                         IAVF_RSS_TYPE_OUTER_IPV4,       &outer_ipv4_tmplt},
 492         {iavf_pattern_eth_ipv4_udp,                     IAVF_RSS_TYPE_OUTER_IPV4_UDP,   &outer_ipv4_udp_tmplt},
 493         {iavf_pattern_eth_ipv4_tcp,                     IAVF_RSS_TYPE_OUTER_IPV4_TCP,   &outer_ipv4_tcp_tmplt},
 494         {iavf_pattern_eth_ipv4_sctp,                    IAVF_RSS_TYPE_OUTER_IPV4_SCTP,  &outer_ipv4_sctp_tmplt},
 495         {iavf_pattern_eth_vlan_ipv4,                    IAVF_RSS_TYPE_VLAN_IPV4,        &outer_ipv4_tmplt},
 496         {iavf_pattern_eth_vlan_ipv4_udp,                IAVF_RSS_TYPE_VLAN_IPV4_UDP,    &outer_ipv4_udp_tmplt},
 497         {iavf_pattern_eth_vlan_ipv4_tcp,                IAVF_RSS_TYPE_VLAN_IPV4_TCP,    &outer_ipv4_tcp_tmplt},
 498         {iavf_pattern_eth_vlan_ipv4_sctp,               IAVF_RSS_TYPE_VLAN_IPV4_SCTP,   &outer_ipv4_sctp_tmplt},
 499         {iavf_pattern_eth_ipv4_gtpu,                    RTE_ETH_RSS_IPV4,                       &outer_ipv4_udp_tmplt},
 500         {iavf_pattern_eth_ipv4_gtpu_ipv4,               IAVF_RSS_TYPE_GTPU_IPV4,        &inner_ipv4_tmplt},
 501         {iavf_pattern_eth_ipv4_gtpu_ipv4_udp,           IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &inner_ipv4_udp_tmplt},
 502         {iavf_pattern_eth_ipv4_gtpu_ipv4_tcp,           IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &inner_ipv4_tcp_tmplt},
 503         {iavf_pattern_eth_ipv6_gtpu_ipv4,               IAVF_RSS_TYPE_GTPU_IPV4,        &inner_ipv4_tmplt},
 504         {iavf_pattern_eth_ipv6_gtpu_ipv4_udp,           IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &inner_ipv4_udp_tmplt},
 505         {iavf_pattern_eth_ipv6_gtpu_ipv4_tcp,           IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &inner_ipv4_tcp_tmplt},
 506         {iavf_pattern_eth_ipv4_gtpu_eh_ipv4,            IAVF_RSS_TYPE_GTPU_IPV4,        &inner_ipv4_tmplt},
 507         {iavf_pattern_eth_ipv4_gtpu_eh_ipv4_udp,        IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &inner_ipv4_udp_tmplt},
 508         {iavf_pattern_eth_ipv4_gtpu_eh_ipv4_tcp,        IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &inner_ipv4_tcp_tmplt},
 509         {iavf_pattern_eth_ipv6_gtpu_eh_ipv4,            IAVF_RSS_TYPE_GTPU_IPV4,        &inner_ipv4_tmplt},
 510         {iavf_pattern_eth_ipv6_gtpu_eh_ipv4_udp,        IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &inner_ipv4_udp_tmplt},
 511         {iavf_pattern_eth_ipv6_gtpu_eh_ipv4_tcp,        IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &inner_ipv4_tcp_tmplt},
 512         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_ipv4,              IAVF_RSS_TYPE_GTPU_IPV4,        &second_inner_ipv4_tmplt},
 513         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_ipv4_udp,          IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &second_inner_ipv4_udp_tmplt},
 514         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_ipv4_tcp,          IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &second_inner_ipv4_tcp_tmplt},
 515         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_ipv4,              IAVF_RSS_TYPE_GTPU_IPV4,        &second_inner_ipv4_tmplt},
 516         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_ipv4_udp,          IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &second_inner_ipv4_udp_tmplt},
 517         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_ipv4_tcp,          IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &second_inner_ipv4_tcp_tmplt},
 518         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_ipv4,              IAVF_RSS_TYPE_GTPU_IPV4,        &second_inner_ipv4_tmplt},
 519         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_ipv4_udp,          IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &second_inner_ipv4_udp_tmplt},
 520         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_ipv4_tcp,          IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &second_inner_ipv4_tcp_tmplt},
 521         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_ipv4,              IAVF_RSS_TYPE_GTPU_IPV4,        &second_inner_ipv4_tmplt},
 522         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_ipv4_udp,          IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &second_inner_ipv4_udp_tmplt},
 523         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_ipv4_tcp,          IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &second_inner_ipv4_tcp_tmplt},
 524         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_eh_ipv4,           IAVF_RSS_TYPE_GTPU_IPV4,        &second_inner_ipv4_tmplt},
 525         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_eh_ipv4_udp,       IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &second_inner_ipv4_udp_tmplt},
 526         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_eh_ipv4_tcp,       IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &second_inner_ipv4_tcp_tmplt},
 527         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_eh_ipv4,           IAVF_RSS_TYPE_GTPU_IPV4,        &second_inner_ipv4_tmplt},
 528         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_eh_ipv4_udp,       IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &second_inner_ipv4_udp_tmplt},
 529         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_eh_ipv4_tcp,       IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &second_inner_ipv4_tcp_tmplt},
 530         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_eh_ipv4,           IAVF_RSS_TYPE_GTPU_IPV4,        &second_inner_ipv4_tmplt},
 531         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_eh_ipv4_udp,       IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &second_inner_ipv4_udp_tmplt},
 532         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_eh_ipv4_tcp,       IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &second_inner_ipv4_tcp_tmplt},
 533         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_eh_ipv4,           IAVF_RSS_TYPE_GTPU_IPV4,        &second_inner_ipv4_tmplt},
 534         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_eh_ipv4_udp,       IAVF_RSS_TYPE_GTPU_IPV4_UDP,    &second_inner_ipv4_udp_tmplt},
 535         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_eh_ipv4_tcp,       IAVF_RSS_TYPE_GTPU_IPV4_TCP,    &second_inner_ipv4_tcp_tmplt},
 536         {iavf_pattern_eth_ipv4_esp,                     IAVF_RSS_TYPE_IPV4_ESP,         &ipv4_esp_tmplt},
 537         {iavf_pattern_eth_ipv4_udp_esp,                 IAVF_RSS_TYPE_IPV4_ESP,         &ipv4_udp_esp_tmplt},
 538         {iavf_pattern_eth_ipv4_ah,                      IAVF_RSS_TYPE_IPV4_AH,          &ipv4_ah_tmplt},
 539         {iavf_pattern_eth_ipv4_l2tpv3,                  IAVF_RSS_TYPE_IPV4_L2TPV3,      &ipv4_l2tpv3_tmplt},
 540         {iavf_pattern_eth_ipv4_pfcp,                    IAVF_RSS_TYPE_IPV4_PFCP,        &ipv4_pfcp_tmplt},
 541         {iavf_pattern_eth_ipv4_gtpc,                    RTE_ETH_RSS_IPV4,                       &ipv4_udp_gtpc_tmplt},
 542         {iavf_pattern_eth_ecpri,                        RTE_ETH_RSS_ECPRI,                      &eth_ecpri_tmplt},
 543         {iavf_pattern_eth_ipv4_ecpri,                   RTE_ETH_RSS_ECPRI,                      &ipv4_ecpri_tmplt},
 544         {iavf_pattern_eth_ipv4_gre_ipv4,                IAVF_RSS_TYPE_INNER_IPV4,       &inner_ipv4_tmplt},
 545         {iavf_pattern_eth_ipv6_gre_ipv4,                IAVF_RSS_TYPE_INNER_IPV4, &inner_ipv4_tmplt},
 546         {iavf_pattern_eth_ipv4_gre_ipv4_tcp,    IAVF_RSS_TYPE_INNER_IPV4_TCP, &inner_ipv4_tcp_tmplt},
 547         {iavf_pattern_eth_ipv6_gre_ipv4_tcp,    IAVF_RSS_TYPE_INNER_IPV4_TCP, &inner_ipv4_tcp_tmplt},
 548         {iavf_pattern_eth_ipv4_gre_ipv4_udp,    IAVF_RSS_TYPE_INNER_IPV4_UDP, &inner_ipv4_udp_tmplt},
 549         {iavf_pattern_eth_ipv6_gre_ipv4_udp,    IAVF_RSS_TYPE_INNER_IPV4_UDP, &inner_ipv4_udp_tmplt},
 550         {iavf_pattern_eth_ipv4_udp_l2tpv2_ppp_ipv4,     IAVF_RSS_TYPE_INNER_IPV4,       &udp_l2tpv2_ppp_ipv4_tmplt},
 551         {iavf_pattern_eth_ipv4_udp_l2tpv2_ppp_ipv4_udp, IAVF_RSS_TYPE_INNER_IPV4_UDP,   &udp_l2tpv2_ppp_ipv4_udp_tmplt},
 552         {iavf_pattern_eth_ipv4_udp_l2tpv2_ppp_ipv4_tcp, IAVF_RSS_TYPE_INNER_IPV4_TCP,   &udp_l2tpv2_ppp_ipv4_tcp_tmplt},
 553         {iavf_pattern_eth_ipv6_udp_l2tpv2_ppp_ipv4,     IAVF_RSS_TYPE_INNER_IPV4,       &udp_l2tpv2_ppp_ipv4_tmplt},
 554         {iavf_pattern_eth_ipv6_udp_l2tpv2_ppp_ipv4_udp, IAVF_RSS_TYPE_INNER_IPV4_UDP,   &udp_l2tpv2_ppp_ipv4_udp_tmplt},
 555         {iavf_pattern_eth_ipv6_udp_l2tpv2_ppp_ipv4_tcp, IAVF_RSS_TYPE_INNER_IPV4_TCP,   &udp_l2tpv2_ppp_ipv4_tcp_tmplt},
 556
 557         /* IPv6 */
 558         {iavf_pattern_eth_ipv6,                         IAVF_RSS_TYPE_OUTER_IPV6,       &outer_ipv6_tmplt},
 559         {iavf_pattern_eth_ipv6_frag_ext,                IAVF_RSS_TYPE_OUTER_IPV6_FRAG,  &outer_ipv6_frag_tmplt},
 560         {iavf_pattern_eth_ipv6_udp,                     IAVF_RSS_TYPE_OUTER_IPV6_UDP,   &outer_ipv6_udp_tmplt},
 561         {iavf_pattern_eth_ipv6_tcp,                     IAVF_RSS_TYPE_OUTER_IPV6_TCP,   &outer_ipv6_tcp_tmplt},
 562         {iavf_pattern_eth_ipv6_sctp,                    IAVF_RSS_TYPE_OUTER_IPV6_SCTP,  &outer_ipv6_sctp_tmplt},
 563         {iavf_pattern_eth_vlan_ipv6,                    IAVF_RSS_TYPE_VLAN_IPV6,        &outer_ipv6_tmplt},
 564         {iavf_pattern_eth_vlan_ipv6_frag_ext,           IAVF_RSS_TYPE_OUTER_IPV6_FRAG,  &outer_ipv6_frag_tmplt},
 565         {iavf_pattern_eth_vlan_ipv6_udp,                IAVF_RSS_TYPE_VLAN_IPV6_UDP,    &outer_ipv6_udp_tmplt},
 566         {iavf_pattern_eth_vlan_ipv6_tcp,                IAVF_RSS_TYPE_VLAN_IPV6_TCP,    &outer_ipv6_tcp_tmplt},
 567         {iavf_pattern_eth_vlan_ipv6_sctp,               IAVF_RSS_TYPE_VLAN_IPV6_SCTP,   &outer_ipv6_sctp_tmplt},
 568         {iavf_pattern_eth_ipv6_gtpu,                    RTE_ETH_RSS_IPV6,                       &outer_ipv6_udp_tmplt},
 569         {iavf_pattern_eth_ipv4_gtpu_ipv6,               IAVF_RSS_TYPE_GTPU_IPV6,        &inner_ipv6_tmplt},
 570         {iavf_pattern_eth_ipv4_gtpu_ipv6_udp,           IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &inner_ipv6_udp_tmplt},
 571         {iavf_pattern_eth_ipv4_gtpu_ipv6_tcp,           IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &inner_ipv6_tcp_tmplt},
 572         {iavf_pattern_eth_ipv6_gtpu_ipv6,               IAVF_RSS_TYPE_GTPU_IPV6,        &inner_ipv6_tmplt},
 573         {iavf_pattern_eth_ipv6_gtpu_ipv6_udp,           IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &inner_ipv6_udp_tmplt},
 574         {iavf_pattern_eth_ipv6_gtpu_ipv6_tcp,           IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &inner_ipv6_tcp_tmplt},
 575         {iavf_pattern_eth_ipv4_gtpu_eh_ipv6,            IAVF_RSS_TYPE_GTPU_IPV6,        &inner_ipv6_tmplt},
 576         {iavf_pattern_eth_ipv4_gtpu_eh_ipv6_udp,        IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &inner_ipv6_udp_tmplt},
 577         {iavf_pattern_eth_ipv4_gtpu_eh_ipv6_tcp,        IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &inner_ipv6_tcp_tmplt},
 578         {iavf_pattern_eth_ipv6_gtpu_eh_ipv6,            IAVF_RSS_TYPE_GTPU_IPV6,        &inner_ipv6_tmplt},
 579         {iavf_pattern_eth_ipv6_gtpu_eh_ipv6_udp,        IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &inner_ipv6_udp_tmplt},
 580         {iavf_pattern_eth_ipv6_gtpu_eh_ipv6_tcp,        IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &inner_ipv6_tcp_tmplt},
 581         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_ipv6,              IAVF_RSS_TYPE_GTPU_IPV6,        &second_inner_ipv6_tmplt},
 582         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_ipv6_udp,          IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &second_inner_ipv6_udp_tmplt},
 583         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_ipv6_tcp,          IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &second_inner_ipv6_tcp_tmplt},
 584         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_ipv6,              IAVF_RSS_TYPE_GTPU_IPV6,        &second_inner_ipv6_tmplt},
 585         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_ipv6_udp,          IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &second_inner_ipv6_udp_tmplt},
 586         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_ipv6_tcp,          IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &second_inner_ipv6_tcp_tmplt},
 587         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_ipv6,              IAVF_RSS_TYPE_GTPU_IPV6,        &second_inner_ipv6_tmplt},
 588         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_ipv6_udp,          IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &second_inner_ipv6_udp_tmplt},
 589         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_ipv6_tcp,          IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &second_inner_ipv6_tcp_tmplt},
 590         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_ipv6,              IAVF_RSS_TYPE_GTPU_IPV6,        &second_inner_ipv6_tmplt},
 591         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_ipv6_udp,          IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &second_inner_ipv6_udp_tmplt},
 592         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_ipv6_tcp,          IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &second_inner_ipv6_tcp_tmplt},
 593         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_eh_ipv6,           IAVF_RSS_TYPE_GTPU_IPV6,        &second_inner_ipv6_tmplt},
 594         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_eh_ipv6_udp,       IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &second_inner_ipv6_udp_tmplt},
 595         {iavf_pattern_eth_ipv4_gre_ipv4_gtpu_eh_ipv6_tcp,       IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &second_inner_ipv6_tcp_tmplt},
 596         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_eh_ipv6,           IAVF_RSS_TYPE_GTPU_IPV6,        &second_inner_ipv6_tmplt},
 597         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_eh_ipv6_udp,       IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &second_inner_ipv6_udp_tmplt},
 598         {iavf_pattern_eth_ipv4_gre_ipv6_gtpu_eh_ipv6_tcp,       IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &second_inner_ipv6_tcp_tmplt},
 599         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_eh_ipv6,           IAVF_RSS_TYPE_GTPU_IPV6,        &second_inner_ipv6_tmplt},
 600         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_eh_ipv6_udp,       IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &second_inner_ipv6_udp_tmplt},
 601         {iavf_pattern_eth_ipv6_gre_ipv4_gtpu_eh_ipv6_tcp,       IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &second_inner_ipv6_tcp_tmplt},
 602         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_eh_ipv6,           IAVF_RSS_TYPE_GTPU_IPV6,        &second_inner_ipv6_tmplt},
 603         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_eh_ipv6_udp,       IAVF_RSS_TYPE_GTPU_IPV6_UDP,    &second_inner_ipv6_udp_tmplt},
 604         {iavf_pattern_eth_ipv6_gre_ipv6_gtpu_eh_ipv6_tcp,       IAVF_RSS_TYPE_GTPU_IPV6_TCP,    &second_inner_ipv6_tcp_tmplt},
 605         {iavf_pattern_eth_ipv6_esp,                     IAVF_RSS_TYPE_IPV6_ESP,         &ipv6_esp_tmplt},
 606         {iavf_pattern_eth_ipv6_udp_esp,                 IAVF_RSS_TYPE_IPV6_ESP,         &ipv6_udp_esp_tmplt},
 607         {iavf_pattern_eth_ipv6_ah,                      IAVF_RSS_TYPE_IPV6_AH,          &ipv6_ah_tmplt},
 608         {iavf_pattern_eth_ipv6_l2tpv3,                  IAVF_RSS_TYPE_IPV6_L2TPV3,      &ipv6_l2tpv3_tmplt},
 609         {iavf_pattern_eth_ipv6_pfcp,                    IAVF_RSS_TYPE_IPV6_PFCP,        &ipv6_pfcp_tmplt},
 610         {iavf_pattern_eth_ipv6_gtpc,                    RTE_ETH_RSS_IPV6,                       &ipv6_udp_gtpc_tmplt},
 611         {iavf_pattern_eth_ipv4_gre_ipv6,                IAVF_RSS_TYPE_INNER_IPV6,       &inner_ipv6_tmplt},
 612         {iavf_pattern_eth_ipv6_gre_ipv6,                IAVF_RSS_TYPE_INNER_IPV6, &inner_ipv6_tmplt},
 613         {iavf_pattern_eth_ipv4_gre_ipv6_tcp,    IAVF_RSS_TYPE_INNER_IPV6_TCP, &inner_ipv6_tcp_tmplt},
 614         {iavf_pattern_eth_ipv6_gre_ipv6_tcp,    IAVF_RSS_TYPE_INNER_IPV6_TCP, &inner_ipv6_tcp_tmplt},
 615         {iavf_pattern_eth_ipv4_gre_ipv6_udp,    IAVF_RSS_TYPE_INNER_IPV6_UDP, &inner_ipv6_udp_tmplt},
 616         {iavf_pattern_eth_ipv6_gre_ipv6_udp,    IAVF_RSS_TYPE_INNER_IPV6_UDP, &inner_ipv6_udp_tmplt},
 617         {iavf_pattern_eth_ipv4_udp_l2tpv2_ppp_ipv6,     IAVF_RSS_TYPE_INNER_IPV6,       &udp_l2tpv2_ppp_ipv6_tmplt},
 618         {iavf_pattern_eth_ipv4_udp_l2tpv2_ppp_ipv6_udp, IAVF_RSS_TYPE_INNER_IPV6_UDP,   &udp_l2tpv2_ppp_ipv6_udp_tmplt},
 619         {iavf_pattern_eth_ipv4_udp_l2tpv2_ppp_ipv6_tcp, IAVF_RSS_TYPE_INNER_IPV6_TCP,   &udp_l2tpv2_ppp_ipv6_tcp_tmplt},
 620         {iavf_pattern_eth_ipv6_udp_l2tpv2_ppp_ipv6,     IAVF_RSS_TYPE_INNER_IPV6,       &udp_l2tpv2_ppp_ipv6_tmplt},
 621         {iavf_pattern_eth_ipv6_udp_l2tpv2_ppp_ipv6_udp, IAVF_RSS_TYPE_INNER_IPV6_UDP,   &udp_l2tpv2_ppp_ipv6_udp_tmplt},
 622         {iavf_pattern_eth_ipv6_udp_l2tpv2_ppp_ipv6_tcp, IAVF_RSS_TYPE_INNER_IPV6_TCP,   &udp_l2tpv2_ppp_ipv6_tcp_tmplt},
 623
 624 };
 625
 626 static struct iavf_flow_engine iavf_hash_engine = {
 627         .init = iavf_hash_init,
 628         .create = iavf_hash_create,
 629         .destroy = iavf_hash_destroy,
 630         .uninit = iavf_hash_uninit,
 631         .free = iavf_hash_free,
 632         .type = IAVF_FLOW_ENGINE_HASH,
 633 };
 634
 635 /* Register parser for comms package. */
 636 static struct iavf_flow_parser iavf_hash_parser = {
 637         .engine = &iavf_hash_engine,
 638         .array = iavf_hash_pattern_list,
 639         .array_len = RTE_DIM(iavf_hash_pattern_list),
 640         .parse_pattern_action = iavf_hash_parse_pattern_action,
 641         .stage = IAVF_FLOW_STAGE_RSS,
 642 };
 643
 644 int
 645 iavf_rss_hash_set(struct iavf_adapter *ad, uint64_t rss_hf, bool add)
 646 {
 647         struct iavf_info *vf =  IAVF_DEV_PRIVATE_TO_VF(ad);
 648         struct virtchnl_rss_cfg rss_cfg;
 649
 650 #define IAVF_RSS_HF_ALL ( \
 651         RTE_ETH_RSS_IPV4 | \
 652         RTE_ETH_RSS_IPV6 | \
 653         RTE_ETH_RSS_NONFRAG_IPV4_UDP | \
 654         RTE_ETH_RSS_NONFRAG_IPV6_UDP | \
 655         RTE_ETH_RSS_NONFRAG_IPV4_TCP | \
 656         RTE_ETH_RSS_NONFRAG_IPV6_TCP | \
 657         RTE_ETH_RSS_NONFRAG_IPV4_SCTP | \
 658         RTE_ETH_RSS_NONFRAG_IPV6_SCTP)
 659
 660         rss_cfg.rss_algorithm = VIRTCHNL_RSS_ALG_TOEPLITZ_ASYMMETRIC;
 661         if (rss_hf & RTE_ETH_RSS_IPV4) {
 662                 rss_cfg.proto_hdrs = inner_ipv4_tmplt;
 663                 iavf_add_del_rss_cfg(ad, &rss_cfg, add);
 664         }
 665
 666         if (rss_hf & RTE_ETH_RSS_NONFRAG_IPV4_UDP) {
 667                 rss_cfg.proto_hdrs = inner_ipv4_udp_tmplt;
 668                 iavf_add_del_rss_cfg(ad, &rss_cfg, add);
 669         }
 670
 671         if (rss_hf & RTE_ETH_RSS_NONFRAG_IPV4_TCP) {
 672                 rss_cfg.proto_hdrs = inner_ipv4_tcp_tmplt;
 673                 iavf_add_del_rss_cfg(ad, &rss_cfg, add);
 674         }
 675
 676         if (rss_hf & RTE_ETH_RSS_NONFRAG_IPV4_SCTP) {
 677                 rss_cfg.proto_hdrs = inner_ipv4_sctp_tmplt;
 678                 iavf_add_del_rss_cfg(ad, &rss_cfg, add);
 679         }
 680
 681         if (rss_hf & RTE_ETH_RSS_IPV6) {
 682                 rss_cfg.proto_hdrs = inner_ipv6_tmplt;
 683                 iavf_add_del_rss_cfg(ad, &rss_cfg, add);
 684         }
 685
 686         if (rss_hf & RTE_ETH_RSS_NONFRAG_IPV6_UDP) {
 687                 rss_cfg.proto_hdrs = inner_ipv6_udp_tmplt;
 688                 iavf_add_del_rss_cfg(ad, &rss_cfg, add);
 689         }
 690
 691         if (rss_hf & RTE_ETH_RSS_NONFRAG_IPV6_TCP) {
 692                 rss_cfg.proto_hdrs = inner_ipv6_tcp_tmplt;
 693                 iavf_add_del_rss_cfg(ad, &rss_cfg, add);
 694         }
 695
 696         if (rss_hf & RTE_ETH_RSS_NONFRAG_IPV6_SCTP) {
 697                 rss_cfg.proto_hdrs = inner_ipv6_sctp_tmplt;
 698                 iavf_add_del_rss_cfg(ad, &rss_cfg, add);
 699         }
 700
 701         vf->rss_hf = rss_hf & IAVF_RSS_HF_ALL;
 702         return 0;
 703 }
 704
 705 RTE_INIT(iavf_hash_engine_init)
 706 {
 707         struct iavf_flow_engine *engine = &iavf_hash_engine;
 708
 709         iavf_register_flow_engine(engine);
 710 }
 711
 712 static int
 713 iavf_hash_init(struct iavf_adapter *ad)
 714 {
 715         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
 716         struct iavf_flow_parser *parser;
 717         int ret;
 718
 719         if (vf->vf_reset)
 720                 return -EIO;
 721
 722         if (!vf->vf_res)
 723                 return -EINVAL;
 724
 725         if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF))
 726                 return -ENOTSUP;
 727
 728         parser = &iavf_hash_parser;
 729
 730         ret = iavf_register_parser(parser, ad);
 731         if (ret) {
 732                 PMD_DRV_LOG(ERR, "fail to register hash parser");
 733                 return ret;
 734         }
 735
 736         return ret;
 737 }
 738
 739 static int
 740 iavf_hash_parse_pattern(const struct rte_flow_item pattern[], uint64_t *phint,
 741                         struct rte_flow_error *error)
 742 {
 743         const struct rte_flow_item *item = pattern;
 744         const struct rte_flow_item_gtp_psc *psc;
 745         const struct rte_flow_item_ecpri *ecpri;
 746         struct rte_ecpri_common_hdr ecpri_common;
 747
 748         for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
 749                 if (item->last) {
 750                         rte_flow_error_set(error, EINVAL,
 751                                            RTE_FLOW_ERROR_TYPE_ITEM, item,
 752                                            "Not support range");
 753                         return -rte_errno;
 754                 }
 755
 756                 switch (item->type) {
 757                 case RTE_FLOW_ITEM_TYPE_IPV4:
 758                         if (!(*phint & IAVF_PHINT_GTPU_MSK) &&
 759                             !(*phint & IAVF_PHINT_GRE) &&
 760                             !(*phint & IAVF_PHINT_L2TPV2))
 761                                 *phint |= IAVF_PHINT_OUTER_IPV4;
 762                         if ((*phint & IAVF_PHINT_GRE) && !(*phint & IAVF_PHINT_GTPU_MSK))
 763                                 *phint |= IAVF_PHINT_MID_IPV4;
 764                         break;
 765                 case RTE_FLOW_ITEM_TYPE_IPV6:
 766                         if (!(*phint & IAVF_PHINT_GTPU_MSK) &&
 767                             !(*phint & IAVF_PHINT_GRE) &&
 768                             !(*phint & IAVF_PHINT_L2TPV2))
 769                                 *phint |= IAVF_PHINT_OUTER_IPV6;
 770                         if ((*phint & IAVF_PHINT_GRE) && !(*phint & IAVF_PHINT_GTPU_MSK))
 771                                 *phint |= IAVF_PHINT_MID_IPV6;
 772                         break;
 773                 case RTE_FLOW_ITEM_TYPE_GTPU:
 774                         *phint |= IAVF_PHINT_GTPU;
 775                         break;
 776                 case RTE_FLOW_ITEM_TYPE_GTP_PSC:
 777                         *phint |= IAVF_PHINT_GTPU_EH;
 778                         psc = item->spec;
 779                         if (!psc)
 780                                 break;
 781                         else if (psc->hdr.type == IAVF_GTPU_EH_UPLINK)
 782                                 *phint |= IAVF_PHINT_GTPU_EH_UP;
 783                         else if (psc->hdr.type == IAVF_GTPU_EH_DWNLINK)
 784                                 *phint |= IAVF_PHINT_GTPU_EH_DWN;
 785                         break;
 786                 case RTE_FLOW_ITEM_TYPE_ECPRI:
 787                         ecpri = item->spec;
 788                         if (!ecpri)
 789                                 break;
 790
 791                         ecpri_common.u32 = rte_be_to_cpu_32(ecpri->hdr.common.u32);
 792
 793                         if (ecpri_common.type !=
 794                                  RTE_ECPRI_MSG_TYPE_IQ_DATA) {
 795                                 rte_flow_error_set(error, EINVAL,
 796                                         RTE_FLOW_ERROR_TYPE_ITEM, item,
 797                                         "Unsupported common type.");
 798                                 return -rte_errno;
 799                         }
 800                         break;
 801                 case RTE_FLOW_ITEM_TYPE_GRE:
 802                         *phint |= IAVF_PHINT_GRE;
 803                         break;
 804                 case RTE_FLOW_ITEM_TYPE_L2TPV2:
 805                         *phint |= IAVF_PHINT_L2TPV2;
 806                         break;
 807                 default:
 808                         break;
 809                 }
 810         }
 811
 812         return 0;
 813 }
 814
 815 #define REFINE_PROTO_FLD(op, fld) \
 816         VIRTCHNL_##op##_PROTO_HDR_FIELD(hdr, VIRTCHNL_PROTO_HDR_##fld)
 817 #define REPALCE_PROTO_FLD(fld_1, fld_2) \
 818 do { \
 819         REFINE_PROTO_FLD(DEL, fld_1);   \
 820         REFINE_PROTO_FLD(ADD, fld_2);   \
 821 } while (0)
 822
 823 static void
 824 iavf_hash_add_fragment_hdr(struct virtchnl_proto_hdrs *hdrs, int layer)
 825 {
 826         struct virtchnl_proto_hdr *hdr1;
 827         struct virtchnl_proto_hdr *hdr2;
 828         int i;
 829
 830         if (layer < 0 || layer > hdrs->count)
 831                 return;
 832
 833         /* shift headers layer */
 834         for (i = hdrs->count; i >= layer; i--) {
 835                 hdr1 = &hdrs->proto_hdr[i];
 836                 hdr2 = &hdrs->proto_hdr[i - 1];
 837                 *hdr1 = *hdr2;
 838         }
 839
 840         /* adding dummy fragment header */
 841         hdr1 = &hdrs->proto_hdr[layer];
 842         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr1, IPV4_FRAG);
 843         hdrs->count = ++layer;
 844 }
 845
 846 /* refine proto hdrs base on l2, l3, l4 rss type */
 847 static void
 848 iavf_refine_proto_hdrs_l234(struct virtchnl_proto_hdrs *proto_hdrs,
 849                             uint64_t rss_type)
 850 {
 851         struct virtchnl_proto_hdr *hdr;
 852         int i;
 853
 854         for (i = 0; i < proto_hdrs->count; i++) {
 855                 hdr = &proto_hdrs->proto_hdr[i];
 856                 switch (hdr->type) {
 857                 case VIRTCHNL_PROTO_HDR_ETH:
 858                         if (!(rss_type & RTE_ETH_RSS_ETH))
 859                                 hdr->field_selector = 0;
 860                         else if (rss_type & RTE_ETH_RSS_L2_SRC_ONLY)
 861                                 REFINE_PROTO_FLD(DEL, ETH_DST);
 862                         else if (rss_type & RTE_ETH_RSS_L2_DST_ONLY)
 863                                 REFINE_PROTO_FLD(DEL, ETH_SRC);
 864                         break;
 865                 case VIRTCHNL_PROTO_HDR_IPV4:
 866                         if (rss_type &
 867                             (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 |
 868                              RTE_ETH_RSS_NONFRAG_IPV4_UDP |
 869                              RTE_ETH_RSS_NONFRAG_IPV4_TCP |
 870                              RTE_ETH_RSS_NONFRAG_IPV4_SCTP)) {
 871                                 if (rss_type & RTE_ETH_RSS_FRAG_IPV4) {
 872                                         iavf_hash_add_fragment_hdr(proto_hdrs, i + 1);
 873                                 } else if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
 874                                         REFINE_PROTO_FLD(DEL, IPV4_DST);
 875                                 } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
 876                                         REFINE_PROTO_FLD(DEL, IPV4_SRC);
 877                                 } else if (rss_type &
 878                                            (RTE_ETH_RSS_L4_SRC_ONLY |
 879                                             RTE_ETH_RSS_L4_DST_ONLY)) {
 880                                         REFINE_PROTO_FLD(DEL, IPV4_DST);
 881                                         REFINE_PROTO_FLD(DEL, IPV4_SRC);
 882                                 }
 883                         } else {
 884                                 hdr->field_selector = 0;
 885                         }
 886
 887                         if (rss_type & RTE_ETH_RSS_IPV4_CHKSUM)
 888                                 REFINE_PROTO_FLD(ADD, IPV4_CHKSUM);
 889
 890                         break;
 891                 case VIRTCHNL_PROTO_HDR_IPV4_FRAG:
 892                         if (rss_type &
 893                             (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 |
 894                              RTE_ETH_RSS_NONFRAG_IPV4_UDP |
 895                              RTE_ETH_RSS_NONFRAG_IPV4_TCP |
 896                              RTE_ETH_RSS_NONFRAG_IPV4_SCTP)) {
 897                                 if (rss_type & RTE_ETH_RSS_FRAG_IPV4)
 898                                         REFINE_PROTO_FLD(ADD, IPV4_FRAG_PKID);
 899                         } else {
 900                                 hdr->field_selector = 0;
 901                         }
 902
 903                         if (rss_type & RTE_ETH_RSS_IPV4_CHKSUM)
 904                                 REFINE_PROTO_FLD(ADD, IPV4_CHKSUM);
 905
 906                         break;
 907                 case VIRTCHNL_PROTO_HDR_IPV6:
 908                         if (rss_type &
 909                             (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 |
 910                              RTE_ETH_RSS_NONFRAG_IPV6_UDP |
 911                              RTE_ETH_RSS_NONFRAG_IPV6_TCP |
 912                              RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
 913                                 if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
 914                                         REFINE_PROTO_FLD(DEL, IPV6_DST);
 915                                 } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
 916                                         REFINE_PROTO_FLD(DEL, IPV6_SRC);
 917                                 } else if (rss_type &
 918                                            (RTE_ETH_RSS_L4_SRC_ONLY |
 919                                             RTE_ETH_RSS_L4_DST_ONLY)) {
 920                                         REFINE_PROTO_FLD(DEL, IPV6_DST);
 921                                         REFINE_PROTO_FLD(DEL, IPV6_SRC);
 922                                 }
 923                         } else {
 924                                 hdr->field_selector = 0;
 925                         }
 926                         if (rss_type & RTE_ETH_RSS_L3_PRE64) {
 927                                 if (REFINE_PROTO_FLD(TEST, IPV6_SRC))
 928                                         REPALCE_PROTO_FLD(IPV6_SRC,
 929                                                           IPV6_PREFIX64_SRC);
 930                                 if (REFINE_PROTO_FLD(TEST, IPV6_DST))
 931                                         REPALCE_PROTO_FLD(IPV6_DST,
 932                                                           IPV6_PREFIX64_DST);
 933                         }
 934                         break;
 935                 case VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG:
 936                         if (rss_type & RTE_ETH_RSS_FRAG_IPV6)
 937                                 REFINE_PROTO_FLD(ADD, IPV6_EH_FRAG_PKID);
 938                         else
 939                                 hdr->field_selector = 0;
 940
 941                         break;
 942                 case VIRTCHNL_PROTO_HDR_UDP:
 943                         if (rss_type &
 944                             (RTE_ETH_RSS_NONFRAG_IPV4_UDP |
 945                              RTE_ETH_RSS_NONFRAG_IPV6_UDP)) {
 946                                 if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
 947                                         REFINE_PROTO_FLD(DEL, UDP_DST_PORT);
 948                                 else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
 949                                         REFINE_PROTO_FLD(DEL, UDP_SRC_PORT);
 950                                 else if (rss_type &
 951                                          (RTE_ETH_RSS_L3_SRC_ONLY |
 952                                           RTE_ETH_RSS_L3_DST_ONLY))
 953                                         hdr->field_selector = 0;
 954                         } else {
 955                                 hdr->field_selector = 0;
 956                         }
 957
 958                         if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
 959                                 REFINE_PROTO_FLD(ADD, UDP_CHKSUM);
 960                         break;
 961                 case VIRTCHNL_PROTO_HDR_TCP:
 962                         if (rss_type &
 963                             (RTE_ETH_RSS_NONFRAG_IPV4_TCP |
 964                              RTE_ETH_RSS_NONFRAG_IPV6_TCP)) {
 965                                 if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
 966                                         REFINE_PROTO_FLD(DEL, TCP_DST_PORT);
 967                                 else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
 968                                         REFINE_PROTO_FLD(DEL, TCP_SRC_PORT);
 969                                 else if (rss_type &
 970                                          (RTE_ETH_RSS_L3_SRC_ONLY |
 971                                           RTE_ETH_RSS_L3_DST_ONLY))
 972                                         hdr->field_selector = 0;
 973                         } else {
 974                                 hdr->field_selector = 0;
 975                         }
 976
 977                         if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
 978                                 REFINE_PROTO_FLD(ADD, TCP_CHKSUM);
 979                         break;
 980                 case VIRTCHNL_PROTO_HDR_SCTP:
 981                         if (rss_type &
 982                             (RTE_ETH_RSS_NONFRAG_IPV4_SCTP |
 983                              RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
 984                                 if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
 985                                         REFINE_PROTO_FLD(DEL, SCTP_DST_PORT);
 986                                 else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
 987                                         REFINE_PROTO_FLD(DEL, SCTP_SRC_PORT);
 988                                 else if (rss_type &
 989                                          (RTE_ETH_RSS_L3_SRC_ONLY |
 990                                           RTE_ETH_RSS_L3_DST_ONLY))
 991                                         hdr->field_selector = 0;
 992                         } else {
 993                                 hdr->field_selector = 0;
 994                         }
 995
 996                         if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
 997                                 REFINE_PROTO_FLD(ADD, SCTP_CHKSUM);
 998                         break;
 999                 case VIRTCHNL_PROTO_HDR_S_VLAN:
1000                         if (!(rss_type & RTE_ETH_RSS_S_VLAN))
1001                                 hdr->field_selector = 0;
1002                         break;
1003                 case VIRTCHNL_PROTO_HDR_C_VLAN:
1004                         if (!(rss_type & RTE_ETH_RSS_C_VLAN))
1005                                 hdr->field_selector = 0;
1006                         break;
1007                 case VIRTCHNL_PROTO_HDR_L2TPV3:
1008                         if (!(rss_type & RTE_ETH_RSS_L2TPV3))
1009                                 hdr->field_selector = 0;
1010                         break;
1011                 case VIRTCHNL_PROTO_HDR_ESP:
1012                         if (!(rss_type & RTE_ETH_RSS_ESP))
1013                                 hdr->field_selector = 0;
1014                         break;
1015                 case VIRTCHNL_PROTO_HDR_AH:
1016                         if (!(rss_type & RTE_ETH_RSS_AH))
1017                                 hdr->field_selector = 0;
1018                         break;
1019                 case VIRTCHNL_PROTO_HDR_PFCP:
1020                         if (!(rss_type & RTE_ETH_RSS_PFCP))
1021                                 hdr->field_selector = 0;
1022                         break;
1023                 case VIRTCHNL_PROTO_HDR_ECPRI:
1024                         if (!(rss_type & RTE_ETH_RSS_ECPRI))
1025                                 hdr->field_selector = 0;
1026                         break;
1027                 default:
1028                         break;
1029                 }
1030         }
1031 }
1032
1033 /* refine proto hdrs base on gtpu rss type */
1034 static void
1035 iavf_refine_proto_hdrs_gtpu(struct virtchnl_proto_hdrs *proto_hdrs,
1036                             uint64_t rss_type)
1037 {
1038         struct virtchnl_proto_hdr *hdr;
1039         int i;
1040
1041         if (!(rss_type & RTE_ETH_RSS_GTPU))
1042                 return;
1043
1044         for (i = 0; i < proto_hdrs->count; i++) {
1045                 hdr = &proto_hdrs->proto_hdr[i];
1046                 switch (hdr->type) {
1047                 case VIRTCHNL_PROTO_HDR_GTPU_IP:
1048                         REFINE_PROTO_FLD(ADD, GTPU_IP_TEID);
1049                         break;
1050                 default:
1051                         break;
1052                 }
1053         }
1054 }
1055
1056 static void
1057 iavf_refine_proto_hdrs_by_pattern(struct virtchnl_proto_hdrs *proto_hdrs,
1058                                   uint64_t phint)
1059 {
1060         struct virtchnl_proto_hdr *hdr1;
1061         struct virtchnl_proto_hdr *hdr2;
1062         int i, shift_count = 1;
1063         int tun_lvl = proto_hdrs->tunnel_level;
1064
1065         if (!(phint & IAVF_PHINT_GTPU_MSK) && !(phint & IAVF_PHINT_GRE))
1066                 return;
1067
1068         while (tun_lvl) {
1069                 if (phint & IAVF_PHINT_LAYERS_MSK)
1070                         shift_count = 2;
1071
1072                 /* shift headers layer */
1073                 for (i = proto_hdrs->count - 1 + shift_count;
1074                      i > shift_count - 1; i--) {
1075                         hdr1 = &proto_hdrs->proto_hdr[i];
1076                         hdr2 = &proto_hdrs->proto_hdr[i - shift_count];
1077                         *hdr1 = *hdr2;
1078                 }
1079
1080                 if (shift_count == 1) {
1081                         /* adding tunnel header at layer 0 */
1082                         hdr1 = &proto_hdrs->proto_hdr[0];
1083                 } else {
1084                         /* adding tunnel header and outer ip header */
1085                         hdr1 = &proto_hdrs->proto_hdr[1];
1086                         hdr2 = &proto_hdrs->proto_hdr[0];
1087                         hdr2->field_selector = 0;
1088                         proto_hdrs->count++;
1089                         tun_lvl--;
1090
1091                         if (tun_lvl == TUNNEL_LEVEL_OUTER) {
1092                                 if (phint & IAVF_PHINT_OUTER_IPV4)
1093                                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr2, IPV4);
1094                                 else if (phint & IAVF_PHINT_OUTER_IPV6)
1095                                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr2, IPV6);
1096                         } else if (tun_lvl == TUNNEL_LEVEL_INNER) {
1097                                 if (phint & IAVF_PHINT_MID_IPV4)
1098                                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr2, IPV4);
1099                                 else if (phint & IAVF_PHINT_MID_IPV6)
1100                                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr2, IPV6);
1101                         }
1102                 }
1103
1104                 hdr1->field_selector = 0;
1105                 proto_hdrs->count++;
1106
1107                 if (phint & IAVF_PHINT_GTPU_EH_DWN)
1108                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr1, GTPU_EH_PDU_DWN);
1109                 else if (phint & IAVF_PHINT_GTPU_EH_UP)
1110                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr1, GTPU_EH_PDU_UP);
1111                 else if (phint & IAVF_PHINT_GTPU_EH)
1112                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr1, GTPU_EH);
1113                 else if (phint & IAVF_PHINT_GTPU)
1114                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr1, GTPU_IP);
1115
1116                 if (phint & IAVF_PHINT_GRE) {
1117                         if (phint & IAVF_PHINT_GTPU) {
1118                                 /* if GTPoGRE, add GRE header at the outer tunnel  */
1119                                 if (tun_lvl == TUNNEL_LEVEL_OUTER)
1120                                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr1, GRE);
1121                         } else {
1122                                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr1, GRE);
1123                         }
1124                 }
1125         }
1126         proto_hdrs->tunnel_level = tun_lvl;
1127 }
1128
1129 static void
1130 iavf_refine_proto_hdrs_l2tpv2(struct virtchnl_proto_hdrs *proto_hdrs,
1131                               uint64_t phint)
1132 {
1133         struct virtchnl_proto_hdr *hdr1;
1134         int i;
1135
1136         if (!(phint & IAVF_PHINT_L2TPV2))
1137                 return;
1138
1139         if (proto_hdrs->tunnel_level == TUNNEL_LEVEL_INNER) {
1140                 /* shift headers layer */
1141                 for (i = proto_hdrs->count - 1 + 1; i > 0; i--)
1142                         proto_hdrs->proto_hdr[i] = proto_hdrs->proto_hdr[i - 1];
1143
1144                 /* adding outer ip header at layer 0 */
1145                 hdr1 = &proto_hdrs->proto_hdr[0];
1146                 hdr1->field_selector = 0;
1147                 proto_hdrs->count++;
1148                 proto_hdrs->tunnel_level = TUNNEL_LEVEL_OUTER;
1149                 if (phint & IAVF_PHINT_OUTER_IPV4)
1150                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr1, IPV4);
1151                 else if (phint & IAVF_PHINT_OUTER_IPV6)
1152                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr1, IPV6);
1153         }
1154 }
1155
1156 static void iavf_refine_proto_hdrs(struct virtchnl_proto_hdrs *proto_hdrs,
1157                                    uint64_t rss_type, uint64_t phint)
1158 {
1159         iavf_refine_proto_hdrs_l234(proto_hdrs, rss_type);
1160         iavf_refine_proto_hdrs_by_pattern(proto_hdrs, phint);
1161         iavf_refine_proto_hdrs_gtpu(proto_hdrs, rss_type);
1162         iavf_refine_proto_hdrs_l2tpv2(proto_hdrs, phint);
1163 }
1164
1165 static uint64_t invalid_rss_comb[] = {
1166         RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_UDP,
1167         RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_TCP,
1168         RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_UDP,
1169         RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_TCP,
1170         RTE_ETH_RSS_L3_PRE32 | RTE_ETH_RSS_L3_PRE40 |
1171         RTE_ETH_RSS_L3_PRE48 | RTE_ETH_RSS_L3_PRE56 |
1172         RTE_ETH_RSS_L3_PRE96
1173 };
1174
1175 struct rss_attr_type {
1176         uint64_t attr;
1177         uint64_t type;
1178 };
1179
1180 #define VALID_RSS_IPV4_L4       (RTE_ETH_RSS_NONFRAG_IPV4_UDP   | \
1181                                  RTE_ETH_RSS_NONFRAG_IPV4_TCP   | \
1182                                  RTE_ETH_RSS_NONFRAG_IPV4_SCTP)
1183
1184 #define VALID_RSS_IPV6_L4       (RTE_ETH_RSS_NONFRAG_IPV6_UDP   | \
1185                                  RTE_ETH_RSS_NONFRAG_IPV6_TCP   | \
1186                                  RTE_ETH_RSS_NONFRAG_IPV6_SCTP)
1187
1188 #define VALID_RSS_IPV4          (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 | \
1189                                  VALID_RSS_IPV4_L4)
1190 #define VALID_RSS_IPV6          (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 | \
1191                                  VALID_RSS_IPV6_L4)
1192 #define VALID_RSS_L3            (VALID_RSS_IPV4 | VALID_RSS_IPV6)
1193 #define VALID_RSS_L4            (VALID_RSS_IPV4_L4 | VALID_RSS_IPV6_L4)
1194
1195 #define VALID_RSS_ATTR          (RTE_ETH_RSS_L3_SRC_ONLY        | \
1196                                  RTE_ETH_RSS_L3_DST_ONLY        | \
1197                                  RTE_ETH_RSS_L4_SRC_ONLY        | \
1198                                  RTE_ETH_RSS_L4_DST_ONLY        | \
1199                                  RTE_ETH_RSS_L2_SRC_ONLY        | \
1200                                  RTE_ETH_RSS_L2_DST_ONLY        | \
1201                                  RTE_ETH_RSS_L3_PRE64)
1202
1203 #define INVALID_RSS_ATTR        (RTE_ETH_RSS_L3_PRE32   | \
1204                                  RTE_ETH_RSS_L3_PRE40   | \
1205                                  RTE_ETH_RSS_L3_PRE48   | \
1206                                  RTE_ETH_RSS_L3_PRE56   | \
1207                                  RTE_ETH_RSS_L3_PRE96)
1208
1209 static struct rss_attr_type rss_attr_to_valid_type[] = {
1210         {RTE_ETH_RSS_L2_SRC_ONLY | RTE_ETH_RSS_L2_DST_ONLY,     RTE_ETH_RSS_ETH},
1211         {RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY,     VALID_RSS_L3},
1212         {RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY,     VALID_RSS_L4},
1213         /* current ipv6 prefix only supports prefix 64 bits*/
1214         {RTE_ETH_RSS_L3_PRE64,                          VALID_RSS_IPV6},
1215         {INVALID_RSS_ATTR,                              0}
1216 };
1217
1218 static bool
1219 iavf_any_invalid_rss_type(enum rte_eth_hash_function rss_func,
1220                           uint64_t rss_type, uint64_t allow_rss_type)
1221 {
1222         uint32_t i;
1223
1224         /**
1225          * Check if l3/l4 SRC/DST_ONLY is set for SYMMETRIC_TOEPLITZ
1226          * hash function.
1227          */
1228         if (rss_func == RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
1229                 if (rss_type & (RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY |
1230                     RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY))
1231                         return true;
1232
1233                 if (!(rss_type &
1234                    (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_IPV6 |
1235                     RTE_ETH_RSS_NONFRAG_IPV4_UDP | RTE_ETH_RSS_NONFRAG_IPV6_UDP |
1236                     RTE_ETH_RSS_NONFRAG_IPV4_TCP | RTE_ETH_RSS_NONFRAG_IPV6_TCP |
1237                     RTE_ETH_RSS_NONFRAG_IPV4_SCTP | RTE_ETH_RSS_NONFRAG_IPV6_SCTP)))
1238                         return true;
1239         }
1240
1241         /* check invalid combination */
1242         for (i = 0; i < RTE_DIM(invalid_rss_comb); i++) {
1243                 if (__builtin_popcountll(rss_type & invalid_rss_comb[i]) > 1)
1244                         return true;
1245         }
1246
1247         /* check invalid RSS attribute */
1248         for (i = 0; i < RTE_DIM(rss_attr_to_valid_type); i++) {
1249                 struct rss_attr_type *rat = &rss_attr_to_valid_type[i];
1250
1251                 if (rat->attr & rss_type && !(rat->type & rss_type))
1252                         return true;
1253         }
1254
1255         /* check not allowed RSS type */
1256         rss_type &= ~VALID_RSS_ATTR;
1257
1258         return ((rss_type & allow_rss_type) != rss_type);
1259 }
1260
1261 static int
1262 iavf_hash_parse_action(struct iavf_pattern_match_item *match_item,
1263                        const struct rte_flow_action actions[],
1264                        uint64_t pattern_hint, void **meta,
1265                        struct rte_flow_error *error)
1266 {
1267         struct iavf_rss_meta *rss_meta = (struct iavf_rss_meta *)*meta;
1268         struct virtchnl_proto_hdrs *proto_hdrs;
1269         enum rte_flow_action_type action_type;
1270         const struct rte_flow_action_rss *rss;
1271         const struct rte_flow_action *action;
1272         uint64_t rss_type;
1273
1274         /* Supported action is RSS. */
1275         for (action = actions; action->type !=
1276                 RTE_FLOW_ACTION_TYPE_END; action++) {
1277                 action_type = action->type;
1278                 switch (action_type) {
1279                 case RTE_FLOW_ACTION_TYPE_RSS:
1280                         rss = action->conf;
1281                         rss_type = rss->types;
1282
1283                         if (rss->func ==
1284                             RTE_ETH_HASH_FUNCTION_SIMPLE_XOR){
1285                                 rss_meta->rss_algorithm =
1286                                         VIRTCHNL_RSS_ALG_XOR_ASYMMETRIC;
1287                                 return rte_flow_error_set(error, ENOTSUP,
1288                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
1289                                         "function simple_xor is not supported");
1290                         } else if (rss->func ==
1291                                    RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
1292                                 rss_meta->rss_algorithm =
1293                                         VIRTCHNL_RSS_ALG_TOEPLITZ_SYMMETRIC;
1294                         } else {
1295                                 rss_meta->rss_algorithm =
1296                                         VIRTCHNL_RSS_ALG_TOEPLITZ_ASYMMETRIC;
1297                         }
1298
1299                         if (rss->level)
1300                                 return rte_flow_error_set(error, ENOTSUP,
1301                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
1302                                         "a nonzero RSS encapsulation level is not supported");
1303
1304                         if (rss->key_len)
1305                                 return rte_flow_error_set(error, ENOTSUP,
1306                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
1307                                         "a nonzero RSS key_len is not supported");
1308
1309                         if (rss->queue_num)
1310                                 return rte_flow_error_set(error, ENOTSUP,
1311                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
1312                                         "a non-NULL RSS queue is not supported");
1313
1314                         /**
1315                          * Check simultaneous use of SRC_ONLY and DST_ONLY
1316                          * of the same level.
1317                          */
1318                         rss_type = rte_eth_rss_hf_refine(rss_type);
1319
1320                         if (iavf_any_invalid_rss_type(rss->func, rss_type,
1321                                         match_item->input_set_mask))
1322                                 return rte_flow_error_set(error, ENOTSUP,
1323                                                 RTE_FLOW_ERROR_TYPE_ACTION,
1324                                                 action, "RSS type not supported");
1325                         proto_hdrs = match_item->meta;
1326                         rss_meta->proto_hdrs = *proto_hdrs;
1327                         iavf_refine_proto_hdrs(&rss_meta->proto_hdrs,
1328                                                rss_type, pattern_hint);
1329                         break;
1330
1331                 case RTE_FLOW_ACTION_TYPE_END:
1332                         break;
1333
1334                 default:
1335                         rte_flow_error_set(error, EINVAL,
1336                                            RTE_FLOW_ERROR_TYPE_ACTION, action,
1337                                            "Invalid action.");
1338                         return -rte_errno;
1339                 }
1340         }
1341
1342         return 0;
1343 }
1344
1345 static int
1346 iavf_hash_parse_pattern_action(__rte_unused struct iavf_adapter *ad,
1347                                struct iavf_pattern_match_item *array,
1348                                uint32_t array_len,
1349                                const struct rte_flow_item pattern[],
1350                                const struct rte_flow_action actions[],
1351                                void **meta,
1352                                struct rte_flow_error *error)
1353 {
1354         struct iavf_pattern_match_item *pattern_match_item;
1355         struct iavf_rss_meta *rss_meta_ptr;
1356         uint64_t phint = IAVF_PHINT_NONE;
1357         int ret = 0;
1358
1359         rss_meta_ptr = rte_zmalloc(NULL, sizeof(*rss_meta_ptr), 0);
1360         if (!rss_meta_ptr) {
1361                 rte_flow_error_set(error, EINVAL,
1362                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1363                                    "No memory for rss_meta_ptr");
1364                 return -ENOMEM;
1365         }
1366
1367         /* Check rss supported pattern and find matched pattern. */
1368         pattern_match_item =
1369                 iavf_search_pattern_match_item(pattern, array, array_len,
1370                                                error);
1371         if (!pattern_match_item) {
1372                 ret = -rte_errno;
1373                 goto error;
1374         }
1375
1376         ret = iavf_hash_parse_pattern(pattern, &phint, error);
1377         if (ret)
1378                 goto error;
1379
1380         ret = iavf_hash_parse_action(pattern_match_item, actions, phint,
1381                                      (void **)&rss_meta_ptr, error);
1382
1383 error:
1384         if (!ret && meta)
1385                 *meta = rss_meta_ptr;
1386         else
1387                 rte_free(rss_meta_ptr);
1388
1389         rte_free(pattern_match_item);
1390
1391         return ret;
1392 }
1393
1394 static int
1395 iavf_hash_create(__rte_unused struct iavf_adapter *ad,
1396                  __rte_unused struct rte_flow *flow, void *meta,
1397                  __rte_unused struct rte_flow_error *error)
1398 {
1399         struct iavf_rss_meta *rss_meta = (struct iavf_rss_meta *)meta;
1400         struct virtchnl_rss_cfg *rss_cfg;
1401         int ret = 0;
1402
1403         rss_cfg = rte_zmalloc("iavf rss rule",
1404                               sizeof(struct virtchnl_rss_cfg), 0);
1405         if (!rss_cfg) {
1406                 rte_flow_error_set(error, EINVAL,
1407                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1408                                    "No memory for rss rule");
1409                 return -ENOMEM;
1410         }
1411
1412         rss_cfg->proto_hdrs = rss_meta->proto_hdrs;
1413         rss_cfg->rss_algorithm = rss_meta->rss_algorithm;
1414
1415         ret = iavf_add_del_rss_cfg(ad, rss_cfg, true);
1416         if (!ret) {
1417                 flow->rule = rss_cfg;
1418         } else {
1419                 PMD_DRV_LOG(ERR, "fail to add RSS configure");
1420                 rte_flow_error_set(error, -ret,
1421                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1422                                    "Failed to add rss rule.");
1423                 rte_free(rss_cfg);
1424                 return -rte_errno;
1425         }
1426
1427         rte_free(meta);
1428
1429         return ret;
1430 }
1431
1432 static int
1433 iavf_hash_destroy(__rte_unused struct iavf_adapter *ad,
1434                   struct rte_flow *flow,
1435                   __rte_unused struct rte_flow_error *error)
1436 {
1437         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1438         struct virtchnl_rss_cfg *rss_cfg;
1439         int ret = 0;
1440
1441         if (vf->vf_reset)
1442                 return 0;
1443
1444         rss_cfg = (struct virtchnl_rss_cfg *)flow->rule;
1445
1446         ret = iavf_add_del_rss_cfg(ad, rss_cfg, false);
1447         if (ret) {
1448                 PMD_DRV_LOG(ERR, "fail to del RSS configure");
1449                 rte_flow_error_set(error, -ret,
1450                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1451                                    "Failed to delete rss rule.");
1452                 return -rte_errno;
1453         }
1454         return ret;
1455 }
1456
1457 static void
1458 iavf_hash_uninit(struct iavf_adapter *ad)
1459 {
1460         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1461         struct rte_eth_rss_conf *rss_conf;
1462
1463         if (vf->vf_reset)
1464                 return;
1465
1466         if (!vf->vf_res)
1467                 return;
1468
1469         if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF))
1470                 return;
1471
1472         rss_conf = &ad->dev_data->dev_conf.rx_adv_conf.rss_conf;
1473         if (iavf_rss_hash_set(ad, rss_conf->rss_hf, false))
1474                 PMD_DRV_LOG(ERR, "fail to delete default RSS");
1475
1476         iavf_unregister_parser(&iavf_hash_parser, ad);
1477 }
1478
1479 static void
1480 iavf_hash_free(struct rte_flow *flow)
1481 {
1482         rte_free(flow->rule);
1483 }