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