Commit ada434cd authored by Michael S. Tsirkin's avatar Michael S. Tsirkin
Browse files

virtio-pci: implement cfg capability 



spec says we must, so let's do it!

Note: the implementation is incorrect for BE targets.
Will fix with a patch on top, not a big deal now as
the only user is seabios, used on x86 only.

Tested-by: default avatarGerd Hoffmann <kraxel@redhat.com>
Signed-off-by: default avatarMichael S. Tsirkin <mst@redhat.com>
parent c36f24a2

hw/virtio/virtio-pci.c

+75 −1
Original line number Diff line number Diff line
@@ -448,6 +448,7 @@ static void virtio_write_config(PCIDevice *pci_dev, uint32_t address, 
{

    VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);

    VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);

    struct virtio_pci_cfg_cap *cfg;



    pci_default_write_config(pci_dev, address, val, len);
@@ -456,6 +457,51 @@ static void virtio_write_config(PCIDevice *pci_dev, uint32_t address, 
        virtio_pci_stop_ioeventfd(proxy);

        virtio_set_status(vdev, vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK);

    }



    if (proxy->config_cap &&

        ranges_overlap(address, len, proxy->config_cap + offsetof(struct virtio_pci_cfg_cap,

                                                                  pci_cfg_data),

                       sizeof cfg->pci_cfg_data)) {

        uint32_t off;

        uint32_t len;



        cfg = (void *)(proxy->pci_dev.config + proxy->config_cap);

        off = le32_to_cpu(cfg->cap.offset);

        len = le32_to_cpu(cfg->cap.length);



        if ((len == 1 || len == 2 || len == 4)) {

            address_space_write(&proxy->modern_as, off,

                                MEMTXATTRS_UNSPECIFIED,

                                cfg->pci_cfg_data, len);

        }

    }

}



static uint32_t virtio_read_config(PCIDevice *pci_dev,

                                   uint32_t address, int len)

{

    VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);

    struct virtio_pci_cfg_cap *cfg;



    if (proxy->config_cap &&

        ranges_overlap(address, len, proxy->config_cap + offsetof(struct virtio_pci_cfg_cap,

                                                                  pci_cfg_data),

                       sizeof cfg->pci_cfg_data)) {

        uint32_t off;

        uint32_t len;



        cfg = (void *)(proxy->pci_dev.config + proxy->config_cap);

        off = le32_to_cpu(cfg->cap.offset);

        len = le32_to_cpu(cfg->cap.length);



        if ((len == 1 || len == 2 || len == 4)) {

            address_space_read(&proxy->modern_as, off,

                                MEMTXATTRS_UNSPECIFIED,

                                cfg->pci_cfg_data, len);

        }

    }



    return pci_default_read_config(pci_dev, address, len);

}



static int kvm_virtio_pci_vq_vector_use(VirtIOPCIProxy *proxy,
@@ -942,7 +988,7 @@ static int virtio_pci_query_nvectors(DeviceState *d) 
    return proxy->nvectors;

}



static void virtio_pci_add_mem_cap(VirtIOPCIProxy *proxy,

static int virtio_pci_add_mem_cap(VirtIOPCIProxy *proxy,

                                   struct virtio_pci_cap *cap)

{

    PCIDevice *dev = &proxy->pci_dev;
@@ -954,6 +1000,8 @@ static void virtio_pci_add_mem_cap(VirtIOPCIProxy *proxy, 
    assert(cap->cap_len >= sizeof *cap);

    memcpy(dev->config + offset + PCI_CAP_FLAGS, &cap->cap_len,

           cap->cap_len - PCI_CAP_FLAGS);



    return offset;

}



static uint64_t virtio_pci_common_read(void *opaque, hwaddr addr,
@@ -1329,6 +1377,11 @@ static void virtio_pci_device_plugged(DeviceState *d, Error **errp) 
            .notify_off_multiplier =

                cpu_to_le32(QEMU_VIRTIO_PCI_QUEUE_MEM_MULT),

        };

        struct virtio_pci_cfg_cap cfg = {

            .cap.cap_len = sizeof cfg,

            .cap.cfg_type = VIRTIO_PCI_CAP_PCI_CFG,

        };

        struct virtio_pci_cfg_cap *cfg_mask;



        /* TODO: add io access for speed */
@@ -1338,11 +1391,19 @@ static void virtio_pci_device_plugged(DeviceState *d, Error **errp) 
        virtio_pci_modern_region_map(proxy, &proxy->isr, &cap);

        virtio_pci_modern_region_map(proxy, &proxy->device, &cap);

        virtio_pci_modern_region_map(proxy, &proxy->notify, &notify.cap);



        pci_register_bar(&proxy->pci_dev, proxy->modern_mem_bar,

                         PCI_BASE_ADDRESS_SPACE_MEMORY |

                         PCI_BASE_ADDRESS_MEM_PREFETCH |

                         PCI_BASE_ADDRESS_MEM_TYPE_64,

                         &proxy->modern_bar);



        proxy->config_cap = virtio_pci_add_mem_cap(proxy, &cfg.cap);

        cfg_mask = (void *)(proxy->pci_dev.wmask + proxy->config_cap);

        pci_set_byte(&cfg_mask->cap.bar, ~0x0);

        pci_set_long((uint8_t *)&cfg_mask->cap.offset, ~0x0);

        pci_set_long((uint8_t *)&cfg_mask->cap.length, ~0x0);

        pci_set_long(cfg_mask->pci_cfg_data, ~0x0);

    }



    if (proxy->nvectors &&
@@ -1354,6 +1415,7 @@ static void virtio_pci_device_plugged(DeviceState *d, Error **errp) 
    }



    proxy->pci_dev.config_write = virtio_write_config;

    proxy->pci_dev.config_read = virtio_read_config;



    if (legacy) {

        size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev)
@@ -1424,6 +1486,15 @@ static void virtio_pci_realize(PCIDevice *pci_dev, Error **errp) 
                       2 * QEMU_VIRTIO_PCI_QUEUE_MEM_MULT *

                       VIRTIO_QUEUE_MAX);



    memory_region_init_alias(&proxy->modern_cfg,

                             OBJECT(proxy),

                             "virtio-pci-cfg",

                             &proxy->modern_bar,

                             0,

                             memory_region_size(&proxy->modern_bar));



    address_space_init(&proxy->modern_as, &proxy->modern_cfg, "virtio-pci-cfg-as");



    virtio_pci_bus_new(&proxy->bus, sizeof(proxy->bus), proxy);

    if (k->realize) {

        k->realize(proxy, errp);
@@ -1432,7 +1503,10 @@ static void virtio_pci_realize(PCIDevice *pci_dev, Error **errp) 


static void virtio_pci_exit(PCIDevice *pci_dev)

{

    VirtIOPCIProxy *proxy = VIRTIO_PCI(pci_dev);



    msix_uninit_exclusive_bar(pci_dev);

    address_space_destroy(&proxy->modern_as);

}



static void virtio_pci_reset(DeviceState *qdev)

hw/virtio/virtio-pci.h

+3 −0
Original line number Diff line number Diff line
@@ -112,9 +112,12 @@ struct VirtIOPCIProxy { 
    VirtIOPCIRegion device;

    VirtIOPCIRegion notify;

    MemoryRegion modern_bar;

    MemoryRegion modern_cfg;

    AddressSpace modern_as;

    uint32_t legacy_io_bar;

    uint32_t msix_bar;

    uint32_t modern_mem_bar;

    int config_cap;

    uint32_t flags;

    uint32_t class_code;

    uint32_t nvectors;