drivers/net/ice/ice_hash.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 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 "ice_logs.h"
  23 #include "base/ice_type.h"
  24 #include "base/ice_flow.h"
  25 #include "ice_ethdev.h"
  26 #include "ice_generic_flow.h"
  27
  28 #define ICE_PHINT_NONE                          0
  29 #define ICE_PHINT_VLAN                          BIT_ULL(0)
  30 #define ICE_PHINT_PPPOE                         BIT_ULL(1)
  31 #define ICE_PHINT_GTPU                          BIT_ULL(2)
  32 #define ICE_PHINT_GTPU_EH                       BIT_ULL(3)
  33 #define ICE_PHINT_GTPU_EH_DWN                   BIT_ULL(4)
  34 #define ICE_PHINT_GTPU_EH_UP                    BIT_ULL(5)
  35
  36 #define ICE_GTPU_EH_DWNLINK     0
  37 #define ICE_GTPU_EH_UPLINK      1
  38
  39 #define ICE_IPV4_PROT           BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)
  40 #define ICE_IPV6_PROT           BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)
  41
  42 #define VALID_RSS_IPV4_L4       (RTE_ETH_RSS_NONFRAG_IPV4_UDP   | \
  43                                  RTE_ETH_RSS_NONFRAG_IPV4_TCP   | \
  44                                  RTE_ETH_RSS_NONFRAG_IPV4_SCTP)
  45
  46 #define VALID_RSS_IPV6_L4       (RTE_ETH_RSS_NONFRAG_IPV6_UDP   | \
  47                                  RTE_ETH_RSS_NONFRAG_IPV6_TCP   | \
  48                                  RTE_ETH_RSS_NONFRAG_IPV6_SCTP)
  49
  50 #define VALID_RSS_IPV4          (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 | \
  51                                  VALID_RSS_IPV4_L4)
  52 #define VALID_RSS_IPV6          (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 | \
  53                                  VALID_RSS_IPV6_L4)
  54 #define VALID_RSS_L3            (VALID_RSS_IPV4 | VALID_RSS_IPV6)
  55 #define VALID_RSS_L4            (VALID_RSS_IPV4_L4 | VALID_RSS_IPV6_L4)
  56
  57 #define VALID_RSS_ATTR          (RTE_ETH_RSS_L3_SRC_ONLY        | \
  58                                  RTE_ETH_RSS_L3_DST_ONLY        | \
  59                                  RTE_ETH_RSS_L4_SRC_ONLY        | \
  60                                  RTE_ETH_RSS_L4_DST_ONLY        | \
  61                                  RTE_ETH_RSS_L2_SRC_ONLY        | \
  62                                  RTE_ETH_RSS_L2_DST_ONLY        | \
  63                                  RTE_ETH_RSS_L3_PRE32   | \
  64                                  RTE_ETH_RSS_L3_PRE48   | \
  65                                  RTE_ETH_RSS_L3_PRE64)
  66
  67 #define INVALID_RSS_ATTR        (RTE_ETH_RSS_L3_PRE40   | \
  68                                  RTE_ETH_RSS_L3_PRE56   | \
  69                                  RTE_ETH_RSS_L3_PRE96)
  70
  71 struct ice_rss_meta {
  72         uint8_t hash_function;
  73         struct ice_rss_hash_cfg cfg;
  74 };
  75
  76 struct ice_hash_flow_cfg {
  77         bool simple_xor;
  78         struct ice_rss_cfg rss_cfg;
  79 };
  80
  81 static int
  82 ice_hash_init(struct ice_adapter *ad);
  83
  84 static int
  85 ice_hash_create(struct ice_adapter *ad,
  86                 struct rte_flow *flow,
  87                 void *meta,
  88                 struct rte_flow_error *error);
  89
  90 static int
  91 ice_hash_destroy(struct ice_adapter *ad,
  92                 struct rte_flow *flow,
  93                 struct rte_flow_error *error);
  94
  95 static void
  96 ice_hash_uninit(struct ice_adapter *ad);
  97
  98 static void
  99 ice_hash_free(struct rte_flow *flow);
 100
 101 static int
 102 ice_hash_parse_pattern_action(struct ice_adapter *ad,
 103                         struct ice_pattern_match_item *array,
 104                         uint32_t array_len,
 105                         const struct rte_flow_item pattern[],
 106                         const struct rte_flow_action actions[],
 107                         uint32_t priority,
 108                         void **meta,
 109                         struct rte_flow_error *error);
 110
 111 /* Rss configuration template */
 112 struct ice_rss_hash_cfg ipv4_tmplt = {
 113         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
 114         ICE_FLOW_SEG_HDR_IPV_OTHER,
 115         ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV4,
 116         ICE_RSS_OUTER_HEADERS,
 117         0
 118 };
 119
 120 struct ice_rss_hash_cfg ipv4_udp_tmplt = {
 121         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
 122         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 123         ICE_FLOW_HASH_ETH | ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
 124         ICE_RSS_OUTER_HEADERS,
 125         0
 126 };
 127
 128 struct ice_rss_hash_cfg ipv4_tcp_tmplt = {
 129         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
 130         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 131         ICE_FLOW_HASH_ETH | ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
 132         ICE_RSS_OUTER_HEADERS,
 133         0
 134 };
 135
 136 struct ice_rss_hash_cfg ipv4_sctp_tmplt = {
 137         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
 138         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
 139         ICE_FLOW_HASH_ETH | ICE_HASH_SCTP_IPV4 | ICE_IPV4_PROT,
 140         ICE_RSS_OUTER_HEADERS,
 141         0
 142 };
 143
 144 struct ice_rss_hash_cfg ipv6_tmplt = {
 145         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
 146         ICE_FLOW_SEG_HDR_IPV_OTHER,
 147         ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV6,
 148         ICE_RSS_OUTER_HEADERS,
 149         0
 150 };
 151
 152 struct ice_rss_hash_cfg ipv6_frag_tmplt = {
 153         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
 154         ICE_FLOW_SEG_HDR_IPV_FRAG,
 155         ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV6,
 156         ICE_RSS_OUTER_HEADERS,
 157         0
 158 };
 159
 160 struct ice_rss_hash_cfg ipv6_udp_tmplt = {
 161         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
 162         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 163         ICE_FLOW_HASH_ETH | ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
 164         ICE_RSS_OUTER_HEADERS,
 165         0
 166 };
 167
 168 struct ice_rss_hash_cfg ipv6_tcp_tmplt = {
 169         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
 170         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 171         ICE_FLOW_HASH_ETH | ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
 172         ICE_RSS_OUTER_HEADERS,
 173         0
 174 };
 175
 176 struct ice_rss_hash_cfg ipv6_sctp_tmplt = {
 177         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
 178         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
 179         ICE_FLOW_HASH_ETH | ICE_HASH_SCTP_IPV6 | ICE_IPV6_PROT,
 180         ICE_RSS_OUTER_HEADERS,
 181         0
 182 };
 183
 184 struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_tmplt = {
 185         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
 186         ICE_FLOW_HASH_IPV4,
 187         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
 188         0
 189 };
 190 struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_udp_tmplt = {
 191         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 192         ICE_FLOW_SEG_HDR_UDP,
 193         ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
 194         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
 195         0
 196 };
 197
 198 struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_tcp_tmplt = {
 199         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 200         ICE_FLOW_SEG_HDR_TCP,
 201         ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
 202         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
 203         0
 204 };
 205
 206 struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_tmplt = {
 207         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
 208         ICE_FLOW_HASH_IPV4,
 209         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
 210         0
 211 };
 212
 213 struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_udp_tmplt = {
 214         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 215         ICE_FLOW_SEG_HDR_UDP,
 216         ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
 217         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
 218         0
 219 };
 220
 221 struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_tcp_tmplt = {
 222         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 223         ICE_FLOW_SEG_HDR_TCP,
 224         ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
 225         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
 226         0
 227 };
 228
 229 struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_tmplt = {
 230         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
 231         ICE_FLOW_HASH_IPV6,
 232         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
 233         0
 234 };
 235
 236 struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_udp_tmplt = {
 237         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 238         ICE_FLOW_SEG_HDR_UDP,
 239         ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
 240         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
 241         0
 242 };
 243
 244 struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_tcp_tmplt = {
 245         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 246         ICE_FLOW_SEG_HDR_TCP,
 247         ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
 248         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
 249         0
 250 };
 251
 252 struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_tmplt = {
 253         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
 254         ICE_FLOW_HASH_IPV6,
 255         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
 256         0
 257 };
 258 struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_udp_tmplt = {
 259         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 260         ICE_FLOW_SEG_HDR_UDP,
 261         ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
 262         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
 263         0
 264 };
 265
 266 struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_tcp_tmplt = {
 267         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 268         ICE_FLOW_SEG_HDR_TCP,
 269         ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
 270         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
 271         0
 272 };
 273
 274 struct ice_rss_hash_cfg eth_ipv4_esp_tmplt = {
 275         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 276         ICE_FLOW_SEG_HDR_ESP,
 277         ICE_FLOW_HASH_ESP_SPI,
 278         ICE_RSS_OUTER_HEADERS,
 279         0
 280 };
 281
 282 struct ice_rss_hash_cfg eth_ipv4_udp_esp_tmplt = {
 283         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 284         ICE_FLOW_SEG_HDR_NAT_T_ESP,
 285         ICE_FLOW_HASH_NAT_T_ESP_SPI,
 286         ICE_RSS_OUTER_HEADERS,
 287         0
 288 };
 289
 290 struct ice_rss_hash_cfg eth_ipv4_ah_tmplt = {
 291         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 292         ICE_FLOW_SEG_HDR_AH,
 293         ICE_FLOW_HASH_AH_SPI,
 294         ICE_RSS_OUTER_HEADERS,
 295         0
 296 };
 297
 298 struct ice_rss_hash_cfg eth_ipv4_l2tpv3_tmplt = {
 299         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 300         ICE_FLOW_SEG_HDR_L2TPV3,
 301         ICE_FLOW_HASH_L2TPV3_SESS_ID,
 302         ICE_RSS_OUTER_HEADERS,
 303         0
 304 };
 305
 306 struct ice_rss_hash_cfg eth_ipv4_pfcp_tmplt = {
 307         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 308         ICE_FLOW_SEG_HDR_PFCP_SESSION,
 309         ICE_FLOW_HASH_PFCP_SEID,
 310         ICE_RSS_OUTER_HEADERS,
 311         0
 312 };
 313
 314 struct ice_rss_hash_cfg eth_ipv6_esp_tmplt = {
 315         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 316         ICE_FLOW_SEG_HDR_ESP,
 317         ICE_FLOW_HASH_ESP_SPI,
 318         ICE_RSS_OUTER_HEADERS,
 319         0
 320 };
 321
 322 struct ice_rss_hash_cfg eth_ipv6_udp_esp_tmplt = {
 323         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 324         ICE_FLOW_SEG_HDR_NAT_T_ESP,
 325         ICE_FLOW_HASH_NAT_T_ESP_SPI,
 326         ICE_RSS_OUTER_HEADERS,
 327         0
 328 };
 329
 330 struct ice_rss_hash_cfg eth_ipv6_ah_tmplt = {
 331         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 332         ICE_FLOW_SEG_HDR_AH,
 333         ICE_FLOW_HASH_AH_SPI,
 334         ICE_RSS_OUTER_HEADERS,
 335         0
 336 };
 337
 338 struct ice_rss_hash_cfg eth_ipv6_l2tpv3_tmplt = {
 339         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 340         ICE_FLOW_SEG_HDR_L2TPV3,
 341         ICE_FLOW_HASH_L2TPV3_SESS_ID,
 342         ICE_RSS_OUTER_HEADERS,
 343         0
 344 };
 345
 346 struct ice_rss_hash_cfg eth_ipv6_pfcp_tmplt = {
 347         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 348         ICE_FLOW_SEG_HDR_PFCP_SESSION,
 349         ICE_FLOW_HASH_PFCP_SEID,
 350         ICE_RSS_OUTER_HEADERS,
 351         0
 352 };
 353
 354 struct ice_rss_hash_cfg pppoe_tmplt = {
 355         ICE_FLOW_SEG_HDR_ETH,
 356         ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_PPPOE_SESS_ID,
 357         ICE_RSS_OUTER_HEADERS,
 358         0
 359 };
 360
 361 struct ice_rss_hash_cfg empty_tmplt = {
 362         ICE_FLOW_SEG_HDR_NONE,
 363         0,
 364         ICE_RSS_ANY_HEADERS,
 365         0
 366 };
 367
 368 struct ice_rss_hash_cfg eth_tmplt = {
 369         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_ETH_NON_IP,
 370         ICE_FLOW_HASH_ETH,
 371         ICE_RSS_OUTER_HEADERS,
 372         0
 373 };
 374
 375 /* IPv4 */
 376 #define ICE_RSS_TYPE_ETH_IPV4           (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV4 | \
 377                                          RTE_ETH_RSS_FRAG_IPV4 | \
 378                                          RTE_ETH_RSS_IPV4_CHKSUM)
 379 #define ICE_RSS_TYPE_ETH_IPV4_UDP       (ICE_RSS_TYPE_ETH_IPV4 | \
 380                                          RTE_ETH_RSS_NONFRAG_IPV4_UDP | \
 381                                          RTE_ETH_RSS_L4_CHKSUM)
 382 #define ICE_RSS_TYPE_ETH_IPV4_TCP       (ICE_RSS_TYPE_ETH_IPV4 | \
 383                                          RTE_ETH_RSS_NONFRAG_IPV4_TCP | \
 384                                          RTE_ETH_RSS_L4_CHKSUM)
 385 #define ICE_RSS_TYPE_ETH_IPV4_SCTP      (ICE_RSS_TYPE_ETH_IPV4 | \
 386                                          RTE_ETH_RSS_NONFRAG_IPV4_SCTP | \
 387                                          RTE_ETH_RSS_L4_CHKSUM)
 388 #define ICE_RSS_TYPE_IPV4               RTE_ETH_RSS_IPV4
 389 #define ICE_RSS_TYPE_IPV4_UDP           (RTE_ETH_RSS_IPV4 | \
 390                                          RTE_ETH_RSS_NONFRAG_IPV4_UDP)
 391 #define ICE_RSS_TYPE_IPV4_TCP           (RTE_ETH_RSS_IPV4 | \
 392                                          RTE_ETH_RSS_NONFRAG_IPV4_TCP)
 393 #define ICE_RSS_TYPE_IPV4_SCTP          (RTE_ETH_RSS_IPV4 | \
 394                                          RTE_ETH_RSS_NONFRAG_IPV4_SCTP)
 395
 396 /* IPv6 */
 397 #define ICE_RSS_TYPE_ETH_IPV6           (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV6)
 398 #define ICE_RSS_TYPE_ETH_IPV6_FRAG      (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV6 | \
 399                                          RTE_ETH_RSS_FRAG_IPV6)
 400 #define ICE_RSS_TYPE_ETH_IPV6_UDP       (ICE_RSS_TYPE_ETH_IPV6 | \
 401                                          RTE_ETH_RSS_NONFRAG_IPV6_UDP | \
 402                                          RTE_ETH_RSS_L4_CHKSUM)
 403 #define ICE_RSS_TYPE_ETH_IPV6_TCP       (ICE_RSS_TYPE_ETH_IPV6 | \
 404                                          RTE_ETH_RSS_NONFRAG_IPV6_TCP | \
 405                                          RTE_ETH_RSS_L4_CHKSUM)
 406 #define ICE_RSS_TYPE_ETH_IPV6_SCTP      (ICE_RSS_TYPE_ETH_IPV6 | \
 407                                          RTE_ETH_RSS_NONFRAG_IPV6_SCTP | \
 408                                          RTE_ETH_RSS_L4_CHKSUM)
 409 #define ICE_RSS_TYPE_IPV6               RTE_ETH_RSS_IPV6
 410 #define ICE_RSS_TYPE_IPV6_UDP           (RTE_ETH_RSS_IPV6 | \
 411                                          RTE_ETH_RSS_NONFRAG_IPV6_UDP)
 412 #define ICE_RSS_TYPE_IPV6_TCP           (RTE_ETH_RSS_IPV6 | \
 413                                          RTE_ETH_RSS_NONFRAG_IPV6_TCP)
 414 #define ICE_RSS_TYPE_IPV6_SCTP          (RTE_ETH_RSS_IPV6 | \
 415                                          RTE_ETH_RSS_NONFRAG_IPV6_SCTP)
 416
 417 /* VLAN IPV4 */
 418 #define ICE_RSS_TYPE_VLAN_IPV4          (ICE_RSS_TYPE_IPV4 | \
 419                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN | \
 420                                          RTE_ETH_RSS_FRAG_IPV4)
 421 #define ICE_RSS_TYPE_VLAN_IPV4_UDP      (ICE_RSS_TYPE_IPV4_UDP | \
 422                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 423 #define ICE_RSS_TYPE_VLAN_IPV4_TCP      (ICE_RSS_TYPE_IPV4_TCP | \
 424                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 425 #define ICE_RSS_TYPE_VLAN_IPV4_SCTP     (ICE_RSS_TYPE_IPV4_SCTP | \
 426                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 427 /* VLAN IPv6 */
 428 #define ICE_RSS_TYPE_VLAN_IPV6          (ICE_RSS_TYPE_IPV6 | \
 429                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 430 #define ICE_RSS_TYPE_VLAN_IPV6_FRAG     (ICE_RSS_TYPE_IPV6 | \
 431                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN | \
 432                                          RTE_ETH_RSS_FRAG_IPV6)
 433 #define ICE_RSS_TYPE_VLAN_IPV6_UDP      (ICE_RSS_TYPE_IPV6_UDP | \
 434                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 435 #define ICE_RSS_TYPE_VLAN_IPV6_TCP      (ICE_RSS_TYPE_IPV6_TCP | \
 436                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 437 #define ICE_RSS_TYPE_VLAN_IPV6_SCTP     (ICE_RSS_TYPE_IPV6_SCTP | \
 438                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
 439
 440 /* GTPU IPv4 */
 441 #define ICE_RSS_TYPE_GTPU_IPV4          (ICE_RSS_TYPE_IPV4 | \
 442                                          RTE_ETH_RSS_GTPU)
 443 #define ICE_RSS_TYPE_GTPU_IPV4_UDP      (ICE_RSS_TYPE_IPV4_UDP | \
 444                                          RTE_ETH_RSS_GTPU)
 445 #define ICE_RSS_TYPE_GTPU_IPV4_TCP      (ICE_RSS_TYPE_IPV4_TCP | \
 446                                          RTE_ETH_RSS_GTPU)
 447 /* GTPU IPv6 */
 448 #define ICE_RSS_TYPE_GTPU_IPV6          (ICE_RSS_TYPE_IPV6 | \
 449                                          RTE_ETH_RSS_GTPU)
 450 #define ICE_RSS_TYPE_GTPU_IPV6_UDP      (ICE_RSS_TYPE_IPV6_UDP | \
 451                                          RTE_ETH_RSS_GTPU)
 452 #define ICE_RSS_TYPE_GTPU_IPV6_TCP      (ICE_RSS_TYPE_IPV6_TCP | \
 453                                          RTE_ETH_RSS_GTPU)
 454
 455 /* PPPOE */
 456 #define ICE_RSS_TYPE_PPPOE              (RTE_ETH_RSS_ETH | RTE_ETH_RSS_PPPOE)
 457
 458 /* PPPOE IPv4 */
 459 #define ICE_RSS_TYPE_PPPOE_IPV4         (ICE_RSS_TYPE_IPV4 | \
 460                                          ICE_RSS_TYPE_PPPOE)
 461 #define ICE_RSS_TYPE_PPPOE_IPV4_UDP     (ICE_RSS_TYPE_IPV4_UDP | \
 462                                          ICE_RSS_TYPE_PPPOE)
 463 #define ICE_RSS_TYPE_PPPOE_IPV4_TCP     (ICE_RSS_TYPE_IPV4_TCP | \
 464                                          ICE_RSS_TYPE_PPPOE)
 465
 466 /* PPPOE IPv6 */
 467 #define ICE_RSS_TYPE_PPPOE_IPV6         (ICE_RSS_TYPE_IPV6 | \
 468                                          ICE_RSS_TYPE_PPPOE)
 469 #define ICE_RSS_TYPE_PPPOE_IPV6_UDP     (ICE_RSS_TYPE_IPV6_UDP | \
 470                                          ICE_RSS_TYPE_PPPOE)
 471 #define ICE_RSS_TYPE_PPPOE_IPV6_TCP     (ICE_RSS_TYPE_IPV6_TCP | \
 472                                          ICE_RSS_TYPE_PPPOE)
 473
 474 /* ESP, AH, L2TPV3 and PFCP */
 475 #define ICE_RSS_TYPE_IPV4_ESP           (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV4)
 476 #define ICE_RSS_TYPE_IPV6_ESP           (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV6)
 477 #define ICE_RSS_TYPE_IPV4_AH            (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV4)
 478 #define ICE_RSS_TYPE_IPV6_AH            (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV6)
 479 #define ICE_RSS_TYPE_IPV4_L2TPV3        (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV4)
 480 #define ICE_RSS_TYPE_IPV6_L2TPV3        (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV6)
 481 #define ICE_RSS_TYPE_IPV4_PFCP          (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV4)
 482 #define ICE_RSS_TYPE_IPV6_PFCP          (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV6)
 483
 484 /* MAC */
 485 #define ICE_RSS_TYPE_ETH                RTE_ETH_RSS_ETH
 486
 487 /**
 488  * Supported pattern for hash.
 489  * The first member is pattern item type,
 490  * the second member is input set mask,
 491  * the third member is ice_rss_hash_cfg template.
 492  */
 493 static struct ice_pattern_match_item ice_hash_pattern_list[] = {
 494         /* IPV4 */
 495         {pattern_eth_ipv4,                      ICE_RSS_TYPE_ETH_IPV4,          ICE_INSET_NONE, &ipv4_tmplt},
 496         {pattern_eth_ipv4_udp,                  ICE_RSS_TYPE_ETH_IPV4_UDP,      ICE_INSET_NONE, &ipv4_udp_tmplt},
 497         {pattern_eth_ipv4_tcp,                  ICE_RSS_TYPE_ETH_IPV4_TCP,      ICE_INSET_NONE, &ipv4_tcp_tmplt},
 498         {pattern_eth_ipv4_sctp,                 ICE_RSS_TYPE_ETH_IPV4_SCTP,     ICE_INSET_NONE, &ipv4_sctp_tmplt},
 499         {pattern_eth_vlan_ipv4,                 ICE_RSS_TYPE_VLAN_IPV4,         ICE_INSET_NONE, &ipv4_tmplt},
 500         {pattern_eth_vlan_ipv4_udp,             ICE_RSS_TYPE_VLAN_IPV4_UDP,     ICE_INSET_NONE, &ipv4_udp_tmplt},
 501         {pattern_eth_vlan_ipv4_tcp,             ICE_RSS_TYPE_VLAN_IPV4_TCP,     ICE_INSET_NONE, &ipv4_tcp_tmplt},
 502         {pattern_eth_vlan_ipv4_sctp,            ICE_RSS_TYPE_VLAN_IPV4_SCTP,    ICE_INSET_NONE, &ipv4_sctp_tmplt},
 503         {pattern_eth_ipv4_gtpu_ipv4,            ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tmplt},
 504         {pattern_eth_ipv4_gtpu_ipv4_udp,        ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_udp_tmplt},
 505         {pattern_eth_ipv4_gtpu_ipv4_tcp,        ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tcp_tmplt},
 506         {pattern_eth_ipv6_gtpu_ipv4,            ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tmplt},
 507         {pattern_eth_ipv6_gtpu_ipv4_udp,        ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_udp_tmplt},
 508         {pattern_eth_ipv6_gtpu_ipv4_tcp,        ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tcp_tmplt},
 509         {pattern_eth_ipv4_gtpu_eh_ipv4,         ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tmplt},
 510         {pattern_eth_ipv4_gtpu_eh_ipv4_udp,     ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_udp_tmplt},
 511         {pattern_eth_ipv4_gtpu_eh_ipv4_tcp,     ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tcp_tmplt},
 512         {pattern_eth_ipv6_gtpu_eh_ipv4,         ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tmplt},
 513         {pattern_eth_ipv6_gtpu_eh_ipv4_udp,     ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_udp_tmplt},
 514         {pattern_eth_ipv6_gtpu_eh_ipv4_tcp,     ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tcp_tmplt},
 515         {pattern_eth_pppoes_ipv4,               ICE_RSS_TYPE_PPPOE_IPV4,        ICE_INSET_NONE, &ipv4_tmplt},
 516         {pattern_eth_pppoes_ipv4_udp,           ICE_RSS_TYPE_PPPOE_IPV4_UDP,    ICE_INSET_NONE, &ipv4_udp_tmplt},
 517         {pattern_eth_pppoes_ipv4_tcp,           ICE_RSS_TYPE_PPPOE_IPV4_TCP,    ICE_INSET_NONE, &ipv4_tcp_tmplt},
 518         {pattern_eth_ipv4_esp,                  ICE_RSS_TYPE_IPV4_ESP,          ICE_INSET_NONE, &eth_ipv4_esp_tmplt},
 519         {pattern_eth_ipv4_udp_esp,              ICE_RSS_TYPE_IPV4_ESP,          ICE_INSET_NONE, &eth_ipv4_udp_esp_tmplt},
 520         {pattern_eth_ipv4_ah,                   ICE_RSS_TYPE_IPV4_AH,           ICE_INSET_NONE, &eth_ipv4_ah_tmplt},
 521         {pattern_eth_ipv4_l2tp,                 ICE_RSS_TYPE_IPV4_L2TPV3,       ICE_INSET_NONE, &eth_ipv4_l2tpv3_tmplt},
 522         {pattern_eth_ipv4_pfcp,                 ICE_RSS_TYPE_IPV4_PFCP,         ICE_INSET_NONE, &eth_ipv4_pfcp_tmplt},
 523         /* IPV6 */
 524         {pattern_eth_ipv6,                      ICE_RSS_TYPE_ETH_IPV6,          ICE_INSET_NONE, &ipv6_tmplt},
 525         {pattern_eth_ipv6_frag_ext,             ICE_RSS_TYPE_ETH_IPV6_FRAG,     ICE_INSET_NONE, &ipv6_frag_tmplt},
 526         {pattern_eth_ipv6_udp,                  ICE_RSS_TYPE_ETH_IPV6_UDP,      ICE_INSET_NONE, &ipv6_udp_tmplt},
 527         {pattern_eth_ipv6_tcp,                  ICE_RSS_TYPE_ETH_IPV6_TCP,      ICE_INSET_NONE, &ipv6_tcp_tmplt},
 528         {pattern_eth_ipv6_sctp,                 ICE_RSS_TYPE_ETH_IPV6_SCTP,     ICE_INSET_NONE, &ipv6_sctp_tmplt},
 529         {pattern_eth_vlan_ipv6,                 ICE_RSS_TYPE_VLAN_IPV6,         ICE_INSET_NONE, &ipv6_tmplt},
 530         {pattern_eth_vlan_ipv6_frag_ext,        ICE_RSS_TYPE_VLAN_IPV6_FRAG,    ICE_INSET_NONE, &ipv6_frag_tmplt},
 531         {pattern_eth_vlan_ipv6_udp,             ICE_RSS_TYPE_VLAN_IPV6_UDP,     ICE_INSET_NONE, &ipv6_udp_tmplt},
 532         {pattern_eth_vlan_ipv6_tcp,             ICE_RSS_TYPE_VLAN_IPV6_TCP,     ICE_INSET_NONE, &ipv6_tcp_tmplt},
 533         {pattern_eth_vlan_ipv6_sctp,            ICE_RSS_TYPE_VLAN_IPV6_SCTP,    ICE_INSET_NONE, &ipv6_sctp_tmplt},
 534         {pattern_eth_ipv4_gtpu_ipv6,            ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tmplt},
 535         {pattern_eth_ipv4_gtpu_ipv6_udp,        ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_udp_tmplt},
 536         {pattern_eth_ipv4_gtpu_ipv6_tcp,        ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tcp_tmplt},
 537         {pattern_eth_ipv6_gtpu_ipv6,            ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tmplt},
 538         {pattern_eth_ipv6_gtpu_ipv6_udp,        ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_udp_tmplt},
 539         {pattern_eth_ipv6_gtpu_ipv6_tcp,        ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tcp_tmplt},
 540         {pattern_eth_ipv4_gtpu_eh_ipv6,         ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tmplt},
 541         {pattern_eth_ipv4_gtpu_eh_ipv6_udp,     ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_udp_tmplt},
 542         {pattern_eth_ipv4_gtpu_eh_ipv6_tcp,     ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tcp_tmplt},
 543         {pattern_eth_ipv6_gtpu_eh_ipv6,         ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tmplt},
 544         {pattern_eth_ipv6_gtpu_eh_ipv6_udp,     ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_udp_tmplt},
 545         {pattern_eth_ipv6_gtpu_eh_ipv6_tcp,     ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tcp_tmplt},
 546         {pattern_eth_pppoes_ipv6,               ICE_RSS_TYPE_PPPOE_IPV6,        ICE_INSET_NONE, &ipv6_tmplt},
 547         {pattern_eth_pppoes_ipv6_udp,           ICE_RSS_TYPE_PPPOE_IPV6_UDP,    ICE_INSET_NONE, &ipv6_udp_tmplt},
 548         {pattern_eth_pppoes_ipv6_tcp,           ICE_RSS_TYPE_PPPOE_IPV6_TCP,    ICE_INSET_NONE, &ipv6_tcp_tmplt},
 549         {pattern_eth_ipv6_esp,                  ICE_RSS_TYPE_IPV6_ESP,          ICE_INSET_NONE, &eth_ipv6_esp_tmplt},
 550         {pattern_eth_ipv6_udp_esp,              ICE_RSS_TYPE_IPV6_ESP,          ICE_INSET_NONE, &eth_ipv6_udp_esp_tmplt},
 551         {pattern_eth_ipv6_ah,                   ICE_RSS_TYPE_IPV6_AH,           ICE_INSET_NONE, &eth_ipv6_ah_tmplt},
 552         {pattern_eth_ipv6_l2tp,                 ICE_RSS_TYPE_IPV6_L2TPV3,       ICE_INSET_NONE, &eth_ipv6_l2tpv3_tmplt},
 553         {pattern_eth_ipv6_pfcp,                 ICE_RSS_TYPE_IPV6_PFCP,         ICE_INSET_NONE, &eth_ipv6_pfcp_tmplt},
 554         /* PPPOE */
 555         {pattern_eth_pppoes,                    ICE_RSS_TYPE_PPPOE,             ICE_INSET_NONE, &pppoe_tmplt},
 556         /* MAC */
 557         {pattern_ethertype,                     ICE_RSS_TYPE_ETH,               ICE_INSET_NONE, &eth_tmplt},
 558         /* EMPTY */
 559         {pattern_empty,                         ICE_INSET_NONE,                 ICE_INSET_NONE, &empty_tmplt},
 560 };
 561
 562 static struct ice_flow_engine ice_hash_engine = {
 563         .init = ice_hash_init,
 564         .create = ice_hash_create,
 565         .destroy = ice_hash_destroy,
 566         .uninit = ice_hash_uninit,
 567         .free = ice_hash_free,
 568         .type = ICE_FLOW_ENGINE_HASH,
 569 };
 570
 571 /* Register parser for os package. */
 572 static struct ice_flow_parser ice_hash_parser = {
 573         .engine = &ice_hash_engine,
 574         .array = ice_hash_pattern_list,
 575         .array_len = RTE_DIM(ice_hash_pattern_list),
 576         .parse_pattern_action = ice_hash_parse_pattern_action,
 577         .stage = ICE_FLOW_STAGE_RSS,
 578 };
 579
 580 RTE_INIT(ice_hash_engine_init)
 581 {
 582         struct ice_flow_engine *engine = &ice_hash_engine;
 583         ice_register_flow_engine(engine);
 584 }
 585
 586 static int
 587 ice_hash_init(struct ice_adapter *ad)
 588 {
 589         struct ice_flow_parser *parser = NULL;
 590
 591         if (ad->hw.dcf_enabled)
 592                 return 0;
 593
 594         parser = &ice_hash_parser;
 595
 596         return ice_register_parser(parser, ad);
 597 }
 598
 599 static int
 600 ice_hash_parse_pattern(const struct rte_flow_item pattern[], uint64_t *phint,
 601                        struct rte_flow_error *error)
 602 {
 603         const struct rte_flow_item *item = pattern;
 604         const struct rte_flow_item_gtp_psc *psc;
 605
 606         for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
 607                 if (item->last) {
 608                         rte_flow_error_set(error, EINVAL,
 609                                         RTE_FLOW_ERROR_TYPE_ITEM, item,
 610                                         "Not support range");
 611                         return -rte_errno;
 612                 }
 613
 614                 switch (item->type) {
 615                 case RTE_FLOW_ITEM_TYPE_VLAN:
 616                         *phint |= ICE_PHINT_VLAN;
 617                         break;
 618                 case RTE_FLOW_ITEM_TYPE_PPPOES:
 619                         *phint |= ICE_PHINT_PPPOE;
 620                         break;
 621                 case RTE_FLOW_ITEM_TYPE_GTPU:
 622                         *phint |= ICE_PHINT_GTPU;
 623                         break;
 624                 case RTE_FLOW_ITEM_TYPE_GTP_PSC:
 625                         *phint |= ICE_PHINT_GTPU_EH;
 626                         psc = item->spec;
 627                         if (!psc)
 628                                 break;
 629                         else if (psc->hdr.type == ICE_GTPU_EH_UPLINK)
 630                                 *phint |= ICE_PHINT_GTPU_EH_UP;
 631                         else if (psc->hdr.type == ICE_GTPU_EH_DWNLINK)
 632                                 *phint |= ICE_PHINT_GTPU_EH_DWN;
 633                         break;
 634                 default:
 635                         break;
 636                 }
 637         }
 638
 639         return 0;
 640 }
 641
 642 static void
 643 ice_refine_hash_cfg_l234(struct ice_rss_hash_cfg *hash_cfg,
 644                          uint64_t rss_type)
 645 {
 646         uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
 647         uint64_t *hash_flds = &hash_cfg->hash_flds;
 648
 649         if (*addl_hdrs & ICE_FLOW_SEG_HDR_ETH) {
 650                 if (!(rss_type & RTE_ETH_RSS_ETH))
 651                         *hash_flds &= ~ICE_FLOW_HASH_ETH;
 652                 if (rss_type & RTE_ETH_RSS_L2_SRC_ONLY)
 653                         *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_DA));
 654                 else if (rss_type & RTE_ETH_RSS_L2_DST_ONLY)
 655                         *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_SA));
 656                 *addl_hdrs &= ~ICE_FLOW_SEG_HDR_ETH;
 657         }
 658
 659         if (*addl_hdrs & ICE_FLOW_SEG_HDR_ETH_NON_IP) {
 660                 if (rss_type & RTE_ETH_RSS_ETH)
 661                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_TYPE);
 662         }
 663
 664         if (*addl_hdrs & ICE_FLOW_SEG_HDR_VLAN) {
 665                 if (rss_type & RTE_ETH_RSS_C_VLAN)
 666                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_C_VLAN);
 667                 else if (rss_type & RTE_ETH_RSS_S_VLAN)
 668                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_S_VLAN);
 669         }
 670
 671         if (*addl_hdrs & ICE_FLOW_SEG_HDR_PPPOE) {
 672                 if (!(rss_type & RTE_ETH_RSS_PPPOE))
 673                         *hash_flds &= ~ICE_FLOW_HASH_PPPOE_SESS_ID;
 674         }
 675
 676         if (*addl_hdrs & ICE_FLOW_SEG_HDR_IPV4) {
 677                 if (rss_type &
 678                    (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 |
 679                     RTE_ETH_RSS_NONFRAG_IPV4_UDP |
 680                     RTE_ETH_RSS_NONFRAG_IPV4_TCP |
 681                     RTE_ETH_RSS_NONFRAG_IPV4_SCTP)) {
 682                         if (rss_type & RTE_ETH_RSS_FRAG_IPV4) {
 683                                 *addl_hdrs |= ICE_FLOW_SEG_HDR_IPV_FRAG;
 684                                 *addl_hdrs &= ~(ICE_FLOW_SEG_HDR_IPV_OTHER);
 685                                 *hash_flds |=
 686                                         BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_ID);
 687                         }
 688                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY)
 689                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA));
 690                         else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY)
 691                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA));
 692                         else if (rss_type &
 693                                 (RTE_ETH_RSS_L4_SRC_ONLY |
 694                                 RTE_ETH_RSS_L4_DST_ONLY))
 695                                 *hash_flds &= ~ICE_FLOW_HASH_IPV4;
 696                 } else {
 697                         *hash_flds &= ~ICE_FLOW_HASH_IPV4;
 698                 }
 699
 700                 if (rss_type & RTE_ETH_RSS_IPV4_CHKSUM)
 701                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM);
 702         }
 703
 704         if (*addl_hdrs & ICE_FLOW_SEG_HDR_IPV6) {
 705                 if (rss_type &
 706                    (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 |
 707                     RTE_ETH_RSS_NONFRAG_IPV6_UDP |
 708                     RTE_ETH_RSS_NONFRAG_IPV6_TCP |
 709                     RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
 710                         if (rss_type & RTE_ETH_RSS_FRAG_IPV6)
 711                                 *hash_flds |=
 712                                         BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_ID);
 713                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY)
 714                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
 715                         else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY)
 716                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
 717                         else if (rss_type &
 718                                 (RTE_ETH_RSS_L4_SRC_ONLY |
 719                                 RTE_ETH_RSS_L4_DST_ONLY))
 720                                 *hash_flds &= ~ICE_FLOW_HASH_IPV6;
 721                 } else {
 722                         *hash_flds &= ~ICE_FLOW_HASH_IPV6;
 723                 }
 724
 725                 if (rss_type & RTE_ETH_RSS_L3_PRE32) {
 726                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
 727                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
 728                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE32_SA));
 729                         } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
 730                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
 731                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE32_DA));
 732                         } else {
 733                                 *hash_flds &= ~ICE_FLOW_HASH_IPV6;
 734                                 *hash_flds |= ICE_FLOW_HASH_IPV6_PRE32;
 735                         }
 736                 }
 737                 if (rss_type & RTE_ETH_RSS_L3_PRE48) {
 738                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
 739                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
 740                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE48_SA));
 741                         } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
 742                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
 743                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE48_DA));
 744                         } else {
 745                                 *hash_flds &= ~ICE_FLOW_HASH_IPV6;
 746                                 *hash_flds |= ICE_FLOW_HASH_IPV6_PRE48;
 747                         }
 748                 }
 749                 if (rss_type & RTE_ETH_RSS_L3_PRE64) {
 750                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
 751                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
 752                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_SA));
 753                         } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
 754                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
 755                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_DA));
 756                         } else {
 757                                 *hash_flds &= ~ICE_FLOW_HASH_IPV6;
 758                                 *hash_flds |= ICE_FLOW_HASH_IPV6_PRE64;
 759                         }
 760                 }
 761         }
 762
 763         if (*addl_hdrs & ICE_FLOW_SEG_HDR_UDP) {
 764                 if (rss_type &
 765                    (RTE_ETH_RSS_NONFRAG_IPV4_UDP |
 766                     RTE_ETH_RSS_NONFRAG_IPV6_UDP)) {
 767                         if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
 768                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT));
 769                         else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
 770                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT));
 771                         else if (rss_type &
 772                                 (RTE_ETH_RSS_L3_SRC_ONLY |
 773                                   RTE_ETH_RSS_L3_DST_ONLY))
 774                                 *hash_flds &= ~ICE_FLOW_HASH_UDP_PORT;
 775                 } else {
 776                         *hash_flds &= ~ICE_FLOW_HASH_UDP_PORT;
 777                 }
 778
 779                 if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
 780                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_CHKSUM);
 781         }
 782
 783         if (*addl_hdrs & ICE_FLOW_SEG_HDR_TCP) {
 784                 if (rss_type &
 785                    (RTE_ETH_RSS_NONFRAG_IPV4_TCP |
 786                     RTE_ETH_RSS_NONFRAG_IPV6_TCP)) {
 787                         if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
 788                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT));
 789                         else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
 790                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT));
 791                         else if (rss_type &
 792                                 (RTE_ETH_RSS_L3_SRC_ONLY |
 793                                   RTE_ETH_RSS_L3_DST_ONLY))
 794                                 *hash_flds &= ~ICE_FLOW_HASH_TCP_PORT;
 795                 } else {
 796                         *hash_flds &= ~ICE_FLOW_HASH_TCP_PORT;
 797                 }
 798
 799                 if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
 800                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_CHKSUM);
 801         }
 802
 803         if (*addl_hdrs & ICE_FLOW_SEG_HDR_SCTP) {
 804                 if (rss_type &
 805                    (RTE_ETH_RSS_NONFRAG_IPV4_SCTP |
 806                     RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
 807                         if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
 808                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT));
 809                         else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
 810                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT));
 811                         else if (rss_type &
 812                                 (RTE_ETH_RSS_L3_SRC_ONLY |
 813                                   RTE_ETH_RSS_L3_DST_ONLY))
 814                                 *hash_flds &= ~ICE_FLOW_HASH_SCTP_PORT;
 815                 } else {
 816                         *hash_flds &= ~ICE_FLOW_HASH_SCTP_PORT;
 817                 }
 818
 819                 if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
 820                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_CHKSUM);
 821         }
 822
 823         if (*addl_hdrs & ICE_FLOW_SEG_HDR_L2TPV3) {
 824                 if (!(rss_type & RTE_ETH_RSS_L2TPV3))
 825                         *hash_flds &= ~ICE_FLOW_HASH_L2TPV3_SESS_ID;
 826         }
 827
 828         if (*addl_hdrs & ICE_FLOW_SEG_HDR_ESP) {
 829                 if (!(rss_type & RTE_ETH_RSS_ESP))
 830                         *hash_flds &= ~ICE_FLOW_HASH_ESP_SPI;
 831         }
 832
 833         if (*addl_hdrs & ICE_FLOW_SEG_HDR_AH) {
 834                 if (!(rss_type & RTE_ETH_RSS_AH))
 835                         *hash_flds &= ~ICE_FLOW_HASH_AH_SPI;
 836         }
 837
 838         if (*addl_hdrs & ICE_FLOW_SEG_HDR_PFCP_SESSION) {
 839                 if (!(rss_type & RTE_ETH_RSS_PFCP))
 840                         *hash_flds &= ~ICE_FLOW_HASH_PFCP_SEID;
 841         }
 842 }
 843
 844 static void
 845 ice_refine_proto_hdrs_by_pattern(struct ice_rss_hash_cfg *hash_cfg,
 846                                  uint64_t phint)
 847 {
 848         uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
 849         if (phint & ICE_PHINT_VLAN)
 850                 *addl_hdrs |= ICE_FLOW_SEG_HDR_VLAN;
 851
 852         if (phint & ICE_PHINT_PPPOE)
 853                 *addl_hdrs |= ICE_FLOW_SEG_HDR_PPPOE;
 854
 855         if (phint & ICE_PHINT_GTPU_EH_DWN)
 856                 *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_DWN;
 857         else if (phint & ICE_PHINT_GTPU_EH_UP)
 858                 *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_UP;
 859         else if (phint & ICE_PHINT_GTPU_EH)
 860                 *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_EH;
 861         else if (phint & ICE_PHINT_GTPU)
 862                 *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_IP;
 863 }
 864
 865 static void
 866 ice_refine_hash_cfg_gtpu(struct ice_rss_hash_cfg *hash_cfg,
 867                          uint64_t rss_type)
 868 {
 869         uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
 870         uint64_t *hash_flds = &hash_cfg->hash_flds;
 871
 872         /* update hash field for gtpu eh/gtpu dwn/gtpu up. */
 873         if (!(rss_type & RTE_ETH_RSS_GTPU))
 874                 return;
 875
 876         if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_DWN)
 877                 *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID);
 878         else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_UP)
 879                 *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_UP_TEID);
 880         else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_EH)
 881                 *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_EH_TEID);
 882         else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_IP)
 883                 *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_IP_TEID);
 884 }
 885
 886 static void ice_refine_hash_cfg(struct ice_rss_hash_cfg *hash_cfg,
 887                                 uint64_t rss_type, uint64_t phint)
 888 {
 889         ice_refine_proto_hdrs_by_pattern(hash_cfg, phint);
 890         ice_refine_hash_cfg_l234(hash_cfg, rss_type);
 891         ice_refine_hash_cfg_gtpu(hash_cfg, rss_type);
 892 }
 893
 894 static uint64_t invalid_rss_comb[] = {
 895         RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_UDP,
 896         RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_TCP,
 897         RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_UDP,
 898         RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_TCP,
 899         RTE_ETH_RSS_L3_PRE40 |
 900         RTE_ETH_RSS_L3_PRE56 |
 901         RTE_ETH_RSS_L3_PRE96
 902 };
 903
 904 struct rss_attr_type {
 905         uint64_t attr;
 906         uint64_t type;
 907 };
 908
 909 static struct rss_attr_type rss_attr_to_valid_type[] = {
 910         {RTE_ETH_RSS_L2_SRC_ONLY | RTE_ETH_RSS_L2_DST_ONLY,     RTE_ETH_RSS_ETH},
 911         {RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY,     VALID_RSS_L3},
 912         {RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY,     VALID_RSS_L4},
 913         /* current ipv6 prefix only supports prefix 64 bits*/
 914         {RTE_ETH_RSS_L3_PRE32,                          VALID_RSS_IPV6},
 915         {RTE_ETH_RSS_L3_PRE48,                          VALID_RSS_IPV6},
 916         {RTE_ETH_RSS_L3_PRE64,                          VALID_RSS_IPV6},
 917         {INVALID_RSS_ATTR,                              0}
 918 };
 919
 920 static bool
 921 ice_any_invalid_rss_type(enum rte_eth_hash_function rss_func,
 922                          uint64_t rss_type, uint64_t allow_rss_type)
 923 {
 924         uint32_t i;
 925
 926         /**
 927          * Check if l3/l4 SRC/DST_ONLY is set for SYMMETRIC_TOEPLITZ
 928          * hash function.
 929          */
 930         if (rss_func == RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
 931                 if (rss_type & (RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY |
 932                     RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY))
 933                         return true;
 934
 935                 if (!(rss_type &
 936                    (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_IPV6 |
 937                     RTE_ETH_RSS_FRAG_IPV4 | RTE_ETH_RSS_FRAG_IPV6 |
 938                     RTE_ETH_RSS_NONFRAG_IPV4_UDP | RTE_ETH_RSS_NONFRAG_IPV6_UDP |
 939                     RTE_ETH_RSS_NONFRAG_IPV4_TCP | RTE_ETH_RSS_NONFRAG_IPV6_TCP |
 940                     RTE_ETH_RSS_NONFRAG_IPV4_SCTP | RTE_ETH_RSS_NONFRAG_IPV6_SCTP)))
 941                         return true;
 942         }
 943
 944         /* check invalid combination */
 945         for (i = 0; i < RTE_DIM(invalid_rss_comb); i++) {
 946                 if (__builtin_popcountll(rss_type & invalid_rss_comb[i]) > 1)
 947                         return true;
 948         }
 949
 950         /* check invalid RSS attribute */
 951         for (i = 0; i < RTE_DIM(rss_attr_to_valid_type); i++) {
 952                 struct rss_attr_type *rat = &rss_attr_to_valid_type[i];
 953
 954                 if (rat->attr & rss_type && !(rat->type & rss_type))
 955                         return true;
 956         }
 957
 958         /* check not allowed RSS type */
 959         rss_type &= ~VALID_RSS_ATTR;
 960
 961         return ((rss_type & allow_rss_type) != rss_type);
 962 }
 963
 964 static int
 965 ice_hash_parse_action(struct ice_pattern_match_item *pattern_match_item,
 966                 const struct rte_flow_action actions[],
 967                 uint64_t pattern_hint, void **meta,
 968                 struct rte_flow_error *error)
 969 {
 970         struct ice_rss_meta *rss_meta = (struct ice_rss_meta *)*meta;
 971         struct ice_rss_hash_cfg *cfg = pattern_match_item->meta;
 972         enum rte_flow_action_type action_type;
 973         const struct rte_flow_action_rss *rss;
 974         const struct rte_flow_action *action;
 975         uint64_t rss_type;
 976
 977         /* Supported action is RSS. */
 978         for (action = actions; action->type !=
 979                 RTE_FLOW_ACTION_TYPE_END; action++) {
 980                 action_type = action->type;
 981                 switch (action_type) {
 982                 case RTE_FLOW_ACTION_TYPE_RSS:
 983                         rss = action->conf;
 984                         rss_type = rss->types;
 985
 986                         /* Check hash function and save it to rss_meta. */
 987                         if (pattern_match_item->pattern_list !=
 988                             pattern_empty && rss->func ==
 989                             RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
 990                                 return rte_flow_error_set(error, ENOTSUP,
 991                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
 992                                         "Not supported flow");
 993                         } else if (rss->func ==
 994                                    RTE_ETH_HASH_FUNCTION_SIMPLE_XOR){
 995                                 rss_meta->hash_function =
 996                                 RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
 997                                 return 0;
 998                         } else if (rss->func ==
 999                                    RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
1000                                 rss_meta->hash_function =
1001                                 RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ;
1002                                 cfg->symm = true;
1003                         }
1004
1005                         if (rss->level)
1006                                 return rte_flow_error_set(error, ENOTSUP,
1007                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
1008                                         "a nonzero RSS encapsulation level is not supported");
1009
1010                         if (rss->key_len)
1011                                 return rte_flow_error_set(error, ENOTSUP,
1012                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
1013                                         "a nonzero RSS key_len is not supported");
1014
1015                         if (rss->queue)
1016                                 return rte_flow_error_set(error, ENOTSUP,
1017                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
1018                                         "a non-NULL RSS queue is not supported");
1019
1020                         /**
1021                          * Check simultaneous use of SRC_ONLY and DST_ONLY
1022                          * of the same level.
1023                          */
1024                         rss_type = rte_eth_rss_hf_refine(rss_type);
1025
1026                         if (ice_any_invalid_rss_type(rss->func, rss_type,
1027                                         pattern_match_item->input_set_mask_o))
1028                                 return rte_flow_error_set(error, ENOTSUP,
1029                                         RTE_FLOW_ERROR_TYPE_ACTION,
1030                                         action, "RSS type not supported");
1031
1032                         rss_meta->cfg = *cfg;
1033                         ice_refine_hash_cfg(&rss_meta->cfg,
1034                                             rss_type, pattern_hint);
1035                         break;
1036                 case RTE_FLOW_ACTION_TYPE_END:
1037                         break;
1038
1039                 default:
1040                         rte_flow_error_set(error, EINVAL,
1041                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
1042                                         "Invalid action.");
1043                         return -rte_errno;
1044                 }
1045         }
1046
1047         return 0;
1048 }
1049
1050 static int
1051 ice_hash_parse_pattern_action(__rte_unused struct ice_adapter *ad,
1052                         struct ice_pattern_match_item *array,
1053                         uint32_t array_len,
1054                         const struct rte_flow_item pattern[],
1055                         const struct rte_flow_action actions[],
1056                         uint32_t priority,
1057                         void **meta,
1058                         struct rte_flow_error *error)
1059 {
1060         int ret = 0;
1061         struct ice_pattern_match_item *pattern_match_item;
1062         struct ice_rss_meta *rss_meta_ptr;
1063         uint64_t phint = ICE_PHINT_NONE;
1064
1065         if (priority >= 1)
1066                 return -rte_errno;
1067
1068         rss_meta_ptr = rte_zmalloc(NULL, sizeof(*rss_meta_ptr), 0);
1069         if (!rss_meta_ptr) {
1070                 rte_flow_error_set(error, EINVAL,
1071                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1072                                 "No memory for rss_meta_ptr");
1073                 return -ENOMEM;
1074         }
1075
1076         /* Check rss supported pattern and find matched pattern. */
1077         pattern_match_item = ice_search_pattern_match_item(ad, pattern, array,
1078                                                            array_len, error);
1079         if (!pattern_match_item) {
1080                 ret = -rte_errno;
1081                 goto error;
1082         }
1083
1084         ret = ice_hash_parse_pattern(pattern, &phint, error);
1085         if (ret)
1086                 goto error;
1087
1088         /* Check rss action. */
1089         ret = ice_hash_parse_action(pattern_match_item, actions, phint,
1090                                     (void **)&rss_meta_ptr, error);
1091
1092 error:
1093         if (!ret && meta)
1094                 *meta = rss_meta_ptr;
1095         else
1096                 rte_free(rss_meta_ptr);
1097         rte_free(pattern_match_item);
1098
1099         return ret;
1100 }
1101
1102 static int
1103 ice_hash_create(struct ice_adapter *ad,
1104                 struct rte_flow *flow,
1105                 void *meta,
1106                 struct rte_flow_error *error)
1107 {
1108         struct ice_pf *pf = &ad->pf;
1109         struct ice_hw *hw = ICE_PF_TO_HW(pf);
1110         struct ice_vsi *vsi = pf->main_vsi;
1111         int ret;
1112         uint32_t reg;
1113         struct ice_hash_flow_cfg *filter_ptr;
1114         struct ice_rss_meta *rss_meta = (struct ice_rss_meta *)meta;
1115         uint8_t hash_function = rss_meta->hash_function;
1116
1117         filter_ptr = rte_zmalloc("ice_rss_filter",
1118                                 sizeof(struct ice_hash_flow_cfg), 0);
1119         if (!filter_ptr) {
1120                 rte_flow_error_set(error, EINVAL,
1121                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1122                                 "No memory for filter_ptr");
1123                 return -ENOMEM;
1124         }
1125
1126         if (hash_function == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
1127                 /* Enable registers for simple_xor hash function. */
1128                 reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
1129                 reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
1130                         (2 << VSIQF_HASH_CTL_HASH_SCHEME_S);
1131                 ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);
1132
1133                 filter_ptr->simple_xor = 1;
1134
1135                 goto out;
1136         } else {
1137                 memcpy(&filter_ptr->rss_cfg.hash, &rss_meta->cfg,
1138                        sizeof(struct ice_rss_hash_cfg));
1139                 ret = ice_add_rss_cfg_wrap(pf, vsi->idx,
1140                                            &filter_ptr->rss_cfg.hash);
1141                 if (ret) {
1142                         rte_flow_error_set(error, EINVAL,
1143                                         RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1144                                         "rss flow create fail");
1145                         goto error;
1146                 }
1147         }
1148
1149 out:
1150         flow->rule = filter_ptr;
1151         rte_free(meta);
1152         return 0;
1153
1154 error:
1155         rte_free(filter_ptr);
1156         rte_free(meta);
1157         return -rte_errno;
1158 }
1159
1160 static int
1161 ice_hash_destroy(struct ice_adapter *ad,
1162                 struct rte_flow *flow,
1163                 struct rte_flow_error *error)
1164 {
1165         struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(ad);
1166         struct ice_hw *hw = ICE_PF_TO_HW(pf);
1167         struct ice_vsi *vsi = pf->main_vsi;
1168         int ret;
1169         uint32_t reg;
1170         struct ice_hash_flow_cfg *filter_ptr;
1171
1172         filter_ptr = (struct ice_hash_flow_cfg *)flow->rule;
1173
1174         if (filter_ptr->simple_xor == 1) {
1175                 /* Return to symmetric_toeplitz state. */
1176                 reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
1177                 reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
1178                         (1 << VSIQF_HASH_CTL_HASH_SCHEME_S);
1179                 ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);
1180         } else {
1181                 ret = ice_rem_rss_cfg_wrap(pf, vsi->idx,
1182                                            &filter_ptr->rss_cfg.hash);
1183                 /* Fixme: Ignore the error if a rule does not exist.
1184                  * Currently a rule for inputset change or symm turn on/off
1185                  * will overwrite an exist rule, while application still
1186                  * have 2 rte_flow handles.
1187                  **/
1188                 if (ret && ret != ICE_ERR_DOES_NOT_EXIST) {
1189                         rte_flow_error_set(error, EINVAL,
1190                                         RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1191                                         "rss flow destroy fail");
1192                         goto error;
1193                 }
1194         }
1195
1196         rte_free(filter_ptr);
1197         return 0;
1198
1199 error:
1200         rte_free(filter_ptr);
1201         return -rte_errno;
1202 }
1203
1204 static void
1205 ice_hash_uninit(struct ice_adapter *ad)
1206 {
1207         if (ad->hw.dcf_enabled)
1208                 return;
1209
1210         ice_unregister_parser(&ice_hash_parser, ad);
1211 }
1212
1213 static void
1214 ice_hash_free(struct rte_flow *flow)
1215 {
1216         rte_free(flow->rule);
1217 }