// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) 2022, Intel Corporation. */

#include "rss.h"
#include "ice_vf_lib_private.h"
#include "ice.h"

#define FIELD_SELECTOR(proto_hdr_field) \
                BIT((proto_hdr_field) & PROTO_HDR_FIELD_MASK)

struct ice_vc_hdr_match_type {
        u32 vc_hdr;     /* virtchnl headers (VIRTCHNL_PROTO_HDR_XXX) */
        u32 ice_hdr;    /* ice headers (ICE_FLOW_SEG_HDR_XXX) */
};

static const struct ice_vc_hdr_match_type ice_vc_hdr_list[] = {
        {VIRTCHNL_PROTO_HDR_NONE,       ICE_FLOW_SEG_HDR_NONE},
        {VIRTCHNL_PROTO_HDR_ETH,        ICE_FLOW_SEG_HDR_ETH},
        {VIRTCHNL_PROTO_HDR_S_VLAN,     ICE_FLOW_SEG_HDR_VLAN},
        {VIRTCHNL_PROTO_HDR_C_VLAN,     ICE_FLOW_SEG_HDR_VLAN},
        {VIRTCHNL_PROTO_HDR_IPV4,       ICE_FLOW_SEG_HDR_IPV4 |
                                        ICE_FLOW_SEG_HDR_IPV_OTHER},
        {VIRTCHNL_PROTO_HDR_IPV6,       ICE_FLOW_SEG_HDR_IPV6 |
                                        ICE_FLOW_SEG_HDR_IPV_OTHER},
        {VIRTCHNL_PROTO_HDR_TCP,        ICE_FLOW_SEG_HDR_TCP},
        {VIRTCHNL_PROTO_HDR_UDP,        ICE_FLOW_SEG_HDR_UDP},
        {VIRTCHNL_PROTO_HDR_SCTP,       ICE_FLOW_SEG_HDR_SCTP},
        {VIRTCHNL_PROTO_HDR_PPPOE,      ICE_FLOW_SEG_HDR_PPPOE},
        {VIRTCHNL_PROTO_HDR_GTPU_IP,    ICE_FLOW_SEG_HDR_GTPU_IP},
        {VIRTCHNL_PROTO_HDR_GTPU_EH,    ICE_FLOW_SEG_HDR_GTPU_EH},
        {VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_DWN,
                                        ICE_FLOW_SEG_HDR_GTPU_DWN},
        {VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_UP,
                                        ICE_FLOW_SEG_HDR_GTPU_UP},
        {VIRTCHNL_PROTO_HDR_L2TPV3,     ICE_FLOW_SEG_HDR_L2TPV3},
        {VIRTCHNL_PROTO_HDR_ESP,        ICE_FLOW_SEG_HDR_ESP},
        {VIRTCHNL_PROTO_HDR_AH,         ICE_FLOW_SEG_HDR_AH},
        {VIRTCHNL_PROTO_HDR_PFCP,       ICE_FLOW_SEG_HDR_PFCP_SESSION},
        {VIRTCHNL_PROTO_HDR_GTPC,       ICE_FLOW_SEG_HDR_GTPC},
        {VIRTCHNL_PROTO_HDR_L2TPV2,     ICE_FLOW_SEG_HDR_L2TPV2},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,  ICE_FLOW_SEG_HDR_IPV_FRAG},
        {VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG,       ICE_FLOW_SEG_HDR_IPV_FRAG},
        {VIRTCHNL_PROTO_HDR_GRE,        ICE_FLOW_SEG_HDR_GRE},
};

struct ice_vc_hash_field_match_type {
        u32 vc_hdr;             /* virtchnl headers
                                 * (VIRTCHNL_PROTO_HDR_XXX)
                                 */
        u32 vc_hash_field;      /* virtchnl hash fields selector
                                 * FIELD_SELECTOR((VIRTCHNL_PROTO_HDR_ETH_XXX))
                                 */
        u64 ice_hash_field;     /* ice hash fields
                                 * (BIT_ULL(ICE_FLOW_FIELD_IDX_XXX))
                                 */
};

static const struct
ice_vc_hash_field_match_type ice_vc_hash_field_list[] = {
        {VIRTCHNL_PROTO_HDR_ETH, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ETH_SRC),
                BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_SA)},
        {VIRTCHNL_PROTO_HDR_ETH, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ETH_DST),
                BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_DA)},
        {VIRTCHNL_PROTO_HDR_ETH, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ETH_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ETH_DST),
                ICE_FLOW_HASH_ETH},
        {VIRTCHNL_PROTO_HDR_ETH,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ETH_ETHERTYPE),
                BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_TYPE)},
        {VIRTCHNL_PROTO_HDR_S_VLAN,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_S_VLAN_ID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_S_VLAN)},
        {VIRTCHNL_PROTO_HDR_C_VLAN,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_C_VLAN_ID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_C_VLAN)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST),
                ICE_FLOW_HASH_IPV4},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT),
                ICE_FLOW_HASH_IPV4 | BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV4,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_FRAG_PKID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_ID)},
        {VIRTCHNL_PROTO_HDR_IPV4,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                ICE_FLOW_HASH_IPV4 | BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                ICE_FLOW_HASH_IPV4 | BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST),
                ICE_FLOW_HASH_IPV4},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT),
                ICE_FLOW_HASH_IPV4 | BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_FRAG_PKID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_ID)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                ICE_FLOW_HASH_IPV4 | BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                ICE_FLOW_HASH_IPV4 | BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV4_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_PROT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV4_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_IPV6, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_SRC),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)},
        {VIRTCHNL_PROTO_HDR_IPV6, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_DST),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)},
        {VIRTCHNL_PROTO_HDR_IPV6, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_DST),
                ICE_FLOW_HASH_IPV6},
        {VIRTCHNL_PROTO_HDR_IPV6, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV6, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV6, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PROT),
                ICE_FLOW_HASH_IPV6 | BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV6, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG_PKID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_ID)},
        {VIRTCHNL_PROTO_HDR_IPV6,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_DST),
                ICE_FLOW_HASH_IPV6_PRE64},
        {VIRTCHNL_PROTO_HDR_IPV6,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_SRC),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_SA)},
        {VIRTCHNL_PROTO_HDR_IPV6,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_DST),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_DA)},
        {VIRTCHNL_PROTO_HDR_IPV6,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PROT),
                ICE_FLOW_HASH_IPV6_PRE64 |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV6,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_SRC) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_SA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
        {VIRTCHNL_PROTO_HDR_IPV6,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_DST) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_IPV6_PROT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_DA) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)},
        {VIRTCHNL_PROTO_HDR_TCP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_SRC_PORT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)},
        {VIRTCHNL_PROTO_HDR_TCP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_DST_PORT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT)},
        {VIRTCHNL_PROTO_HDR_TCP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_SRC_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_DST_PORT),
                ICE_FLOW_HASH_TCP_PORT},
        {VIRTCHNL_PROTO_HDR_TCP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_TCP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_SRC_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_TCP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_DST_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_TCP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_SRC_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_DST_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_TCP_CHKSUM),
                ICE_FLOW_HASH_TCP_PORT |
                BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_UDP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_SRC_PORT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)},
        {VIRTCHNL_PROTO_HDR_UDP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_DST_PORT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT)},
        {VIRTCHNL_PROTO_HDR_UDP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_SRC_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_DST_PORT),
                ICE_FLOW_HASH_UDP_PORT},
        {VIRTCHNL_PROTO_HDR_UDP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_UDP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_SRC_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_UDP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_DST_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_UDP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_SRC_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_DST_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_UDP_CHKSUM),
                ICE_FLOW_HASH_UDP_PORT |
                BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_SCTP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)},
        {VIRTCHNL_PROTO_HDR_SCTP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_DST_PORT),
                BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT)},
        {VIRTCHNL_PROTO_HDR_SCTP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_DST_PORT),
                ICE_FLOW_HASH_SCTP_PORT},
        {VIRTCHNL_PROTO_HDR_SCTP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_SCTP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_SCTP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_DST_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_CHKSUM),
                BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT) |
                BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_SCTP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_DST_PORT) |
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_SCTP_CHKSUM),
                ICE_FLOW_HASH_SCTP_PORT |
                BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_CHKSUM)},
        {VIRTCHNL_PROTO_HDR_PPPOE,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_PPPOE_SESS_ID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_PPPOE_SESS_ID)},
        {VIRTCHNL_PROTO_HDR_GTPU_IP,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_GTPU_IP_TEID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_IP_TEID)},
        {VIRTCHNL_PROTO_HDR_L2TPV3,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_L2TPV3_SESS_ID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_L2TPV3_SESS_ID)},
        {VIRTCHNL_PROTO_HDR_ESP, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_ESP_SPI),
                BIT_ULL(ICE_FLOW_FIELD_IDX_ESP_SPI)},
        {VIRTCHNL_PROTO_HDR_AH, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_AH_SPI),
                BIT_ULL(ICE_FLOW_FIELD_IDX_AH_SPI)},
        {VIRTCHNL_PROTO_HDR_PFCP, FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_PFCP_SEID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_PFCP_SEID)},
        {VIRTCHNL_PROTO_HDR_GTPC,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_GTPC_TEID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_GTPC_TEID)},
        {VIRTCHNL_PROTO_HDR_L2TPV2,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_L2TPV2_SESS_ID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_L2TPV2_SESS_ID)},
        {VIRTCHNL_PROTO_HDR_L2TPV2,
                FIELD_SELECTOR(VIRTCHNL_PROTO_HDR_L2TPV2_LEN_SESS_ID),
                BIT_ULL(ICE_FLOW_FIELD_IDX_L2TPV2_LEN_SESS_ID)},
};

static int
ice_vc_rss_hash_update(struct ice_hw *hw, struct ice_vsi *vsi, u8 hash_type)
{
        struct ice_vsi_ctx *ctx;
        int ret;

        ctx = kzalloc_obj(*ctx);
        if (!ctx)
                return -ENOMEM;

        /* clear previous hash_type */
        ctx->info.q_opt_rss = vsi->info.q_opt_rss &
                ~ICE_AQ_VSI_Q_OPT_RSS_HASH_M;
        /* hash_type is passed in as ICE_AQ_VSI_Q_OPT_RSS_<XOR|TPLZ|SYM_TPLZ */
        ctx->info.q_opt_rss |= FIELD_PREP(ICE_AQ_VSI_Q_OPT_RSS_HASH_M,
                                          hash_type);

        /* Preserve existing queueing option setting */
        ctx->info.q_opt_tc = vsi->info.q_opt_tc;
        ctx->info.q_opt_flags = vsi->info.q_opt_flags;

        ctx->info.valid_sections =
                        cpu_to_le16(ICE_AQ_VSI_PROP_Q_OPT_VALID);

        ret = ice_update_vsi(hw, vsi->idx, ctx, NULL);
        if (ret) {
                dev_err(ice_hw_to_dev(hw), "update VSI for RSS failed, err %d aq_err %s\n",
                        ret, libie_aq_str(hw->adminq.sq_last_status));
        } else {
                vsi->info.q_opt_rss = ctx->info.q_opt_rss;
        }

        kfree(ctx);

        return ret;
}

/**
 * ice_vc_validate_pattern
 * @vf: pointer to the VF info
 * @proto: virtchnl protocol headers
 *
 * validate the pattern is supported or not.
 *
 * Return: true on success, false on error.
 */
bool
ice_vc_validate_pattern(struct ice_vf *vf, struct virtchnl_proto_hdrs *proto)
{
        bool is_ipv4 = false;
        bool is_ipv6 = false;
        bool is_udp = false;
        u16 ptype = -1;
        int i = 0;

        while (i < proto->count &&
               proto->proto_hdr[i].type != VIRTCHNL_PROTO_HDR_NONE) {
                switch (proto->proto_hdr[i].type) {
                case VIRTCHNL_PROTO_HDR_ETH:
                        ptype = ICE_PTYPE_MAC_PAY;
                        break;
                case VIRTCHNL_PROTO_HDR_IPV4:
                        ptype = ICE_PTYPE_IPV4_PAY;
                        is_ipv4 = true;
                        break;
                case VIRTCHNL_PROTO_HDR_IPV6:
                        ptype = ICE_PTYPE_IPV6_PAY;
                        is_ipv6 = true;
                        break;
                case VIRTCHNL_PROTO_HDR_UDP:
                        if (is_ipv4)
                                ptype = ICE_PTYPE_IPV4_UDP_PAY;
                        else if (is_ipv6)
                                ptype = ICE_PTYPE_IPV6_UDP_PAY;
                        is_udp = true;
                        break;
                case VIRTCHNL_PROTO_HDR_TCP:
                        if (is_ipv4)
                                ptype = ICE_PTYPE_IPV4_TCP_PAY;
                        else if (is_ipv6)
                                ptype = ICE_PTYPE_IPV6_TCP_PAY;
                        break;
                case VIRTCHNL_PROTO_HDR_SCTP:
                        if (is_ipv4)
                                ptype = ICE_PTYPE_IPV4_SCTP_PAY;
                        else if (is_ipv6)
                                ptype = ICE_PTYPE_IPV6_SCTP_PAY;
                        break;
                case VIRTCHNL_PROTO_HDR_GTPU_IP:
                case VIRTCHNL_PROTO_HDR_GTPU_EH:
                        if (is_ipv4)
                                ptype = ICE_MAC_IPV4_GTPU;
                        else if (is_ipv6)
                                ptype = ICE_MAC_IPV6_GTPU;
                        goto out;
                case VIRTCHNL_PROTO_HDR_L2TPV3:
                        if (is_ipv4)
                                ptype = ICE_MAC_IPV4_L2TPV3;
                        else if (is_ipv6)
                                ptype = ICE_MAC_IPV6_L2TPV3;
                        goto out;
                case VIRTCHNL_PROTO_HDR_ESP:
                        if (is_ipv4)
                                ptype = is_udp ? ICE_MAC_IPV4_NAT_T_ESP :
                                                ICE_MAC_IPV4_ESP;
                        else if (is_ipv6)
                                ptype = is_udp ? ICE_MAC_IPV6_NAT_T_ESP :
                                                ICE_MAC_IPV6_ESP;
                        goto out;
                case VIRTCHNL_PROTO_HDR_AH:
                        if (is_ipv4)
                                ptype = ICE_MAC_IPV4_AH;
                        else if (is_ipv6)
                                ptype = ICE_MAC_IPV6_AH;
                        goto out;
                case VIRTCHNL_PROTO_HDR_PFCP:
                        if (is_ipv4)
                                ptype = ICE_MAC_IPV4_PFCP_SESSION;
                        else if (is_ipv6)
                                ptype = ICE_MAC_IPV6_PFCP_SESSION;
                        goto out;
                default:
                        break;
                }
                i++;
        }

out:
        return ice_hw_ptype_ena(&vf->pf->hw, ptype);
}

/**
 * ice_vc_parse_rss_cfg - parses hash fields and headers from
 * a specific virtchnl RSS cfg
 * @hw: pointer to the hardware
 * @rss_cfg: pointer to the virtchnl RSS cfg
 * @hash_cfg: pointer to the HW hash configuration
 *
 * Return true if all the protocol header and hash fields in the RSS cfg could
 * be parsed, else return false
 *
 * This function parses the virtchnl RSS cfg to be the intended
 * hash fields and the intended header for RSS configuration
 */
static bool ice_vc_parse_rss_cfg(struct ice_hw *hw,
                                 struct virtchnl_rss_cfg *rss_cfg,
                                 struct ice_rss_hash_cfg *hash_cfg)
{
        const struct ice_vc_hash_field_match_type *hf_list;
        const struct ice_vc_hdr_match_type *hdr_list;
        int i, hf_list_len, hdr_list_len;
        bool outer_ipv4 = false;
        bool outer_ipv6 = false;
        bool inner_hdr = false;
        bool has_gre = false;

        u32 *addl_hdrs = &hash_cfg->addl_hdrs;
        u64 *hash_flds = &hash_cfg->hash_flds;

        /* set outer layer RSS as default */
        hash_cfg->hdr_type = ICE_RSS_OUTER_HEADERS;

        if (rss_cfg->rss_algorithm == VIRTCHNL_RSS_ALG_TOEPLITZ_SYMMETRIC)
                hash_cfg->symm = true;
        else
                hash_cfg->symm = false;

        hf_list = ice_vc_hash_field_list;
        hf_list_len = ARRAY_SIZE(ice_vc_hash_field_list);
        hdr_list = ice_vc_hdr_list;
        hdr_list_len = ARRAY_SIZE(ice_vc_hdr_list);

        for (i = 0; i < rss_cfg->proto_hdrs.count; i++) {
                struct virtchnl_proto_hdr *proto_hdr =
                                        &rss_cfg->proto_hdrs.proto_hdr[i];
                u32 hdr_found = 0;
                int j;

                /* Find matched ice headers according to virtchnl headers.
                 * Also figure out the outer type of GTPU headers.
                 */
                for (j = 0; j < hdr_list_len; j++) {
                        struct ice_vc_hdr_match_type hdr_map = hdr_list[j];

                        if (proto_hdr->type == hdr_map.vc_hdr)
                                hdr_found = hdr_map.ice_hdr;
                }

                if (!hdr_found)
                        return false;

                /* Find matched ice hash fields according to
                 * virtchnl hash fields.
                 */
                for (j = 0; j < hf_list_len; j++) {
                        struct ice_vc_hash_field_match_type hf_map = hf_list[j];

                        if (proto_hdr->type == hf_map.vc_hdr &&
                            proto_hdr->field_selector == hf_map.vc_hash_field) {
                                *hash_flds |= hf_map.ice_hash_field;
                                break;
                        }
                }

                if (proto_hdr->type == VIRTCHNL_PROTO_HDR_IPV4 && !inner_hdr)
                        outer_ipv4 = true;
                else if (proto_hdr->type == VIRTCHNL_PROTO_HDR_IPV6 &&
                         !inner_hdr)
                        outer_ipv6 = true;
                /* for GRE and L2TPv2, take inner header as input set if no
                 * any field is selected from outer headers.
                 * for GTPU, take inner header and GTPU teid as input set.
                 */
                else if ((proto_hdr->type == VIRTCHNL_PROTO_HDR_GTPU_IP ||
                          proto_hdr->type == VIRTCHNL_PROTO_HDR_GTPU_EH ||
                          proto_hdr->type == VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_DWN ||
                          proto_hdr->type ==
                                VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_UP) ||
                         ((proto_hdr->type == VIRTCHNL_PROTO_HDR_L2TPV2 ||
                           proto_hdr->type == VIRTCHNL_PROTO_HDR_GRE) &&
                           *hash_flds == 0)) {
                        /* set inner_hdr flag, and clean up outer header */
                        inner_hdr = true;

                        /* clear outer headers */
                        *addl_hdrs = 0;

                        if (outer_ipv4 && outer_ipv6)
                                return false;

                        if (outer_ipv4)
                                hash_cfg->hdr_type = ICE_RSS_INNER_HEADERS_W_OUTER_IPV4;
                        else if (outer_ipv6)
                                hash_cfg->hdr_type = ICE_RSS_INNER_HEADERS_W_OUTER_IPV6;
                        else
                                hash_cfg->hdr_type = ICE_RSS_INNER_HEADERS;

                        if (has_gre && outer_ipv4)
                                hash_cfg->hdr_type =
                                        ICE_RSS_INNER_HEADERS_W_OUTER_IPV4_GRE;
                        if (has_gre && outer_ipv6)
                                hash_cfg->hdr_type =
                                        ICE_RSS_INNER_HEADERS_W_OUTER_IPV6_GRE;

                        if (proto_hdr->type == VIRTCHNL_PROTO_HDR_GRE)
                                has_gre = true;
                }

                *addl_hdrs |= hdr_found;

                /* refine hash hdrs and fields for IP fragment */
                if (VIRTCHNL_TEST_PROTO_HDR_FIELD(proto_hdr,
                                                  VIRTCHNL_PROTO_HDR_IPV4_FRAG_PKID) &&
                    proto_hdr->type == VIRTCHNL_PROTO_HDR_IPV4_FRAG) {
                        *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);
                        VIRTCHNL_DEL_PROTO_HDR_FIELD(proto_hdr,
                                                     VIRTCHNL_PROTO_HDR_IPV4_FRAG_PKID);
                }
                if (VIRTCHNL_TEST_PROTO_HDR_FIELD(proto_hdr,
                                                  VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG_PKID) &&
                    proto_hdr->type == VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG) {
                        *addl_hdrs |= ICE_FLOW_SEG_HDR_IPV_FRAG;
                        *addl_hdrs &= ~(ICE_FLOW_SEG_HDR_IPV_OTHER);
                        *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_ID);
                        VIRTCHNL_DEL_PROTO_HDR_FIELD(proto_hdr,
                                                     VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG_PKID);
                }
        }

        /* refine gtpu header if we take outer as input set for a no inner
         * ip gtpu flow.
         */
        if (hash_cfg->hdr_type == ICE_RSS_OUTER_HEADERS &&
            *addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_IP) {
                *addl_hdrs &= ~(ICE_FLOW_SEG_HDR_GTPU_IP);
                *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_NON_IP;
        }

        /* refine hash field for esp and nat-t-esp. */
        if ((*addl_hdrs & ICE_FLOW_SEG_HDR_UDP) &&
            (*addl_hdrs & ICE_FLOW_SEG_HDR_ESP)) {
                *addl_hdrs &= ~(ICE_FLOW_SEG_HDR_ESP | ICE_FLOW_SEG_HDR_UDP);
                *addl_hdrs |= ICE_FLOW_SEG_HDR_NAT_T_ESP;
                *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ESP_SPI));
                *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_NAT_T_ESP_SPI);
        }

        /* refine hash hdrs for L4 udp/tcp/sctp. */
        if (*addl_hdrs & (ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_UDP |
                          ICE_FLOW_SEG_HDR_SCTP) &&
            *addl_hdrs & ICE_FLOW_SEG_HDR_IPV_OTHER)
                *addl_hdrs &= ~ICE_FLOW_SEG_HDR_IPV_OTHER;

        return true;
}

/**
 * ice_vf_adv_rss_offload_ena - determine if capabilities support advanced
 * RSS offloads
 * @caps: VF driver negotiated capabilities
 *
 * Return true if VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF capability is set,
 * else return false
 */
static bool ice_vf_adv_rss_offload_ena(u32 caps)
{
        return !!(caps & VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF);
}

/**
 * ice_is_hash_cfg_valid - Check whether an RSS hash context is valid
 * @cfg: RSS hash configuration to test
 *
 * Return: true if both @cfg->hash_flds and @cfg->addl_hdrs are non-zero; false otherwise.
 */
static bool ice_is_hash_cfg_valid(struct ice_rss_hash_cfg *cfg)
{
        return cfg->hash_flds && cfg->addl_hdrs;
}

/**
 * ice_hash_cfg_reset - Reset an RSS hash context
 * @cfg: RSS hash configuration to reset
 *
 * Reset fields of @cfg that store the active rule information.
 */
static void ice_hash_cfg_reset(struct ice_rss_hash_cfg *cfg)
{
        cfg->hash_flds = 0;
        cfg->addl_hdrs = 0;
        cfg->hdr_type = ICE_RSS_OUTER_HEADERS;
        cfg->symm = 0;
}

/**
 * ice_hash_cfg_record - Record an RSS hash context
 * @ctx: destination (global) RSS hash configuration
 * @cfg: source RSS hash configuration to record
 *
 * Copy the active rule information from @cfg into @ctx.
 */
static void ice_hash_cfg_record(struct ice_rss_hash_cfg *ctx,
                                struct ice_rss_hash_cfg *cfg)
{
        ctx->hash_flds = cfg->hash_flds;
        ctx->addl_hdrs = cfg->addl_hdrs;
        ctx->hdr_type = cfg->hdr_type;
        ctx->symm = cfg->symm;
}

/**
 * ice_hash_moveout - Delete an RSS configuration (keep context)
 * @vf: VF pointer
 * @cfg: RSS hash configuration
 *
 * Return: 0 on success (including when already absent); -ENOENT if @cfg is
 * invalid or VSI is missing; -EBUSY on hardware removal failure.
 */
static int
ice_hash_moveout(struct ice_vf *vf, struct ice_rss_hash_cfg *cfg)
{
        struct device *dev = ice_pf_to_dev(vf->pf);
        struct ice_vsi *vsi = ice_get_vf_vsi(vf);
        struct ice_hw *hw = &vf->pf->hw;
        int ret;

        if (!ice_is_hash_cfg_valid(cfg) || !vsi)
                return -ENOENT;

        ret = ice_rem_rss_cfg(hw, vsi->idx, cfg);
        if (ret && ret != -ENOENT) {
                dev_err(dev, "ice_rem_rss_cfg failed for VF %d, VSI %d, error:%d\n",
                        vf->vf_id, vf->lan_vsi_idx, ret);
                return -EBUSY;
        }

        return 0;
}

/**
 * ice_hash_moveback - Add an RSS hash configuration for a VF
 * @vf: VF pointer
 * @cfg: RSS hash configuration to apply
 *
 * Add @cfg to @vf if the context is valid and VSI exists; programs HW.
 *
 * Return:
 * * 0 on success
 * * -ENOENT if @cfg is invalid or VSI is missing
 * * -EBUSY if hardware programming fails
 */
static int
ice_hash_moveback(struct ice_vf *vf, struct ice_rss_hash_cfg *cfg)
{
        struct device *dev = ice_pf_to_dev(vf->pf);
        struct ice_vsi *vsi = ice_get_vf_vsi(vf);
        struct ice_hw *hw = &vf->pf->hw;
        int ret;

        if (!ice_is_hash_cfg_valid(cfg) || !vsi)
                return -ENOENT;

        ret = ice_add_rss_cfg(hw, vsi, cfg);
        if (ret) {
                dev_err(dev, "ice_add_rss_cfg failed for VF %d, VSI %d, error:%d\n",
                        vf->vf_id, vf->lan_vsi_idx, ret);
                return -EBUSY;
        }

        return 0;
}

/**
 * ice_hash_remove - remove a RSS configuration
 * @vf: pointer to the VF info
 * @cfg: pointer to the RSS hash configuration
 *
 * This function will delete a RSS hash configuration and also delete the
 * hash context which stores the rule info.
 *
 * Return: 0 on success, or a negative error code on failure.
 */
static int
ice_hash_remove(struct ice_vf *vf, struct ice_rss_hash_cfg *cfg)
{
        int ret;

        ret = ice_hash_moveout(vf, cfg);
        if (ret && ret != -ENOENT)
                return ret;

        ice_hash_cfg_reset(cfg);

        return 0;
}

struct ice_gtpu_ctx_action {
        u32 ctx_idx;
        const u32 *remove_list;
        int remove_count;
        const u32 *moveout_list;
        int moveout_count;
};

/**
 * ice_add_rss_cfg_pre_gtpu - Pre-process the GTPU RSS configuration
 * @vf: pointer to the VF info
 * @ctx: pointer to the context of the GTPU hash
 * @ctx_idx: index of the hash context
 *
 * Pre-processes the GTPU hash configuration before adding a new
 * hash context. It removes or reorders existing hash configurations that may
 * conflict with the new one. For example, if a GTPU_UP or GTPU_DWN rule is
 * configured after a GTPU_EH rule, the GTPU_EH hash will be matched first due
 * to TCAM write and match order (top-down). In such cases, the GTPU_EH rule
 * must be moved after the GTPU_UP/DWN rule. Conversely, if a GTPU_EH rule is
 * configured after a GTPU_UP/DWN rule, the UP/DWN rules should be removed to
 * avoid conflict.
 *
 * Return: 0 on success or a negative error code on failure
 */
static int ice_add_rss_cfg_pre_gtpu(struct ice_vf *vf,
                                    struct ice_vf_hash_gtpu_ctx *ctx,
                                    u32 ctx_idx)
{
        int ret, i;

        static const u32 remove_eh_ip[] = {
                ICE_HASH_GTPU_CTX_EH_IP_UDP, ICE_HASH_GTPU_CTX_EH_IP_TCP,
                ICE_HASH_GTPU_CTX_UP_IP,     ICE_HASH_GTPU_CTX_UP_IP_UDP,
                ICE_HASH_GTPU_CTX_UP_IP_TCP, ICE_HASH_GTPU_CTX_DW_IP,
                ICE_HASH_GTPU_CTX_DW_IP_UDP, ICE_HASH_GTPU_CTX_DW_IP_TCP,
        };

        static const u32 remove_eh_ip_udp[] = {
                ICE_HASH_GTPU_CTX_UP_IP_UDP,
                ICE_HASH_GTPU_CTX_DW_IP_UDP,
        };
        static const u32 moveout_eh_ip_udp[] = {
                ICE_HASH_GTPU_CTX_UP_IP,
                ICE_HASH_GTPU_CTX_UP_IP_TCP,
                ICE_HASH_GTPU_CTX_DW_IP,
                ICE_HASH_GTPU_CTX_DW_IP_TCP,
        };

        static const u32 remove_eh_ip_tcp[] = {
                ICE_HASH_GTPU_CTX_UP_IP_TCP,
                ICE_HASH_GTPU_CTX_DW_IP_TCP,
        };
        static const u32 moveout_eh_ip_tcp[] = {
                ICE_HASH_GTPU_CTX_UP_IP,
                ICE_HASH_GTPU_CTX_UP_IP_UDP,
                ICE_HASH_GTPU_CTX_DW_IP,
                ICE_HASH_GTPU_CTX_DW_IP_UDP,
        };

        static const u32 remove_up_ip[] = {
                ICE_HASH_GTPU_CTX_UP_IP_UDP,
                ICE_HASH_GTPU_CTX_UP_IP_TCP,
        };
        static const u32 moveout_up_ip[] = {
                ICE_HASH_GTPU_CTX_EH_IP,
                ICE_HASH_GTPU_CTX_EH_IP_UDP,
                ICE_HASH_GTPU_CTX_EH_IP_TCP,
        };

        static const u32 moveout_up_ip_udp_tcp[] = {
                ICE_HASH_GTPU_CTX_EH_IP,
                ICE_HASH_GTPU_CTX_EH_IP_UDP,
                ICE_HASH_GTPU_CTX_EH_IP_TCP,
        };

        static const u32 remove_dw_ip[] = {
                ICE_HASH_GTPU_CTX_DW_IP_UDP,
                ICE_HASH_GTPU_CTX_DW_IP_TCP,
        };
        static const u32 moveout_dw_ip[] = {
                ICE_HASH_GTPU_CTX_EH_IP,
                ICE_HASH_GTPU_CTX_EH_IP_UDP,
                ICE_HASH_GTPU_CTX_EH_IP_TCP,
        };

        static const struct ice_gtpu_ctx_action actions[] = {
                { ICE_HASH_GTPU_CTX_EH_IP, remove_eh_ip,
                  ARRAY_SIZE(remove_eh_ip), NULL, 0 },
                { ICE_HASH_GTPU_CTX_EH_IP_UDP, remove_eh_ip_udp,
                  ARRAY_SIZE(remove_eh_ip_udp), moveout_eh_ip_udp,
                  ARRAY_SIZE(moveout_eh_ip_udp) },
                { ICE_HASH_GTPU_CTX_EH_IP_TCP, remove_eh_ip_tcp,
                  ARRAY_SIZE(remove_eh_ip_tcp), moveout_eh_ip_tcp,
                  ARRAY_SIZE(moveout_eh_ip_tcp) },
                { ICE_HASH_GTPU_CTX_UP_IP, remove_up_ip,
                  ARRAY_SIZE(remove_up_ip), moveout_up_ip,
                  ARRAY_SIZE(moveout_up_ip) },
                { ICE_HASH_GTPU_CTX_UP_IP_UDP, NULL, 0, moveout_up_ip_udp_tcp,
                  ARRAY_SIZE(moveout_up_ip_udp_tcp) },
                { ICE_HASH_GTPU_CTX_UP_IP_TCP, NULL, 0, moveout_up_ip_udp_tcp,
                  ARRAY_SIZE(moveout_up_ip_udp_tcp) },
                { ICE_HASH_GTPU_CTX_DW_IP, remove_dw_ip,
                  ARRAY_SIZE(remove_dw_ip), moveout_dw_ip,
                  ARRAY_SIZE(moveout_dw_ip) },
                { ICE_HASH_GTPU_CTX_DW_IP_UDP, NULL, 0, moveout_dw_ip,
                  ARRAY_SIZE(moveout_dw_ip) },
                { ICE_HASH_GTPU_CTX_DW_IP_TCP, NULL, 0, moveout_dw_ip,
                  ARRAY_SIZE(moveout_dw_ip) },
        };

        for (i = 0; i < ARRAY_SIZE(actions); i++) {
                if (actions[i].ctx_idx != ctx_idx)
                        continue;

                if (actions[i].remove_list) {
                        for (int j = 0; j < actions[i].remove_count; j++) {
                                u16 rm = actions[i].remove_list[j];

                                ret = ice_hash_remove(vf, &ctx->ctx[rm]);
                                if (ret && ret != -ENOENT)
                                        return ret;
                        }
                }

                if (actions[i].moveout_list) {
                        for (int j = 0; j < actions[i].moveout_count; j++) {
                                u16 mv = actions[i].moveout_list[j];

                                ret = ice_hash_moveout(vf, &ctx->ctx[mv]);
                                if (ret && ret != -ENOENT)
                                        return ret;
                        }
                }
                break;
        }

        return 0;
}

/**
 * ice_add_rss_cfg_pre_ip - Pre-process IP-layer RSS configuration
 * @vf: VF pointer
 * @ctx: IP L4 hash context (ESP/UDP-ESP/AH/PFCP and UDP/TCP/SCTP)
 *
 * Remove covered/recorded IP RSS configurations prior to adding a new one.
 *
 * Return: 0 on success; negative error code on failure.
 */
static int
ice_add_rss_cfg_pre_ip(struct ice_vf *vf, struct ice_vf_hash_ip_ctx *ctx)
{
        int i, ret;

        for (i = 1; i < ICE_HASH_IP_CTX_MAX; i++)
                if (ice_is_hash_cfg_valid(&ctx->ctx[i])) {
                        ret = ice_hash_remove(vf, &ctx->ctx[i]);
                        if (ret)
                                return ret;
                }

        return 0;
}

/**
 * ice_calc_gtpu_ctx_idx - Calculate GTPU hash context index
 * @hdrs: Bitmask of protocol headers prefixed with ICE_FLOW_SEG_HDR_*
 *
 * Determine the GTPU hash context index based on the combination of
 * encapsulation headers (GTPU_EH, GTPU_UP, GTPU_DWN) and transport
 * protocols (UDP, TCP) within IPv4 or IPv6 flows.
 *
 * Return: A valid context index (0-8) if the header combination is supported,
 *         or ICE_HASH_GTPU_CTX_MAX if the combination is invalid.
 */
static enum ice_hash_gtpu_ctx_type ice_calc_gtpu_ctx_idx(u32 hdrs)
{
        u32 eh_idx, ip_idx;

        if (hdrs & ICE_FLOW_SEG_HDR_GTPU_EH)
                eh_idx = 0;
        else if (hdrs & ICE_FLOW_SEG_HDR_GTPU_UP)
                eh_idx = 1;
        else if (hdrs & ICE_FLOW_SEG_HDR_GTPU_DWN)
                eh_idx = 2;
        else
                return ICE_HASH_GTPU_CTX_MAX;

        ip_idx = 0;
        if (hdrs & ICE_FLOW_SEG_HDR_UDP)
                ip_idx = 1;
        else if (hdrs & ICE_FLOW_SEG_HDR_TCP)
                ip_idx = 2;

        if (hdrs & (ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV6))
                return eh_idx * 3 + ip_idx;
        else
                return ICE_HASH_GTPU_CTX_MAX;
}

/**
 * ice_map_ip_ctx_idx - map the index of the IP L4 hash context
 * @hdrs: protocol headers prefix with ICE_FLOW_SEG_HDR_XXX.
 *
 * The IP L4 hash context use the index to classify for IPv4/IPv6 with
 * ESP/UDP_ESP/AH/PFCP and non-tunnel UDP/TCP/SCTP
 * this function map the index based on the protocol headers.
 *
 * Return: The mapped IP context index on success, or ICE_HASH_IP_CTX_MAX
 *         if no matching context is found.
 */
static u8 ice_map_ip_ctx_idx(u32 hdrs)
{
        u8 i;

        static struct {
                u32 hdrs;
                u8 ctx_idx;
        } ip_ctx_idx_map[] = {
                { ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
                        ICE_FLOW_SEG_HDR_ESP,
                        ICE_HASH_IP_CTX_IP_ESP },
                { ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
                        ICE_FLOW_SEG_HDR_NAT_T_ESP,
                        ICE_HASH_IP_CTX_IP_UDP_ESP },
                { ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
                        ICE_FLOW_SEG_HDR_AH,
                        ICE_HASH_IP_CTX_IP_AH },
                { ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
                        ICE_FLOW_SEG_HDR_PFCP_SESSION,
                        ICE_HASH_IP_CTX_IP_PFCP },
                { ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN |
                        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_UDP,
                        ICE_HASH_IP_CTX_IP_UDP },
                { ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN |
                        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_TCP,
                        ICE_HASH_IP_CTX_IP_TCP },
                { ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN |
                        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_SCTP,
                        ICE_HASH_IP_CTX_IP_SCTP },
                { ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN |
                        ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
                        ICE_HASH_IP_CTX_IP },
                { ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
                        ICE_FLOW_SEG_HDR_ESP,
                        ICE_HASH_IP_CTX_IP_ESP },
                { ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
                        ICE_FLOW_SEG_HDR_NAT_T_ESP,
                        ICE_HASH_IP_CTX_IP_UDP_ESP },
                { ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
                        ICE_FLOW_SEG_HDR_AH,
                        ICE_HASH_IP_CTX_IP_AH },
                { ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
                        ICE_FLOW_SEG_HDR_PFCP_SESSION,
                        ICE_HASH_IP_CTX_IP_PFCP },
                { ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN |
                        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_UDP,
                        ICE_HASH_IP_CTX_IP_UDP },
                { ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN |
                        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_TCP,
                        ICE_HASH_IP_CTX_IP_TCP },
                { ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN |
                        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_SCTP,
                        ICE_HASH_IP_CTX_IP_SCTP },
                { ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN |
                        ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
                        ICE_HASH_IP_CTX_IP },
                /* the remaining mappings are used for default RSS */
                { ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_UDP,
                        ICE_HASH_IP_CTX_IP_UDP },
                { ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_TCP,
                        ICE_HASH_IP_CTX_IP_TCP },
                { ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_SCTP,
                        ICE_HASH_IP_CTX_IP_SCTP },
                { ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
                        ICE_HASH_IP_CTX_IP },
                { ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_UDP,
                        ICE_HASH_IP_CTX_IP_UDP },
                { ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_TCP,
                        ICE_HASH_IP_CTX_IP_TCP },
                { ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_SCTP,
                        ICE_HASH_IP_CTX_IP_SCTP },
                { ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
                        ICE_HASH_IP_CTX_IP },
        };

        for (i = 0; i < ARRAY_SIZE(ip_ctx_idx_map); i++) {
                if (hdrs == ip_ctx_idx_map[i].hdrs)
                        return ip_ctx_idx_map[i].ctx_idx;
        }

        return ICE_HASH_IP_CTX_MAX;
}

/**
 * ice_add_rss_cfg_pre - Prepare RSS configuration context for a VF
 * @vf: pointer to the VF structure
 * @cfg: pointer to the RSS hash configuration
 *
 * Prepare the RSS hash context for a given VF based on the additional
 * protocol headers specified in @cfg. This includes pre-configuration
 * for IP and GTPU-based flows.
 *
 * If the configuration matches a known IP context, the function sets up
 * the appropriate IP hash context. If the configuration includes GTPU
 * headers, it prepares the GTPU-specific context accordingly.
 *
 * Return: 0 on success, or a negative error code on failure.
 */
static int
ice_add_rss_cfg_pre(struct ice_vf *vf, struct ice_rss_hash_cfg *cfg)
{
        u32 ice_gtpu_ctx_idx = ice_calc_gtpu_ctx_idx(cfg->addl_hdrs);
        u8 ip_ctx_idx = ice_map_ip_ctx_idx(cfg->addl_hdrs);

        if (ip_ctx_idx == ICE_HASH_IP_CTX_IP) {
                int ret = 0;

                if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV4)
                        ret = ice_add_rss_cfg_pre_ip(vf, &vf->hash_ctx.v4);
                else if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV6)
                        ret = ice_add_rss_cfg_pre_ip(vf, &vf->hash_ctx.v6);

                if (ret)
                        return ret;
        }

        if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV4) {
                return ice_add_rss_cfg_pre_gtpu(vf, &vf->hash_ctx.ipv4,
                                                ice_gtpu_ctx_idx);
        } else if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV6) {
                return ice_add_rss_cfg_pre_gtpu(vf, &vf->hash_ctx.ipv6,
                                                ice_gtpu_ctx_idx);
        }

        return 0;
}

/**
 * ice_add_rss_cfg_post_gtpu - Post-process GTPU RSS configuration
 * @vf: pointer to the VF info
 * @ctx: pointer to the context of the GTPU hash
 * @cfg: pointer to the RSS hash configuration
 * @ctx_idx: index of the hash context
 *
 * Post-processes the GTPU hash configuration after a new hash
 * context has been successfully added. It updates the context with the new
 * configuration and restores any previously removed hash contexts that need
 * to be re-applied. This ensures proper TCAM rule ordering and avoids
 * conflicts between overlapping GTPU rules.
 *
 * Return: 0 on success or a negative error code on failure
 */
static int ice_add_rss_cfg_post_gtpu(struct ice_vf *vf,
                                     struct ice_vf_hash_gtpu_ctx *ctx,
                                     struct ice_rss_hash_cfg *cfg, u32 ctx_idx)
{
        /* GTPU hash moveback lookup table indexed by context ID.
         * Each entry is a bitmap indicating which contexts need moveback
         * operations when the corresponding context index is processed.
         */
        static const unsigned long
                ice_gtpu_moveback_tbl[ICE_HASH_GTPU_CTX_MAX] = {
                        [ICE_HASH_GTPU_CTX_EH_IP] = 0,
                        [ICE_HASH_GTPU_CTX_EH_IP_UDP] =
                                BIT(ICE_HASH_GTPU_CTX_UP_IP) |
                                BIT(ICE_HASH_GTPU_CTX_UP_IP_TCP) |
                                BIT(ICE_HASH_GTPU_CTX_DW_IP) |
                                BIT(ICE_HASH_GTPU_CTX_DW_IP_TCP),
                        [ICE_HASH_GTPU_CTX_EH_IP_TCP] =
                                BIT(ICE_HASH_GTPU_CTX_UP_IP) |
                                BIT(ICE_HASH_GTPU_CTX_UP_IP_UDP) |
                                BIT(ICE_HASH_GTPU_CTX_DW_IP) |
                                BIT(ICE_HASH_GTPU_CTX_DW_IP_UDP),
                        [ICE_HASH_GTPU_CTX_UP_IP] =
                                BIT(ICE_HASH_GTPU_CTX_EH_IP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_UDP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_TCP),
                        [ICE_HASH_GTPU_CTX_UP_IP_UDP] =
                                BIT(ICE_HASH_GTPU_CTX_EH_IP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_UDP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_TCP),
                        [ICE_HASH_GTPU_CTX_UP_IP_TCP] =
                                BIT(ICE_HASH_GTPU_CTX_EH_IP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_UDP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_TCP),
                        [ICE_HASH_GTPU_CTX_DW_IP] =
                                BIT(ICE_HASH_GTPU_CTX_EH_IP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_UDP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_TCP),
                        [ICE_HASH_GTPU_CTX_DW_IP_UDP] =
                                BIT(ICE_HASH_GTPU_CTX_EH_IP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_UDP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_TCP),
                        [ICE_HASH_GTPU_CTX_DW_IP_TCP] =
                                BIT(ICE_HASH_GTPU_CTX_EH_IP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_UDP) |
                                BIT(ICE_HASH_GTPU_CTX_EH_IP_TCP),
                };
        unsigned long moveback_mask;
        int ret;
        int i;

        if (unlikely(ctx_idx >= ICE_HASH_GTPU_CTX_MAX))
                return 0;

        ctx->ctx[ctx_idx].addl_hdrs = cfg->addl_hdrs;
        ctx->ctx[ctx_idx].hash_flds = cfg->hash_flds;
        ctx->ctx[ctx_idx].hdr_type = cfg->hdr_type;
        ctx->ctx[ctx_idx].symm = cfg->symm;

        moveback_mask = ice_gtpu_moveback_tbl[ctx_idx];
        for_each_set_bit(i, &moveback_mask, ICE_HASH_GTPU_CTX_MAX) {
                ret = ice_hash_moveback(vf, &ctx->ctx[i]);
                if (ret && ret != -ENOENT)
                        return ret;
        }

        return 0;
}

static int
ice_add_rss_cfg_post(struct ice_vf *vf, struct ice_rss_hash_cfg *cfg)
{
        u32 ice_gtpu_ctx_idx = ice_calc_gtpu_ctx_idx(cfg->addl_hdrs);
        u8 ip_ctx_idx = ice_map_ip_ctx_idx(cfg->addl_hdrs);

        if (ip_ctx_idx && ip_ctx_idx < ICE_HASH_IP_CTX_MAX) {
                if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV4)
                        ice_hash_cfg_record(&vf->hash_ctx.v4.ctx[ip_ctx_idx], cfg);
                else if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV6)
                        ice_hash_cfg_record(&vf->hash_ctx.v6.ctx[ip_ctx_idx], cfg);
        }

        if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV4) {
                return ice_add_rss_cfg_post_gtpu(vf, &vf->hash_ctx.ipv4,
                                                 cfg, ice_gtpu_ctx_idx);
        } else if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV6) {
                return ice_add_rss_cfg_post_gtpu(vf, &vf->hash_ctx.ipv6,
                                                 cfg, ice_gtpu_ctx_idx);
        }

        return 0;
}

/**
 * ice_rem_rss_cfg_post - post-process the RSS configuration
 * @vf: pointer to the VF info
 * @cfg: pointer to the RSS hash configuration
 *
 * Post process the RSS hash configuration after deleting a hash
 * config. Such as, it will reset the hash context for the GTPU hash.
 */
static void
ice_rem_rss_cfg_post(struct ice_vf *vf, struct ice_rss_hash_cfg *cfg)
{
        u32 ice_gtpu_ctx_idx = ice_calc_gtpu_ctx_idx(cfg->addl_hdrs);
        u8 ip_ctx_idx = ice_map_ip_ctx_idx(cfg->addl_hdrs);

        if (ip_ctx_idx && ip_ctx_idx < ICE_HASH_IP_CTX_MAX) {
                if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV4)
                        ice_hash_cfg_reset(&vf->hash_ctx.v4.ctx[ip_ctx_idx]);
                else if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV6)
                        ice_hash_cfg_reset(&vf->hash_ctx.v6.ctx[ip_ctx_idx]);
        }

        if (ice_gtpu_ctx_idx >= ICE_HASH_GTPU_CTX_MAX)
                return;

        if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV4)
                ice_hash_cfg_reset(&vf->hash_ctx.ipv4.ctx[ice_gtpu_ctx_idx]);
        else if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV6)
                ice_hash_cfg_reset(&vf->hash_ctx.ipv6.ctx[ice_gtpu_ctx_idx]);
}

/**
 * ice_rem_rss_cfg_wrap - Wrapper for deleting an RSS configuration
 * @vf: pointer to the VF info
 * @cfg: pointer to the RSS hash configuration
 *
 * Wrapper function to delete a flow profile base on an RSS configuration,
 * and also post process the hash context base on the rollback mechanism
 * which handle some rules conflict by ice_add_rss_cfg_wrap.
 *
 * Return: 0 on success; negative error code on failure.
 */
static int
ice_rem_rss_cfg_wrap(struct ice_vf *vf, struct ice_rss_hash_cfg *cfg)
{
        struct device *dev = ice_pf_to_dev(vf->pf);
        struct ice_vsi *vsi = ice_get_vf_vsi(vf);
        struct ice_hw *hw = &vf->pf->hw;
        int ret;

        ret = ice_rem_rss_cfg(hw, vsi->idx, cfg);
        /* We just ignore -ENOENT, because if two configurations share the same
         * profile remove one of them actually removes both, since the
         * profile is deleted.
         */
        if (ret && ret != -ENOENT) {
                dev_err(dev, "ice_rem_rss_cfg failed for VF %d, VSI %d, error:%d\n",
                        vf->vf_id, vf->lan_vsi_idx, ret);
                return ret;
        }

        ice_rem_rss_cfg_post(vf, cfg);

        return 0;
}

/**
 * ice_add_rss_cfg_wrap - Wrapper for adding an RSS configuration
 * @vf: pointer to the VF info
 * @cfg: pointer to the RSS hash configuration
 *
 * Add a flow profile based on an RSS configuration. Use a rollback
 * mechanism to handle rule conflicts due to TCAM
 * write sequence from top to down.
 *
 * Return: 0 on success; negative error code on failure.
 */
static int
ice_add_rss_cfg_wrap(struct ice_vf *vf, struct ice_rss_hash_cfg *cfg)
{
        struct device *dev = ice_pf_to_dev(vf->pf);
        struct ice_vsi *vsi = ice_get_vf_vsi(vf);
        struct ice_hw *hw = &vf->pf->hw;
        int ret;

        if (ice_add_rss_cfg_pre(vf, cfg))
                return -EINVAL;

        ret = ice_add_rss_cfg(hw, vsi, cfg);
        if (ret) {
                dev_err(dev, "ice_add_rss_cfg failed for VF %d, VSI %d, error:%d\n",
                        vf->vf_id, vf->lan_vsi_idx, ret);
                return ret;
        }

        if (ice_add_rss_cfg_post(vf, cfg))
                ret = -EINVAL;

        return ret;
}

/**
 * ice_parse_raw_rss_pattern - Parse raw pattern spec and mask for RSS
 * @vf: pointer to the VF info
 * @proto: pointer to the virtchnl protocol header
 * @raw_cfg: pointer to the RSS raw pattern configuration
 *
 * Parser function to get spec and mask from virtchnl message, and parse
 * them to get the corresponding profile and offset. The profile is used
 * to add RSS configuration.
 *
 * Return: 0 on success; negative error code on failure.
 */
static int
ice_parse_raw_rss_pattern(struct ice_vf *vf, struct virtchnl_proto_hdrs *proto,
                          struct ice_rss_raw_cfg *raw_cfg)
{
        struct ice_parser_result pkt_parsed;
        struct ice_hw *hw = &vf->pf->hw;
        struct ice_parser_profile prof;
        struct ice_parser *psr;
        u8 *pkt_buf, *msk_buf;
        u16 pkt_len;
        int ret = 0;

        pkt_len = proto->raw.pkt_len;
        if (!pkt_len)
                return -EINVAL;
        if (pkt_len > VIRTCHNL_MAX_SIZE_RAW_PACKET)
                pkt_len = VIRTCHNL_MAX_SIZE_RAW_PACKET;

        pkt_buf = kzalloc(pkt_len, GFP_KERNEL);
        msk_buf = kzalloc(pkt_len, GFP_KERNEL);
        if (!pkt_buf || !msk_buf) {
                ret = -ENOMEM;
                goto free_alloc;
        }

        memcpy(pkt_buf, proto->raw.spec, pkt_len);
        memcpy(msk_buf, proto->raw.mask, pkt_len);

        psr = ice_parser_create(hw);
        if (IS_ERR(psr)) {
                ret = PTR_ERR(psr);
                goto free_alloc;
        }

        ret = ice_parser_run(psr, pkt_buf, pkt_len, &pkt_parsed);
        if (ret)
                goto parser_destroy;

        ret = ice_parser_profile_init(&pkt_parsed, pkt_buf, msk_buf,
                                      pkt_len, ICE_BLK_RSS, &prof);
        if (ret)
                goto parser_destroy;

        memcpy(&raw_cfg->prof, &prof, sizeof(prof));

parser_destroy:
        ice_parser_destroy(psr);
free_alloc:
        kfree(pkt_buf);
        kfree(msk_buf);
        return ret;
}

/**
 * ice_add_raw_rss_cfg - add RSS configuration for raw pattern
 * @vf: pointer to the VF info
 * @cfg: pointer to the RSS raw pattern configuration
 *
 * This function adds the RSS configuration for raw pattern.
 * Check if current profile is matched. If not, remove the old
 * one and add the new profile to HW directly. Update the symmetric
 * hash configuration as well.
 *
 * Return: 0 on success; negative error code on failure.
 */
static int
ice_add_raw_rss_cfg(struct ice_vf *vf, struct ice_rss_raw_cfg *cfg)
{
        struct ice_parser_profile *prof = &cfg->prof;
        struct device *dev = ice_pf_to_dev(vf->pf);
        struct ice_rss_prof_info *rss_prof;
        struct ice_hw *hw = &vf->pf->hw;
        int i, ptg, ret = 0;
        u16 vsi_handle;
        u64 id;

        vsi_handle = vf->lan_vsi_idx;
        id = find_first_bit(prof->ptypes, ICE_FLOW_PTYPE_MAX);

        ptg = hw->blk[ICE_BLK_RSS].xlt1.t[id];
        rss_prof = &vf->rss_prof_info[ptg];

        /* check if ptg already has a 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 ret;
                }

                /* 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) {
                        dev_err(dev, "remove RSS flow failed\n");
                        return ret;
                }

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

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

        memcpy(&rss_prof->prof, prof, sizeof(struct ice_parser_profile));

update_symm:
        rss_prof->symm = cfg->symm;
        ice_rss_update_raw_symm(hw, cfg, id);
        return ret;
}

/**
 * ice_rem_raw_rss_cfg - remove RSS configuration for raw pattern
 * @vf: pointer to the VF info
 * @cfg: pointer to the RSS raw pattern configuration
 *
 * This function removes the RSS configuration for raw pattern.
 * Check if vsi group is already removed first. If not, remove the
 * profile.
 *
 * Return: 0 on success; negative error code on failure.
 */
static int
ice_rem_raw_rss_cfg(struct ice_vf *vf, struct ice_rss_raw_cfg *cfg)
{
        struct ice_parser_profile *prof = &cfg->prof;
        struct device *dev = ice_pf_to_dev(vf->pf);
        struct ice_hw *hw = &vf->pf->hw;
        int ptg, ret = 0;
        u16 vsig, vsi;
        u64 id;

        id = find_first_bit(prof->ptypes, ICE_FLOW_PTYPE_MAX);

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

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

        /* check if vsig is already removed */
        vsi = ice_get_hw_vsi_num(hw, vf->lan_vsi_idx);
        if (vsi >= ICE_MAX_VSI) {
                ret = -EINVAL;
                goto err;
        }

        vsig = hw->blk[ICE_BLK_RSS].xlt2.vsis[vsi].vsig;
        if (vsig) {
                ret = ice_rem_prof_id_flow(hw, ICE_BLK_RSS, vsi, id);
                if (ret)
                        goto err;

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

        return ret;

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

/**
 * ice_vc_handle_rss_cfg
 * @vf: pointer to the VF info
 * @msg: pointer to the message buffer
 * @add: add a RSS config if true, otherwise delete a RSS config
 *
 * This function adds/deletes a RSS config
 */
int ice_vc_handle_rss_cfg(struct ice_vf *vf, u8 *msg, bool add)
{
        u32 v_opcode = add ? VIRTCHNL_OP_ADD_RSS_CFG : VIRTCHNL_OP_DEL_RSS_CFG;
        struct virtchnl_rss_cfg *rss_cfg = (struct virtchnl_rss_cfg *)msg;
        enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS;
        struct device *dev = ice_pf_to_dev(vf->pf);
        struct ice_hw *hw = &vf->pf->hw;
        struct ice_vsi *vsi;
        u8 hash_type;
        bool symm;
        int ret;

        if (!test_bit(ICE_FLAG_RSS_ENA, vf->pf->flags)) {
                dev_dbg(dev, "VF %d attempting to configure RSS, but RSS is not supported by the PF\n",
                        vf->vf_id);
                v_ret = VIRTCHNL_STATUS_ERR_NOT_SUPPORTED;
                goto error_param;
        }

        if (!ice_vf_adv_rss_offload_ena(vf->driver_caps)) {
                dev_dbg(dev, "VF %d attempting to configure RSS, but Advanced RSS offload is not supported\n",
                        vf->vf_id);
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (rss_cfg->proto_hdrs.count > VIRTCHNL_MAX_NUM_PROTO_HDRS ||
            rss_cfg->rss_algorithm < VIRTCHNL_RSS_ALG_TOEPLITZ_ASYMMETRIC ||
            rss_cfg->rss_algorithm > VIRTCHNL_RSS_ALG_XOR_SYMMETRIC) {
                dev_dbg(dev, "VF %d attempting to configure RSS, but RSS configuration is not valid\n",
                        vf->vf_id);
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        vsi = ice_get_vf_vsi(vf);
        if (!vsi) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (rss_cfg->rss_algorithm == VIRTCHNL_RSS_ALG_R_ASYMMETRIC) {
                hash_type = add ? ICE_AQ_VSI_Q_OPT_RSS_HASH_XOR :
                                  ICE_AQ_VSI_Q_OPT_RSS_HASH_TPLZ;

                ret = ice_vc_rss_hash_update(hw, vsi, hash_type);
                if (ret)
                        v_ret = ice_err_to_virt_err(ret);
                goto error_param;
        }

        hash_type = add ? ICE_AQ_VSI_Q_OPT_RSS_HASH_SYM_TPLZ :
                          ICE_AQ_VSI_Q_OPT_RSS_HASH_TPLZ;
        ret = ice_vc_rss_hash_update(hw, vsi, hash_type);
        if (ret) {
                v_ret = ice_err_to_virt_err(ret);
                goto error_param;
        }

        symm = rss_cfg->rss_algorithm == VIRTCHNL_RSS_ALG_TOEPLITZ_SYMMETRIC;
        /* Configure RSS hash for raw pattern */
        if (rss_cfg->proto_hdrs.tunnel_level == 0 &&
            rss_cfg->proto_hdrs.count == 0) {
                struct ice_rss_raw_cfg raw_cfg;

                if (ice_parse_raw_rss_pattern(vf, &rss_cfg->proto_hdrs,
                                              &raw_cfg)) {
                        v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                        goto error_param;
                }

                if (add) {
                        raw_cfg.symm = symm;
                        if (ice_add_raw_rss_cfg(vf, &raw_cfg))
                                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                } else {
                        if (ice_rem_raw_rss_cfg(vf, &raw_cfg))
                                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                }
        } else {
                struct ice_rss_hash_cfg cfg;

                /* Only check for none raw pattern case */
                if (!ice_vc_validate_pattern(vf, &rss_cfg->proto_hdrs)) {
                        v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                        goto error_param;
                }
                cfg.addl_hdrs = ICE_FLOW_SEG_HDR_NONE;
                cfg.hash_flds = ICE_HASH_INVALID;
                cfg.hdr_type = ICE_RSS_ANY_HEADERS;

                if (!ice_vc_parse_rss_cfg(hw, rss_cfg, &cfg)) {
                        v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                        goto error_param;
                }

                if (add) {
                        cfg.symm = symm;
                        if (ice_add_rss_cfg_wrap(vf, &cfg))
                                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                } else {
                        if (ice_rem_rss_cfg_wrap(vf, &cfg))
                                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                }
        }

error_param:
        return ice_vc_send_msg_to_vf(vf, v_opcode, v_ret, NULL, 0);
}

/**
 * ice_vc_config_rss_key
 * @vf: pointer to the VF info
 * @msg: pointer to the msg buffer
 *
 * Configure the VF's RSS key
 */
int ice_vc_config_rss_key(struct ice_vf *vf, u8 *msg)
{
        enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS;
        struct virtchnl_rss_key *vrk =
                (struct virtchnl_rss_key *)msg;
        struct ice_vsi *vsi;

        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (!ice_vc_isvalid_vsi_id(vf, vrk->vsi_id)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (vrk->key_len != ICE_VSIQF_HKEY_ARRAY_SIZE) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (!test_bit(ICE_FLAG_RSS_ENA, vf->pf->flags)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        vsi = ice_get_vf_vsi(vf);
        if (!vsi) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (ice_set_rss_key(vsi, vrk->key))
                v_ret = VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR;
error_param:
        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_KEY, v_ret,
                                     NULL, 0);
}

/**
 * ice_vc_config_rss_lut
 * @vf: pointer to the VF info
 * @msg: pointer to the msg buffer
 *
 * Configure the VF's RSS LUT
 */
int ice_vc_config_rss_lut(struct ice_vf *vf, u8 *msg)
{
        struct virtchnl_rss_lut *vrl = (struct virtchnl_rss_lut *)msg;
        enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS;
        struct ice_vsi *vsi;

        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (!ice_vc_isvalid_vsi_id(vf, vrl->vsi_id)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (vrl->lut_entries != ICE_LUT_VSI_SIZE) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (!test_bit(ICE_FLAG_RSS_ENA, vf->pf->flags)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        vsi = ice_get_vf_vsi(vf);
        if (!vsi) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (ice_set_rss_lut(vsi, vrl->lut, ICE_LUT_VSI_SIZE))
                v_ret = VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR;
error_param:
        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_LUT, v_ret,
                                     NULL, 0);
}

/**
 * ice_vc_config_rss_hfunc
 * @vf: pointer to the VF info
 * @msg: pointer to the msg buffer
 *
 * Configure the VF's RSS Hash function
 */
int ice_vc_config_rss_hfunc(struct ice_vf *vf, u8 *msg)
{
        struct virtchnl_rss_hfunc *vrh = (struct virtchnl_rss_hfunc *)msg;
        enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS;
        u8 hfunc = ICE_AQ_VSI_Q_OPT_RSS_HASH_TPLZ;
        struct ice_vsi *vsi;

        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (!ice_vc_isvalid_vsi_id(vf, vrh->vsi_id)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (!test_bit(ICE_FLAG_RSS_ENA, vf->pf->flags)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        vsi = ice_get_vf_vsi(vf);
        if (!vsi) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto error_param;
        }

        if (vrh->rss_algorithm == VIRTCHNL_RSS_ALG_TOEPLITZ_SYMMETRIC)
                hfunc = ICE_AQ_VSI_Q_OPT_RSS_HASH_SYM_TPLZ;

        if (ice_set_rss_hfunc(vsi, hfunc))
                v_ret = VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR;
error_param:
        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_HFUNC, v_ret,
                                     NULL, 0);
}

/**
 * ice_vc_get_rss_hashcfg - return the RSS Hash configuration
 * @vf: pointer to the VF info
 */
int ice_vc_get_rss_hashcfg(struct ice_vf *vf)
{
        enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS;
        struct virtchnl_rss_hashcfg *vrh = NULL;
        int len = 0, ret;

        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto err;
        }

        if (!test_bit(ICE_FLAG_RSS_ENA, vf->pf->flags)) {
                dev_err(ice_pf_to_dev(vf->pf), "RSS not supported by PF\n");
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto err;
        }

        len = sizeof(struct virtchnl_rss_hashcfg);
        vrh = kzalloc(len, GFP_KERNEL);
        if (!vrh) {
                v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
                len = 0;
                goto err;
        }

        vrh->hashcfg = ICE_DEFAULT_RSS_HASHCFG;
err:
        /* send the response back to the VF */
        ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_RSS_HASHCFG_CAPS, v_ret,
                                    (u8 *)vrh, len);
        kfree(vrh);
        return ret;
}

/**
 * ice_vc_set_rss_hashcfg - set RSS Hash configuration bits for the VF
 * @vf: pointer to the VF info
 * @msg: pointer to the msg buffer
 */
int ice_vc_set_rss_hashcfg(struct ice_vf *vf, u8 *msg)
{
        struct virtchnl_rss_hashcfg *vrh = (struct virtchnl_rss_hashcfg *)msg;
        enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS;
        struct ice_pf *pf = vf->pf;
        struct ice_vsi *vsi;
        struct device *dev;
        int status;

        dev = ice_pf_to_dev(pf);

        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto err;
        }

        if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
                dev_err(dev, "RSS not supported by PF\n");
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto err;
        }

        vsi = ice_get_vf_vsi(vf);
        if (!vsi) {
                v_ret = VIRTCHNL_STATUS_ERR_PARAM;
                goto err;
        }

        /* clear all previously programmed RSS configuration to allow VF drivers
         * the ability to customize the RSS configuration and/or completely
         * disable RSS
         */
        status = ice_rem_vsi_rss_cfg(&pf->hw, vsi->idx);
        if (status && !vrh->hashcfg) {
                /* only report failure to clear the current RSS configuration if
                 * that was clearly the VF's intention (i.e. vrh->hashcfg = 0)
                 */
                v_ret = ice_err_to_virt_err(status);
                goto err;
        } else if (status) {
                /* allow the VF to update the RSS configuration even on failure
                 * to clear the current RSS confguration in an attempt to keep
                 * RSS in a working state
                 */
                dev_warn(dev, "Failed to clear the RSS configuration for VF %u\n",
                         vf->vf_id);
        }

        if (vrh->hashcfg) {
                status = ice_add_avf_rss_cfg(&pf->hw, vsi, vrh->hashcfg);
                v_ret = ice_err_to_virt_err(status);
        }

        /* save the requested VF configuration */
        if (!v_ret)
                vf->rss_hashcfg = vrh->hashcfg;

        /* send the response to the VF */
err:
        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_SET_RSS_HASHCFG, v_ret,
                                     NULL, 0);
}