| // 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); | |
| } | |