virtio.h

Go to the documentation of this file.

 
#ifndef __VIRTIO_H__
#define __VIRTIO_H__
 
#include <stdint.h>
#include <stddef.h>
#if defined(__GNUC__) || defined(__clang__)
#ifndef __cplusplus
#include <stdbool.h>
#endif
#endif
 
struct VirtioCommonCfg {
    volatile uint32_t DevFeatureSelect;
    volatile uint32_t DevFeature;
    volatile uint32_t GuestFeatureSelect;
    volatile uint32_t GuestFeature;
    volatile uint16_t MSix;
    volatile uint16_t Queues;
    volatile uint8_t  DeviceStatus;
    volatile uint8_t  ConfigGeneration;
 
    volatile uint16_t QueueSelect;
    volatile uint16_t QueueSize;
    volatile uint16_t QueueMSixVector;
    volatile uint16_t QueueEnable;
    volatile uint16_t QueueNotifyOff;
 
    volatile uint64_t QueueDesc;
    volatile uint64_t QueueAvail;
    volatile uint64_t QueueUsed;
};
 
struct VirtioDeviceConfig {
    volatile uint8_t select;
    volatile uint8_t subsel;
    volatile uint8_t size;
    volatile uint8_t pad[5];
    union {
        struct {
            volatile uint32_t min;
            volatile uint32_t max;
            volatile uint32_t fuzz;
            volatile uint32_t flat;
            volatile uint32_t res;
        }tablet_data;
        uint8_t str[128];
    }data;
};
 
struct VirtioBuffer {
    uint64_t Addr;
    uint32_t Length;
    uint16_t Flags;
    uint16_t Next;
};
 
struct VirtioAvail {
    uint16_t flags;
    volatile uint16_t index;
    uint16_t ring[64];
    uint16_t int_index;
};
 
struct VirtioRing {
    uint32_t index;
    uint32_t length;
};
 
struct VirtioUsed {
    uint16_t flags;
    volatile uint16_t index;
    struct VirtioRing ring[64];
    uint16_t int_index;
};
 
struct VirtioQueue {
    struct VirtioBuffer buffers[64];
    struct VirtioAvail available;
    struct VirtioUsed used;
};
 
struct VirtioInputEvent {
    uint16_t type;
    uint16_t code;
    uint32_t value;
};
 
 
#define OFFSETOF(s,m) ((size_t)&(((s*)0)->m))
 
#define VIRTIO_NET_F_CSUM (1ULL << 0)
#define VIRTIO_NET_F_GUEST_CSUM (1ULL << 2)
#define VIRTIO_NET_F_MAC (1ULL << 5)
#define VIRTIO_NET_F_CTRL_VQ (1ULL << 17)
#define VIRTIO_NET_HDR_GSO_NONE 0
 
typedef struct _virtio_net_hdr_ {
    uint8_t flags;
    uint8_t gso_type;
    uint16_t hdr_len;
    uint16_t gso_size;
    uint16_t csum_start;
    uint16_t csum_offset;
    uint16_t padding;
}virtio_net_hdr_t;
 
 
typedef struct {
    uint8_t cap_vndr;
    uint8_t cap_next;
    uint8_t cap_len;
    uint8_t cfg_type;
    uint8_t bar;
    uint8_t padding[3];
    uint32_t offset;
    uint32_t length;
}virtio_pci_cap;
 
 
 
struct virtio_notifier_cap {
    virtio_pci_cap cap;
    uint32_t notifer_mult_base;
};
 
/* modern virtio-pci capability types, virtio-v1.1 sec 4.1.4 */
#define VIRTIO_PCI_CAP_VENDOR_ID  0x09 /* PCI capability ID for "vendor specific" */
#define VIRTIO_PCI_CAP_COMMON_CFG 1
#define VIRTIO_PCI_CAP_NOTIFY_CFG 2
#define VIRTIO_PCI_CAP_ISR_CFG    3
#define VIRTIO_PCI_CAP_DEVICE_CFG 4
#define VIRTIO_PCI_CAP_PCI_CFG    5
 
/* device status register bits, virtio-v1.1 sec 2.1 */
#define VIRTIO_STATUS_ACKNOWLEDGE         0x01
#define VIRTIO_STATUS_DRIVER              0x02
#define VIRTIO_STATUS_DRIVER_OK       0x04
#define VIRTIO_STATUS_FEATURES_OK         0x08
#define VIRTIO_STATUS_DEVICE_NEEDS_RESET 0x40
#define VIRTIO_STATUS_FAILED              0x80
 
/* bit 32 of the feature bitmap (high half, feature-select 1) --
 * required on every modern (non-transitional-legacy) negotiation --axiss */
#define VIRTIO_F_VERSION_1_BIT 32
 
#define VIRTQ_DESC_F_NEXT  1
#define VIRTQ_DESC_F_WRITE 2
#define VIRTIO_MSI_NO_VECTOR 0xFFFF
 
/* split-ring layout, sized to whatever queue size the device reports --
 * NOT the fixed 64-entry VirtioQueue above. Modern virtio-pci gives
 * QueueDesc/QueueAvail/QueueUsed as independent 64-bit addresses, so
 * these don't need to be contiguous or share a struct --axiss */
struct VirtqDesc {
    volatile uint64_t addr;
    volatile uint32_t len;
    volatile uint16_t flags;
    volatile uint16_t next;
};
 
struct VirtqAvailHdr {
    volatile uint16_t flags;
    volatile uint16_t idx;
    volatile uint16_t ring[];
};
 
struct VirtqUsedElem {
    volatile uint32_t id;
    volatile uint32_t len;
};
 
struct VirtqUsedHdr {
    volatile uint16_t flags;
    volatile uint16_t idx;
    volatile struct VirtqUsedElem ring[];
};
 
struct VirtioPCIDevice {
    uint64_t address;
    int bus, dev, func;
    struct VirtioCommonCfg* common;
    volatile uint8_t* isr;
    void* deviceCfg;
    uint8_t* notifyBase;
    uint32_t notifyOffMultiplier;
};
 
extern bool AuVirtioPCIInit(uint64_t address, int bus, int dev, int func,
                             uint32_t wantedFeaturesLow, struct VirtioPCIDevice* out);
 
extern uint16_t AuVirtioPCISetupQueue(struct VirtioPCIDevice* dev,
                                       uint16_t qidx,
                                       struct VirtqDesc** outDesc,
                                       struct VirtqAvailHdr** outAvail,
                                       struct VirtqUsedHdr** outUsed,
                                       uint16_t msixVector);
 
extern void AuVirtioPCINotifyQueue(struct VirtioPCIDevice* dev, uint16_t qidx);
 
extern void AuVirtioBlkInitialize(uint64_t device, int bus, int dev, int func);
 
extern void AuVirtioKbdInitialize(uint64_t device, int bus, int dev, int func);
 
extern void AuVirtioTabletInitialize(uint64_t device, int bus, int dev, int func);
 
extern void AuVirtioKbdDown();
 
extern void AuVirtioTabletDown();
 
extern void AuVirtioNetInitialize(uint64_t device);
#endif