virtio: fill Rx avail ring with blank mbufs

[dpdk.git] / drivers / net / virtio / virtio_ethdev.c

diff --git a/drivers/net/virtio/virtio_ethdev.c b/drivers/net/virtio/virtio_ethdev.c
index 465d3cd..0d93331 100644 (file)
--- a/drivers/net/virtio/virtio_ethdev.c
+++ b/drivers/net/virtio/virtio_ethdev.c
@@ -61,6 +61,7 @@
 #include "virtio_pci.h"
 #include "virtio_logs.h"
 #include "virtqueue.h"
+#include "virtio_rxtx.h"
 
 
 static int eth_virtio_dev_init(struct rte_eth_dev *eth_dev);
@@ -239,15 +240,16 @@ virtio_set_multiple_queues(struct rte_eth_dev *dev, uint16_t nb_queues)
 
 void
 virtio_dev_queue_release(struct virtqueue *vq) {
-       struct virtio_hw *hw = vq->hw;
+       struct virtio_hw *hw;
 
        if (vq) {
+               hw = vq->hw;
                /* Select and deactivate the queue */
                VIRTIO_WRITE_REG_2(hw, VIRTIO_PCI_QUEUE_SEL, vq->queue_id);
                VIRTIO_WRITE_REG_4(hw, VIRTIO_PCI_QUEUE_PFN, 0);
 
+               rte_free(vq->sw_ring);
                rte_free(vq);
-               vq = NULL;
        }
 }
 
@@ -261,21 +263,20 @@ int virtio_dev_queue_setup(struct rte_eth_dev *dev,
 {
        char vq_name[VIRTQUEUE_MAX_NAME_SZ];
        const struct rte_memzone *mz;
-       uint16_t vq_size;
-       int size;
+       unsigned int vq_size, size;
        struct virtio_hw *hw = dev->data->dev_private;
        struct virtqueue *vq = NULL;
 
        /* Write the virtqueue index to the Queue Select Field */
        VIRTIO_WRITE_REG_2(hw, VIRTIO_PCI_QUEUE_SEL, vtpci_queue_idx);
-       PMD_INIT_LOG(DEBUG, "selecting queue: %d", vtpci_queue_idx);
+       PMD_INIT_LOG(DEBUG, "selecting queue: %u", vtpci_queue_idx);
 
        /*
         * Read the virtqueue size from the Queue Size field
         * Always power of 2 and if 0 virtqueue does not exist
         */
        vq_size = VIRTIO_READ_REG_2(hw, VIRTIO_PCI_QUEUE_NUM);
-       PMD_INIT_LOG(DEBUG, "vq_size: %d nb_desc:%d", vq_size, nb_desc);
+       PMD_INIT_LOG(DEBUG, "vq_size: %u nb_desc:%u", vq_size, nb_desc);
        if (vq_size == 0) {
                PMD_INIT_LOG(ERR, "%s: virtqueue does not exist", __func__);
                return -EINVAL;
@@ -291,6 +292,9 @@ int virtio_dev_queue_setup(struct rte_eth_dev *dev,
                        dev->data->port_id, queue_idx);
                vq = rte_zmalloc(vq_name, sizeof(struct virtqueue) +
                        vq_size * sizeof(struct vq_desc_extra), RTE_CACHE_LINE_SIZE);
+               vq->sw_ring = rte_zmalloc_socket("rxq->sw_ring",
+                       (RTE_PMD_VIRTIO_RX_MAX_BURST + vq_size) *
+                       sizeof(vq->sw_ring[0]), RTE_CACHE_LINE_SIZE, socket_id);
        } else if (queue_type == VTNET_TQ) {
                snprintf(vq_name, sizeof(vq_name), "port%d_tvq%d",
                        dev->data->port_id, queue_idx);
@@ -307,6 +311,12 @@ int virtio_dev_queue_setup(struct rte_eth_dev *dev,
                PMD_INIT_LOG(ERR, "%s: Can not allocate virtqueue", __func__);
                return (-ENOMEM);
        }
+       if (queue_type == VTNET_RQ && vq->sw_ring == NULL) {
+               PMD_INIT_LOG(ERR, "%s: Can not allocate RX soft ring",
+                       __func__);
+               rte_free(vq);
+               return -ENOMEM;
+       }
 
        vq->hw = hw;
        vq->port_id = dev->data->port_id;
@@ -1162,7 +1172,6 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
        struct virtio_hw *hw = eth_dev->data->dev_private;
        struct virtio_net_config *config;
        struct virtio_net_config local_config;
-       uint32_t offset_conf = sizeof(config->mac);
        struct rte_pci_device *pci_dev;
 
        RTE_BUILD_BUG_ON(RTE_PKTMBUF_HEADROOM < sizeof(struct virtio_net_hdr));
@@ -1201,6 +1210,10 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
        vtpci_set_status(hw, VIRTIO_CONFIG_STATUS_DRIVER);
        virtio_negotiate_features(hw);
 
+       /* If host does not support status then disable LSC */
+       if (!vtpci_with_feature(hw, VIRTIO_NET_F_STATUS))
+               pci_dev->driver->drv_flags &= ~RTE_PCI_DRV_INTR_LSC;
+
        rx_func_get(eth_dev);
 
        /* Setting up rx_header size for the device */
@@ -1221,8 +1234,14 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
        if (vtpci_with_feature(hw, VIRTIO_NET_F_CTRL_VQ)) {
                config = &local_config;
 
+               vtpci_read_dev_config(hw,
+                       offsetof(struct virtio_net_config, mac),
+                       &config->mac, sizeof(config->mac));
+
                if (vtpci_with_feature(hw, VIRTIO_NET_F_STATUS)) {
-                       offset_conf += sizeof(config->status);
+                       vtpci_read_dev_config(hw,
+                               offsetof(struct virtio_net_config, status),
+                               &config->status, sizeof(config->status));
                } else {
                        PMD_INIT_LOG(DEBUG,
                                     "VIRTIO_NET_F_STATUS is not supported");
@@ -1230,15 +1249,16 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
                }
 
                if (vtpci_with_feature(hw, VIRTIO_NET_F_MQ)) {
-                       offset_conf += sizeof(config->max_virtqueue_pairs);
+                       vtpci_read_dev_config(hw,
+                               offsetof(struct virtio_net_config, max_virtqueue_pairs),
+                               &config->max_virtqueue_pairs,
+                               sizeof(config->max_virtqueue_pairs));
                } else {
                        PMD_INIT_LOG(DEBUG,
                                     "VIRTIO_NET_F_MQ is not supported");
                        config->max_virtqueue_pairs = 1;
                }
 
-               vtpci_read_dev_config(hw, 0, (uint8_t *)config, offset_conf);
-
                hw->max_rx_queues =
                        (VIRTIO_MAX_RX_QUEUES < config->max_virtqueue_pairs) ?
                        VIRTIO_MAX_RX_QUEUES : config->max_virtqueue_pairs;
@@ -1394,9 +1414,8 @@ virtio_dev_start(struct rte_eth_dev *dev)
        struct rte_pci_device *pci_dev = dev->pci_dev;
 
        /* check if lsc interrupt feature is enabled */
-       if ((dev->data->dev_conf.intr_conf.lsc) &&
-               (pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)) {
-               if (!vtpci_with_feature(hw, VIRTIO_NET_F_STATUS)) {
+       if (dev->data->dev_conf.intr_conf.lsc) {
+               if (!(pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)) {
                        PMD_DRV_LOG(ERR, "link status not supported by host");
                        return -ENOTSUP;
                }