#include <ipxe/dma.h>

Data Structures
struct	virtio_pci_cap

struct	virtio_pci_notify_cap

struct	virtio_pci_cfg_cap

struct	virtio_pci_common_cfg

struct	virtio_pci_region

struct	virtio_pci_modern_device

Macros
#define	VIRTIO_PCI_HOST_FEATURES 0

#define	VIRTIO_PCI_GUEST_FEATURES 4

#define	VIRTIO_PCI_QUEUE_PFN 8

#define	VIRTIO_PCI_QUEUE_NUM 12

#define	VIRTIO_PCI_QUEUE_SEL 14

#define	VIRTIO_PCI_QUEUE_NOTIFY 16

#define	VIRTIO_PCI_STATUS 18

#define	VIRTIO_PCI_ISR 19

#define	VIRTIO_PCI_ISR_CONFIG 0x2

#define	VIRTIO_PCI_CONFIG 20

#define	VIRTIO_PCI_ABI_VERSION 0

#define	VIRTIO_PCI_CAP_COMMON_CFG 1 /* Common configuration */

#define	VIRTIO_PCI_CAP_NOTIFY_CFG 2 /* Notifications */

#define	VIRTIO_PCI_CAP_ISR_CFG 3 /* ISR access */

#define	VIRTIO_PCI_CAP_DEVICE_CFG 4 /* Device specific configuration */

#define	VIRTIO_PCI_CAP_PCI_CFG 5 /* PCI configuration access */

#define	__u8 uint8_t

#define	__le16 uint16_t

#define	__le32 uint32_t

#define	__le64 uint64_t

#define	VIRTIO_PCI_REGION_TYPE_MASK 0x00000003

#define	VIRTIO_PCI_REGION_MEMORY 0x00000001

#define	VIRTIO_PCI_REGION_PORT 0x00000002

#define	VIRTIO_PCI_REGION_PCI_CONFIG 0x00000003

#define	COMMON_OFFSET(field) offsetof(struct virtio_pci_common_cfg, field)

Functions
static u32	vp_get_features (unsigned int ioaddr)

static void	vp_set_features (unsigned int ioaddr, u32 features)

static void	vp_get (unsigned int ioaddr, unsigned offset, void *buf, unsigned len)

static u8	vp_get_status (unsigned int ioaddr)

static void	vp_set_status (unsigned int ioaddr, u8 status)

static u8	vp_get_isr (unsigned int ioaddr)

static void	vp_reset (unsigned int ioaddr)

static void	vp_notify (unsigned int ioaddr, int queue_index)

static void	vp_del_vq (unsigned int ioaddr, int queue_index)

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)

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)

static void	vpm_iowrite64 (struct virtio_pci_modern_device vdev, struct virtio_pci_region region, u64 data, size_t offset_lo, size_t offset_hi)

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)

static void	vpm_reset (struct virtio_pci_modern_device *vdev)

static u8	vpm_get_status (struct virtio_pci_modern_device *vdev)

static void	vpm_add_status (struct virtio_pci_modern_device *vdev, u8 status)

static u64	vpm_get_features (struct virtio_pci_modern_device *vdev)

static void	vpm_set_features (struct virtio_pci_modern_device *vdev, u64 features)

static void	vpm_get (struct virtio_pci_modern_device vdev, unsigned offset, void buf, unsigned len)

static u8	vpm_get_isr (struct virtio_pci_modern_device *vdev)

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)

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)

Macro Definition Documentation

◆ VIRTIO_PCI_HOST_FEATURES

#define VIRTIO_PCI_HOST_FEATURES 0

Definition at line 7 of file virtio-pci.h.

◆ VIRTIO_PCI_GUEST_FEATURES

#define VIRTIO_PCI_GUEST_FEATURES 4

Definition at line 10 of file virtio-pci.h.

◆ VIRTIO_PCI_QUEUE_PFN

#define VIRTIO_PCI_QUEUE_PFN 8

Definition at line 13 of file virtio-pci.h.

◆ VIRTIO_PCI_QUEUE_NUM

#define VIRTIO_PCI_QUEUE_NUM 12

Definition at line 16 of file virtio-pci.h.

◆ VIRTIO_PCI_QUEUE_SEL

#define VIRTIO_PCI_QUEUE_SEL 14

Definition at line 19 of file virtio-pci.h.

◆ VIRTIO_PCI_QUEUE_NOTIFY

#define VIRTIO_PCI_QUEUE_NOTIFY 16

Definition at line 22 of file virtio-pci.h.

◆ VIRTIO_PCI_STATUS

#define VIRTIO_PCI_STATUS 18

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

◆ VIRTIO_PCI_ISR

#define VIRTIO_PCI_ISR 19

Definition at line 30 of file virtio-pci.h.

◆ VIRTIO_PCI_ISR_CONFIG

#define VIRTIO_PCI_ISR_CONFIG 0x2

Definition at line 33 of file virtio-pci.h.

◆ VIRTIO_PCI_CONFIG

#define VIRTIO_PCI_CONFIG 20

Definition at line 37 of file virtio-pci.h.

◆ VIRTIO_PCI_ABI_VERSION

#define VIRTIO_PCI_ABI_VERSION 0

Definition at line 40 of file virtio-pci.h.

◆ VIRTIO_PCI_CAP_COMMON_CFG

#define VIRTIO_PCI_CAP_COMMON_CFG 1 /* Common configuration */

Definition at line 43 of file virtio-pci.h.

◆ VIRTIO_PCI_CAP_NOTIFY_CFG

#define VIRTIO_PCI_CAP_NOTIFY_CFG 2 /* Notifications */

Definition at line 44 of file virtio-pci.h.

◆ VIRTIO_PCI_CAP_ISR_CFG

#define VIRTIO_PCI_CAP_ISR_CFG 3 /* ISR access */

Definition at line 45 of file virtio-pci.h.

◆ VIRTIO_PCI_CAP_DEVICE_CFG

#define VIRTIO_PCI_CAP_DEVICE_CFG 4 /* Device specific configuration */

Definition at line 46 of file virtio-pci.h.

◆ VIRTIO_PCI_CAP_PCI_CFG

#define VIRTIO_PCI_CAP_PCI_CFG 5 /* PCI configuration access */

Definition at line 47 of file virtio-pci.h.

◆ __u8

#define __u8 uint8_t

Definition at line 49 of file virtio-pci.h.

◆ __le16

#define __le16 uint16_t

Definition at line 50 of file virtio-pci.h.

◆ __le32

#define __le32 uint32_t

Definition at line 51 of file virtio-pci.h.

◆ __le64

#define __le64 uint64_t

Definition at line 52 of file virtio-pci.h.

◆ VIRTIO_PCI_REGION_TYPE_MASK

#define VIRTIO_PCI_REGION_TYPE_MASK 0x00000003

Definition at line 110 of file virtio-pci.h.

◆ VIRTIO_PCI_REGION_MEMORY

#define VIRTIO_PCI_REGION_MEMORY 0x00000001

Definition at line 112 of file virtio-pci.h.

◆ VIRTIO_PCI_REGION_PORT

#define VIRTIO_PCI_REGION_PORT 0x00000002

Definition at line 114 of file virtio-pci.h.

◆ VIRTIO_PCI_REGION_PCI_CONFIG

#define VIRTIO_PCI_REGION_PCI_CONFIG 0x00000003

Definition at line 116 of file virtio-pci.h.

◆ COMMON_OFFSET

#define COMMON_OFFSET ( field ) offsetof(struct virtio_pci_common_cfg, field)

Definition at line 239 of file virtio-pci.h.

Function Documentation

◆ vp_get_features()

static u32 vp_get_features ( unsigned int ioaddr )

inlinestatic

Definition at line 140 of file virtio-pci.h.

 {
    return inl(ioaddr + VIRTIO_PCI_HOST_FEATURES);
 }

References inl(), ioaddr, and VIRTIO_PCI_HOST_FEATURES.

Referenced by virtnet_open_legacy(), and virtnet_probe_legacy().

◆ vp_set_features()

static void vp_set_features	(	unsigned int	ioaddr,
		u32	features
	)

inlinestatic

Definition at line 145 of file virtio-pci.h.

 {
         outl(features, ioaddr + VIRTIO_PCI_GUEST_FEATURES);
 }

References features, ioaddr, outl, and VIRTIO_PCI_GUEST_FEATURES.

Referenced by virtnet_open_legacy().

◆ vp_get()

static void vp_get	(	unsigned int	ioaddr,
		unsigned	offset,
		void *	buf,
		unsigned	len
	)

inlinestatic

Definition at line 150 of file virtio-pci.h.

 {
    u8 *ptr = buf;
    unsigned i;
 
    for (i = 0; i < len; i++)
            ptr[i] = inb(ioaddr + VIRTIO_PCI_CONFIG + offset + i);
 }

References inb(), ioaddr, len, offset, and VIRTIO_PCI_CONFIG.

Referenced by virtnet_probe_legacy().

◆ vp_get_status()

static u8 vp_get_status ( unsigned int ioaddr )

inlinestatic

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

 {
    return inb(ioaddr + VIRTIO_PCI_STATUS);
 }

References inb(), ioaddr, and VIRTIO_PCI_STATUS.

◆ vp_set_status()

static void vp_set_status	(	unsigned int	ioaddr,
		u8	status
	)

inlinestatic

Definition at line 165 of file virtio-pci.h.

 {
    if (status == 0)        /* reset */
            return;
    outb(status, ioaddr + VIRTIO_PCI_STATUS);
 }

References ioaddr, outb, status, and VIRTIO_PCI_STATUS.

Referenced by virtnet_open_legacy().

◆ vp_get_isr()

static u8 vp_get_isr ( unsigned int ioaddr )

inlinestatic

Definition at line 172 of file virtio-pci.h.

 {
    return inb(ioaddr + VIRTIO_PCI_ISR);
 }

References inb(), ioaddr, and VIRTIO_PCI_ISR.

Referenced by virtnet_poll().

◆ vp_reset()

static void vp_reset ( unsigned int ioaddr )

inlinestatic

Definition at line 177 of file virtio-pci.h.

 {
    outb(0, ioaddr + VIRTIO_PCI_STATUS);
    (void)inb(ioaddr + VIRTIO_PCI_ISR);
 }

References inb(), ioaddr, outb, VIRTIO_PCI_ISR, and VIRTIO_PCI_STATUS.

Referenced by virtnet_close(), virtnet_open_legacy(), and virtnet_probe_legacy().

◆ vp_notify()

static void vp_notify	(	unsigned int	ioaddr,
		int	queue_index
	)

inlinestatic

Definition at line 183 of file virtio-pci.h.

 {
    outw(queue_index, ioaddr + VIRTIO_PCI_QUEUE_NOTIFY);
 }

References ioaddr, outw, and VIRTIO_PCI_QUEUE_NOTIFY.

Referenced by vring_kick().

◆ vp_del_vq()

static void vp_del_vq	(	unsigned int	ioaddr,
		int	queue_index
	)

inlinestatic

Definition at line 188 of file virtio-pci.h.

 {
    /* select the queue */
 
    outw(queue_index, ioaddr + VIRTIO_PCI_QUEUE_SEL);
 
    /* deactivate the queue */
 
    outl(0, ioaddr + VIRTIO_PCI_QUEUE_PFN);
 }

References ioaddr, outl, outw, VIRTIO_PCI_QUEUE_PFN, and VIRTIO_PCI_QUEUE_SEL.

◆ 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, vring_virtqueue::dma, dma(), inl(), inw(), ioaddr, vring_virtqueue::map, num, outl, outw, PAGE_SHIFT, vring_virtqueue::queue, vring_virtqueue::queue_index, rc, 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().

◆ 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(), 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(), 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(), 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_iowrite64()

static void vpm_iowrite64	(	struct virtio_pci_modern_device *	vdev,
		struct virtio_pci_region *	region,
		u64	data,
		size_t	offset_lo,
		size_t	offset_hi
	)

inlinestatic

Definition at line 220 of file virtio-pci.h.

 {
     vpm_iowrite32(vdev, region, (u32)data, offset_lo);
     vpm_iowrite32(vdev, region, data >> 32, offset_hi);
 }

References data, and vpm_iowrite32().

Referenced by vpm_find_vqs().

◆ 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(), 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(), 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(), VIRTIO_PCI_REGION_MEMORY, VIRTIO_PCI_REGION_PCI_CONFIG, VIRTIO_PCI_REGION_PORT, and VIRTIO_PCI_REGION_TYPE_MASK.

Referenced by vpm_get_features().

◆ vpm_reset()

static void vpm_reset ( struct virtio_pci_modern_device * vdev )

inlinestatic

Definition at line 241 of file virtio-pci.h.

 {
     vpm_iowrite8(vdev, &vdev->common, 0, COMMON_OFFSET(device_status));
     while (vpm_ioread8(vdev, &vdev->common, COMMON_OFFSET(device_status)))
         mdelay(1);
 }

References virtio_pci_modern_device::common, COMMON_OFFSET, mdelay(), vpm_ioread8(), and vpm_iowrite8().

Referenced by virtnet_close(), and virtnet_probe_modern().

◆ vpm_get_status()

static u8 vpm_get_status ( struct virtio_pci_modern_device * vdev )

inlinestatic

Definition at line 248 of file virtio-pci.h.

 {
     return vpm_ioread8(vdev, &vdev->common, COMMON_OFFSET(device_status));
 }

References virtio_pci_modern_device::common, COMMON_OFFSET, and vpm_ioread8().

Referenced by virtnet_open_modern().

◆ vpm_add_status()

static void vpm_add_status	(	struct virtio_pci_modern_device *	vdev,
		u8	status
	)

inlinestatic

Definition at line 253 of file virtio-pci.h.

 {
     u8 curr_status = vpm_ioread8(vdev, &vdev->common, COMMON_OFFSET(device_status));
     vpm_iowrite8(vdev, &vdev->common,
                  curr_status | status, COMMON_OFFSET(device_status));
 }

References virtio_pci_modern_device::common, COMMON_OFFSET, status, vpm_ioread8(), and vpm_iowrite8().

Referenced by virtnet_open_modern(), and virtnet_probe_modern().

◆ vpm_get_features()

static u64 vpm_get_features ( struct virtio_pci_modern_device * vdev )

inlinestatic

Definition at line 261 of file virtio-pci.h.

 {
     u32 features_lo, features_hi;
 
     vpm_iowrite32(vdev, &vdev->common, 0, COMMON_OFFSET(device_feature_select));
     features_lo = vpm_ioread32(vdev, &vdev->common, COMMON_OFFSET(device_feature));
     vpm_iowrite32(vdev, &vdev->common, 1, COMMON_OFFSET(device_feature_select));
     features_hi = vpm_ioread32(vdev, &vdev->common, COMMON_OFFSET(device_feature));
 
     return ((u64)features_hi << 32) | features_lo;
 }

References virtio_pci_modern_device::common, COMMON_OFFSET, vpm_ioread32(), and vpm_iowrite32().

Referenced by virtnet_open_modern(), and virtnet_probe_modern().

◆ vpm_set_features()

static void vpm_set_features	(	struct virtio_pci_modern_device *	vdev,
		u64	features
	)

inlinestatic

Definition at line 273 of file virtio-pci.h.

 {
     u32 features_lo = (u32)features;
     u32 features_hi = features >> 32;
 
     vpm_iowrite32(vdev, &vdev->common, 0, COMMON_OFFSET(guest_feature_select));
     vpm_iowrite32(vdev, &vdev->common, features_lo, COMMON_OFFSET(guest_feature));
     vpm_iowrite32(vdev, &vdev->common, 1, COMMON_OFFSET(guest_feature_select));
     vpm_iowrite32(vdev, &vdev->common, features_hi, COMMON_OFFSET(guest_feature));
 }

References virtio_pci_modern_device::common, COMMON_OFFSET, features, u32, and vpm_iowrite32().

Referenced by virtnet_open_modern().

◆ vpm_get()

static void vpm_get	(	struct virtio_pci_modern_device *	vdev,
		unsigned	offset,
		void *	buf,
		unsigned	len
	)

inlinestatic

Definition at line 285 of file virtio-pci.h.

 {
     u8 *ptr = buf;
     unsigned i;
 
     for (i = 0; i < len; i++)
         ptr[i] = vpm_ioread8(vdev, &vdev->device, offset + i);
 }

References virtio_pci_modern_device::device, len, offset, and vpm_ioread8().

Referenced by virtnet_probe_modern().

◆ vpm_get_isr()

static u8 vpm_get_isr ( struct virtio_pci_modern_device * vdev )

inlinestatic

Definition at line 295 of file virtio-pci.h.

 {
     return vpm_ioread8(vdev, &vdev->isr, 0);
 }

References virtio_pci_modern_device::isr, and vpm_ioread8().

Referenced by virtnet_poll().

◆ 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, 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, vring_virtqueue::dma, 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, 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().

◆ 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 align, virtio_pci_region::bar, virtio_pci_region::base, 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, 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().

Data Structures

Macros

Functions

Macro Definition Documentation

◆ VIRTIO_PCI_HOST_FEATURES

◆ VIRTIO_PCI_GUEST_FEATURES

◆ VIRTIO_PCI_QUEUE_PFN

◆ VIRTIO_PCI_QUEUE_NUM

◆ VIRTIO_PCI_QUEUE_SEL

◆ VIRTIO_PCI_QUEUE_NOTIFY

◆ VIRTIO_PCI_STATUS

◆ VIRTIO_PCI_ISR

◆ VIRTIO_PCI_ISR_CONFIG

◆ VIRTIO_PCI_CONFIG

◆ VIRTIO_PCI_ABI_VERSION

◆ VIRTIO_PCI_CAP_COMMON_CFG

◆ VIRTIO_PCI_CAP_NOTIFY_CFG

◆ VIRTIO_PCI_CAP_ISR_CFG

◆ VIRTIO_PCI_CAP_DEVICE_CFG

◆ VIRTIO_PCI_CAP_PCI_CFG

◆ __u8

◆ __le16

◆ __le32

◆ __le64

◆ VIRTIO_PCI_REGION_TYPE_MASK

◆ VIRTIO_PCI_REGION_MEMORY

◆ VIRTIO_PCI_REGION_PORT

◆ VIRTIO_PCI_REGION_PCI_CONFIG

◆ COMMON_OFFSET

Function Documentation

◆ vp_get_features()

◆ vp_set_features()

◆ vp_get()

◆ vp_get_status()

◆ vp_set_status()

◆ vp_get_isr()

◆ vp_reset()

◆ vp_notify()

◆ vp_del_vq()

◆ vp_free_vq()

◆ vp_find_vq()

◆ vpm_iowrite8()

◆ vpm_iowrite16()

◆ vpm_iowrite32()

◆ vpm_iowrite64()

◆ vpm_ioread8()

◆ vpm_ioread16()

◆ vpm_ioread32()

◆ vpm_reset()

◆ vpm_get_status()

◆ vpm_add_status()

◆ vpm_get_features()

◆ vpm_set_features()

◆ vpm_get()

◆ vpm_get_isr()

◆ vpm_notify()

◆ vpm_find_vqs()

◆ virtio_pci_find_capability()

◆ virtio_pci_map_capability()

◆ virtio_pci_unmap_capability()