720 lines
21 KiB
C
720 lines
21 KiB
C
// 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},
|
|
};
|
|
|
|
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_PROT),
|
|
BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)},
|
|
{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_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_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_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_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)},
|
|
};
|
|
|
|
/**
|
|
* 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;
|
|
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];
|
|
bool hdr_found = false;
|
|
int j;
|
|
|
|
/* Find matched ice headers according to virtchnl 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) {
|
|
*addl_hdrs |= hdr_map.ice_hdr;
|
|
hdr_found = true;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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_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;
|
|
|
|
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 (!ice_vc_validate_pattern(vf, &rss_cfg->proto_hdrs)) {
|
|
v_ret = VIRTCHNL_STATUS_ERR_PARAM;
|
|
goto error_param;
|
|
}
|
|
|
|
if (rss_cfg->rss_algorithm == VIRTCHNL_RSS_ALG_R_ASYMMETRIC) {
|
|
struct ice_vsi_ctx *ctx;
|
|
u8 lut_type, hash_type;
|
|
int status;
|
|
|
|
lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_VSI;
|
|
hash_type = add ? ICE_AQ_VSI_Q_OPT_RSS_HASH_XOR :
|
|
ICE_AQ_VSI_Q_OPT_RSS_HASH_TPLZ;
|
|
|
|
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
|
|
if (!ctx) {
|
|
v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
|
|
goto error_param;
|
|
}
|
|
|
|
ctx->info.q_opt_rss =
|
|
FIELD_PREP(ICE_AQ_VSI_Q_OPT_RSS_LUT_M, lut_type) |
|
|
FIELD_PREP(ICE_AQ_VSI_Q_OPT_RSS_HASH_M, hash_type);
|
|
|
|
/* Preserve existing queueing option setting */
|
|
ctx->info.q_opt_rss |= (vsi->info.q_opt_rss &
|
|
ICE_AQ_VSI_Q_OPT_RSS_GBL_LUT_M);
|
|
ctx->info.q_opt_tc = vsi->info.q_opt_tc;
|
|
ctx->info.q_opt_flags = vsi->info.q_opt_rss;
|
|
|
|
ctx->info.valid_sections =
|
|
cpu_to_le16(ICE_AQ_VSI_PROP_Q_OPT_VALID);
|
|
|
|
status = ice_update_vsi(hw, vsi->idx, ctx, NULL);
|
|
if (status) {
|
|
dev_err(dev, "update VSI for RSS failed, err %d aq_err %s\n",
|
|
status, libie_aq_str(hw->adminq.sq_last_status));
|
|
v_ret = VIRTCHNL_STATUS_ERR_PARAM;
|
|
} else {
|
|
vsi->info.q_opt_rss = ctx->info.q_opt_rss;
|
|
}
|
|
|
|
kfree(ctx);
|
|
} 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) {
|
|
if (ice_add_rss_cfg(hw, vsi, &cfg)) {
|
|
v_ret = VIRTCHNL_STATUS_ERR_PARAM;
|
|
dev_err(dev, "ice_add_rss_cfg failed for vsi = %d, v_ret = %d\n",
|
|
vsi->vsi_num, v_ret);
|
|
}
|
|
} else {
|
|
int status;
|
|
|
|
status = 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 (status && status != -ENOENT) {
|
|
v_ret = VIRTCHNL_STATUS_ERR_PARAM;
|
|
dev_err(dev, "ice_rem_rss_cfg failed for VF ID:%d, error:%d\n",
|
|
vf->vf_id, status);
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|