DEV_TX_OFFLOAD_VLAN_INSERT)
#define HN_RX_OFFLOAD_CAPS (DEV_RX_OFFLOAD_CHECKSUM | \
- DEV_RX_OFFLOAD_VLAN_STRIP)
+ DEV_RX_OFFLOAD_VLAN_STRIP | \
+ DEV_RX_OFFLOAD_RSS_HASH)
int hn_logtype_init;
int hn_logtype_driver;
{ "good_bytes", offsetof(struct hn_stats, bytes) },
{ "errors", offsetof(struct hn_stats, errors) },
{ "ring full", offsetof(struct hn_stats, ring_full) },
+ { "channel full", offsetof(struct hn_stats, channel_full) },
{ "multicast_packets", offsetof(struct hn_stats, multicast) },
{ "broadcast_packets", offsetof(struct hn_stats, broadcast) },
{ "undersize_packets", offsetof(struct hn_stats, size_bins[0]) },
/* The default RSS key.
* This value is the same as MLX5 so that flows will be
- * received on same path for both VF ans synthetic NIC.
+ * received on same path for both VF and synthetic NIC.
*/
static const uint8_t rss_default_key[NDIS_HASH_KEYSIZE_TOEPLITZ] = {
0x2c, 0xc6, 0x81, 0xd1, 0x5b, 0xdb, 0xf4, 0xf7,
static void
eth_dev_vmbus_release(struct rte_eth_dev *eth_dev)
{
- /* mac_addrs must not be freed alone because part of dev_private */
- eth_dev->data->mac_addrs = NULL;
/* free ether device */
rte_eth_dev_release_port(eth_dev);
return rte_eth_linkstatus_set(dev, &link);
}
-static void hn_dev_info_get(struct rte_eth_dev *dev,
- struct rte_eth_dev_info *dev_info)
+static int hn_dev_info_get(struct rte_eth_dev *dev,
+ struct rte_eth_dev_info *dev_info)
{
struct hn_data *hv = dev->data->dev_private;
+ int rc;
dev_info->speed_capa = ETH_LINK_SPEED_10G;
dev_info->min_rx_bufsize = HN_MIN_RX_BUF_SIZE;
dev_info->max_rx_queues = hv->max_queues;
dev_info->max_tx_queues = hv->max_queues;
- hn_rndis_get_offload(hv, dev_info);
- hn_vf_info_get(hv, dev_info);
+ dev_info->tx_desc_lim.nb_min = 1;
+ dev_info->tx_desc_lim.nb_max = 4096;
+
+ if (rte_eal_process_type() != RTE_PROC_PRIMARY)
+ return 0;
+
+ /* fills in rx and tx offload capability */
+ rc = hn_rndis_get_offload(hv, dev_info);
+ if (rc != 0)
+ return rc;
+
+ /* merges the offload and queues of vf */
+ return hn_vf_info_get(hv, dev_info);
}
static int hn_rss_reta_update(struct rte_eth_dev *dev,
hv->rss_ind[i] = reta_conf[idx].reta[shift];
}
+ err = hn_rndis_conf_rss(hv, NDIS_RSS_FLAG_DISABLE);
+ if (err) {
+ PMD_DRV_LOG(NOTICE,
+ "rss disable failed");
+ return err;
+ }
+
err = hn_rndis_conf_rss(hv, 0);
if (err) {
PMD_DRV_LOG(NOTICE,
hn_rss_hash_init(hv, rss_conf);
- err = hn_rndis_conf_rss(hv, 0);
- if (err) {
- PMD_DRV_LOG(NOTICE,
- "rss reconfig failed (RSS disabled)");
- return err;
+ if (rss_conf->rss_hf != 0) {
+ err = hn_rndis_conf_rss(hv, 0);
+ if (err) {
+ PMD_DRV_LOG(NOTICE,
+ "rss reconfig failed (RSS disabled)");
+ return err;
+ }
}
-
return hn_vf_rss_hash_update(dev, rss_conf);
}
return 0;
}
-static void
+static int
hn_dev_promiscuous_enable(struct rte_eth_dev *dev)
{
struct hn_data *hv = dev->data->dev_private;
hn_rndis_set_rxfilter(hv, NDIS_PACKET_TYPE_PROMISCUOUS);
- hn_vf_promiscuous_enable(dev);
+ return hn_vf_promiscuous_enable(dev);
}
-static void
+static int
hn_dev_promiscuous_disable(struct rte_eth_dev *dev)
{
struct hn_data *hv = dev->data->dev_private;
if (dev->data->all_multicast)
filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
hn_rndis_set_rxfilter(hv, filter);
- hn_vf_promiscuous_disable(dev);
+ return hn_vf_promiscuous_disable(dev);
}
-static void
+static int
hn_dev_allmulticast_enable(struct rte_eth_dev *dev)
{
struct hn_data *hv = dev->data->dev_private;
hn_rndis_set_rxfilter(hv, NDIS_PACKET_TYPE_DIRECTED |
NDIS_PACKET_TYPE_ALL_MULTICAST |
NDIS_PACKET_TYPE_BROADCAST);
- hn_vf_allmulticast_enable(dev);
+ return hn_vf_allmulticast_enable(dev);
}
-static void
+static int
hn_dev_allmulticast_disable(struct rte_eth_dev *dev)
{
struct hn_data *hv = dev->data->dev_private;
hn_rndis_set_rxfilter(hv, NDIS_PACKET_TYPE_DIRECTED |
NDIS_PACKET_TYPE_BROADCAST);
- hn_vf_allmulticast_disable(dev);
+ return hn_vf_allmulticast_disable(dev);
}
static int
PMD_INIT_FUNC_TRACE();
+ if (dev_conf->rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG)
+ dev_conf->rxmode.offloads |= DEV_RX_OFFLOAD_RSS_HASH;
+
unsupported = txmode->offloads & ~HN_TX_OFFLOAD_CAPS;
if (unsupported) {
PMD_DRV_LOG(NOTICE,
dev->data->nb_tx_queues);
for (i = 0; i < NDIS_HASH_INDCNT; i++)
- hv->rss_ind[i] = i % hv->num_queues;
+ hv->rss_ind[i] = i % dev->data->nb_rx_queues;
hn_rss_hash_init(hv, rss_conf);
return err;
}
- err = hn_rndis_conf_rss(hv, 0);
+ err = hn_rndis_conf_rss(hv, NDIS_RSS_FLAG_DISABLE);
if (err) {
PMD_DRV_LOG(NOTICE,
- "initial RSS config failed");
+ "rss disable failed");
return err;
}
+
+ if (rss_conf->rss_hf != 0) {
+ err = hn_rndis_conf_rss(hv, 0);
+ if (err) {
+ PMD_DRV_LOG(NOTICE,
+ "initial RSS config failed");
+ return err;
+ }
+ }
}
return hn_vf_configure(dev, dev_conf);
return 0;
}
-static void
+static int
hn_dev_stats_reset(struct rte_eth_dev *dev)
{
unsigned int i;
memset(&rxq->stats, 0, sizeof(struct hn_stats));
}
+
+ return 0;
}
-static void
+static int
hn_dev_xstats_reset(struct rte_eth_dev *dev)
{
- hn_dev_stats_reset(dev);
- hn_vf_xstats_reset(dev);
+ int ret;
+
+ ret = hn_dev_stats_reset(dev);
+ if (ret != 0)
+ return 0;
+
+ return hn_vf_xstats_reset(dev);
}
static int
continue;
stats = (const char *)&txq->stats;
- for (t = 0; t < RTE_DIM(hn_stat_strings); t++)
- xstats[count++].value = *(const uint64_t *)
+ for (t = 0; t < RTE_DIM(hn_stat_strings); t++, count++) {
+ xstats[count].id = count;
+ xstats[count].value = *(const uint64_t *)
(stats + hn_stat_strings[t].offset);
+ }
}
for (i = 0; i < dev->data->nb_rx_queues; i++) {
continue;
stats = (const char *)&rxq->stats;
- for (t = 0; t < RTE_DIM(hn_stat_strings); t++)
- xstats[count++].value = *(const uint64_t *)
+ for (t = 0; t < RTE_DIM(hn_stat_strings); t++, count++) {
+ xstats[count].id = count;
+ xstats[count].value = *(const uint64_t *)
(stats + hn_stat_strings[t].offset);
+ }
}
- ret = hn_vf_xstats_get(dev, xstats + count, n - count);
+ ret = hn_vf_xstats_get(dev, xstats, count, n);
if (ret < 0)
return ret;
if (error)
hn_rndis_set_rxfilter(hv, 0);
+ /* Initialize Link state */
+ if (error == 0)
+ hn_dev_link_update(dev, 0);
+
return error;
}
.dev_stop = hn_dev_stop,
.dev_close = hn_dev_close,
.dev_infos_get = hn_dev_info_get,
+ .txq_info_get = hn_dev_tx_queue_info,
+ .rxq_info_get = hn_dev_rx_queue_info,
.dev_supported_ptypes_get = hn_vf_supported_ptypes,
.promiscuous_enable = hn_dev_promiscuous_enable,
.promiscuous_disable = hn_dev_promiscuous_disable,
.tx_queue_setup = hn_dev_tx_queue_setup,
.tx_queue_release = hn_dev_tx_queue_release,
.tx_done_cleanup = hn_dev_tx_done_cleanup,
+ .tx_descriptor_status = hn_dev_tx_descriptor_status,
.rx_queue_setup = hn_dev_rx_queue_setup,
.rx_queue_release = hn_dev_rx_queue_release,
+ .rx_queue_count = hn_dev_rx_queue_count,
+ .rx_descriptor_status = hn_dev_rx_queue_status,
.link_update = hn_dev_link_update,
.stats_get = hn_dev_stats_get,
.stats_reset = hn_dev_stats_reset,
if (rte_eal_process_type() != RTE_PROC_PRIMARY)
return 0;
- /* Since Hyper-V only supports one MAC address, just use local data */
- eth_dev->data->mac_addrs = &hv->mac_addr;
+ /* Since Hyper-V only supports one MAC address */
+ eth_dev->data->mac_addrs = rte_calloc("hv_mac", HN_MAX_MAC_ADDRS,
+ sizeof(struct rte_ether_addr), 0);
+ if (eth_dev->data->mac_addrs == NULL) {
+ PMD_INIT_LOG(ERR,
+ "Failed to allocate memory store MAC addresses");
+ return -ENOMEM;
+ }
hv->vmbus = vmbus;
hv->rxbuf_res = &vmbus->resource[HV_RECV_BUF_MAP];
hv->port_id = eth_dev->data->port_id;
hv->latency = HN_CHAN_LATENCY_NS;
hv->max_queues = 1;
- rte_spinlock_init(&hv->vf_lock);
+ rte_rwlock_init(&hv->vf_lock);
hv->vf_port = HN_INVALID_PORT;
err = hn_parse_args(eth_dev);
if (err)
goto failed;
- err = hn_tx_pool_init(eth_dev);
+ err = hn_chim_init(eth_dev);
if (err)
goto failed;
- err = hn_rndis_get_eaddr(hv, hv->mac_addr.addr_bytes);
+ err = hn_rndis_get_eaddr(hv, eth_dev->data->mac_addrs->addr_bytes);
if (err)
goto failed;
failed:
PMD_INIT_LOG(NOTICE, "device init failed");
- hn_tx_pool_uninit(eth_dev);
+ hn_chim_uninit(eth_dev);
hn_detach(hv);
return err;
}
eth_hn_dev_uninit(struct rte_eth_dev *eth_dev)
{
struct hn_data *hv = eth_dev->data->dev_private;
+ int ret;
PMD_INIT_FUNC_TRACE();
eth_dev->rx_pkt_burst = NULL;
hn_detach(hv);
- hn_tx_pool_uninit(eth_dev);
+ hn_chim_uninit(eth_dev);
rte_vmbus_chan_close(hv->primary->chan);
rte_free(hv->primary);
- rte_eth_dev_owner_delete(hv->owner.id);
+ ret = rte_eth_dev_owner_delete(hv->owner.id);
+ if (ret != 0)
+ return ret;
return 0;
}