#include "errno.h"
#include "byteswap.h"
#include "etherboot.h"
#include "ipxe/io.h"
#include "ipxe/iomap.h"
#include "ipxe/pci.h"
#include "ipxe/dma.h"
#include "ipxe/reboot.h"
#include "ipxe/virtio-pci.h"
#include "ipxe/virtio-ring.h"

Macros
#define	CFG_POS(vdev, field)

Functions
static int	vp_alloc_vq (struct vring_virtqueue *vq, u16 num, size_t header_size)
void	vp_free_vq (struct vring_virtqueue *vq)
int	vp_find_vq (unsigned int ioaddr, int queue_index, struct vring_virtqueue vq, struct dma_device dma_dev, size_t header_size)
static void	prep_pci_cfg_cap (struct virtio_pci_modern_device vdev, struct virtio_pci_region region, size_t offset, u32 length)
void	vpm_iowrite8 (struct virtio_pci_modern_device vdev, struct virtio_pci_region region, u8 data, size_t offset)
void	vpm_iowrite16 (struct virtio_pci_modern_device vdev, struct virtio_pci_region region, u16 data, size_t offset)
void	vpm_iowrite32 (struct virtio_pci_modern_device vdev, struct virtio_pci_region region, u32 data, size_t offset)
u8	vpm_ioread8 (struct virtio_pci_modern_device vdev, struct virtio_pci_region region, size_t offset)
u16	vpm_ioread16 (struct virtio_pci_modern_device vdev, struct virtio_pci_region region, size_t offset)
u32	vpm_ioread32 (struct virtio_pci_modern_device vdev, struct virtio_pci_region region, size_t offset)
int	virtio_pci_find_capability (struct pci_device *pci, uint8_t cfg_type)
int	virtio_pci_map_capability (struct pci_device pci, int cap, size_t minlen, u32 align, u32 start, u32 size, struct virtio_pci_region region)
void	virtio_pci_unmap_capability (struct virtio_pci_region *region)
void	vpm_notify (struct virtio_pci_modern_device vdev, struct vring_virtqueue vq)
int	vpm_find_vqs (struct virtio_pci_modern_device vdev, unsigned nvqs, struct vring_virtqueue vqs, struct dma_device *dma_dev, size_t header_size)

Macro Definition Documentation

◆ CFG_POS

#define CFG_POS	(		vdev,
			field )

Value:

(vdev->cfg_cap_pos + offsetof(struct virtio_pci_cfg_cap, field))

offsetof

#define offsetof(type, field)

Get offset of a field within a structure.

Definition stddef.h:25

virtio_pci_cfg_cap

Definition virtio-pci.h:71

Definition at line 106 of file virtio-pci.c.

106#define CFG_POS(vdev, field) \

107 (vdev->cfg_cap_pos + offsetof(struct virtio_pci_cfg_cap, field))

Referenced by prep_pci_cfg_cap(), vpm_ioread16(), vpm_ioread32(), vpm_ioread8(), vpm_iowrite16(), vpm_iowrite32(), and vpm_iowrite8().

Function Documentation

◆ vp_alloc_vq()

int vp_alloc_vq	(	struct vring_virtqueue *	vq,
		u16	num,
		size_t	header_size )

static

Definition at line 25 of file virtio-pci.c.

{
    size_t ring_size = PAGE_MASK + vring_size(num);
    size_t vdata_size = num * sizeof(void *);
    size_t queue_size = ring_size + vdata_size + header_size;
 
    vq->queue = dma_alloc(vq->dma, &vq->map, queue_size, queue_size);
    if (!vq->queue) {
        return -ENOMEM;
    }
 
    memset ( vq->queue, 0, queue_size );
    vq->queue_size = queue_size;
 
    /* vdata immediately follows the ring */
    vq->vdata = (void **)(vq->queue + ring_size);
 
    /* empty header immediately follows vdata */
    vq->empty_header = (struct virtio_net_hdr_modern *)(vq->queue + ring_size + vdata_size);
 
    return 0;
}

References vring_virtqueue::dma, dma_alloc(), vring_virtqueue::empty_header, ENOMEM, vring_virtqueue::map, memset(), num, PAGE_MASK, vring_virtqueue::queue, vring_virtqueue::queue_size, u16, vring_virtqueue::vdata, and vring_size.

Referenced by vp_find_vq(), and vpm_find_vqs().

◆ vp_free_vq()

void vp_free_vq ( struct vring_virtqueue * vq )

Definition at line 48 of file virtio-pci.c.

{
    if (vq->queue && vq->queue_size) {
        dma_free(&vq->map, vq->queue, vq->queue_size);
        vq->queue = NULL;
        vq->vdata = NULL;
        vq->queue_size = 0;
    }
}

References dma_free(), vring_virtqueue::map, NULL, vring_virtqueue::queue, vring_virtqueue::queue_size, and vring_virtqueue::vdata.

Referenced by virtnet_free_virtqueues().

◆ vp_find_vq()

int vp_find_vq	(	unsigned int	ioaddr,
		int	queue_index,
		struct vring_virtqueue *	vq,
		struct dma_device *	dma_dev,
		size_t	header_size )

Definition at line 58 of file virtio-pci.c.

{
   struct vring * vr = &vq->vring;
   u16 num;
   int rc;
 
   /* select the queue */
 
   outw(queue_index, ioaddr + VIRTIO_PCI_QUEUE_SEL);
 
   /* check if the queue is available */
 
   num = inw(ioaddr + VIRTIO_PCI_QUEUE_NUM);
   if (!num) {
           DBG("VIRTIO-PCI ERROR: queue size is 0\n");
           return -1;
   }
 
   /* check if the queue is already active */
 
   if (inl(ioaddr + VIRTIO_PCI_QUEUE_PFN)) {
           DBG("VIRTIO-PCI ERROR: queue already active\n");
           return -1;
   }
 
   vq->queue_index = queue_index;
   vq->dma = dma_dev;
 
   /* initialize the queue */
   rc = vp_alloc_vq(vq, num, header_size);
   if (rc) {
           DBG("VIRTIO-PCI ERROR: failed to allocate queue memory\n");
           return rc;
   }
   vring_init(vr, num, vq->queue);
 
   /* activate the queue
    *
    * NOTE: vr->desc is initialized by vring_init()
    */
 
   outl(dma(&vq->map, vr->desc) >> PAGE_SHIFT, ioaddr + VIRTIO_PCI_QUEUE_PFN);
 
   return num;
}

References DBG, vring::desc, dma(), vring_virtqueue::dma, inl, inw, ioaddr, vring_virtqueue::map, num, outl, outw, PAGE_SHIFT, vring_virtqueue::queue, vring_virtqueue::queue_index, rc, u16, VIRTIO_PCI_QUEUE_NUM, VIRTIO_PCI_QUEUE_PFN, VIRTIO_PCI_QUEUE_SEL, vp_alloc_vq(), vring_virtqueue::vring, and vring_init().

Referenced by virtnet_open_legacy().

◆ prep_pci_cfg_cap()

void prep_pci_cfg_cap	(	struct virtio_pci_modern_device *	vdev,
		struct virtio_pci_region *	region,
		size_t	offset,
		u32	length )

static

Definition at line 109 of file virtio-pci.c.

{
    pci_write_config_byte(vdev->pci, CFG_POS(vdev, cap.bar), region->bar);
    pci_write_config_dword(vdev->pci, CFG_POS(vdev, cap.length), length);
    pci_write_config_dword(vdev->pci, CFG_POS(vdev, cap.offset),
        (intptr_t)(region->base + offset));
}

References virtio_pci_region::bar, virtio_pci_region::base, CFG_POS, length, offset, virtio_pci_modern_device::pci, pci_write_config_byte(), pci_write_config_dword(), and u32.

Referenced by vpm_ioread16(), vpm_ioread32(), vpm_ioread8(), vpm_iowrite16(), vpm_iowrite32(), and vpm_iowrite8().

◆ vpm_iowrite8()

void vpm_iowrite8	(	struct virtio_pci_modern_device *	vdev,
		struct virtio_pci_region *	region,
		u8	data,
		size_t	offset )

Definition at line 119 of file virtio-pci.c.

{
    switch (region->flags & VIRTIO_PCI_REGION_TYPE_MASK) {
    case VIRTIO_PCI_REGION_MEMORY:
        writeb(data, region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PORT:
        outb(data, region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PCI_CONFIG:
        prep_pci_cfg_cap(vdev, region, offset, 1);
        pci_write_config_byte(vdev->pci, CFG_POS(vdev, pci_cfg_data), data);
        break;
    default:
        assert(0);
        break;
    }
}

References assert, virtio_pci_region::base, CFG_POS, data, virtio_pci_region::flags, offset, outb, virtio_pci_modern_device::pci, pci_write_config_byte(), prep_pci_cfg_cap(), u8, VIRTIO_PCI_REGION_MEMORY, VIRTIO_PCI_REGION_PCI_CONFIG, VIRTIO_PCI_REGION_PORT, VIRTIO_PCI_REGION_TYPE_MASK, and writeb.

Referenced by vpm_add_status(), and vpm_reset().

◆ vpm_iowrite16()

void vpm_iowrite16	(	struct virtio_pci_modern_device *	vdev,
		struct virtio_pci_region *	region,
		u16	data,
		size_t	offset )

Definition at line 139 of file virtio-pci.c.

{
    data = cpu_to_le16(data);
    switch (region->flags & VIRTIO_PCI_REGION_TYPE_MASK) {
    case VIRTIO_PCI_REGION_MEMORY:
        writew(data, region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PORT:
        outw(data, region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PCI_CONFIG:
        prep_pci_cfg_cap(vdev, region, offset, 2);
        pci_write_config_word(vdev->pci, CFG_POS(vdev, pci_cfg_data), data);
        break;
    default:
        assert(0);
        break;
    }
}

References assert, virtio_pci_region::base, CFG_POS, cpu_to_le16, data, virtio_pci_region::flags, offset, outw, virtio_pci_modern_device::pci, pci_write_config_word(), prep_pci_cfg_cap(), u16, VIRTIO_PCI_REGION_MEMORY, VIRTIO_PCI_REGION_PCI_CONFIG, VIRTIO_PCI_REGION_PORT, VIRTIO_PCI_REGION_TYPE_MASK, and writew.

Referenced by vpm_find_vqs(), and vpm_notify().

◆ vpm_iowrite32()

void vpm_iowrite32	(	struct virtio_pci_modern_device *	vdev,
		struct virtio_pci_region *	region,
		u32	data,
		size_t	offset )

Definition at line 160 of file virtio-pci.c.

{
    data = cpu_to_le32(data);
    switch (region->flags & VIRTIO_PCI_REGION_TYPE_MASK) {
    case VIRTIO_PCI_REGION_MEMORY:
        writel(data, region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PORT:
        outl(data, region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PCI_CONFIG:
        prep_pci_cfg_cap(vdev, region, offset, 4);
        pci_write_config_dword(vdev->pci, CFG_POS(vdev, pci_cfg_data), data);
        break;
    default:
        assert(0);
        break;
    }
}

References assert, virtio_pci_region::base, CFG_POS, cpu_to_le32, data, virtio_pci_region::flags, offset, outl, virtio_pci_modern_device::pci, pci_write_config_dword(), prep_pci_cfg_cap(), u32, VIRTIO_PCI_REGION_MEMORY, VIRTIO_PCI_REGION_PCI_CONFIG, VIRTIO_PCI_REGION_PORT, VIRTIO_PCI_REGION_TYPE_MASK, and writel.

Referenced by vpm_get_features(), vpm_iowrite64(), and vpm_set_features().

◆ vpm_ioread8()

u8 vpm_ioread8	(	struct virtio_pci_modern_device *	vdev,
		struct virtio_pci_region *	region,
		size_t	offset )

Definition at line 181 of file virtio-pci.c.

{
    uint8_t data;
    switch (region->flags & VIRTIO_PCI_REGION_TYPE_MASK) {
    case VIRTIO_PCI_REGION_MEMORY:
        data = readb(region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PORT:
        data = inb(region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PCI_CONFIG:
        prep_pci_cfg_cap(vdev, region, offset, 1);
        pci_read_config_byte(vdev->pci, CFG_POS(vdev, pci_cfg_data), &data);
        break;
    default:
        assert(0);
        data = 0;
        break;
    }
    return data;
}

References assert, virtio_pci_region::base, CFG_POS, data, virtio_pci_region::flags, inb, offset, virtio_pci_modern_device::pci, pci_read_config_byte(), prep_pci_cfg_cap(), readb, u8, VIRTIO_PCI_REGION_MEMORY, VIRTIO_PCI_REGION_PCI_CONFIG, VIRTIO_PCI_REGION_PORT, and VIRTIO_PCI_REGION_TYPE_MASK.

Referenced by vpm_add_status(), vpm_get(), vpm_get_isr(), vpm_get_status(), and vpm_reset().

◆ vpm_ioread16()

u16 vpm_ioread16	(	struct virtio_pci_modern_device *	vdev,
		struct virtio_pci_region *	region,
		size_t	offset )

Definition at line 204 of file virtio-pci.c.

{
    uint16_t data;
    switch (region->flags & VIRTIO_PCI_REGION_TYPE_MASK) {
    case VIRTIO_PCI_REGION_MEMORY:
        data = readw(region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PORT:
        data = inw(region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PCI_CONFIG:
        prep_pci_cfg_cap(vdev, region, offset, 2);
        pci_read_config_word(vdev->pci, CFG_POS(vdev, pci_cfg_data), &data);
        break;
    default:
        assert(0);
        data = 0;
        break;
    }
    return le16_to_cpu(data);
}

References assert, virtio_pci_region::base, CFG_POS, data, virtio_pci_region::flags, inw, le16_to_cpu, offset, virtio_pci_modern_device::pci, pci_read_config_word(), prep_pci_cfg_cap(), readw, u16, VIRTIO_PCI_REGION_MEMORY, VIRTIO_PCI_REGION_PCI_CONFIG, VIRTIO_PCI_REGION_PORT, and VIRTIO_PCI_REGION_TYPE_MASK.

Referenced by vpm_find_vqs().

◆ vpm_ioread32()

u32 vpm_ioread32	(	struct virtio_pci_modern_device *	vdev,
		struct virtio_pci_region *	region,
		size_t	offset )

Definition at line 227 of file virtio-pci.c.

{
    uint32_t data;
    switch (region->flags & VIRTIO_PCI_REGION_TYPE_MASK) {
    case VIRTIO_PCI_REGION_MEMORY:
        data = readl(region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PORT:
        data = inl(region->base + offset);
        break;
    case VIRTIO_PCI_REGION_PCI_CONFIG:
        prep_pci_cfg_cap(vdev, region, offset, 4);
        pci_read_config_dword(vdev->pci, CFG_POS(vdev, pci_cfg_data), &data);
        break;
    default:
        assert(0);
        data = 0;
        break;
    }
    return le32_to_cpu(data);
}

References assert, virtio_pci_region::base, CFG_POS, data, virtio_pci_region::flags, inl, le32_to_cpu, offset, virtio_pci_modern_device::pci, pci_read_config_dword(), prep_pci_cfg_cap(), readl, u32, VIRTIO_PCI_REGION_MEMORY, VIRTIO_PCI_REGION_PCI_CONFIG, VIRTIO_PCI_REGION_PORT, and VIRTIO_PCI_REGION_TYPE_MASK.

Referenced by vpm_get_features().

◆ virtio_pci_find_capability()

int virtio_pci_find_capability	(	struct pci_device *	pci,
		uint8_t	cfg_type )

Definition at line 250 of file virtio-pci.c.

{
    int pos;
    uint8_t type, bar;
 
    for (pos = pci_find_capability(pci, PCI_CAP_ID_VNDR);
         pos > 0;
         pos = pci_find_next_capability(pci, pos, PCI_CAP_ID_VNDR)) {
 
        pci_read_config_byte(pci, pos + offsetof(struct virtio_pci_cap,
            cfg_type), &type);
        pci_read_config_byte(pci, pos + offsetof(struct virtio_pci_cap,
            bar), &bar);
 
        /* Ignore structures with reserved BAR values */
        if (bar > 0x5) {
            continue;
        }
 
        if (type == cfg_type) {
            return pos;
        }
    }
    return 0;
}

References offsetof, PCI_CAP_ID_VNDR, pci_find_capability(), pci_find_next_capability(), pci_read_config_byte(), and type.

Referenced by virtnet_probe_modern().

◆ virtio_pci_map_capability()

int virtio_pci_map_capability	(	struct pci_device *	pci,
		int	cap,
		size_t	minlen,
		u32	align,
		u32	start,
		u32	size,
		struct virtio_pci_region *	region )

Definition at line 276 of file virtio-pci.c.

{
    u8 bar;
    u32 offset, length, base_raw;
    unsigned long base;
 
    pci_read_config_byte(pci, cap + offsetof(struct virtio_pci_cap, bar), &bar);
    pci_read_config_dword(pci, cap + offsetof(struct virtio_pci_cap, offset),
                          &offset);
    pci_read_config_dword(pci, cap + offsetof(struct virtio_pci_cap, length),
                          &length);
 
    if (length <= start) {
        DBG("VIRTIO-PCI bad capability len %d (>%d expected)\n", length, start);
        return -EINVAL;
    }
    if (length - start < minlen) {
        DBG("VIRTIO-PCI bad capability len %d (>=%zd expected)\n", length, minlen);
        return -EINVAL;
    }
    length -= start;
    if (start + offset < offset) {
        DBG("VIRTIO-PCI map wrap-around %d+%d\n", start, offset);
        return -EINVAL;
    }
    offset += start;
    if (offset & (align - 1)) {
        DBG("VIRTIO-PCI offset %d not aligned to %d\n", offset, align);
        return -EINVAL;
    }
    if (length > size) {
        length = size;
    }
 
    if (minlen + offset < minlen ||
        minlen + offset > pci_bar_size(pci, PCI_BASE_ADDRESS(bar))) {
        DBG("VIRTIO-PCI map virtio %zd@%d out of range on bar %i length %ld\n",
            minlen, offset,
            bar, pci_bar_size(pci, PCI_BASE_ADDRESS(bar)));
        return -EINVAL;
    }
 
    region->base = NULL;
    region->length = length;
    region->bar = bar;
 
    base = pci_bar_start(pci, PCI_BASE_ADDRESS(bar));
    if (base) {
        pci_read_config_dword(pci, PCI_BASE_ADDRESS(bar), &base_raw);
 
        if (base_raw & PCI_BASE_ADDRESS_SPACE_IO) {
            /* Region accessed using port I/O */
            region->base = (void *)(base + offset);
            region->flags = VIRTIO_PCI_REGION_PORT;
        } else {
            /* Region mapped into memory space */
            region->base = pci_ioremap(pci, base + offset, length);
            region->flags = VIRTIO_PCI_REGION_MEMORY;
        }
    }
    if (!region->base) {
        /* Region accessed via PCI config space window */
            region->base = (void *)(intptr_t)offset;
        region->flags = VIRTIO_PCI_REGION_PCI_CONFIG;
    }
    return 0;
}

References virtio_pci_region::bar, base, virtio_pci_region::base, DBG, EINVAL, virtio_pci_region::flags, length, virtio_pci_region::length, NULL, offset, offsetof, pci_bar_size(), pci_bar_start(), PCI_BASE_ADDRESS, PCI_BASE_ADDRESS_SPACE_IO, pci_ioremap(), pci_read_config_byte(), pci_read_config_dword(), size, start, u32, u8, VIRTIO_PCI_REGION_MEMORY, VIRTIO_PCI_REGION_PCI_CONFIG, and VIRTIO_PCI_REGION_PORT.

Referenced by virtnet_probe_modern(), and vpm_find_vqs().

◆ virtio_pci_unmap_capability()

void virtio_pci_unmap_capability ( struct virtio_pci_region * region )

Definition at line 346 of file virtio-pci.c.

{
    unsigned region_type = region->flags & VIRTIO_PCI_REGION_TYPE_MASK;
    if (region_type == VIRTIO_PCI_REGION_MEMORY) {
        iounmap(region->base);
    }
}

References virtio_pci_region::base, virtio_pci_region::flags, iounmap(), VIRTIO_PCI_REGION_MEMORY, and VIRTIO_PCI_REGION_TYPE_MASK.

Referenced by virtnet_free_virtqueues(), virtnet_probe_modern(), and virtnet_remove().

◆ vpm_notify()

void vpm_notify	(	struct virtio_pci_modern_device *	vdev,
		struct vring_virtqueue *	vq )

Definition at line 354 of file virtio-pci.c.

{
    vpm_iowrite16(vdev, &vq->notification, (u16)vq->queue_index, 0);
}

References vring_virtqueue::notification, vring_virtqueue::queue_index, u16, and vpm_iowrite16().

Referenced by vring_kick().

◆ vpm_find_vqs()

int vpm_find_vqs	(	struct virtio_pci_modern_device *	vdev,
		unsigned	nvqs,
		struct vring_virtqueue *	vqs,
		struct dma_device *	dma_dev,
		size_t	header_size )

Definition at line 360 of file virtio-pci.c.

{
    unsigned i;
    struct vring_virtqueue *vq;
    u16 size, off;
    u32 notify_offset_multiplier;
    int err;
 
    if (nvqs > vpm_ioread16(vdev, &vdev->common, COMMON_OFFSET(num_queues))) {
        return -ENOENT;
    }
 
    /* Read notify_off_multiplier from config space. */
    pci_read_config_dword(vdev->pci,
        vdev->notify_cap_pos + offsetof(struct virtio_pci_notify_cap,
        notify_off_multiplier),
        &notify_offset_multiplier);
 
    for (i = 0; i < nvqs; i++) {
        /* Select the queue we're interested in */
        vpm_iowrite16(vdev, &vdev->common, (u16)i, COMMON_OFFSET(queue_select));
 
        /* Check if queue is either not available or already active. */
        size = vpm_ioread16(vdev, &vdev->common, COMMON_OFFSET(queue_size));
        /* QEMU has a bug where queues don't revert to inactive on device
         * reset. Skip checking the queue_enable field until it is fixed.
         */
        if (!size /*|| vpm_ioread16(vdev, &vdev->common.queue_enable)*/)
            return -ENOENT;
 
        if (size & (size - 1)) {
            DBG("VIRTIO-PCI %p: bad queue size %d\n", vdev, size);
            return -EINVAL;
        }
 
        if (size > MAX_QUEUE_NUM) {
            /* iPXE networking tends to be not perf critical so there's no
             * need to accept large queue sizes.
             */
            size = MAX_QUEUE_NUM;
        }
 
        vq = &vqs[i];
        vq->queue_index = i;
        vq->dma = dma_dev;
 
        /* get offset of notification word for this vq */
        off = vpm_ioread16(vdev, &vdev->common, COMMON_OFFSET(queue_notify_off));
 
        err = vp_alloc_vq(vq, size, header_size);
        if (err) {
            DBG("VIRTIO-PCI %p: failed to allocate queue memory\n", vdev);
            return err;
        }
        vring_init(&vq->vring, size, vq->queue);
 
        /* activate the queue */
        vpm_iowrite16(vdev, &vdev->common, size, COMMON_OFFSET(queue_size));
 
        vpm_iowrite64(vdev, &vdev->common,
                      dma(&vq->map, vq->vring.desc),
                      COMMON_OFFSET(queue_desc_lo),
                      COMMON_OFFSET(queue_desc_hi));
        vpm_iowrite64(vdev, &vdev->common,
                      dma(&vq->map, vq->vring.avail),
                      COMMON_OFFSET(queue_avail_lo),
                      COMMON_OFFSET(queue_avail_hi));
        vpm_iowrite64(vdev, &vdev->common,
                      dma(&vq->map, vq->vring.used),
                      COMMON_OFFSET(queue_used_lo),
                      COMMON_OFFSET(queue_used_hi));
 
        err = virtio_pci_map_capability(vdev->pci,
            vdev->notify_cap_pos, 2, 2,
            off * notify_offset_multiplier, 2,
            &vq->notification);
        if (err) {
            return err;
        }
    }
 
    /* Select and activate all queues. Has to be done last: once we do
     * this, there's no way to go back except reset.
     */
    for (i = 0; i < nvqs; i++) {
        vq = &vqs[i];
        vpm_iowrite16(vdev, &vdev->common, (u16)vq->queue_index,
                      COMMON_OFFSET(queue_select));
        vpm_iowrite16(vdev, &vdev->common, 1, COMMON_OFFSET(queue_enable));
    }
    return 0;
}

References vring::avail, virtio_pci_modern_device::common, COMMON_OFFSET, DBG, vring::desc, dma(), vring_virtqueue::dma, EINVAL, ENOENT, vring_virtqueue::map, MAX_QUEUE_NUM, vring_virtqueue::notification, virtio_pci_modern_device::notify_cap_pos, offsetof, virtio_pci_modern_device::pci, pci_read_config_dword(), vring_virtqueue::queue, vring_virtqueue::queue_index, vring_virtqueue::queue_size, size, u16, u32, vring::used, virtio_pci_map_capability(), vp_alloc_vq(), vpm_ioread16(), vpm_iowrite16(), vpm_iowrite64(), vring_virtqueue::vring, and vring_init().

Referenced by virtnet_open_modern().

Macros

Functions