Add support for these device ops:
- rss_reta_update
- rss_reta_query
- rss_hash_update
- rss_hash_conf_get
Signed-off-by: Mingxia Liu <mingxia....@intel.com>
---
drivers/net/cpfl/cpfl_ethdev.c | 303 +++++++++++++++++++++++++++++++++
1 file changed, 303 insertions(+)
diff --git a/drivers/net/cpfl/cpfl_ethdev.c b/drivers/net/cpfl/cpfl_ethdev.c
index 026ac52997..578137dca0 100644
--- a/drivers/net/cpfl/cpfl_ethdev.c
+++ b/drivers/net/cpfl/cpfl_ethdev.c
@@ -30,6 +30,56 @@ static const char * const cpfl_valid_args[] = {
NULL
};
+static const uint64_t cpfl_map_hena_rss[] = {
+ [IDPF_HASH_NONF_UNICAST_IPV4_UDP] =
+ RTE_ETH_RSS_NONFRAG_IPV4_UDP,
+ [IDPF_HASH_NONF_MULTICAST_IPV4_UDP] =
+ RTE_ETH_RSS_NONFRAG_IPV4_UDP,
+ [IDPF_HASH_NONF_IPV4_UDP] =
+ RTE_ETH_RSS_NONFRAG_IPV4_UDP,
+ [IDPF_HASH_NONF_IPV4_TCP_SYN_NO_ACK] =
+ RTE_ETH_RSS_NONFRAG_IPV4_TCP,
+ [IDPF_HASH_NONF_IPV4_TCP] =
+ RTE_ETH_RSS_NONFRAG_IPV4_TCP,
+ [IDPF_HASH_NONF_IPV4_SCTP] =
+ RTE_ETH_RSS_NONFRAG_IPV4_SCTP,
+ [IDPF_HASH_NONF_IPV4_OTHER] =
+ RTE_ETH_RSS_NONFRAG_IPV4_OTHER,
+ [IDPF_HASH_FRAG_IPV4] = RTE_ETH_RSS_FRAG_IPV4,
+
+ /* IPv6 */
+ [IDPF_HASH_NONF_UNICAST_IPV6_UDP] =
+ RTE_ETH_RSS_NONFRAG_IPV6_UDP,
+ [IDPF_HASH_NONF_MULTICAST_IPV6_UDP] =
+ RTE_ETH_RSS_NONFRAG_IPV6_UDP,
+ [IDPF_HASH_NONF_IPV6_UDP] =
+ RTE_ETH_RSS_NONFRAG_IPV6_UDP,
+ [IDPF_HASH_NONF_IPV6_TCP_SYN_NO_ACK] =
+ RTE_ETH_RSS_NONFRAG_IPV6_TCP,
+ [IDPF_HASH_NONF_IPV6_TCP] =
+ RTE_ETH_RSS_NONFRAG_IPV6_TCP,
+ [IDPF_HASH_NONF_IPV6_SCTP] =
+ RTE_ETH_RSS_NONFRAG_IPV6_SCTP,
+ [IDPF_HASH_NONF_IPV6_OTHER] =
+ RTE_ETH_RSS_NONFRAG_IPV6_OTHER,
+ [IDPF_HASH_FRAG_IPV6] = RTE_ETH_RSS_FRAG_IPV6,
+
+ /* L2 Payload */
+ [IDPF_HASH_L2_PAYLOAD] = RTE_ETH_RSS_L2_PAYLOAD
+};
+
+static const uint64_t cpfl_ipv4_rss = RTE_ETH_RSS_NONFRAG_IPV4_UDP |
+ RTE_ETH_RSS_NONFRAG_IPV4_TCP |
+ RTE_ETH_RSS_NONFRAG_IPV4_SCTP |
+ RTE_ETH_RSS_NONFRAG_IPV4_OTHER |
+ RTE_ETH_RSS_FRAG_IPV4;
+
+static const uint64_t cpfl_ipv6_rss = RTE_ETH_RSS_NONFRAG_IPV6_UDP |
+ RTE_ETH_RSS_NONFRAG_IPV6_TCP |
+ RTE_ETH_RSS_NONFRAG_IPV6_SCTP |
+ RTE_ETH_RSS_NONFRAG_IPV6_OTHER |
+ RTE_ETH_RSS_FRAG_IPV6;
+
static int
cpfl_dev_link_update(struct rte_eth_dev *dev,
__rte_unused int wait_to_complete)
@@ -97,6 +147,9 @@ cpfl_dev_info_get(struct rte_eth_dev *dev, struct
rte_eth_dev_info *dev_info)
dev_info->max_mtu = dev_info->max_rx_pktlen - CPFL_ETH_OVERHEAD;
dev_info->min_mtu = RTE_ETHER_MIN_MTU;
+ dev_info->hash_key_size = vport->rss_key_size;
+ dev_info->reta_size = vport->rss_lut_size;
+
dev_info->flow_type_rss_offloads = CPFL_RSS_OFFLOAD_ALL;
dev_info->rx_offload_capa =
@@ -250,6 +303,54 @@ cpfl_dev_stats_reset(struct rte_eth_dev *dev)
return 0;
}
+static int cpfl_config_rss_hf(struct idpf_vport *vport, uint64_t rss_hf)
+{
+ uint64_t hena = 0, valid_rss_hf = 0;
+ int ret = 0;
+ uint16_t i;
+
+ /**
+ * RTE_ETH_RSS_IPV4 and RTE_ETH_RSS_IPV6 can be considered as 2
+ * generalizations of all other IPv4 and IPv6 RSS types.
+ */
+ if (rss_hf & RTE_ETH_RSS_IPV4)
+ rss_hf |= cpfl_ipv4_rss;
+
+ if (rss_hf & RTE_ETH_RSS_IPV6)
+ rss_hf |= cpfl_ipv6_rss;
+
+ for (i = 0; i < RTE_DIM(cpfl_map_hena_rss); i++) {
+ uint64_t bit = BIT_ULL(i);
+
+ if (cpfl_map_hena_rss[i] & rss_hf) {
+ valid_rss_hf |= cpfl_map_hena_rss[i];
+ hena |= bit;
+ }
+ }
+
+ vport->rss_hf = hena;
+
+ ret = idpf_vc_set_rss_hash(vport);
+ if (ret != 0) {
+ PMD_DRV_LOG(WARNING,
+ "fail to set RSS offload types, ret: %d", ret);
+ return ret;
+ }
+
+ if (valid_rss_hf & cpfl_ipv4_rss)
+ valid_rss_hf |= rss_hf & RTE_ETH_RSS_IPV4;
+
+ if (valid_rss_hf & cpfl_ipv6_rss)
+ valid_rss_hf |= rss_hf & RTE_ETH_RSS_IPV6;
+
+ if (rss_hf & ~valid_rss_hf)
+ PMD_DRV_LOG(WARNING, "Unsupported rss_hf 0x%" PRIx64,
+ rss_hf & ~valid_rss_hf);
+ vport->last_general_rss_hf = valid_rss_hf;
+
+ return ret;
+}
+
static int
cpfl_init_rss(struct idpf_vport *vport)
{
@@ -286,6 +387,204 @@ cpfl_init_rss(struct idpf_vport *vport)
return ret;
}
+static int
+cpfl_rss_reta_update(struct rte_eth_dev *dev,
+ struct rte_eth_rss_reta_entry64 *reta_conf,
+ uint16_t reta_size)
+{
+ struct idpf_vport *vport = dev->data->dev_private;
+ struct idpf_adapter *adapter = vport->adapter;
+ uint16_t idx, shift;
+ uint32_t *lut;
+ int ret = 0;
+ uint16_t i;
+
+ if (adapter->caps.rss_caps == 0 || dev->data->nb_rx_queues == 0) {
+ PMD_DRV_LOG(DEBUG, "RSS is not supported");
+ return -ENOTSUP;
+ }
+
+ if (reta_size != vport->rss_lut_size) {
+ PMD_DRV_LOG(ERR, "The size of hash lookup table configured "
+ "(%d) doesn't match the number of hardware can
"
+ "support (%d)",
+ reta_size, vport->rss_lut_size);
+ return -EINVAL;
+ }
+
+ /* It MUST use the current LUT size to get the RSS lookup table,
+ * otherwise if will fail with -100 error code.
+ */
+ lut = rte_zmalloc(NULL, reta_size * sizeof(uint32_t), 0);
+ if (!lut) {
+ PMD_DRV_LOG(ERR, "No memory can be allocated");
+ return -ENOMEM;
+ }
+ /* store the old lut table temporarily */
+ rte_memcpy(lut, vport->rss_lut, reta_size);
+
+ for (i = 0; i < reta_size; i++) {
+ idx = i / RTE_ETH_RETA_GROUP_SIZE;
+ shift = i % RTE_ETH_RETA_GROUP_SIZE;
+ if (reta_conf[idx].mask & (1ULL << shift))
+ lut[i] = reta_conf[idx].reta[shift];
+ }
+
+ rte_memcpy(vport->rss_lut, lut, reta_size);
+ /* send virtchnl ops to configure RSS */
+ ret = idpf_vc_set_rss_lut(vport);
+ if (ret) {
+ PMD_INIT_LOG(ERR, "Failed to configure RSS lut");
+ goto out;
+ }
+out:
+ rte_free(lut);
+
+ return ret;
+}
+
+static int
+cpfl_rss_reta_query(struct rte_eth_dev *dev,
+ struct rte_eth_rss_reta_entry64 *reta_conf,
+ uint16_t reta_size)
+{
+ struct idpf_vport *vport = dev->data->dev_private;
+ struct idpf_adapter *adapter = vport->adapter;
+ uint16_t idx, shift;
+ int ret = 0;
+ uint16_t i;
+
+ if (adapter->caps.rss_caps == 0 || dev->data->nb_rx_queues == 0) {
+ PMD_DRV_LOG(DEBUG, "RSS is not supported");
+ return -ENOTSUP;
+ }
+
+ if (reta_size != vport->rss_lut_size) {
+ PMD_DRV_LOG(ERR, "The size of hash lookup table configured "
+ "(%d) doesn't match the number of hardware can "
+ "support (%d)", reta_size, vport->rss_lut_size);
+ return -EINVAL;
+ }
+
+ ret = idpf_vc_get_rss_lut(vport);
+ if (ret) {
+ PMD_DRV_LOG(ERR, "Failed to get RSS LUT");
+ return ret;
+ }
+
+ for (i = 0; i < reta_size; i++) {
+ idx = i / RTE_ETH_RETA_GROUP_SIZE;
+ shift = i % RTE_ETH_RETA_GROUP_SIZE;
+ if (reta_conf[idx].mask & (1ULL << shift))
+ reta_conf[idx].reta[shift] = vport->rss_lut[i];
+ }
+
+ return 0;
+}
+
+static int
+cpfl_rss_hash_update(struct rte_eth_dev *dev,
+ struct rte_eth_rss_conf *rss_conf)
+{
+ struct idpf_vport *vport = dev->data->dev_private;
+ struct idpf_adapter *adapter = vport->adapter;
+ int ret = 0;
+
+ if (adapter->caps.rss_caps == 0 || dev->data->nb_rx_queues == 0) {
+ PMD_DRV_LOG(DEBUG, "RSS is not supported");
+ return -ENOTSUP;
+ }
+
+ if (!rss_conf->rss_key || rss_conf->rss_key_len == 0) {
+ PMD_DRV_LOG(DEBUG, "No key to be configured");
+ goto skip_rss_key;
+ } else if (rss_conf->rss_key_len != vport->rss_key_size) {
+ PMD_DRV_LOG(ERR, "The size of hash key configured "
+ "(%d) doesn't match the size of hardware can "
+ "support (%d)",
+ rss_conf->rss_key_len,
+ vport->rss_key_size);
+ return -EINVAL;
+ }
+
+ rte_memcpy(vport->rss_key, rss_conf->rss_key,
+ vport->rss_key_size);
+ ret = idpf_vc_set_rss_key(vport);
+ if (ret != 0) {
+ PMD_INIT_LOG(ERR, "Failed to configure RSS key");
+ return ret;
+ }
+
+skip_rss_key:
+ ret = cpfl_config_rss_hf(vport, rss_conf->rss_hf);
+ if (ret != 0) {
+ PMD_INIT_LOG(ERR, "Failed to configure RSS hash");
+ return ret;
+ }
+
+ return 0;
+}
+
+static uint64_t
+cpfl_map_general_rss_hf(uint64_t config_rss_hf, uint64_t last_general_rss_hf)
+{
+ uint64_t valid_rss_hf = 0;
+ uint16_t i;
+
+ for (i = 0; i < RTE_DIM(cpfl_map_hena_rss); i++) {
+ uint64_t bit = BIT_ULL(i);
+
+ if (bit & config_rss_hf)
+ valid_rss_hf |= cpfl_map_hena_rss[i];
+ }
+
+ if (valid_rss_hf & cpfl_ipv4_rss)
+ valid_rss_hf |= last_general_rss_hf & RTE_ETH_RSS_IPV4;
+
+ if (valid_rss_hf & cpfl_ipv6_rss)
+ valid_rss_hf |= last_general_rss_hf & RTE_ETH_RSS_IPV6;
+
+ return valid_rss_hf;
+}
+
+static int
+cpfl_rss_hash_conf_get(struct rte_eth_dev *dev,
+ struct rte_eth_rss_conf *rss_conf)
+{
+ struct idpf_vport *vport = dev->data->dev_private;
+ struct idpf_adapter *adapter = vport->adapter;
+ int ret = 0;
+
+ if (adapter->caps.rss_caps == 0 || dev->data->nb_rx_queues == 0) {
+ PMD_DRV_LOG(DEBUG, "RSS is not supported");
+ return -ENOTSUP;
+ }
+
+ ret = idpf_vc_get_rss_hash(vport);
+ if (ret) {
+ PMD_DRV_LOG(ERR, "Failed to get RSS hf");
+ return ret;
+ }
+
+ rss_conf->rss_hf = cpfl_map_general_rss_hf(vport->rss_hf,
vport->last_general_rss_hf);
+
+ if (!rss_conf->rss_key)
+ return 0;
+
+ ret = idpf_vc_get_rss_key(vport);
+ if (ret) {
+ PMD_DRV_LOG(ERR, "Failed to get RSS key");
+ return ret;
+ }
+
+ if (rss_conf->rss_key_len > vport->rss_key_size)
+ rss_conf->rss_key_len = vport->rss_key_size;
+
+ rte_memcpy(rss_conf->rss_key, vport->rss_key, rss_conf->rss_key_len);
+
+ return 0;
+}
+
static int
cpfl_dev_configure(struct rte_eth_dev *dev)
{
@@ -845,6 +1144,10 @@ static const struct eth_dev_ops cpfl_eth_dev_ops = {
.dev_supported_ptypes_get = cpfl_dev_supported_ptypes_get,
.stats_get = cpfl_dev_stats_get,
.stats_reset = cpfl_dev_stats_reset,
+ .reta_update = cpfl_rss_reta_update,
+ .reta_query = cpfl_rss_reta_query,
+ .rss_hash_update = cpfl_rss_hash_update,
+ .rss_hash_conf_get = cpfl_rss_hash_conf_get,
};
static uint16_t
--
2.25.1
