/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2019 Intel Corporation
 */

#include <sys/queue.h>
#include <stdio.h>
#include <errno.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <stdarg.h>

#include <rte_debug.h>
#include <rte_ether.h>
#include <ethdev_driver.h>
#include <rte_log.h>
#include <rte_malloc.h>
#include <rte_eth_ctrl.h>
#include <rte_tailq.h>
#include <rte_flow_driver.h>

#include "ice_logs.h"
#include "base/ice_type.h"
#include "base/ice_flow.h"
#include "ice_ethdev.h"
#include "ice_generic_flow.h"

#define ICE_PHINT_NONE                          0
#define ICE_PHINT_VLAN                          BIT_ULL(0)
#define ICE_PHINT_PPPOE                         BIT_ULL(1)
#define ICE_PHINT_GTPU                          BIT_ULL(2)
#define ICE_PHINT_GTPU_EH                       BIT_ULL(3)
#define ICE_PHINT_GTPU_EH_DWN                   BIT_ULL(4)
#define ICE_PHINT_GTPU_EH_UP                    BIT_ULL(5)
#define ICE_PHINT_RAW                           BIT_ULL(6)

#define ICE_GTPU_EH_DWNLINK     0
#define ICE_GTPU_EH_UPLINK      1

#define ICE_IPV4_PROT           BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)
#define ICE_IPV6_PROT           BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)

#define VALID_RSS_IPV4_L4       (RTE_ETH_RSS_NONFRAG_IPV4_UDP   | \
                                 RTE_ETH_RSS_NONFRAG_IPV4_TCP   | \
                                 RTE_ETH_RSS_NONFRAG_IPV4_SCTP)

#define VALID_RSS_IPV6_L4       (RTE_ETH_RSS_NONFRAG_IPV6_UDP   | \
                                 RTE_ETH_RSS_NONFRAG_IPV6_TCP   | \
                                 RTE_ETH_RSS_NONFRAG_IPV6_SCTP)

#define VALID_RSS_IPV4          (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 | \
                                 VALID_RSS_IPV4_L4)
#define VALID_RSS_IPV6          (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 | \
                                 VALID_RSS_IPV6_L4)
#define VALID_RSS_L3            (VALID_RSS_IPV4 | VALID_RSS_IPV6)
#define VALID_RSS_L4            (VALID_RSS_IPV4_L4 | VALID_RSS_IPV6_L4)

#define VALID_RSS_ATTR          (RTE_ETH_RSS_L3_SRC_ONLY        | \
                                 RTE_ETH_RSS_L3_DST_ONLY        | \
                                 RTE_ETH_RSS_L4_SRC_ONLY        | \
                                 RTE_ETH_RSS_L4_DST_ONLY        | \
                                 RTE_ETH_RSS_L2_SRC_ONLY        | \
                                 RTE_ETH_RSS_L2_DST_ONLY        | \
                                 RTE_ETH_RSS_L3_PRE32   | \
                                 RTE_ETH_RSS_L3_PRE48   | \
                                 RTE_ETH_RSS_L3_PRE64)

#define INVALID_RSS_ATTR        (RTE_ETH_RSS_L3_PRE40   | \
                                 RTE_ETH_RSS_L3_PRE56   | \
                                 RTE_ETH_RSS_L3_PRE96)

struct ice_rss_meta {
        uint8_t hash_function;
        struct ice_rss_hash_cfg cfg;
        struct ice_rss_raw_cfg raw;
};

struct ice_hash_flow_cfg {
        bool simple_xor;
        struct ice_rss_cfg rss_cfg;
};

static int
ice_hash_init(struct ice_adapter *ad);

static int
ice_hash_create(struct ice_adapter *ad,
                struct rte_flow *flow,
                void *meta,
                struct rte_flow_error *error);

static int
ice_hash_destroy(struct ice_adapter *ad,
                struct rte_flow *flow,
                struct rte_flow_error *error);

static void
ice_hash_uninit(struct ice_adapter *ad);

static void
ice_hash_free(struct rte_flow *flow);

static int
ice_hash_parse_pattern_action(struct ice_adapter *ad,
                        struct ice_pattern_match_item *array,
                        uint32_t array_len,
                        const struct rte_flow_item pattern[],
                        const struct rte_flow_action actions[],
                        uint32_t priority,
                        void **meta,
                        struct rte_flow_error *error);

/* Rss configuration template */
struct ice_rss_hash_cfg ipv4_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
        ICE_FLOW_SEG_HDR_IPV_OTHER,
        ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV4,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg ipv4_udp_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
        ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
        ICE_FLOW_HASH_ETH | ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg ipv4_tcp_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
        ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
        ICE_FLOW_HASH_ETH | ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg ipv4_sctp_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
        ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
        ICE_FLOW_HASH_ETH | ICE_HASH_SCTP_IPV4 | ICE_IPV4_PROT,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg ipv6_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
        ICE_FLOW_SEG_HDR_IPV_OTHER,
        ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV6,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg ipv6_frag_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
        ICE_FLOW_SEG_HDR_IPV_FRAG,
        ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV6,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg ipv6_udp_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
        ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
        ICE_FLOW_HASH_ETH | ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg ipv6_tcp_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
        ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
        ICE_FLOW_HASH_ETH | ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg ipv6_sctp_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
        ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
        ICE_FLOW_HASH_ETH | ICE_HASH_SCTP_IPV6 | ICE_IPV6_PROT,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
        ICE_FLOW_HASH_IPV4,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
        0
};
struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_udp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_UDP,
        ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
        0
};

struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_tcp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_TCP,
        ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
        0
};

struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
        ICE_FLOW_HASH_IPV4,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
        0
};

struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_udp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_UDP,
        ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
        0
};

struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_tcp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_TCP,
        ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
        0
};

struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
        ICE_FLOW_HASH_IPV6,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
        0
};

struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_udp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_UDP,
        ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
        0
};

struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_tcp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_TCP,
        ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
        0
};

struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
        ICE_FLOW_HASH_IPV6,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
        0
};
struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_udp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_UDP,
        ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
        0
};

struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_tcp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_TCP,
        ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
        ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
        0
};

struct ice_rss_hash_cfg eth_ipv4_esp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_ESP,
        ICE_FLOW_HASH_ESP_SPI,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_ipv4_udp_esp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_NAT_T_ESP,
        ICE_FLOW_HASH_NAT_T_ESP_SPI,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_ipv4_ah_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_AH,
        ICE_FLOW_HASH_AH_SPI,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_ipv4_l2tpv3_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_L2TPV3,
        ICE_FLOW_HASH_L2TPV3_SESS_ID,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_ipv4_pfcp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_PFCP_SESSION,
        ICE_FLOW_HASH_PFCP_SEID,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_ipv6_esp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_ESP,
        ICE_FLOW_HASH_ESP_SPI,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_ipv6_udp_esp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_NAT_T_ESP,
        ICE_FLOW_HASH_NAT_T_ESP_SPI,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_ipv6_ah_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_AH,
        ICE_FLOW_HASH_AH_SPI,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_ipv6_l2tpv3_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_L2TPV3,
        ICE_FLOW_HASH_L2TPV3_SESS_ID,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_ipv6_pfcp_tmplt = {
        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
        ICE_FLOW_SEG_HDR_PFCP_SESSION,
        ICE_FLOW_HASH_PFCP_SEID,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg pppoe_tmplt = {
        ICE_FLOW_SEG_HDR_ETH,
        ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_PPPOE_SESS_ID,
        ICE_RSS_OUTER_HEADERS,
        0
};

struct ice_rss_hash_cfg empty_tmplt = {
        ICE_FLOW_SEG_HDR_NONE,
        0,
        ICE_RSS_ANY_HEADERS,
        0
};

struct ice_rss_hash_cfg eth_tmplt = {
        ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_ETH_NON_IP,
        ICE_FLOW_HASH_ETH,
        ICE_RSS_OUTER_HEADERS,
        0
};

/* IPv4 */
#define ICE_RSS_TYPE_ETH_IPV4           (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV4 | \
                                         RTE_ETH_RSS_FRAG_IPV4 | \
                                         RTE_ETH_RSS_IPV4_CHKSUM)
#define ICE_RSS_TYPE_ETH_IPV4_UDP       (ICE_RSS_TYPE_ETH_IPV4 | \
                                         RTE_ETH_RSS_NONFRAG_IPV4_UDP | \
                                         RTE_ETH_RSS_L4_CHKSUM)
#define ICE_RSS_TYPE_ETH_IPV4_TCP       (ICE_RSS_TYPE_ETH_IPV4 | \
                                         RTE_ETH_RSS_NONFRAG_IPV4_TCP | \
                                         RTE_ETH_RSS_L4_CHKSUM)
#define ICE_RSS_TYPE_ETH_IPV4_SCTP      (ICE_RSS_TYPE_ETH_IPV4 | \
                                         RTE_ETH_RSS_NONFRAG_IPV4_SCTP | \
                                         RTE_ETH_RSS_L4_CHKSUM)
#define ICE_RSS_TYPE_IPV4               RTE_ETH_RSS_IPV4
#define ICE_RSS_TYPE_IPV4_UDP           (RTE_ETH_RSS_IPV4 | \
                                         RTE_ETH_RSS_NONFRAG_IPV4_UDP)
#define ICE_RSS_TYPE_IPV4_TCP           (RTE_ETH_RSS_IPV4 | \
                                         RTE_ETH_RSS_NONFRAG_IPV4_TCP)
#define ICE_RSS_TYPE_IPV4_SCTP          (RTE_ETH_RSS_IPV4 | \
                                         RTE_ETH_RSS_NONFRAG_IPV4_SCTP)

/* IPv6 */
#define ICE_RSS_TYPE_ETH_IPV6           (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV6)
#define ICE_RSS_TYPE_ETH_IPV6_FRAG      (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV6 | \
                                         RTE_ETH_RSS_FRAG_IPV6)
#define ICE_RSS_TYPE_ETH_IPV6_UDP       (ICE_RSS_TYPE_ETH_IPV6 | \
                                         RTE_ETH_RSS_NONFRAG_IPV6_UDP | \
                                         RTE_ETH_RSS_L4_CHKSUM)
#define ICE_RSS_TYPE_ETH_IPV6_TCP       (ICE_RSS_TYPE_ETH_IPV6 | \
                                         RTE_ETH_RSS_NONFRAG_IPV6_TCP | \
                                         RTE_ETH_RSS_L4_CHKSUM)
#define ICE_RSS_TYPE_ETH_IPV6_SCTP      (ICE_RSS_TYPE_ETH_IPV6 | \
                                         RTE_ETH_RSS_NONFRAG_IPV6_SCTP | \
                                         RTE_ETH_RSS_L4_CHKSUM)
#define ICE_RSS_TYPE_IPV6               RTE_ETH_RSS_IPV6
#define ICE_RSS_TYPE_IPV6_UDP           (RTE_ETH_RSS_IPV6 | \
                                         RTE_ETH_RSS_NONFRAG_IPV6_UDP)
#define ICE_RSS_TYPE_IPV6_TCP           (RTE_ETH_RSS_IPV6 | \
                                         RTE_ETH_RSS_NONFRAG_IPV6_TCP)
#define ICE_RSS_TYPE_IPV6_SCTP          (RTE_ETH_RSS_IPV6 | \
                                         RTE_ETH_RSS_NONFRAG_IPV6_SCTP)

/* VLAN IPV4 */
#define ICE_RSS_TYPE_VLAN_IPV4          (ICE_RSS_TYPE_IPV4 | \
                                         RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN | \
                                         RTE_ETH_RSS_FRAG_IPV4)
#define ICE_RSS_TYPE_VLAN_IPV4_UDP      (ICE_RSS_TYPE_IPV4_UDP | \
                                         RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
#define ICE_RSS_TYPE_VLAN_IPV4_TCP      (ICE_RSS_TYPE_IPV4_TCP | \
                                         RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
#define ICE_RSS_TYPE_VLAN_IPV4_SCTP     (ICE_RSS_TYPE_IPV4_SCTP | \
                                         RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
/* VLAN IPv6 */
#define ICE_RSS_TYPE_VLAN_IPV6          (ICE_RSS_TYPE_IPV6 | \
                                         RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
#define ICE_RSS_TYPE_VLAN_IPV6_FRAG     (ICE_RSS_TYPE_IPV6 | \
                                         RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN | \
                                         RTE_ETH_RSS_FRAG_IPV6)
#define ICE_RSS_TYPE_VLAN_IPV6_UDP      (ICE_RSS_TYPE_IPV6_UDP | \
                                         RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
#define ICE_RSS_TYPE_VLAN_IPV6_TCP      (ICE_RSS_TYPE_IPV6_TCP | \
                                         RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
#define ICE_RSS_TYPE_VLAN_IPV6_SCTP     (ICE_RSS_TYPE_IPV6_SCTP | \
                                         RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)

/* GTPU IPv4 */
#define ICE_RSS_TYPE_GTPU_IPV4          (ICE_RSS_TYPE_IPV4 | \
                                         RTE_ETH_RSS_GTPU)
#define ICE_RSS_TYPE_GTPU_IPV4_UDP      (ICE_RSS_TYPE_IPV4_UDP | \
                                         RTE_ETH_RSS_GTPU)
#define ICE_RSS_TYPE_GTPU_IPV4_TCP      (ICE_RSS_TYPE_IPV4_TCP | \
                                         RTE_ETH_RSS_GTPU)
/* GTPU IPv6 */
#define ICE_RSS_TYPE_GTPU_IPV6          (ICE_RSS_TYPE_IPV6 | \
                                         RTE_ETH_RSS_GTPU)
#define ICE_RSS_TYPE_GTPU_IPV6_UDP      (ICE_RSS_TYPE_IPV6_UDP | \
                                         RTE_ETH_RSS_GTPU)
#define ICE_RSS_TYPE_GTPU_IPV6_TCP      (ICE_RSS_TYPE_IPV6_TCP | \
                                         RTE_ETH_RSS_GTPU)

/* PPPOE */
#define ICE_RSS_TYPE_PPPOE              (RTE_ETH_RSS_ETH | RTE_ETH_RSS_PPPOE)

/* PPPOE IPv4 */
#define ICE_RSS_TYPE_PPPOE_IPV4         (ICE_RSS_TYPE_IPV4 | \
                                         ICE_RSS_TYPE_PPPOE)
#define ICE_RSS_TYPE_PPPOE_IPV4_UDP     (ICE_RSS_TYPE_IPV4_UDP | \
                                         ICE_RSS_TYPE_PPPOE)
#define ICE_RSS_TYPE_PPPOE_IPV4_TCP     (ICE_RSS_TYPE_IPV4_TCP | \
                                         ICE_RSS_TYPE_PPPOE)

/* PPPOE IPv6 */
#define ICE_RSS_TYPE_PPPOE_IPV6         (ICE_RSS_TYPE_IPV6 | \
                                         ICE_RSS_TYPE_PPPOE)
#define ICE_RSS_TYPE_PPPOE_IPV6_UDP     (ICE_RSS_TYPE_IPV6_UDP | \
                                         ICE_RSS_TYPE_PPPOE)
#define ICE_RSS_TYPE_PPPOE_IPV6_TCP     (ICE_RSS_TYPE_IPV6_TCP | \
                                         ICE_RSS_TYPE_PPPOE)

/* ESP, AH, L2TPV3 and PFCP */
#define ICE_RSS_TYPE_IPV4_ESP           (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV4)
#define ICE_RSS_TYPE_IPV6_ESP           (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV6)
#define ICE_RSS_TYPE_IPV4_AH            (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV4)
#define ICE_RSS_TYPE_IPV6_AH            (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV6)
#define ICE_RSS_TYPE_IPV4_L2TPV3        (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV4)
#define ICE_RSS_TYPE_IPV6_L2TPV3        (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV6)
#define ICE_RSS_TYPE_IPV4_PFCP          (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV4)
#define ICE_RSS_TYPE_IPV6_PFCP          (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV6)

/* MAC */
#define ICE_RSS_TYPE_ETH                RTE_ETH_RSS_ETH

/**
 * Supported pattern for hash.
 * The first member is pattern item type,
 * the second member is input set mask,
 * the third member is ice_rss_hash_cfg template.
 */
static struct ice_pattern_match_item ice_hash_pattern_list[] = {
        /* IPV4 */
        {pattern_raw,                           ICE_INSET_NONE,                         ICE_INSET_NONE, NULL},
        {pattern_eth_ipv4,                      ICE_RSS_TYPE_ETH_IPV4,          ICE_INSET_NONE, &ipv4_tmplt},
        {pattern_eth_ipv4_udp,                  ICE_RSS_TYPE_ETH_IPV4_UDP,      ICE_INSET_NONE, &ipv4_udp_tmplt},
        {pattern_eth_ipv4_tcp,                  ICE_RSS_TYPE_ETH_IPV4_TCP,      ICE_INSET_NONE, &ipv4_tcp_tmplt},
        {pattern_eth_ipv4_sctp,                 ICE_RSS_TYPE_ETH_IPV4_SCTP,     ICE_INSET_NONE, &ipv4_sctp_tmplt},
        {pattern_eth_vlan_ipv4,                 ICE_RSS_TYPE_VLAN_IPV4,         ICE_INSET_NONE, &ipv4_tmplt},
        {pattern_eth_vlan_ipv4_udp,             ICE_RSS_TYPE_VLAN_IPV4_UDP,     ICE_INSET_NONE, &ipv4_udp_tmplt},
        {pattern_eth_vlan_ipv4_tcp,             ICE_RSS_TYPE_VLAN_IPV4_TCP,     ICE_INSET_NONE, &ipv4_tcp_tmplt},
        {pattern_eth_vlan_ipv4_sctp,            ICE_RSS_TYPE_VLAN_IPV4_SCTP,    ICE_INSET_NONE, &ipv4_sctp_tmplt},
        {pattern_eth_ipv4_gtpu_ipv4,            ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tmplt},
        {pattern_eth_ipv4_gtpu_ipv4_udp,        ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_udp_tmplt},
        {pattern_eth_ipv4_gtpu_ipv4_tcp,        ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tcp_tmplt},
        {pattern_eth_ipv6_gtpu_ipv4,            ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tmplt},
        {pattern_eth_ipv6_gtpu_ipv4_udp,        ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_udp_tmplt},
        {pattern_eth_ipv6_gtpu_ipv4_tcp,        ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tcp_tmplt},
        {pattern_eth_ipv4_gtpu_eh_ipv4,         ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tmplt},
        {pattern_eth_ipv4_gtpu_eh_ipv4_udp,     ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_udp_tmplt},
        {pattern_eth_ipv4_gtpu_eh_ipv4_tcp,     ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tcp_tmplt},
        {pattern_eth_ipv6_gtpu_eh_ipv4,         ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tmplt},
        {pattern_eth_ipv6_gtpu_eh_ipv4_udp,     ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_udp_tmplt},
        {pattern_eth_ipv6_gtpu_eh_ipv4_tcp,     ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tcp_tmplt},
        {pattern_eth_pppoes_ipv4,               ICE_RSS_TYPE_PPPOE_IPV4,        ICE_INSET_NONE, &ipv4_tmplt},
        {pattern_eth_pppoes_ipv4_udp,           ICE_RSS_TYPE_PPPOE_IPV4_UDP,    ICE_INSET_NONE, &ipv4_udp_tmplt},
        {pattern_eth_pppoes_ipv4_tcp,           ICE_RSS_TYPE_PPPOE_IPV4_TCP,    ICE_INSET_NONE, &ipv4_tcp_tmplt},
        {pattern_eth_ipv4_esp,                  ICE_RSS_TYPE_IPV4_ESP,          ICE_INSET_NONE, &eth_ipv4_esp_tmplt},
        {pattern_eth_ipv4_udp_esp,              ICE_RSS_TYPE_IPV4_ESP,          ICE_INSET_NONE, &eth_ipv4_udp_esp_tmplt},
        {pattern_eth_ipv4_ah,                   ICE_RSS_TYPE_IPV4_AH,           ICE_INSET_NONE, &eth_ipv4_ah_tmplt},
        {pattern_eth_ipv4_l2tp,                 ICE_RSS_TYPE_IPV4_L2TPV3,       ICE_INSET_NONE, &eth_ipv4_l2tpv3_tmplt},
        {pattern_eth_ipv4_pfcp,                 ICE_RSS_TYPE_IPV4_PFCP,         ICE_INSET_NONE, &eth_ipv4_pfcp_tmplt},
        /* IPV6 */
        {pattern_eth_ipv6,                      ICE_RSS_TYPE_ETH_IPV6,          ICE_INSET_NONE, &ipv6_tmplt},
        {pattern_eth_ipv6_frag_ext,             ICE_RSS_TYPE_ETH_IPV6_FRAG,     ICE_INSET_NONE, &ipv6_frag_tmplt},
        {pattern_eth_ipv6_udp,                  ICE_RSS_TYPE_ETH_IPV6_UDP,      ICE_INSET_NONE, &ipv6_udp_tmplt},
        {pattern_eth_ipv6_tcp,                  ICE_RSS_TYPE_ETH_IPV6_TCP,      ICE_INSET_NONE, &ipv6_tcp_tmplt},
        {pattern_eth_ipv6_sctp,                 ICE_RSS_TYPE_ETH_IPV6_SCTP,     ICE_INSET_NONE, &ipv6_sctp_tmplt},
        {pattern_eth_vlan_ipv6,                 ICE_RSS_TYPE_VLAN_IPV6,         ICE_INSET_NONE, &ipv6_tmplt},
        {pattern_eth_vlan_ipv6_frag_ext,        ICE_RSS_TYPE_VLAN_IPV6_FRAG,    ICE_INSET_NONE, &ipv6_frag_tmplt},
        {pattern_eth_vlan_ipv6_udp,             ICE_RSS_TYPE_VLAN_IPV6_UDP,     ICE_INSET_NONE, &ipv6_udp_tmplt},
        {pattern_eth_vlan_ipv6_tcp,             ICE_RSS_TYPE_VLAN_IPV6_TCP,     ICE_INSET_NONE, &ipv6_tcp_tmplt},
        {pattern_eth_vlan_ipv6_sctp,            ICE_RSS_TYPE_VLAN_IPV6_SCTP,    ICE_INSET_NONE, &ipv6_sctp_tmplt},
        {pattern_eth_ipv4_gtpu_ipv6,            ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tmplt},
        {pattern_eth_ipv4_gtpu_ipv6_udp,        ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_udp_tmplt},
        {pattern_eth_ipv4_gtpu_ipv6_tcp,        ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tcp_tmplt},
        {pattern_eth_ipv6_gtpu_ipv6,            ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tmplt},
        {pattern_eth_ipv6_gtpu_ipv6_udp,        ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_udp_tmplt},
        {pattern_eth_ipv6_gtpu_ipv6_tcp,        ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tcp_tmplt},
        {pattern_eth_ipv4_gtpu_eh_ipv6,         ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tmplt},
        {pattern_eth_ipv4_gtpu_eh_ipv6_udp,     ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_udp_tmplt},
        {pattern_eth_ipv4_gtpu_eh_ipv6_tcp,     ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tcp_tmplt},
        {pattern_eth_ipv6_gtpu_eh_ipv6,         ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tmplt},
        {pattern_eth_ipv6_gtpu_eh_ipv6_udp,     ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_udp_tmplt},
        {pattern_eth_ipv6_gtpu_eh_ipv6_tcp,     ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tcp_tmplt},
        {pattern_eth_pppoes_ipv6,               ICE_RSS_TYPE_PPPOE_IPV6,        ICE_INSET_NONE, &ipv6_tmplt},
        {pattern_eth_pppoes_ipv6_udp,           ICE_RSS_TYPE_PPPOE_IPV6_UDP,    ICE_INSET_NONE, &ipv6_udp_tmplt},
        {pattern_eth_pppoes_ipv6_tcp,           ICE_RSS_TYPE_PPPOE_IPV6_TCP,    ICE_INSET_NONE, &ipv6_tcp_tmplt},
        {pattern_eth_ipv6_esp,                  ICE_RSS_TYPE_IPV6_ESP,          ICE_INSET_NONE, &eth_ipv6_esp_tmplt},
        {pattern_eth_ipv6_udp_esp,              ICE_RSS_TYPE_IPV6_ESP,          ICE_INSET_NONE, &eth_ipv6_udp_esp_tmplt},
        {pattern_eth_ipv6_ah,                   ICE_RSS_TYPE_IPV6_AH,           ICE_INSET_NONE, &eth_ipv6_ah_tmplt},
        {pattern_eth_ipv6_l2tp,                 ICE_RSS_TYPE_IPV6_L2TPV3,       ICE_INSET_NONE, &eth_ipv6_l2tpv3_tmplt},
        {pattern_eth_ipv6_pfcp,                 ICE_RSS_TYPE_IPV6_PFCP,         ICE_INSET_NONE, &eth_ipv6_pfcp_tmplt},
        /* PPPOE */
        {pattern_eth_pppoes,                    ICE_RSS_TYPE_PPPOE,             ICE_INSET_NONE, &pppoe_tmplt},
        /* MAC */
        {pattern_ethertype,                     ICE_RSS_TYPE_ETH,               ICE_INSET_NONE, &eth_tmplt},
        /* EMPTY */
        {pattern_empty,                         ICE_INSET_NONE,                 ICE_INSET_NONE, &empty_tmplt},
};

static struct ice_flow_engine ice_hash_engine = {
        .init = ice_hash_init,
        .create = ice_hash_create,
        .destroy = ice_hash_destroy,
        .uninit = ice_hash_uninit,
        .free = ice_hash_free,
        .type = ICE_FLOW_ENGINE_HASH,
};

/* Register parser for os package. */
static struct ice_flow_parser ice_hash_parser = {
        .engine = &ice_hash_engine,
        .array = ice_hash_pattern_list,
        .array_len = RTE_DIM(ice_hash_pattern_list),
        .parse_pattern_action = ice_hash_parse_pattern_action,
        .stage = ICE_FLOW_STAGE_RSS,
};

RTE_INIT(ice_hash_engine_init)
{
        struct ice_flow_engine *engine = &ice_hash_engine;
        ice_register_flow_engine(engine);
}

static int
ice_hash_init(struct ice_adapter *ad)
{
        struct ice_flow_parser *parser = NULL;

        if (ad->hw.dcf_enabled)
                return 0;

        parser = &ice_hash_parser;

        return ice_register_parser(parser, ad);
}

static int
ice_hash_parse_pattern(const struct rte_flow_item pattern[], uint64_t *phint,
                       struct rte_flow_error *error)
{
        const struct rte_flow_item *item = pattern;
        const struct rte_flow_item_gtp_psc *psc;

        for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
                if (item->last) {
                        rte_flow_error_set(error, EINVAL,
                                        RTE_FLOW_ERROR_TYPE_ITEM, item,
                                        "Not support range");
                        return -rte_errno;
                }

                switch (item->type) {
                case RTE_FLOW_ITEM_TYPE_RAW:
                        *phint |= ICE_PHINT_RAW;
                        break;
                case RTE_FLOW_ITEM_TYPE_VLAN:
                        *phint |= ICE_PHINT_VLAN;
                        break;
                case RTE_FLOW_ITEM_TYPE_PPPOES:
                        *phint |= ICE_PHINT_PPPOE;
                        break;
                case RTE_FLOW_ITEM_TYPE_GTPU:
                        *phint |= ICE_PHINT_GTPU;
                        break;
                case RTE_FLOW_ITEM_TYPE_GTP_PSC:
                        *phint |= ICE_PHINT_GTPU_EH;
                        psc = item->spec;
                        if (!psc)
                                break;
                        else if (psc->hdr.type == ICE_GTPU_EH_UPLINK)
                                *phint |= ICE_PHINT_GTPU_EH_UP;
                        else if (psc->hdr.type == ICE_GTPU_EH_DWNLINK)
                                *phint |= ICE_PHINT_GTPU_EH_DWN;
                        break;
                default:
                        break;
                }
        }

        return 0;
}

static int
ice_hash_parse_raw_pattern(struct ice_adapter *ad,
                                const struct rte_flow_item *item,
                                struct ice_rss_meta *meta)
{
        const struct rte_flow_item_raw *raw_spec, *raw_mask;
        struct ice_parser_profile prof;
        struct ice_parser_result rslt;
        struct ice_parser *psr;
        uint8_t *pkt_buf, *msk_buf;
        uint8_t spec_len, pkt_len;
        uint8_t tmp_val = 0;
        uint8_t tmp_c = 0;
        int i, j;

        raw_spec = item->spec;
        raw_mask = item->mask;

        spec_len = strlen((char *)(uintptr_t)raw_spec->pattern);
        if (strlen((char *)(uintptr_t)raw_mask->pattern) !=
                spec_len)
                return -rte_errno;

        pkt_len = spec_len / 2;

        pkt_buf = rte_zmalloc(NULL, pkt_len, 0);
        if (!pkt_buf)
                return -ENOMEM;

        msk_buf = rte_zmalloc(NULL, pkt_len, 0);
        if (!msk_buf)
                return -ENOMEM;

        /* convert string to int array */
        for (i = 0, j = 0; i < spec_len; i += 2, j++) {
                tmp_c = raw_spec->pattern[i];
                if (tmp_c >= 'a' && tmp_c <= 'f')
                        tmp_val = tmp_c - 'a' + 10;
                if (tmp_c >= 'A' && tmp_c <= 'F')
                        tmp_val = tmp_c - 'A' + 10;
                if (tmp_c >= '0' && tmp_c <= '9')
                        tmp_val = tmp_c - '0';

                tmp_c = raw_spec->pattern[i + 1];
                if (tmp_c >= 'a' && tmp_c <= 'f')
                        pkt_buf[j] = tmp_val * 16 + tmp_c - 'a' + 10;
                if (tmp_c >= 'A' && tmp_c <= 'F')
                        pkt_buf[j] = tmp_val * 16 + tmp_c - 'A' + 10;
                if (tmp_c >= '0' && tmp_c <= '9')
                        pkt_buf[j] = tmp_val * 16 + tmp_c - '0';

                tmp_c = raw_mask->pattern[i];
                if (tmp_c >= 'a' && tmp_c <= 'f')
                        tmp_val = tmp_c - 0x57;
                if (tmp_c >= 'A' && tmp_c <= 'F')
                        tmp_val = tmp_c - 0x37;
                if (tmp_c >= '0' && tmp_c <= '9')
                        tmp_val = tmp_c - '0';

                tmp_c = raw_mask->pattern[i + 1];
                if (tmp_c >= 'a' && tmp_c <= 'f')
                        msk_buf[j] = tmp_val * 16 + tmp_c - 'a' + 10;
                if (tmp_c >= 'A' && tmp_c <= 'F')
                        msk_buf[j] = tmp_val * 16 + tmp_c - 'A' + 10;
                if (tmp_c >= '0' && tmp_c <= '9')
                        msk_buf[j] = tmp_val * 16 + tmp_c - '0';
        }

        if (ice_parser_create(&ad->hw, &psr))
                return -rte_errno;
        if (ice_parser_run(psr, pkt_buf, pkt_len, &rslt))
                return -rte_errno;
        ice_parser_destroy(psr);

        if (ice_parser_profile_init(&rslt, pkt_buf, msk_buf,
                pkt_len, ICE_BLK_RSS, true, &prof))
                return -rte_errno;

        rte_memcpy(&meta->raw.prof, &prof, sizeof(prof));

        rte_free(pkt_buf);
        rte_free(msk_buf);
        return 0;
}

static void
ice_refine_hash_cfg_l234(struct ice_rss_hash_cfg *hash_cfg,
                         uint64_t rss_type)
{
        uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
        uint64_t *hash_flds = &hash_cfg->hash_flds;

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_ETH) {
                if (!(rss_type & RTE_ETH_RSS_ETH))
                        *hash_flds &= ~ICE_FLOW_HASH_ETH;
                if (rss_type & RTE_ETH_RSS_L2_SRC_ONLY)
                        *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_DA));
                else if (rss_type & RTE_ETH_RSS_L2_DST_ONLY)
                        *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_SA));
                *addl_hdrs &= ~ICE_FLOW_SEG_HDR_ETH;
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_ETH_NON_IP) {
                if (rss_type & RTE_ETH_RSS_ETH)
                        *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_TYPE);
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_VLAN) {
                if (rss_type & RTE_ETH_RSS_C_VLAN)
                        *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_C_VLAN);
                else if (rss_type & RTE_ETH_RSS_S_VLAN)
                        *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_S_VLAN);
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_PPPOE) {
                if (!(rss_type & RTE_ETH_RSS_PPPOE))
                        *hash_flds &= ~ICE_FLOW_HASH_PPPOE_SESS_ID;
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_IPV4) {
                if (rss_type &
                   (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 |
                    RTE_ETH_RSS_NONFRAG_IPV4_UDP |
                    RTE_ETH_RSS_NONFRAG_IPV4_TCP |
                    RTE_ETH_RSS_NONFRAG_IPV4_SCTP)) {
                        if (rss_type & RTE_ETH_RSS_FRAG_IPV4) {
                                *addl_hdrs |= ICE_FLOW_SEG_HDR_IPV_FRAG;
                                *addl_hdrs &= ~(ICE_FLOW_SEG_HDR_IPV_OTHER);
                                *hash_flds |=
                                        BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_ID);
                        }
                        if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA));
                        else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA));
                        else if (rss_type &
                                (RTE_ETH_RSS_L4_SRC_ONLY |
                                RTE_ETH_RSS_L4_DST_ONLY))
                                *hash_flds &= ~ICE_FLOW_HASH_IPV4;
                } else {
                        *hash_flds &= ~ICE_FLOW_HASH_IPV4;
                }

                if (rss_type & RTE_ETH_RSS_IPV4_CHKSUM)
                        *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM);
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_IPV6) {
                if (rss_type &
                   (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 |
                    RTE_ETH_RSS_NONFRAG_IPV6_UDP |
                    RTE_ETH_RSS_NONFRAG_IPV6_TCP |
                    RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
                        if (rss_type & RTE_ETH_RSS_FRAG_IPV6)
                                *hash_flds |=
                                        BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_ID);
                        if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
                        else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
                        else if (rss_type &
                                (RTE_ETH_RSS_L4_SRC_ONLY |
                                RTE_ETH_RSS_L4_DST_ONLY))
                                *hash_flds &= ~ICE_FLOW_HASH_IPV6;
                } else {
                        *hash_flds &= ~ICE_FLOW_HASH_IPV6;
                }

                if (rss_type & RTE_ETH_RSS_L3_PRE32) {
                        if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
                                *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE32_SA));
                        } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
                                *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE32_DA));
                        } else {
                                *hash_flds &= ~ICE_FLOW_HASH_IPV6;
                                *hash_flds |= ICE_FLOW_HASH_IPV6_PRE32;
                        }
                }
                if (rss_type & RTE_ETH_RSS_L3_PRE48) {
                        if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
                                *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE48_SA));
                        } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
                                *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE48_DA));
                        } else {
                                *hash_flds &= ~ICE_FLOW_HASH_IPV6;
                                *hash_flds |= ICE_FLOW_HASH_IPV6_PRE48;
                        }
                }
                if (rss_type & RTE_ETH_RSS_L3_PRE64) {
                        if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
                                *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_SA));
                        } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
                                *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_DA));
                        } else {
                                *hash_flds &= ~ICE_FLOW_HASH_IPV6;
                                *hash_flds |= ICE_FLOW_HASH_IPV6_PRE64;
                        }
                }
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_UDP) {
                if (rss_type &
                   (RTE_ETH_RSS_NONFRAG_IPV4_UDP |
                    RTE_ETH_RSS_NONFRAG_IPV6_UDP)) {
                        if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT));
                        else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT));
                        else if (rss_type &
                                (RTE_ETH_RSS_L3_SRC_ONLY |
                                  RTE_ETH_RSS_L3_DST_ONLY))
                                *hash_flds &= ~ICE_FLOW_HASH_UDP_PORT;
                } else {
                        *hash_flds &= ~ICE_FLOW_HASH_UDP_PORT;
                }

                if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
                        *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_CHKSUM);
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_TCP) {
                if (rss_type &
                   (RTE_ETH_RSS_NONFRAG_IPV4_TCP |
                    RTE_ETH_RSS_NONFRAG_IPV6_TCP)) {
                        if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT));
                        else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT));
                        else if (rss_type &
                                (RTE_ETH_RSS_L3_SRC_ONLY |
                                  RTE_ETH_RSS_L3_DST_ONLY))
                                *hash_flds &= ~ICE_FLOW_HASH_TCP_PORT;
                } else {
                        *hash_flds &= ~ICE_FLOW_HASH_TCP_PORT;
                }

                if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
                        *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_CHKSUM);
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_SCTP) {
                if (rss_type &
                   (RTE_ETH_RSS_NONFRAG_IPV4_SCTP |
                    RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
                        if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT));
                        else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
                                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT));
                        else if (rss_type &
                                (RTE_ETH_RSS_L3_SRC_ONLY |
                                  RTE_ETH_RSS_L3_DST_ONLY))
                                *hash_flds &= ~ICE_FLOW_HASH_SCTP_PORT;
                } else {
                        *hash_flds &= ~ICE_FLOW_HASH_SCTP_PORT;
                }

                if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
                        *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_CHKSUM);
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_L2TPV3) {
                if (!(rss_type & RTE_ETH_RSS_L2TPV3))
                        *hash_flds &= ~ICE_FLOW_HASH_L2TPV3_SESS_ID;
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_ESP) {
                if (!(rss_type & RTE_ETH_RSS_ESP))
                        *hash_flds &= ~ICE_FLOW_HASH_ESP_SPI;
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_AH) {
                if (!(rss_type & RTE_ETH_RSS_AH))
                        *hash_flds &= ~ICE_FLOW_HASH_AH_SPI;
        }

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_PFCP_SESSION) {
                if (!(rss_type & RTE_ETH_RSS_PFCP))
                        *hash_flds &= ~ICE_FLOW_HASH_PFCP_SEID;
        }
}

static void
ice_refine_proto_hdrs_by_pattern(struct ice_rss_hash_cfg *hash_cfg,
                                 uint64_t phint)
{
        uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
        if (phint & ICE_PHINT_VLAN)
                *addl_hdrs |= ICE_FLOW_SEG_HDR_VLAN;

        if (phint & ICE_PHINT_PPPOE)
                *addl_hdrs |= ICE_FLOW_SEG_HDR_PPPOE;

        if (phint & ICE_PHINT_GTPU_EH_DWN)
                *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_DWN;
        else if (phint & ICE_PHINT_GTPU_EH_UP)
                *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_UP;
        else if (phint & ICE_PHINT_GTPU_EH)
                *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_EH;
        else if (phint & ICE_PHINT_GTPU)
                *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_IP;
}

static void
ice_refine_hash_cfg_gtpu(struct ice_rss_hash_cfg *hash_cfg,
                         uint64_t rss_type)
{
        uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
        uint64_t *hash_flds = &hash_cfg->hash_flds;

        /* update hash field for gtpu eh/gtpu dwn/gtpu up. */
        if (!(rss_type & RTE_ETH_RSS_GTPU))
                return;

        if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_DWN)
                *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID);
        else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_UP)
                *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_UP_TEID);
        else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_EH)
                *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_EH_TEID);
        else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_IP)
                *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_IP_TEID);
}

static void ice_refine_hash_cfg(struct ice_rss_hash_cfg *hash_cfg,
                                uint64_t rss_type, uint64_t phint)
{
        ice_refine_proto_hdrs_by_pattern(hash_cfg, phint);
        ice_refine_hash_cfg_l234(hash_cfg, rss_type);
        ice_refine_hash_cfg_gtpu(hash_cfg, rss_type);
}

static uint64_t invalid_rss_comb[] = {
        RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_UDP,
        RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_TCP,
        RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_UDP,
        RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_TCP,
        RTE_ETH_RSS_L3_PRE40 |
        RTE_ETH_RSS_L3_PRE56 |
        RTE_ETH_RSS_L3_PRE96
};

struct rss_attr_type {
        uint64_t attr;
        uint64_t type;
};

static struct rss_attr_type rss_attr_to_valid_type[] = {

        {RTE_ETH_RSS_L2_SRC_ONLY | RTE_ETH_RSS_L2_DST_ONLY,     RTE_ETH_RSS_ETH},
        {RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY,     VALID_RSS_L3},
        {RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY,     VALID_RSS_L4},
        /* current ipv6 prefix only supports prefix 64 bits*/
        {RTE_ETH_RSS_L3_PRE32,                          VALID_RSS_IPV6},
        {RTE_ETH_RSS_L3_PRE48,                          VALID_RSS_IPV6},
        {RTE_ETH_RSS_L3_PRE64,                          VALID_RSS_IPV6},
        {INVALID_RSS_ATTR,                              0}
};

static bool
ice_any_invalid_rss_type(enum rte_eth_hash_function rss_func,
                         uint64_t rss_type, uint64_t allow_rss_type)
{
        uint32_t i;

        /**
         * Check if l3/l4 SRC/DST_ONLY is set for SYMMETRIC_TOEPLITZ
         * hash function.
         */
        if (rss_func == RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
                if (rss_type & (RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY |
                    RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY))
                        return true;

                if (!(rss_type &
                   (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_IPV6 |
                    RTE_ETH_RSS_FRAG_IPV4 | RTE_ETH_RSS_FRAG_IPV6 |
                    RTE_ETH_RSS_NONFRAG_IPV4_UDP | RTE_ETH_RSS_NONFRAG_IPV6_UDP |
                    RTE_ETH_RSS_NONFRAG_IPV4_TCP | RTE_ETH_RSS_NONFRAG_IPV6_TCP |
                    RTE_ETH_RSS_NONFRAG_IPV4_SCTP | RTE_ETH_RSS_NONFRAG_IPV6_SCTP)))
                        return true;
        }

        /* check invalid combination */
        for (i = 0; i < RTE_DIM(invalid_rss_comb); i++) {
                if (__builtin_popcountll(rss_type & invalid_rss_comb[i]) > 1)
                        return true;
        }

        /* check invalid RSS attribute */
        for (i = 0; i < RTE_DIM(rss_attr_to_valid_type); i++) {
                struct rss_attr_type *rat = &rss_attr_to_valid_type[i];

                if (rat->attr & rss_type && !(rat->type & rss_type))
                        return true;
        }

        /* check not allowed RSS type */
        rss_type &= ~VALID_RSS_ATTR;

        return ((rss_type & allow_rss_type) != rss_type);
}

static int
ice_hash_parse_action(struct ice_pattern_match_item *pattern_match_item,
                const struct rte_flow_action actions[],
                uint64_t pattern_hint, struct ice_rss_meta *rss_meta,
                struct rte_flow_error *error)
{
        struct ice_rss_hash_cfg *cfg = pattern_match_item->meta;
        enum rte_flow_action_type action_type;
        const struct rte_flow_action_rss *rss;
        const struct rte_flow_action *action;
        uint64_t rss_type;

        /* Supported action is RSS. */
        for (action = actions; action->type !=
                RTE_FLOW_ACTION_TYPE_END; action++) {
                action_type = action->type;
                switch (action_type) {
                case RTE_FLOW_ACTION_TYPE_RSS:
                        rss = action->conf;
                        rss_type = rss->types;

                        /* Check hash function and save it to rss_meta. */
                        if (pattern_match_item->pattern_list !=
                            pattern_empty && rss->func ==
                            RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
                                return rte_flow_error_set(error, ENOTSUP,
                                        RTE_FLOW_ERROR_TYPE_ACTION, action,
                                        "Not supported flow");
                        } else if (rss->func ==
                                   RTE_ETH_HASH_FUNCTION_SIMPLE_XOR){
                                rss_meta->hash_function =
                                RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
                                return 0;
                        } else if (rss->func ==
                                   RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
                                rss_meta->hash_function =
                                RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ;
                                if (pattern_hint == ICE_PHINT_RAW)
                                        rss_meta->raw.symm = true;
                                else
                                        cfg->symm = true;
                        }

                        if (rss->level)
                                return rte_flow_error_set(error, ENOTSUP,
                                        RTE_FLOW_ERROR_TYPE_ACTION, action,
                                        "a nonzero RSS encapsulation level is not supported");

                        if (rss->key_len)
                                return rte_flow_error_set(error, ENOTSUP,
                                        RTE_FLOW_ERROR_TYPE_ACTION, action,
                                        "a nonzero RSS key_len is not supported");

                        if (rss->queue)
                                return rte_flow_error_set(error, ENOTSUP,
                                        RTE_FLOW_ERROR_TYPE_ACTION, action,
                                        "a non-NULL RSS queue is not supported");

                        /* If pattern type is raw, no need to refine rss type */
                        if (pattern_hint == ICE_PHINT_RAW)
                                break;

                        /**
                         * Check simultaneous use of SRC_ONLY and DST_ONLY
                         * of the same level.
                         */
                        rss_type = rte_eth_rss_hf_refine(rss_type);

                        if (ice_any_invalid_rss_type(rss->func, rss_type,
                                        pattern_match_item->input_set_mask_o))
                                return rte_flow_error_set(error, ENOTSUP,
                                        RTE_FLOW_ERROR_TYPE_ACTION,
                                        action, "RSS type not supported");

                        rss_meta->cfg = *cfg;
                        ice_refine_hash_cfg(&rss_meta->cfg,
                                            rss_type, pattern_hint);
                        break;
                case RTE_FLOW_ACTION_TYPE_END:
                        break;

                default:
                        rte_flow_error_set(error, EINVAL,
                                        RTE_FLOW_ERROR_TYPE_ACTION, action,
                                        "Invalid action.");
                        return -rte_errno;
                }
        }

        return 0;
}

static int
ice_hash_parse_pattern_action(__rte_unused struct ice_adapter *ad,
                        struct ice_pattern_match_item *array,
                        uint32_t array_len,
                        const struct rte_flow_item pattern[],
                        const struct rte_flow_action actions[],
                        uint32_t priority,
                        void **meta,
                        struct rte_flow_error *error)
{
        int ret = 0;
        struct ice_pattern_match_item *pattern_match_item;
        struct ice_rss_meta *rss_meta_ptr;
        uint64_t phint = ICE_PHINT_NONE;

        if (priority >= 1)
                return -rte_errno;

        rss_meta_ptr = rte_zmalloc(NULL, sizeof(*rss_meta_ptr), 0);
        if (!rss_meta_ptr) {
                rte_flow_error_set(error, EINVAL,
                                RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
                                "No memory for rss_meta_ptr");
                return -ENOMEM;
        }

        /* Check rss supported pattern and find matched pattern. */
        pattern_match_item = ice_search_pattern_match_item(ad, pattern, array,
                                                           array_len, error);
        if (!pattern_match_item) {
                ret = -rte_errno;
                goto error;
        }

        ret = ice_hash_parse_pattern(pattern, &phint, error);
        if (ret)
                goto error;

        if (phint == ICE_PHINT_RAW) {
                rss_meta_ptr->raw.raw_ena = true;
                ret = ice_hash_parse_raw_pattern(ad, pattern, rss_meta_ptr);
                if (ret) {
                        rte_flow_error_set(error, EINVAL,
                                           RTE_FLOW_ERROR_TYPE_ITEM, NULL,
                                           "Parse raw pattern failed");
                        goto error;
                }
        }

        /* Check rss action. */
        ret = ice_hash_parse_action(pattern_match_item, actions, phint,
                                    rss_meta_ptr, error);

error:
        if (!ret && meta)
                *meta = rss_meta_ptr;
        else
                rte_free(rss_meta_ptr);
        rte_free(pattern_match_item);

        return ret;
}

static int
ice_hash_add_raw_cfg(struct ice_adapter *ad,
                struct ice_rss_raw_cfg *cfg, u16 vsi_handle)
{
        struct ice_parser_profile *prof = &cfg->prof;
        struct ice_rss_prof_info *rss_prof;
        struct ice_hw *hw = &ad->hw;
        int i, ptg, ret;
        u64 id;

        id = (u64)ice_find_first_bit(prof->ptypes, UINT16_MAX);

        ptg = hw->blk[ICE_BLK_RSS].xlt1.t[id];
        rss_prof = &ad->rss_prof_info[ptg];
        /* check if ptg already has profile */
        if (rss_prof->prof.fv_num) {
                for (i = 0; i < ICE_MAX_FV_WORDS; i++) {
                        if (rss_prof->prof.fv[i].proto_id !=
                            prof->fv[i].proto_id ||
                            rss_prof->prof.fv[i].offset !=
                            prof->fv[i].offset)
                                break;
                }

                /* current profile is matched, check symmetric hash */
                if (i == ICE_MAX_FV_WORDS) {
                        if (rss_prof->symm != cfg->symm)
                                goto update_symm;

                        return 0;
                }

                /* current profile is not matched, remove it */
                ret = ice_rem_prof_id_flow(hw, ICE_BLK_RSS,
                                           ice_get_hw_vsi_num(hw, vsi_handle),
                                           id);
                if (ret) {
                        PMD_DRV_LOG(ERR, "remove RSS flow failed\n");
                        return ret;
                }

                ret = ice_rem_prof(hw, ICE_BLK_RSS, id);
                if (ret) {
                        PMD_DRV_LOG(ERR, "remove RSS profile failed\n");
                        return ret;
                }
        }

        /* add new profile */
        ret = ice_flow_set_hw_prof(hw, vsi_handle, 0, prof, ICE_BLK_RSS);
        if (ret) {
                PMD_DRV_LOG(ERR, "HW profile add failed\n");
                return ret;
        }

        rss_prof->symm = cfg->symm;
        ice_memcpy(&rss_prof->prof, prof,
                   sizeof(struct ice_parser_profile),
                   ICE_NONDMA_TO_NONDMA);

update_symm:
        ice_rss_update_raw_symm(hw, cfg, id);
        return 0;
}

static int
ice_hash_create(struct ice_adapter *ad,
                struct rte_flow *flow,
                void *meta,
                struct rte_flow_error *error)
{
        struct ice_pf *pf = &ad->pf;
        struct ice_hw *hw = ICE_PF_TO_HW(pf);
        struct ice_vsi *vsi = pf->main_vsi;
        int ret;
        uint32_t reg;
        struct ice_hash_flow_cfg *filter_ptr;
        struct ice_rss_meta *rss_meta = (struct ice_rss_meta *)meta;
        uint8_t hash_function = rss_meta->hash_function;

        filter_ptr = rte_zmalloc("ice_rss_filter",
                                sizeof(struct ice_hash_flow_cfg), 0);
        if (!filter_ptr) {
                rte_flow_error_set(error, EINVAL,
                                RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
                                "No memory for filter_ptr");
                return -ENOMEM;
        }

        if (hash_function == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
                /* Enable registers for simple_xor hash function. */
                reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
                reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
                        (2 << VSIQF_HASH_CTL_HASH_SCHEME_S);
                ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);

                filter_ptr->simple_xor = 1;

                goto out;
        } else {
                if (rss_meta->raw.raw_ena) {
                        memcpy(&filter_ptr->rss_cfg.raw, &rss_meta->raw,
                               sizeof(struct ice_rss_raw_cfg));
                        ret = ice_hash_add_raw_cfg(ad, &rss_meta->raw,
                                                   pf->main_vsi->idx);
                        if (ret) {
                                rte_flow_error_set(error, EINVAL,
                                                   RTE_FLOW_ERROR_TYPE_HANDLE,
                                                   NULL,
                                                   "rss flow create fail");
                                goto error;
                        }
                } else {
                        memcpy(&filter_ptr->rss_cfg.hash, &rss_meta->cfg,
                               sizeof(struct ice_rss_hash_cfg));
                        ret = ice_add_rss_cfg_wrap(pf, vsi->idx,
                                                   &filter_ptr->rss_cfg.hash);
                        if (ret) {
                                rte_flow_error_set(error, EINVAL,
                                                   RTE_FLOW_ERROR_TYPE_HANDLE,
                                                   NULL,
                                                   "rss flow create fail");
                                goto error;
                        }
                }
        }

out:
        flow->rule = filter_ptr;
        rte_free(meta);
        return 0;

error:
        rte_free(filter_ptr);
        rte_free(meta);
        return -rte_errno;
}

static int
ice_hash_rem_raw_cfg(struct ice_adapter *ad,
                        struct ice_parser_profile *prof,
                    u16 vsi_handle)
{
        struct ice_hw *hw = &ad->hw;
        int ptg, ret;
        u16 vsig;
        u64 id;

        id = (u64)ice_find_first_bit(prof->ptypes, 0xFFFF);

        ptg = hw->blk[ICE_BLK_RSS].xlt1.t[id];

        memset(&ad->rss_prof_info[ptg], 0,
                sizeof(struct ice_rss_prof_info));

        /* check if vsig is already removed */
        ret = ice_vsig_find_vsi(hw, ICE_BLK_RSS,
                ice_get_hw_vsi_num(hw, vsi_handle), &vsig);
        if (!ret && vsig) {
                ret = ice_rem_prof_id_flow(hw, ICE_BLK_RSS,
                                           ice_get_hw_vsi_num(hw, vsi_handle),
                                           id);
                if (ret)
                        goto err;

                ret = ice_rem_prof(hw, ICE_BLK_RSS, id);
                if (ret)
                        goto err;
        }

        return 0;

err:
        PMD_DRV_LOG(ERR, "HW profile remove failed\n");
        return ret;
}

static int
ice_hash_destroy(struct ice_adapter *ad,
                struct rte_flow *flow,
                struct rte_flow_error *error)
{
        struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(ad);
        struct ice_hw *hw = ICE_PF_TO_HW(pf);
        struct ice_vsi *vsi = pf->main_vsi;
        int ret;
        uint32_t reg;
        struct ice_hash_flow_cfg *filter_ptr;

        filter_ptr = (struct ice_hash_flow_cfg *)flow->rule;

        if (filter_ptr->simple_xor == 1) {
                /* Return to symmetric_toeplitz state. */
                reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
                reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
                        (1 << VSIQF_HASH_CTL_HASH_SCHEME_S);
                ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);
        } else {
                if (filter_ptr->rss_cfg.raw.raw_ena) {
                        ret =
                        ice_hash_rem_raw_cfg(ad, &filter_ptr->rss_cfg.raw.prof,
                                             pf->main_vsi->idx);
                        if (ret) {
                                rte_flow_error_set(error, EINVAL,
                                                   RTE_FLOW_ERROR_TYPE_HANDLE,
                                                   NULL,
                                                   "rss flow destroy fail");
                                goto error;
                        }
                } else {
                        ret = ice_rem_rss_cfg_wrap(pf, vsi->idx,
                                                   &filter_ptr->rss_cfg.hash);
                        /* Fixme: Ignore the error if a rule does not exist.
                         * Currently a rule for inputset change or symm turn
                         * on/off will overwrite an exist rule, while
                         * application still have 2 rte_flow handles.
                         **/
                        if (ret && ret != ICE_ERR_DOES_NOT_EXIST) {
                                rte_flow_error_set(error, EINVAL,
                                                   RTE_FLOW_ERROR_TYPE_HANDLE,
                                                   NULL,
                                                   "rss flow destroy fail");
                                goto error;
                        }
                }
        }

        rte_free(filter_ptr);
        return 0;

error:
        rte_free(filter_ptr);
        return -rte_errno;
}

static void
ice_hash_uninit(struct ice_adapter *ad)
{
        if (ad->hw.dcf_enabled)
                return;

        ice_unregister_parser(&ice_hash_parser, ad);
}

static void
ice_hash_free(struct rte_flow *flow)
{
        rte_free(flow->rule);
}