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 <rte_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_GTPU_EH_DWNLINK     0
  29 #define ICE_GTPU_EH_UPLINK      1
  30
  31 struct rss_type_match_hdr {
  32         uint32_t hdr_mask;
  33         uint64_t eth_rss_hint;
  34 };
  35
  36 struct ice_hash_match_type {
  37         uint64_t hash_type;
  38         uint64_t hash_flds;
  39 };
  40
  41 struct rss_meta {
  42         uint32_t pkt_hdr;
  43         uint64_t hash_flds;
  44         uint8_t hash_function;
  45 };
  46
  47 struct ice_hash_flow_cfg {
  48         bool simple_xor;
  49         struct ice_rss_cfg rss_cfg;
  50 };
  51
  52 static int
  53 ice_hash_init(struct ice_adapter *ad);
  54
  55 static int
  56 ice_hash_create(struct ice_adapter *ad,
  57                 struct rte_flow *flow,
  58                 void *meta,
  59                 struct rte_flow_error *error);
  60
  61 static int
  62 ice_hash_destroy(struct ice_adapter *ad,
  63                 struct rte_flow *flow,
  64                 struct rte_flow_error *error);
  65
  66 static void
  67 ice_hash_uninit(struct ice_adapter *ad);
  68
  69 static void
  70 ice_hash_free(struct rte_flow *flow);
  71
  72 static int
  73 ice_hash_parse_pattern_action(struct ice_adapter *ad,
  74                         struct ice_pattern_match_item *array,
  75                         uint32_t array_len,
  76                         const struct rte_flow_item pattern[],
  77                         const struct rte_flow_action actions[],
  78                         void **meta,
  79                         struct rte_flow_error *error);
  80
  81 /* The first member is protocol header, the second member is ETH_RSS_*. */
  82 struct rss_type_match_hdr hint_empty = {
  83         ICE_FLOW_SEG_HDR_NONE,  0};
  84 struct rss_type_match_hdr hint_eth_ipv4 = {
  85         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
  86         ETH_RSS_ETH | ETH_RSS_IPV4};
  87 struct rss_type_match_hdr hint_eth_ipv4_udp = {
  88         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
  89         ICE_FLOW_SEG_HDR_UDP,
  90         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV4_UDP};
  91 struct rss_type_match_hdr hint_eth_ipv4_tcp = {
  92         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
  93         ICE_FLOW_SEG_HDR_TCP,
  94         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV4_TCP};
  95 struct rss_type_match_hdr hint_eth_ipv4_sctp = {
  96         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
  97         ICE_FLOW_SEG_HDR_SCTP,
  98         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV4_SCTP};
  99 struct rss_type_match_hdr hint_eth_ipv4_gtpu_ipv4 = {
 100         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV4 |
 101         ICE_FLOW_SEG_HDR_IPV_OTHER,
 102         ETH_RSS_GTPU | ETH_RSS_IPV4};
 103 struct rss_type_match_hdr hint_eth_ipv4_gtpu_ipv4_udp = {
 104         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV4 |
 105         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 106         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV4_UDP};
 107 struct rss_type_match_hdr hint_eth_ipv4_gtpu_ipv4_tcp = {
 108         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV4 |
 109         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 110         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV4_TCP};
 111 struct rss_type_match_hdr hint_eth_ipv4_gtpu_ipv6 = {
 112         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV6 |
 113         ICE_FLOW_SEG_HDR_IPV_OTHER,
 114         ETH_RSS_GTPU | ETH_RSS_IPV6};
 115 struct rss_type_match_hdr hint_eth_ipv4_gtpu_ipv6_udp = {
 116         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV6 |
 117         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 118         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV6_UDP};
 119 struct rss_type_match_hdr hint_eth_ipv4_gtpu_ipv6_tcp = {
 120         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV6 |
 121         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 122         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV6_TCP};
 123 struct rss_type_match_hdr hint_eth_ipv6_gtpu_ipv4 = {
 124         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV4 |
 125         ICE_FLOW_SEG_HDR_IPV_OTHER,
 126         ETH_RSS_GTPU | ETH_RSS_IPV4};
 127 struct rss_type_match_hdr hint_eth_ipv6_gtpu_ipv4_udp = {
 128         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV4 |
 129         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 130         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV4_UDP};
 131 struct rss_type_match_hdr hint_eth_ipv6_gtpu_ipv4_tcp = {
 132         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV4 |
 133         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 134         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV4_TCP};
 135 struct rss_type_match_hdr hint_eth_ipv6_gtpu_ipv6 = {
 136         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV6 |
 137         ICE_FLOW_SEG_HDR_IPV_OTHER,
 138         ETH_RSS_GTPU | ETH_RSS_IPV6};
 139 struct rss_type_match_hdr hint_eth_ipv6_gtpu_ipv6_udp = {
 140         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV6 |
 141         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 142         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV6_UDP};
 143 struct rss_type_match_hdr hint_eth_ipv6_gtpu_ipv6_tcp = {
 144         ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV6 |
 145         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 146         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV6_TCP};
 147 struct rss_type_match_hdr hint_eth_ipv4_gtpu_eh_ipv4 = {
 148         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV4 |
 149         ICE_FLOW_SEG_HDR_IPV_OTHER,
 150         ETH_RSS_GTPU | ETH_RSS_IPV4};
 151 struct rss_type_match_hdr hint_eth_ipv4_gtpu_eh_ipv4_udp = {
 152         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV4 |
 153         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 154         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV4_UDP};
 155 struct rss_type_match_hdr hint_eth_ipv4_gtpu_eh_ipv4_tcp = {
 156         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV4 |
 157         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 158         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV4_TCP};
 159 struct rss_type_match_hdr hint_eth_ipv4_gtpu_eh_ipv6 = {
 160         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV6 |
 161         ICE_FLOW_SEG_HDR_IPV_OTHER,
 162         ETH_RSS_GTPU | ETH_RSS_IPV6};
 163 struct rss_type_match_hdr hint_eth_ipv4_gtpu_eh_ipv6_udp = {
 164         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV6 |
 165         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 166         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV6_UDP};
 167 struct rss_type_match_hdr hint_eth_ipv4_gtpu_eh_ipv6_tcp = {
 168         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV6 |
 169         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 170         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV6_TCP};
 171 struct rss_type_match_hdr hint_eth_ipv6_gtpu_eh_ipv4 = {
 172         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV4 |
 173         ICE_FLOW_SEG_HDR_IPV_OTHER,
 174         ETH_RSS_GTPU | ETH_RSS_IPV4};
 175 struct rss_type_match_hdr hint_eth_ipv6_gtpu_eh_ipv4_udp = {
 176         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV4 |
 177         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 178         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV4_UDP};
 179 struct rss_type_match_hdr hint_eth_ipv6_gtpu_eh_ipv4_tcp = {
 180         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV4 |
 181         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 182         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV4_TCP};
 183 struct rss_type_match_hdr hint_eth_ipv6_gtpu_eh_ipv6 = {
 184         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV6 |
 185         ICE_FLOW_SEG_HDR_IPV_OTHER,
 186         ETH_RSS_GTPU | ETH_RSS_IPV6};
 187 struct rss_type_match_hdr hint_eth_ipv6_gtpu_eh_ipv6_udp = {
 188         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV6 |
 189         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 190         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV6_UDP};
 191 struct rss_type_match_hdr hint_eth_ipv6_gtpu_eh_ipv6_tcp = {
 192         ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV6 |
 193         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 194         ETH_RSS_GTPU | ETH_RSS_NONFRAG_IPV6_TCP};
 195 struct rss_type_match_hdr hint_eth_pppoes_ipv4 = {
 196         ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV4 |
 197         ICE_FLOW_SEG_HDR_IPV_OTHER,
 198         ETH_RSS_ETH | ETH_RSS_PPPOE | ETH_RSS_IPV4};
 199 struct rss_type_match_hdr hint_eth_pppoes_ipv4_udp = {
 200         ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV4 |
 201         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 202         ETH_RSS_ETH | ETH_RSS_PPPOE | ETH_RSS_NONFRAG_IPV4_UDP};
 203 struct rss_type_match_hdr hint_eth_pppoes_ipv4_tcp = {
 204         ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV4 |
 205         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 206         ETH_RSS_ETH | ETH_RSS_PPPOE | ETH_RSS_NONFRAG_IPV4_TCP};
 207 struct rss_type_match_hdr hint_eth_pppoes_ipv4_sctp = {
 208         ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV4 |
 209         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
 210         ETH_RSS_ETH | ETH_RSS_PPPOE | ETH_RSS_NONFRAG_IPV4_SCTP};
 211 struct rss_type_match_hdr hint_eth_ipv4_esp = {
 212         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 213         ICE_FLOW_SEG_HDR_ESP,
 214         ETH_RSS_ETH | ETH_RSS_IPV4 | ETH_RSS_ESP};
 215 struct rss_type_match_hdr hint_eth_ipv4_udp_esp = {
 216         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 217         ICE_FLOW_SEG_HDR_NAT_T_ESP,
 218         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_ESP};
 219 struct rss_type_match_hdr hint_eth_ipv4_ah = {
 220         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 221         ICE_FLOW_SEG_HDR_AH,
 222         ETH_RSS_ETH | ETH_RSS_IPV4 | ETH_RSS_AH};
 223 struct rss_type_match_hdr hint_eth_ipv4_l2tpv3 = {
 224         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 225         ICE_FLOW_SEG_HDR_L2TPV3,
 226         ETH_RSS_ETH | ETH_RSS_IPV4 | ETH_RSS_L2TPV3};
 227 struct rss_type_match_hdr hint_eth_ipv4_pfcp = {
 228         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 229         ICE_FLOW_SEG_HDR_PFCP_SESSION,
 230         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_PFCP};
 231 struct rss_type_match_hdr hint_eth_vlan_ipv4 = {
 232         ICE_FLOW_SEG_HDR_VLAN | ICE_FLOW_SEG_HDR_IPV4 |
 233         ICE_FLOW_SEG_HDR_IPV_OTHER,
 234         ETH_RSS_ETH | ETH_RSS_IPV4 | ETH_RSS_C_VLAN};
 235 struct rss_type_match_hdr hint_eth_vlan_ipv4_udp = {
 236         ICE_FLOW_SEG_HDR_VLAN | ICE_FLOW_SEG_HDR_IPV4 |
 237         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 238         ETH_RSS_ETH | ETH_RSS_C_VLAN |
 239         ETH_RSS_NONFRAG_IPV4_UDP};
 240 struct rss_type_match_hdr hint_eth_vlan_ipv4_tcp = {
 241         ICE_FLOW_SEG_HDR_VLAN | ICE_FLOW_SEG_HDR_IPV4 |
 242         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 243         ETH_RSS_ETH | ETH_RSS_C_VLAN |
 244         ETH_RSS_NONFRAG_IPV4_TCP};
 245 struct rss_type_match_hdr hint_eth_vlan_ipv4_sctp = {
 246         ICE_FLOW_SEG_HDR_VLAN | ICE_FLOW_SEG_HDR_IPV4 |
 247         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
 248         ETH_RSS_ETH | ETH_RSS_C_VLAN |
 249         ETH_RSS_NONFRAG_IPV4_SCTP};
 250 struct rss_type_match_hdr hint_eth_ipv6 = {
 251         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
 252         ETH_RSS_ETH | ETH_RSS_IPV6};
 253 struct rss_type_match_hdr hint_eth_ipv6_udp = {
 254         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 255         ICE_FLOW_SEG_HDR_UDP,
 256         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV6_UDP};
 257 struct rss_type_match_hdr hint_eth_ipv6_tcp = {
 258         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 259         ICE_FLOW_SEG_HDR_TCP,
 260         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV6_TCP};
 261 struct rss_type_match_hdr hint_eth_ipv6_sctp = {
 262         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 263         ICE_FLOW_SEG_HDR_SCTP,
 264         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV6_SCTP};
 265 struct rss_type_match_hdr hint_eth_ipv6_esp = {
 266         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 267         ICE_FLOW_SEG_HDR_ESP,
 268         ETH_RSS_ETH | ETH_RSS_IPV6 | ETH_RSS_ESP};
 269 struct rss_type_match_hdr hint_eth_ipv6_udp_esp = {
 270         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 271         ICE_FLOW_SEG_HDR_NAT_T_ESP,
 272         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_ESP};
 273 struct rss_type_match_hdr hint_eth_ipv6_ah = {
 274         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 275         ICE_FLOW_SEG_HDR_AH,
 276         ETH_RSS_ETH | ETH_RSS_IPV6 | ETH_RSS_AH};
 277 struct rss_type_match_hdr hint_eth_ipv6_l2tpv3 = {
 278         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 279         ICE_FLOW_SEG_HDR_L2TPV3,
 280         ETH_RSS_ETH | ETH_RSS_IPV6 | ETH_RSS_L2TPV3};
 281 struct rss_type_match_hdr hint_eth_ipv6_pfcp = {
 282         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
 283         ICE_FLOW_SEG_HDR_PFCP_SESSION,
 284         ETH_RSS_ETH | ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_PFCP};
 285 struct rss_type_match_hdr hint_eth_vlan_ipv6 = {
 286         ICE_FLOW_SEG_HDR_VLAN | ICE_FLOW_SEG_HDR_IPV6 |
 287         ICE_FLOW_SEG_HDR_IPV_OTHER,
 288         ETH_RSS_ETH | ETH_RSS_IPV6 | ETH_RSS_C_VLAN};
 289 struct rss_type_match_hdr hint_eth_vlan_ipv6_udp = {
 290         ICE_FLOW_SEG_HDR_VLAN | ICE_FLOW_SEG_HDR_IPV6 |
 291         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 292         ETH_RSS_ETH | ETH_RSS_C_VLAN |
 293         ETH_RSS_NONFRAG_IPV6_UDP};
 294 struct rss_type_match_hdr hint_eth_vlan_ipv6_tcp = {
 295         ICE_FLOW_SEG_HDR_VLAN | ICE_FLOW_SEG_HDR_IPV6 |
 296         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 297         ETH_RSS_ETH | ETH_RSS_C_VLAN |
 298         ETH_RSS_NONFRAG_IPV6_TCP};
 299 struct rss_type_match_hdr hint_eth_vlan_ipv6_sctp = {
 300         ICE_FLOW_SEG_HDR_VLAN | ICE_FLOW_SEG_HDR_IPV6 |
 301         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
 302         ETH_RSS_ETH | ETH_RSS_C_VLAN |
 303         ETH_RSS_NONFRAG_IPV6_SCTP};
 304 struct rss_type_match_hdr hint_eth_pppoes_ipv6 = {
 305         ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV6 |
 306         ICE_FLOW_SEG_HDR_IPV_OTHER,
 307         ETH_RSS_ETH | ETH_RSS_PPPOE | ETH_RSS_IPV6};
 308 struct rss_type_match_hdr hint_eth_pppoes_ipv6_udp = {
 309         ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV6 |
 310         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
 311         ETH_RSS_ETH | ETH_RSS_PPPOE | ETH_RSS_NONFRAG_IPV6_UDP};
 312 struct rss_type_match_hdr hint_eth_pppoes_ipv6_tcp = {
 313         ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV6 |
 314         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
 315         ETH_RSS_ETH | ETH_RSS_PPPOE | ETH_RSS_NONFRAG_IPV6_TCP};
 316 struct rss_type_match_hdr hint_eth_pppoes_ipv6_sctp = {
 317         ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV6 |
 318         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
 319         ETH_RSS_ETH | ETH_RSS_PPPOE | ETH_RSS_NONFRAG_IPV6_SCTP};
 320 struct rss_type_match_hdr hint_eth_pppoes = {
 321         ICE_FLOW_SEG_HDR_PPPOE,
 322         ETH_RSS_ETH | ETH_RSS_PPPOE};
 323
 324 /* Supported pattern for os default package. */
 325 static struct ice_pattern_match_item ice_hash_pattern_list_os[] = {
 326         {pattern_eth_ipv4,      ICE_INSET_NONE, &hint_eth_ipv4},
 327         {pattern_eth_ipv4_udp,  ICE_INSET_NONE, &hint_eth_ipv4_udp},
 328         {pattern_eth_ipv4_tcp,  ICE_INSET_NONE, &hint_eth_ipv4_tcp},
 329         {pattern_eth_ipv4_sctp, ICE_INSET_NONE, &hint_eth_ipv4_sctp},
 330         {pattern_eth_ipv6,      ICE_INSET_NONE, &hint_eth_ipv6},
 331         {pattern_eth_ipv6_udp,  ICE_INSET_NONE, &hint_eth_ipv6_udp},
 332         {pattern_eth_ipv6_tcp,  ICE_INSET_NONE, &hint_eth_ipv6_tcp},
 333         {pattern_eth_ipv6_sctp, ICE_INSET_NONE, &hint_eth_ipv6_sctp},
 334         {pattern_empty,         ICE_INSET_NONE, &hint_empty},
 335 };
 336
 337 /* Supported pattern for comms package. */
 338 static struct ice_pattern_match_item ice_hash_pattern_list_comms[] = {
 339         {pattern_empty,                     ICE_INSET_NONE,
 340                 &hint_empty},
 341         {pattern_eth_ipv4,                  ICE_INSET_NONE,
 342                 &hint_eth_ipv4},
 343         {pattern_eth_ipv4_udp,              ICE_INSET_NONE,
 344                 &hint_eth_ipv4_udp},
 345         {pattern_eth_ipv4_tcp,              ICE_INSET_NONE,
 346                 &hint_eth_ipv4_tcp},
 347         {pattern_eth_ipv4_sctp,             ICE_INSET_NONE,
 348                 &hint_eth_ipv4_sctp},
 349         {pattern_eth_ipv4_gtpu_ipv4,        ICE_INSET_NONE,
 350                 &hint_eth_ipv4_gtpu_ipv4},
 351         {pattern_eth_ipv4_gtpu_ipv4_udp,    ICE_INSET_NONE,
 352                 &hint_eth_ipv4_gtpu_ipv4_udp},
 353         {pattern_eth_ipv4_gtpu_ipv4_tcp,    ICE_INSET_NONE,
 354                 &hint_eth_ipv4_gtpu_ipv4_tcp},
 355         {pattern_eth_ipv4_gtpu_ipv6,        ICE_INSET_NONE,
 356                 &hint_eth_ipv4_gtpu_ipv6},
 357         {pattern_eth_ipv4_gtpu_ipv6_udp,    ICE_INSET_NONE,
 358                 &hint_eth_ipv4_gtpu_ipv6_udp},
 359         {pattern_eth_ipv4_gtpu_ipv6_tcp,    ICE_INSET_NONE,
 360                 &hint_eth_ipv4_gtpu_ipv6_tcp},
 361         {pattern_eth_ipv6_gtpu_ipv4,        ICE_INSET_NONE,
 362                 &hint_eth_ipv6_gtpu_ipv4},
 363         {pattern_eth_ipv6_gtpu_ipv4_udp,    ICE_INSET_NONE,
 364                 &hint_eth_ipv6_gtpu_ipv4_udp},
 365         {pattern_eth_ipv6_gtpu_ipv4_tcp,    ICE_INSET_NONE,
 366                 &hint_eth_ipv6_gtpu_ipv4_tcp},
 367         {pattern_eth_ipv6_gtpu_ipv6,        ICE_INSET_NONE,
 368                 &hint_eth_ipv6_gtpu_ipv6},
 369         {pattern_eth_ipv6_gtpu_ipv6_udp,    ICE_INSET_NONE,
 370                 &hint_eth_ipv6_gtpu_ipv6_udp},
 371         {pattern_eth_ipv6_gtpu_ipv6_tcp,    ICE_INSET_NONE,
 372                 &hint_eth_ipv6_gtpu_ipv6_tcp},
 373         {pattern_eth_ipv4_gtpu_eh_ipv4,     ICE_INSET_NONE,
 374                 &hint_eth_ipv4_gtpu_eh_ipv4},
 375         {pattern_eth_ipv4_gtpu_eh_ipv4_udp, ICE_INSET_NONE,
 376                 &hint_eth_ipv4_gtpu_eh_ipv4_udp},
 377         {pattern_eth_ipv4_gtpu_eh_ipv4_tcp, ICE_INSET_NONE,
 378                 &hint_eth_ipv4_gtpu_eh_ipv4_tcp},
 379         {pattern_eth_ipv4_gtpu_eh_ipv6,     ICE_INSET_NONE,
 380                 &hint_eth_ipv4_gtpu_eh_ipv6},
 381         {pattern_eth_ipv4_gtpu_eh_ipv6_udp, ICE_INSET_NONE,
 382                 &hint_eth_ipv4_gtpu_eh_ipv6_udp},
 383         {pattern_eth_ipv4_gtpu_eh_ipv6_tcp, ICE_INSET_NONE,
 384                 &hint_eth_ipv4_gtpu_eh_ipv6_tcp},
 385         {pattern_eth_ipv6_gtpu_eh_ipv4,     ICE_INSET_NONE,
 386                 &hint_eth_ipv6_gtpu_eh_ipv4},
 387         {pattern_eth_ipv6_gtpu_eh_ipv4_udp, ICE_INSET_NONE,
 388                 &hint_eth_ipv6_gtpu_eh_ipv4_udp},
 389         {pattern_eth_ipv6_gtpu_eh_ipv4_tcp, ICE_INSET_NONE,
 390                 &hint_eth_ipv6_gtpu_eh_ipv4_tcp},
 391         {pattern_eth_ipv6_gtpu_eh_ipv6,     ICE_INSET_NONE,
 392                 &hint_eth_ipv6_gtpu_eh_ipv6},
 393         {pattern_eth_ipv6_gtpu_eh_ipv6_udp, ICE_INSET_NONE,
 394                 &hint_eth_ipv6_gtpu_eh_ipv6_udp},
 395         {pattern_eth_ipv6_gtpu_eh_ipv6_tcp, ICE_INSET_NONE,
 396                 &hint_eth_ipv6_gtpu_eh_ipv6_tcp},
 397         {pattern_eth_pppoes_ipv4,           ICE_INSET_NONE,
 398                 &hint_eth_pppoes_ipv4},
 399         {pattern_eth_pppoes_ipv4_udp,       ICE_INSET_NONE,
 400                 &hint_eth_pppoes_ipv4_udp},
 401         {pattern_eth_pppoes_ipv4_tcp,       ICE_INSET_NONE,
 402                 &hint_eth_pppoes_ipv4_tcp},
 403         {pattern_eth_pppoes_ipv4_sctp,      ICE_INSET_NONE,
 404                 &hint_eth_pppoes_ipv4_sctp},
 405         {pattern_eth_ipv4_esp,              ICE_INSET_NONE,
 406                 &hint_eth_ipv4_esp},
 407         {pattern_eth_ipv4_udp_esp,          ICE_INSET_NONE,
 408                 &hint_eth_ipv4_udp_esp},
 409         {pattern_eth_ipv4_ah,               ICE_INSET_NONE,
 410                 &hint_eth_ipv4_ah},
 411         {pattern_eth_ipv4_l2tp,             ICE_INSET_NONE,
 412                 &hint_eth_ipv4_l2tpv3},
 413         {pattern_eth_ipv4_pfcp,             ICE_INSET_NONE,
 414                 &hint_eth_ipv4_pfcp},
 415         {pattern_eth_vlan_ipv4,             ICE_INSET_NONE,
 416                 &hint_eth_vlan_ipv4},
 417         {pattern_eth_vlan_ipv4_udp,         ICE_INSET_NONE,
 418                 &hint_eth_vlan_ipv4_udp},
 419         {pattern_eth_vlan_ipv4_tcp,         ICE_INSET_NONE,
 420                 &hint_eth_vlan_ipv4_tcp},
 421         {pattern_eth_vlan_ipv4_sctp,        ICE_INSET_NONE,
 422                 &hint_eth_vlan_ipv4_sctp},
 423         {pattern_eth_ipv6,                  ICE_INSET_NONE,
 424                 &hint_eth_ipv6},
 425         {pattern_eth_ipv6_udp,              ICE_INSET_NONE,
 426                 &hint_eth_ipv6_udp},
 427         {pattern_eth_ipv6_tcp,              ICE_INSET_NONE,
 428                 &hint_eth_ipv6_tcp},
 429         {pattern_eth_ipv6_sctp,             ICE_INSET_NONE,
 430                 &hint_eth_ipv6_sctp},
 431         {pattern_eth_ipv6_esp,              ICE_INSET_NONE,
 432                 &hint_eth_ipv6_esp},
 433         {pattern_eth_ipv6_udp_esp,          ICE_INSET_NONE,
 434                 &hint_eth_ipv6_udp_esp},
 435         {pattern_eth_ipv6_ah,               ICE_INSET_NONE,
 436                 &hint_eth_ipv6_ah},
 437         {pattern_eth_ipv6_l2tp,             ICE_INSET_NONE,
 438                 &hint_eth_ipv6_l2tpv3},
 439         {pattern_eth_ipv6_pfcp,             ICE_INSET_NONE,
 440                 &hint_eth_ipv6_pfcp},
 441         {pattern_eth_vlan_ipv6,             ICE_INSET_NONE,
 442                 &hint_eth_vlan_ipv6},
 443         {pattern_eth_vlan_ipv6_udp,         ICE_INSET_NONE,
 444                 &hint_eth_vlan_ipv6_udp},
 445         {pattern_eth_vlan_ipv6_tcp,         ICE_INSET_NONE,
 446                 &hint_eth_vlan_ipv6_tcp},
 447         {pattern_eth_vlan_ipv6_sctp,        ICE_INSET_NONE,
 448                 &hint_eth_vlan_ipv6_sctp},
 449         {pattern_eth_pppoes_ipv6,           ICE_INSET_NONE,
 450                 &hint_eth_pppoes_ipv6},
 451         {pattern_eth_pppoes_ipv6_udp,       ICE_INSET_NONE,
 452                 &hint_eth_pppoes_ipv6_udp},
 453         {pattern_eth_pppoes_ipv6_tcp,       ICE_INSET_NONE,
 454                 &hint_eth_pppoes_ipv6_tcp},
 455         {pattern_eth_pppoes_ipv6_sctp,      ICE_INSET_NONE,
 456                 &hint_eth_pppoes_ipv6_sctp},
 457         {pattern_eth_pppoes,                ICE_INSET_NONE,
 458                 &hint_eth_pppoes},
 459 };
 460
 461 /**
 462  * The first member is input set combination,
 463  * the second member is hash fields.
 464  */
 465 struct ice_hash_match_type ice_hash_type_list[] = {
 466         {ETH_RSS_L2_SRC_ONLY,
 467                 BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_SA)},
 468         {ETH_RSS_L2_DST_ONLY,
 469                 BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_DA)},
 470         {ETH_RSS_ETH | ETH_RSS_L2_SRC_ONLY,
 471                 BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_SA)},
 472         {ETH_RSS_ETH | ETH_RSS_L2_DST_ONLY,
 473                 BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_DA)},
 474         {ETH_RSS_ETH,
 475                 BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_SA) |
 476                 BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_DA)},
 477         {ETH_RSS_PPPOE,
 478                 ICE_FLOW_HASH_PPPOE_SESS_ID},
 479         {ETH_RSS_ETH | ETH_RSS_PPPOE | ETH_RSS_L2_SRC_ONLY,
 480                 ICE_FLOW_HASH_PPPOE_SESS_ID |
 481                 BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_SA)},
 482         {ETH_RSS_C_VLAN,
 483                 BIT_ULL(ICE_FLOW_FIELD_IDX_C_VLAN)},
 484         {ETH_RSS_S_VLAN,
 485                 BIT_ULL(ICE_FLOW_FIELD_IDX_S_VLAN)},
 486         {ETH_RSS_ESP,
 487                 BIT_ULL(ICE_FLOW_FIELD_IDX_ESP_SPI)},
 488         {ETH_RSS_AH,
 489                 BIT_ULL(ICE_FLOW_FIELD_IDX_AH_SPI)},
 490         {ETH_RSS_L2TPV3,
 491                 BIT_ULL(ICE_FLOW_FIELD_IDX_L2TPV3_SESS_ID)},
 492         {ETH_RSS_PFCP,
 493                 BIT_ULL(ICE_FLOW_FIELD_IDX_PFCP_SEID)},
 494         /* IPV4 */
 495         {ETH_RSS_IPV4 | ETH_RSS_L3_SRC_ONLY,
 496                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)},
 497         {ETH_RSS_IPV4 | ETH_RSS_L3_DST_ONLY,
 498                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)},
 499         {ETH_RSS_IPV4, ICE_FLOW_HASH_IPV4},
 500         {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY,
 501                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
 502                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 503                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)},
 504         {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY,
 505                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
 506                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 507                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT)},
 508         {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY,
 509                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)},
 510         {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY,
 511                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
 512                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 513                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)},
 514         {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY,
 515                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
 516                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 517                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT)},
 518         {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY,
 519                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)},
 520         {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_SRC_ONLY,
 521                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT) |
 522                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
 523         {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_DST_ONLY,
 524                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT) |
 525                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
 526         {ETH_RSS_NONFRAG_IPV4_UDP,
 527                 ICE_HASH_UDP_IPV4 |
 528                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
 529         {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY,
 530                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
 531                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 532                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)},
 533         {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY,
 534                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
 535                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 536                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT)},
 537         {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_SRC_ONLY,
 538                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)},
 539         {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY,
 540                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
 541                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 542                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)},
 543         {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY,
 544                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
 545                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 546                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT)},
 547         {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY,
 548                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)},
 549         {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_SRC_ONLY,
 550                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT) |
 551                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
 552         {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_DST_ONLY,
 553                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT) |
 554                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
 555         {ETH_RSS_NONFRAG_IPV4_TCP,
 556                 ICE_HASH_TCP_IPV4 |
 557                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
 558         {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY,
 559                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
 560                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 561                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)},
 562         {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY,
 563                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
 564                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 565                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT)},
 566         {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_SRC_ONLY,
 567                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)},
 568         {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY,
 569                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
 570                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 571                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)},
 572         {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY,
 573                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
 574                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
 575                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT)},
 576         {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY,
 577                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)},
 578         {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_SRC_ONLY,
 579                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT) |
 580                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
 581         {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_DST_ONLY,
 582                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT) |
 583                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
 584         {ETH_RSS_NONFRAG_IPV4_SCTP,
 585                 ICE_HASH_SCTP_IPV4 |
 586                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
 587         /* IPV6 */
 588         {ETH_RSS_IPV6 | ETH_RSS_L3_SRC_ONLY,
 589                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)},
 590         {ETH_RSS_IPV6 | ETH_RSS_L3_DST_ONLY,
 591                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)},
 592         {ETH_RSS_IPV6, ICE_FLOW_HASH_IPV6},
 593         {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY,
 594                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA) |
 595                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 596                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)},
 597         {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY,
 598                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA) |
 599                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 600                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT)},
 601         {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_SRC_ONLY,
 602                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)},
 603         {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY,
 604                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA) |
 605                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 606                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)},
 607         {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY,
 608                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA) |
 609                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 610                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT)},
 611         {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_DST_ONLY,
 612                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)},
 613         {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_SRC_ONLY,
 614                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT) |
 615                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
 616         {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_DST_ONLY,
 617                 BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT) |
 618                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
 619         {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_PFCP,
 620                 BIT_ULL(ICE_FLOW_FIELD_IDX_PFCP_SEID)},
 621         {ETH_RSS_NONFRAG_IPV6_UDP,
 622                 ICE_HASH_UDP_IPV6 |
 623                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
 624         {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY,
 625                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA) |
 626                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 627                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)},
 628         {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY,
 629                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA) |
 630                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 631                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT)},
 632         {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_SRC_ONLY,
 633                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)},
 634         {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY,
 635                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA) |
 636                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 637                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)},
 638         {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY,
 639                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA) |
 640                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 641                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT)},
 642         {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_DST_ONLY,
 643                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)},
 644         {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_SRC_ONLY,
 645                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT) |
 646                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
 647         {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_DST_ONLY,
 648                 BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT) |
 649                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
 650         {ETH_RSS_NONFRAG_IPV6_TCP,
 651                 ICE_HASH_TCP_IPV6 |
 652                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
 653         {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY,
 654                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA) |
 655                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 656                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)},
 657         {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY,
 658                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA) |
 659                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 660                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT)},
 661         {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_SRC_ONLY,
 662                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)},
 663         {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY,
 664                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA) |
 665                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 666                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)},
 667         {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY,
 668                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA) |
 669                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT) |
 670                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT)},
 671         {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_DST_ONLY,
 672                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)},
 673         {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_SRC_ONLY,
 674                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT) |
 675                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
 676         {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_DST_ONLY,
 677                 BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT) |
 678                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
 679         {ETH_RSS_NONFRAG_IPV6_SCTP,
 680                 ICE_HASH_SCTP_IPV6 |
 681                 BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
 682 };
 683
 684 static struct ice_flow_engine ice_hash_engine = {
 685         .init = ice_hash_init,
 686         .create = ice_hash_create,
 687         .destroy = ice_hash_destroy,
 688         .uninit = ice_hash_uninit,
 689         .free = ice_hash_free,
 690         .type = ICE_FLOW_ENGINE_HASH,
 691 };
 692
 693 /* Register parser for os package. */
 694 static struct ice_flow_parser ice_hash_parser_os = {
 695         .engine = &ice_hash_engine,
 696         .array = ice_hash_pattern_list_os,
 697         .array_len = RTE_DIM(ice_hash_pattern_list_os),
 698         .parse_pattern_action = ice_hash_parse_pattern_action,
 699         .stage = ICE_FLOW_STAGE_RSS,
 700 };
 701
 702 /* Register parser for comms package. */
 703 static struct ice_flow_parser ice_hash_parser_comms = {
 704         .engine = &ice_hash_engine,
 705         .array = ice_hash_pattern_list_comms,
 706         .array_len = RTE_DIM(ice_hash_pattern_list_comms),
 707         .parse_pattern_action = ice_hash_parse_pattern_action,
 708         .stage = ICE_FLOW_STAGE_RSS,
 709 };
 710
 711 RTE_INIT(ice_hash_engine_init)
 712 {
 713         struct ice_flow_engine *engine = &ice_hash_engine;
 714         ice_register_flow_engine(engine);
 715 }
 716
 717 static int
 718 ice_hash_init(struct ice_adapter *ad)
 719 {
 720         struct ice_flow_parser *parser = NULL;
 721
 722         if (ad->hw.dcf_enabled)
 723                 return 0;
 724
 725         if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT)
 726                 parser = &ice_hash_parser_os;
 727         else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS)
 728                 parser = &ice_hash_parser_comms;
 729         else
 730                 return -EINVAL;
 731
 732         return ice_register_parser(parser, ad);
 733 }
 734
 735 static int
 736 ice_hash_parse_pattern(struct ice_pattern_match_item *pattern_match_item,
 737                        const struct rte_flow_item pattern[], void **meta,
 738                        struct rte_flow_error *error)
 739 {
 740         uint32_t hdr_mask = ((struct rss_type_match_hdr *)
 741                 (pattern_match_item->meta))->hdr_mask;
 742         const struct rte_flow_item *item = pattern;
 743         const struct rte_flow_item_gtp_psc *psc;
 744         uint32_t hdrs = 0;
 745
 746         for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
 747                 if (item->last) {
 748                         rte_flow_error_set(error, EINVAL,
 749                                         RTE_FLOW_ERROR_TYPE_ITEM, item,
 750                                         "Not support range");
 751                         return -rte_errno;
 752                 }
 753
 754                 switch (item->type) {
 755                 case RTE_FLOW_ITEM_TYPE_GTPU:
 756                         hdrs |= ICE_FLOW_SEG_HDR_GTPU_IP;
 757                         break;
 758                 case RTE_FLOW_ITEM_TYPE_GTP_PSC:
 759                         psc = item->spec;
 760                         hdr_mask &= ~ICE_FLOW_SEG_HDR_GTPU_EH;
 761                         hdrs &= ~ICE_FLOW_SEG_HDR_GTPU_IP;
 762                         if (!psc)
 763                                 hdrs |= ICE_FLOW_SEG_HDR_GTPU_EH;
 764                         else if (psc->pdu_type == ICE_GTPU_EH_UPLINK)
 765                                 hdrs |= ICE_FLOW_SEG_HDR_GTPU_UP;
 766                         else if (psc->pdu_type == ICE_GTPU_EH_DWNLINK)
 767                                 hdrs |= ICE_FLOW_SEG_HDR_GTPU_DWN;
 768                         break;
 769                 default:
 770                         break;
 771                 }
 772         }
 773
 774         /* Save protocol header to rss_meta. */
 775         ((struct rss_meta *)*meta)->pkt_hdr |= hdr_mask | hdrs;
 776
 777         return 0;
 778 }
 779
 780 static int
 781 ice_hash_parse_action(struct ice_pattern_match_item *pattern_match_item,
 782                 const struct rte_flow_action actions[],
 783                 void **meta,
 784                 struct rte_flow_error *error)
 785 {
 786         struct rss_type_match_hdr *m = (struct rss_type_match_hdr *)
 787                                 (pattern_match_item->meta);
 788         struct rss_meta *hash_meta = (struct rss_meta *)*meta;
 789         uint32_t type_list_len = RTE_DIM(ice_hash_type_list);
 790         enum rte_flow_action_type action_type;
 791         const struct rte_flow_action_rss *rss;
 792         const struct rte_flow_action *action;
 793         uint64_t combine_type;
 794         uint64_t rss_type;
 795         uint16_t i;
 796
 797         /* Supported action is RSS. */
 798         for (action = actions; action->type !=
 799                 RTE_FLOW_ACTION_TYPE_END; action++) {
 800                 action_type = action->type;
 801                 switch (action_type) {
 802                 case RTE_FLOW_ACTION_TYPE_RSS:
 803                         rss = action->conf;
 804                         rss_type = rss->types;
 805
 806                         /* Check hash function and save it to rss_meta. */
 807                         if (pattern_match_item->pattern_list !=
 808                             pattern_empty && rss->func ==
 809                             RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
 810                                 return rte_flow_error_set(error, ENOTSUP,
 811                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
 812                                         "Not supported flow");
 813                         } else if (rss->func ==
 814                                    RTE_ETH_HASH_FUNCTION_SIMPLE_XOR){
 815                                 ((struct rss_meta *)*meta)->hash_function =
 816                                 RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
 817                                 return 0;
 818                         } else if (rss->func ==
 819                                    RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
 820                                 ((struct rss_meta *)*meta)->hash_function =
 821                                 RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ;
 822                         }
 823
 824                         if (rss->level)
 825                                 return rte_flow_error_set(error, ENOTSUP,
 826                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
 827                                         "a nonzero RSS encapsulation level is not supported");
 828
 829                         if (rss->key_len)
 830                                 return rte_flow_error_set(error, ENOTSUP,
 831                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
 832                                         "a nonzero RSS key_len is not supported");
 833
 834                         if (rss->queue)
 835                                 return rte_flow_error_set(error, ENOTSUP,
 836                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
 837                                         "a non-NULL RSS queue is not supported");
 838
 839                         /**
 840                          * Check simultaneous use of SRC_ONLY and DST_ONLY
 841                          * of the same level.
 842                          */
 843                         rss_type = rte_eth_rss_hf_refine(rss_type);
 844
 845                         combine_type = ETH_RSS_L2_SRC_ONLY |
 846                                         ETH_RSS_L2_DST_ONLY |
 847                                         ETH_RSS_L3_SRC_ONLY |
 848                                         ETH_RSS_L3_DST_ONLY |
 849                                         ETH_RSS_L4_SRC_ONLY |
 850                                         ETH_RSS_L4_DST_ONLY;
 851
 852                         /* Check if rss types match pattern. */
 853                         if (rss_type & ~combine_type & ~m->eth_rss_hint) {
 854                                 return rte_flow_error_set(error,
 855                                 ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION,
 856                                 action, "Not supported RSS types");
 857                         }
 858
 859                         /* Find matched hash fields according to hash type. */
 860                         for (i = 0; i < type_list_len; i++) {
 861                                 struct ice_hash_match_type *ht_map =
 862                                         &ice_hash_type_list[i];
 863
 864                                 if (rss_type == ht_map->hash_type) {
 865                                         hash_meta->hash_flds =
 866                                                         ht_map->hash_flds;
 867                                         break;
 868                                 }
 869                         }
 870
 871                         /* update hash field for nat-t esp. */
 872                         if (rss_type == ETH_RSS_ESP &&
 873                             (m->eth_rss_hint & ETH_RSS_NONFRAG_IPV4_UDP)) {
 874                                 hash_meta->hash_flds &=
 875                                 ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ESP_SPI));
 876                                 hash_meta->hash_flds |=
 877                                 BIT_ULL(ICE_FLOW_FIELD_IDX_NAT_T_ESP_SPI);
 878                         }
 879
 880                         /* update hash field for gtpu-ip and gtpu-eh. */
 881                         if (rss_type != ETH_RSS_GTPU)
 882                                 break;
 883                         else if (hash_meta->pkt_hdr & ICE_FLOW_SEG_HDR_GTPU_IP)
 884                                 hash_meta->hash_flds |=
 885                                 BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_IP_TEID);
 886                         else if (hash_meta->pkt_hdr & ICE_FLOW_SEG_HDR_GTPU_EH)
 887                                 hash_meta->hash_flds |=
 888                                 BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_EH_TEID);
 889                         else if (hash_meta->pkt_hdr & ICE_FLOW_SEG_HDR_GTPU_DWN)
 890                                 hash_meta->hash_flds |=
 891                                 BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID);
 892                         else if (hash_meta->pkt_hdr & ICE_FLOW_SEG_HDR_GTPU_UP)
 893                                 hash_meta->hash_flds |=
 894                                 BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_UP_TEID);
 895
 896                         break;
 897
 898                 case RTE_FLOW_ACTION_TYPE_END:
 899                         break;
 900
 901                 default:
 902                         rte_flow_error_set(error, EINVAL,
 903                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
 904                                         "Invalid action.");
 905                         return -rte_errno;
 906                 }
 907         }
 908
 909         return 0;
 910 }
 911
 912 static int
 913 ice_hash_parse_pattern_action(__rte_unused struct ice_adapter *ad,
 914                         struct ice_pattern_match_item *array,
 915                         uint32_t array_len,
 916                         const struct rte_flow_item pattern[],
 917                         const struct rte_flow_action actions[],
 918                         void **meta,
 919                         struct rte_flow_error *error)
 920 {
 921         int ret = 0;
 922         struct ice_pattern_match_item *pattern_match_item;
 923         struct rss_meta *rss_meta_ptr;
 924
 925         rss_meta_ptr = rte_zmalloc(NULL, sizeof(*rss_meta_ptr), 0);
 926         if (!rss_meta_ptr) {
 927                 rte_flow_error_set(error, EINVAL,
 928                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
 929                                 "No memory for rss_meta_ptr");
 930                 return -ENOMEM;
 931         }
 932
 933         /* Check rss supported pattern and find matched pattern. */
 934         pattern_match_item = ice_search_pattern_match_item(pattern,
 935                                         array, array_len, error);
 936         if (!pattern_match_item) {
 937                 ret = -rte_errno;
 938                 goto error;
 939         }
 940
 941         ret = ice_hash_parse_pattern(pattern_match_item, pattern,
 942                                      (void **)&rss_meta_ptr, error);
 943         if (ret)
 944                 goto error;
 945
 946         /* Check rss action. */
 947         ret = ice_hash_parse_action(pattern_match_item, actions,
 948                                     (void **)&rss_meta_ptr, error);
 949
 950 error:
 951         if (!ret && meta)
 952                 *meta = rss_meta_ptr;
 953         else
 954                 rte_free(rss_meta_ptr);
 955         rte_free(pattern_match_item);
 956
 957         return ret;
 958 }
 959
 960 static int
 961 ice_hash_create(struct ice_adapter *ad,
 962                 struct rte_flow *flow,
 963                 void *meta,
 964                 struct rte_flow_error *error)
 965 {
 966         struct ice_pf *pf = &ad->pf;
 967         struct ice_hw *hw = ICE_PF_TO_HW(pf);
 968         struct ice_vsi *vsi = pf->main_vsi;
 969         int ret;
 970         uint32_t reg;
 971         struct ice_hash_flow_cfg *filter_ptr;
 972
 973         uint32_t headermask = ((struct rss_meta *)meta)->pkt_hdr;
 974         uint64_t hash_field = ((struct rss_meta *)meta)->hash_flds;
 975         uint8_t hash_function = ((struct rss_meta *)meta)->hash_function;
 976
 977         filter_ptr = rte_zmalloc("ice_rss_filter",
 978                                 sizeof(struct ice_hash_flow_cfg), 0);
 979         if (!filter_ptr) {
 980                 rte_flow_error_set(error, EINVAL,
 981                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
 982                                 "No memory for filter_ptr");
 983                 return -ENOMEM;
 984         }
 985
 986         if (hash_function == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
 987                 /* Enable registers for simple_xor hash function. */
 988                 reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
 989                 reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
 990                         (2 << VSIQF_HASH_CTL_HASH_SCHEME_S);
 991                 ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);
 992
 993                 filter_ptr->simple_xor = 1;
 994
 995                 goto out;
 996         } else {
 997                 filter_ptr->rss_cfg.packet_hdr = headermask;
 998                 filter_ptr->rss_cfg.hashed_flds = hash_field;
 999                 filter_ptr->rss_cfg.symm =
1000                         (hash_function ==
1001                                 RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ);
1002
1003                 ret = ice_add_rss_cfg(hw, vsi->idx,
1004                                 filter_ptr->rss_cfg.hashed_flds,
1005                                 filter_ptr->rss_cfg.packet_hdr,
1006                                 filter_ptr->rss_cfg.symm);
1007                 if (ret) {
1008                         rte_flow_error_set(error, EINVAL,
1009                                         RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1010                                         "rss flow create fail");
1011                         goto error;
1012                 }
1013         }
1014
1015 out:
1016         flow->rule = filter_ptr;
1017         rte_free(meta);
1018         return 0;
1019
1020 error:
1021         rte_free(filter_ptr);
1022         rte_free(meta);
1023         return -rte_errno;
1024 }
1025
1026 static int
1027 ice_hash_destroy(struct ice_adapter *ad,
1028                 struct rte_flow *flow,
1029                 struct rte_flow_error *error)
1030 {
1031         struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(ad);
1032         struct ice_hw *hw = ICE_PF_TO_HW(pf);
1033         struct ice_vsi *vsi = pf->main_vsi;
1034         int ret;
1035         uint32_t reg;
1036         struct ice_hash_flow_cfg *filter_ptr;
1037
1038         filter_ptr = (struct ice_hash_flow_cfg *)flow->rule;
1039
1040         if (filter_ptr->simple_xor == 1) {
1041                 /* Return to symmetric_toeplitz state. */
1042                 reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
1043                 reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
1044                         (1 << VSIQF_HASH_CTL_HASH_SCHEME_S);
1045                 ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);
1046         } else {
1047                 ret = ice_rem_rss_cfg(hw, vsi->idx,
1048                                 filter_ptr->rss_cfg.hashed_flds,
1049                                 filter_ptr->rss_cfg.packet_hdr);
1050                 /* Fixme: Ignore the error if a rule does not exist.
1051                  * Currently a rule for inputset change or symm turn on/off
1052                  * will overwrite an exist rule, while application still
1053                  * have 2 rte_flow handles.
1054                  **/
1055                 if (ret && ret != ICE_ERR_DOES_NOT_EXIST) {
1056                         rte_flow_error_set(error, EINVAL,
1057                                         RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1058                                         "rss flow destroy fail");
1059                         goto error;
1060                 }
1061         }
1062
1063         rte_free(filter_ptr);
1064         return 0;
1065
1066 error:
1067         rte_free(filter_ptr);
1068         return -rte_errno;
1069 }
1070
1071 static void
1072 ice_hash_uninit(struct ice_adapter *ad)
1073 {
1074         if (ad->hw.dcf_enabled)
1075                 return;
1076
1077         if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT)
1078                 ice_unregister_parser(&ice_hash_parser_os, ad);
1079         else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS)
1080                 ice_unregister_parser(&ice_hash_parser_comms, ad);
1081 }
1082
1083 static void
1084 ice_hash_free(struct rte_flow *flow)
1085 {
1086         rte_free(flow->rule);
1087 }