DEV_RX_OFFLOAD_VLAN_STRIP | \
DEV_RX_OFFLOAD_RSS_HASH)
-int hn_logtype_init;
-int hn_logtype_driver;
+#define NETVSC_ARG_LATENCY "latency"
+#define NETVSC_ARG_RXBREAK "rx_copybreak"
+#define NETVSC_ARG_TXBREAK "tx_copybreak"
+#define NETVSC_ARG_RX_EXTMBUF_ENABLE "rx_extmbuf_enable"
struct hn_xstats_name_off {
char name[RTE_ETH_XSTATS_NAME_SIZE];
{ "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]) },
eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
eth_dev->intr_handle = &dev->intr_handle;
- /* allow ethdev to remove on close */
- eth_dev->data->dev_flags |= RTE_ETH_DEV_CLOSE_REMOVE;
-
return eth_dev;
}
eth_dev->intr_handle = NULL;
}
-/* handle "latency=X" from devargs */
-static int hn_set_latency(const char *key, const char *value, void *opaque)
+static int hn_set_parameter(const char *key, const char *value, void *opaque)
{
struct hn_data *hv = opaque;
char *endp = NULL;
- unsigned long lat;
-
- errno = 0;
- lat = strtoul(value, &endp, 0);
+ unsigned long v;
+ v = strtoul(value, &endp, 0);
if (*value == '\0' || *endp != '\0') {
PMD_DRV_LOG(ERR, "invalid parameter %s=%s", key, value);
return -EINVAL;
}
- PMD_DRV_LOG(DEBUG, "set latency %lu usec", lat);
+ if (!strcmp(key, NETVSC_ARG_LATENCY)) {
+ /* usec to nsec */
+ hv->latency = v * 1000;
+ PMD_DRV_LOG(DEBUG, "set latency %u usec", hv->latency);
+ } else if (!strcmp(key, NETVSC_ARG_RXBREAK)) {
+ hv->rx_copybreak = v;
+ PMD_DRV_LOG(DEBUG, "rx copy break set to %u",
+ hv->rx_copybreak);
+ } else if (!strcmp(key, NETVSC_ARG_TXBREAK)) {
+ hv->tx_copybreak = v;
+ PMD_DRV_LOG(DEBUG, "tx copy break set to %u",
+ hv->tx_copybreak);
+ } else if (!strcmp(key, NETVSC_ARG_RX_EXTMBUF_ENABLE)) {
+ hv->rx_extmbuf_enable = v;
+ PMD_DRV_LOG(DEBUG, "rx extmbuf enable set to %u",
+ hv->rx_extmbuf_enable);
+ }
- hv->latency = lat * 1000; /* usec to nsec */
return 0;
}
struct hn_data *hv = dev->data->dev_private;
struct rte_devargs *devargs = dev->device->devargs;
static const char * const valid_keys[] = {
- "latency",
+ NETVSC_ARG_LATENCY,
+ NETVSC_ARG_RXBREAK,
+ NETVSC_ARG_TXBREAK,
+ NETVSC_ARG_RX_EXTMBUF_ENABLE,
NULL
};
struct rte_kvargs *kvlist;
kvlist = rte_kvargs_parse(devargs->args, valid_keys);
if (!kvlist) {
- PMD_DRV_LOG(NOTICE, "invalid parameters");
+ PMD_DRV_LOG(ERR, "invalid parameters");
return -EINVAL;
}
- ret = rte_kvargs_process(kvlist, "latency", hn_set_latency, hv);
- if (ret)
- PMD_DRV_LOG(ERR, "Unable to process latency arg\n");
-
+ ret = rte_kvargs_process(kvlist, NULL, hn_set_parameter, hv);
rte_kvargs_free(kvlist);
+
return ret;
}
*/
int
hn_dev_link_update(struct rte_eth_dev *dev,
- int wait_to_complete)
+ int wait_to_complete __rte_unused)
{
struct hn_data *hv = dev->data->dev_private;
struct rte_eth_link link, old;
hn_rndis_get_linkspeed(hv);
- hn_vf_link_update(dev, wait_to_complete);
-
link = (struct rte_eth_link) {
.link_duplex = ETH_LINK_FULL_DUPLEX,
.link_autoneg = ETH_LINK_SPEED_FIXED,
return error;
}
-static void
+static int
hn_dev_stop(struct rte_eth_dev *dev)
{
struct hn_data *hv = dev->data->dev_private;
PMD_INIT_FUNC_TRACE();
+ dev->data->dev_started = 0;
hn_rndis_set_rxfilter(hv, 0);
- hn_vf_stop(dev);
+ return hn_vf_stop(dev);
}
-static void
+static int
hn_dev_close(struct rte_eth_dev *dev)
{
+ int ret;
+
PMD_INIT_FUNC_TRACE();
+ if (rte_eal_process_type() != RTE_PROC_PRIMARY)
+ return 0;
- hn_vf_close(dev);
+ ret = hn_vf_close(dev);
hn_dev_free_queues(dev);
+
+ return ret;
}
static const struct eth_dev_ops hn_eth_dev_ops = {
vmbus = container_of(device, struct rte_vmbus_device, device);
eth_dev->dev_ops = &hn_eth_dev_ops;
+ eth_dev->rx_queue_count = hn_dev_rx_queue_count;
+ eth_dev->rx_descriptor_status = hn_dev_rx_queue_status;
+ eth_dev->tx_descriptor_status = hn_dev_tx_descriptor_status;
eth_dev->tx_pkt_burst = &hn_xmit_pkts;
eth_dev->rx_pkt_burst = &hn_recv_pkts;
if (rte_eal_process_type() != RTE_PROC_PRIMARY)
return 0;
+ eth_dev->data->dev_flags |= RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS;
+
/* 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);
hv->chim_res = &vmbus->resource[HV_SEND_BUF_MAP];
hv->port_id = eth_dev->data->port_id;
hv->latency = HN_CHAN_LATENCY_NS;
+ hv->rx_copybreak = HN_RXCOPY_THRESHOLD;
+ hv->tx_copybreak = HN_TXCOPY_THRESHOLD;
+ hv->rx_extmbuf_enable = HN_RX_EXTMBUF_ENABLE;
hv->max_queues = 1;
+
rte_rwlock_init(&hv->vf_lock);
hv->vf_port = HN_INVALID_PORT;
eth_hn_dev_uninit(struct rte_eth_dev *eth_dev)
{
struct hn_data *hv = eth_dev->data->dev_private;
- int ret;
+ int ret, ret_stop;
PMD_INIT_FUNC_TRACE();
if (rte_eal_process_type() != RTE_PROC_PRIMARY)
return 0;
- hn_dev_stop(eth_dev);
+ ret_stop = hn_dev_stop(eth_dev);
hn_dev_close(eth_dev);
- eth_dev->dev_ops = NULL;
- eth_dev->tx_pkt_burst = NULL;
- eth_dev->rx_pkt_burst = NULL;
-
hn_detach(hv);
hn_chim_uninit(eth_dev);
rte_vmbus_chan_close(hv->primary->chan);
if (ret != 0)
return ret;
- return 0;
+ return ret_stop;
}
static int eth_hn_probe(struct rte_vmbus_driver *drv __rte_unused,
eth_dev = rte_eth_dev_allocated(dev->device.name);
if (!eth_dev)
- return -ENODEV;
+ return 0; /* port already released */
ret = eth_hn_dev_uninit(eth_dev);
if (ret)
RTE_PMD_REGISTER_VMBUS(net_netvsc, rte_netvsc_pmd);
RTE_PMD_REGISTER_KMOD_DEP(net_netvsc, "* uio_hv_generic");
-
-RTE_INIT(hn_init_log)
-{
- hn_logtype_init = rte_log_register("pmd.net.netvsc.init");
- if (hn_logtype_init >= 0)
- rte_log_set_level(hn_logtype_init, RTE_LOG_NOTICE);
- hn_logtype_driver = rte_log_register("pmd.net.netvsc.driver");
- if (hn_logtype_driver >= 0)
- rte_log_set_level(hn_logtype_driver, RTE_LOG_NOTICE);
-}
+RTE_LOG_REGISTER(hn_logtype_init, pmd.net.netvsc.init, NOTICE);
+RTE_LOG_REGISTER(hn_logtype_driver, pmd.net.netvsc.driver, NOTICE);
+RTE_PMD_REGISTER_PARAM_STRING(net_netvsc,
+ NETVSC_ARG_LATENCY "=<uint32> "
+ NETVSC_ARG_RXBREAK "=<uint32> "
+ NETVSC_ARG_TXBREAK "=<uint32> "
+ NETVSC_ARG_RX_EXTMBUF_ENABLE "=<0|1>");
git.droids-corp.org / dpdk.git / blobdiff