[qemu.git] / tests / libqos / virtio.h

/*
 * libqos virtio definitions
 *
 * Copyright (c) 2014 Marc Marí
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#ifndef LIBQOS_VIRTIO_H
#define LIBQOS_VIRTIO_H

#include "libqos/malloc.h"

#define QVIRTIO_VENDOR_ID       0x1AF4

#define QVIRTIO_RESET           0x0
#define QVIRTIO_ACKNOWLEDGE     0x1
#define QVIRTIO_DRIVER          0x2
#define QVIRTIO_DRIVER_OK       0x4

#define QVIRTIO_NET_DEVICE_ID       0x1
#define QVIRTIO_BLK_DEVICE_ID       0x2
#define QVIRTIO_CONSOLE_DEVICE_ID   0x3
#define QVIRTIO_RNG_DEVICE_ID       0x4
#define QVIRTIO_BALLOON_DEVICE_ID   0x5
#define QVIRTIO_RPMSG_DEVICE_ID     0x7
#define QVIRTIO_SCSI_DEVICE_ID      0x8
#define QVIRTIO_9P_DEVICE_ID        0x9

#define QVIRTIO_F_NOTIFY_ON_EMPTY       0x01000000
#define QVIRTIO_F_ANY_LAYOUT            0x08000000
#define QVIRTIO_F_RING_INDIRECT_DESC    0x10000000
#define QVIRTIO_F_RING_EVENT_IDX        0x20000000
#define QVIRTIO_F_BAD_FEATURE           0x40000000

#define QVRING_DESC_F_NEXT      0x1
#define QVRING_DESC_F_WRITE     0x2
#define QVRING_DESC_F_INDIRECT  0x4

#define QVIRTIO_F_NOTIFY_ON_EMPTY       0x01000000
#define QVIRTIO_F_ANY_LAYOUT            0x08000000
#define QVIRTIO_F_RING_INDIRECT_DESC    0x10000000
#define QVIRTIO_F_RING_EVENT_IDX        0x20000000
#define QVIRTIO_F_BAD_FEATURE           0x40000000

#define QVRING_AVAIL_F_NO_INTERRUPT     1

#define QVRING_USED_F_NO_NOTIFY     1

typedef struct QVirtioDevice {
    /* Device type */
    uint16_t device_type;
} QVirtioDevice;

typedef struct QVRingDesc {
    uint64_t addr;
    uint32_t len;
    uint16_t flags;
    uint16_t next;
} QVRingDesc;

typedef struct QVRingAvail {
    uint16_t flags;
    uint16_t idx;
    uint16_t ring[0]; /* This is an array of uint16_t */
    uint16_t used_event;
} QVRingAvail;

typedef struct QVRingUsedElem {
    uint32_t id;
    uint32_t len;
} QVRingUsedElem;

typedef struct QVRingUsed {
    uint16_t flags;
    uint16_t idx;
    QVRingUsedElem ring[0]; /* This is an array of QVRingUsedElem structs */
    uint16_t avail_event;
} QVRingUsed;

typedef struct QVirtQueue {
    uint64_t desc; /* This points to an array of QVRingDesc */
    uint64_t avail; /* This points to a QVRingAvail */
    uint64_t used; /* This points to a QVRingDesc */
    uint16_t index;
    uint32_t size;
    uint32_t free_head;
    uint32_t num_free;
    uint32_t align;
    bool indirect;
    bool event;
} QVirtQueue;

typedef struct QVRingIndirectDesc {
    uint64_t desc; /* This points to an array fo QVRingDesc */
    uint16_t index;
    uint16_t elem;
} QVRingIndirectDesc;

typedef struct QVirtioBus {
    uint8_t (*config_readb)(QVirtioDevice *d, uint64_t addr);
    uint16_t (*config_readw)(QVirtioDevice *d, uint64_t addr);
    uint32_t (*config_readl)(QVirtioDevice *d, uint64_t addr);
    uint64_t (*config_readq)(QVirtioDevice *d, uint64_t addr);

    /* Get features of the device */
    uint32_t (*get_features)(QVirtioDevice *d);

    /* Set features of the device */
    void (*set_features)(QVirtioDevice *d, uint32_t features);

    /* Get features of the guest */
    uint32_t (*get_guest_features)(QVirtioDevice *d);

    /* Get status of the device */
    uint8_t (*get_status)(QVirtioDevice *d);

    /* Set status of the device  */
    void (*set_status)(QVirtioDevice *d, uint8_t status);

    /* Get the queue ISR status of the device */
    bool (*get_queue_isr_status)(QVirtioDevice *d, QVirtQueue *vq);

    /* Get the configuration ISR status of the device */
    bool (*get_config_isr_status)(QVirtioDevice *d);

    /* Select a queue to work on */
    void (*queue_select)(QVirtioDevice *d, uint16_t index);

    /* Get the size of the selected queue */
    uint16_t (*get_queue_size)(QVirtioDevice *d);

    /* Set the address of the selected queue */
    void (*set_queue_address)(QVirtioDevice *d, uint32_t pfn);

    /* Setup the virtqueue specified by index */
    QVirtQueue *(*virtqueue_setup)(QVirtioDevice *d, QGuestAllocator *alloc,
                                                                uint16_t index);

    /* Notify changes in virtqueue */
    void (*virtqueue_kick)(QVirtioDevice *d, QVirtQueue *vq);
} QVirtioBus;

static inline uint32_t qvring_size(uint32_t num, uint32_t align)
{
    return ((sizeof(struct QVRingDesc) * num + sizeof(uint16_t) * (3 + num)
        + align - 1) & ~(align - 1))
        + sizeof(uint16_t) * 3 + sizeof(struct QVRingUsedElem) * num;
}

uint8_t qvirtio_config_readb(const QVirtioBus *bus, QVirtioDevice *d,
                                                                uint64_t addr);
uint16_t qvirtio_config_readw(const QVirtioBus *bus, QVirtioDevice *d,
                                                                uint64_t addr);
uint32_t qvirtio_config_readl(const QVirtioBus *bus, QVirtioDevice *d,
                                                                uint64_t addr);
uint64_t qvirtio_config_readq(const QVirtioBus *bus, QVirtioDevice *d,
                                                                uint64_t addr);
uint32_t qvirtio_get_features(const QVirtioBus *bus, QVirtioDevice *d);
void qvirtio_set_features(const QVirtioBus *bus, QVirtioDevice *d,
                                                            uint32_t features);

void qvirtio_reset(const QVirtioBus *bus, QVirtioDevice *d);
void qvirtio_set_acknowledge(const QVirtioBus *bus, QVirtioDevice *d);
void qvirtio_set_driver(const QVirtioBus *bus, QVirtioDevice *d);
void qvirtio_set_driver_ok(const QVirtioBus *bus, QVirtioDevice *d);

void qvirtio_wait_queue_isr(const QVirtioBus *bus, QVirtioDevice *d,
                            QVirtQueue *vq, gint64 timeout_us);
uint8_t qvirtio_wait_status_byte_no_isr(const QVirtioBus *bus,
                                        QVirtioDevice *d,
                                        QVirtQueue *vq,
                                        uint64_t addr,
                                        gint64 timeout_us);
void qvirtio_wait_config_isr(const QVirtioBus *bus, QVirtioDevice *d,
                             gint64 timeout_us);
QVirtQueue *qvirtqueue_setup(const QVirtioBus *bus, QVirtioDevice *d,
                                        QGuestAllocator *alloc, uint16_t index);

void qvring_init(const QGuestAllocator *alloc, QVirtQueue *vq, uint64_t addr);
QVRingIndirectDesc *qvring_indirect_desc_setup(QVirtioDevice *d,
                                        QGuestAllocator *alloc, uint16_t elem);
void qvring_indirect_desc_add(QVRingIndirectDesc *indirect, uint64_t data,
                                                    uint32_t len, bool write);
uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write,
                                                                    bool next);
uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect);
void qvirtqueue_kick(const QVirtioBus *bus, QVirtioDevice *d, QVirtQueue *vq,
                                                            uint32_t free_head);

void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx);
#endif
Commit	Line	Data
311e666a MM	1	/*
	2	* libqos virtio definitions
	3	*
	4	* Copyright (c) 2014 Marc Marí
	5	*
	6	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	7	* See the COPYING file in the top-level directory.
	8	*/
	9
	10	#ifndef LIBQOS_VIRTIO_H
	11	#define LIBQOS_VIRTIO_H
	12
bf3c63d2 MM	13	#include "libqos/malloc.h"
bf3c63d2 MM	14
311e666a MM	15	#define QVIRTIO_VENDOR_ID 0x1AF4
311e666a MM	16
46e0cf76 MM	17	#define QVIRTIO_RESET 0x0
	18	#define QVIRTIO_ACKNOWLEDGE 0x1
	19	#define QVIRTIO_DRIVER 0x2
bf3c63d2	20	#define QVIRTIO_DRIVER_OK 0x4
46e0cf76	21
bea2f098 FZ	22	#define QVIRTIO_NET_DEVICE_ID 0x1
	23	#define QVIRTIO_BLK_DEVICE_ID 0x2
	24	#define QVIRTIO_CONSOLE_DEVICE_ID 0x3
	25	#define QVIRTIO_RNG_DEVICE_ID 0x4
	26	#define QVIRTIO_BALLOON_DEVICE_ID 0x5
	27	#define QVIRTIO_RPMSG_DEVICE_ID 0x7
	28	#define QVIRTIO_SCSI_DEVICE_ID 0x8
	29	#define QVIRTIO_9P_DEVICE_ID 0x9
311e666a	30
f294b029 MM	31	#define QVIRTIO_F_NOTIFY_ON_EMPTY 0x01000000
	32	#define QVIRTIO_F_ANY_LAYOUT 0x08000000
	33	#define QVIRTIO_F_RING_INDIRECT_DESC 0x10000000
	34	#define QVIRTIO_F_RING_EVENT_IDX 0x20000000
1053587c	35	#define QVIRTIO_F_BAD_FEATURE 0x40000000
f294b029	36
bf3c63d2 MM	37	#define QVRING_DESC_F_NEXT 0x1
	38	#define QVRING_DESC_F_WRITE 0x2
	39	#define QVRING_DESC_F_INDIRECT 0x4
	40
	41	#define QVIRTIO_F_NOTIFY_ON_EMPTY 0x01000000
	42	#define QVIRTIO_F_ANY_LAYOUT 0x08000000
	43	#define QVIRTIO_F_RING_INDIRECT_DESC 0x10000000
	44	#define QVIRTIO_F_RING_EVENT_IDX 0x20000000
	45	#define QVIRTIO_F_BAD_FEATURE 0x40000000
	46
	47	#define QVRING_AVAIL_F_NO_INTERRUPT 1
	48
	49	#define QVRING_USED_F_NO_NOTIFY 1
	50
311e666a MM	51	typedef struct QVirtioDevice {
	52	/* Device type */
	53	uint16_t device_type;
	54	} QVirtioDevice;
	55
bf3c63d2 MM	56	typedef struct QVRingDesc {
	57	uint64_t addr;
	58	uint32_t len;
	59	uint16_t flags;
	60	uint16_t next;
	61	} QVRingDesc;
	62
	63	typedef struct QVRingAvail {
	64	uint16_t flags;
	65	uint16_t idx;
	66	uint16_t ring[0]; /* This is an array of uint16_t */
1053587c	67	uint16_t used_event;
bf3c63d2 MM	68	} QVRingAvail;
	69
	70	typedef struct QVRingUsedElem {
	71	uint32_t id;
	72	uint32_t len;
	73	} QVRingUsedElem;
	74
	75	typedef struct QVRingUsed {
	76	uint16_t flags;
	77	uint16_t idx;
	78	QVRingUsedElem ring[0]; /* This is an array of QVRingUsedElem structs */
1053587c	79	uint16_t avail_event;
bf3c63d2 MM	80	} QVRingUsed;
	81
	82	typedef struct QVirtQueue {
	83	uint64_t desc; /* This points to an array of QVRingDesc */
	84	uint64_t avail; /* This points to a QVRingAvail */
	85	uint64_t used; /* This points to a QVRingDesc */
	86	uint16_t index;
	87	uint32_t size;
	88	uint32_t free_head;
	89	uint32_t num_free;
	90	uint32_t align;
f294b029	91	bool indirect;
1053587c	92	bool event;
bf3c63d2 MM	93	} QVirtQueue;
bf3c63d2 MM	94
f294b029 MM	95	typedef struct QVRingIndirectDesc {
	96	uint64_t desc; /* This points to an array fo QVRingDesc */
	97	uint16_t index;
	98	uint16_t elem;
	99	} QVRingIndirectDesc;
	100
46e0cf76	101	typedef struct QVirtioBus {
728312b8 MM	102	uint8_t (config_readb)(QVirtioDevice d, uint64_t addr);
	103	uint16_t (config_readw)(QVirtioDevice d, uint64_t addr);
	104	uint32_t (config_readl)(QVirtioDevice d, uint64_t addr);
	105	uint64_t (config_readq)(QVirtioDevice d, uint64_t addr);
46e0cf76	106
bf3c63d2 MM	107	/* Get features of the device */
	108	uint32_t (get_features)(QVirtioDevice d);
	109
f294b029	110	/* Set features of the device */
bf3c63d2 MM	111	void (set_features)(QVirtioDevice d, uint32_t features);
bf3c63d2 MM	112
f294b029 MM	113	/* Get features of the guest */
	114	uint32_t (get_guest_features)(QVirtioDevice d);
	115
46e0cf76 MM	116	/* Get status of the device */
	117	uint8_t (get_status)(QVirtioDevice d);
	118
	119	/* Set status of the device */
	120	void (set_status)(QVirtioDevice d, uint8_t status);
bf3c63d2	121
58368113 MM	122	/* Get the queue ISR status of the device */
	123	bool (get_queue_isr_status)(QVirtioDevice d, QVirtQueue *vq);
	124
	125	/* Get the configuration ISR status of the device */
	126	bool (get_config_isr_status)(QVirtioDevice d);
bf3c63d2 MM	127
	128	/* Select a queue to work on */
	129	void (queue_select)(QVirtioDevice d, uint16_t index);
	130
	131	/* Get the size of the selected queue */
	132	uint16_t (get_queue_size)(QVirtioDevice d);
	133
	134	/* Set the address of the selected queue */
	135	void (set_queue_address)(QVirtioDevice d, uint32_t pfn);
	136
	137	/* Setup the virtqueue specified by index */
	138	QVirtQueue (virtqueue_setup)(QVirtioDevice d, QGuestAllocator alloc,
	139	uint16_t index);
	140
	141	/* Notify changes in virtqueue */
	142	void (virtqueue_kick)(QVirtioDevice d, QVirtQueue *vq);
46e0cf76 MM	143	} QVirtioBus;
46e0cf76 MM	144
bf3c63d2 MM	145	static inline uint32_t qvring_size(uint32_t num, uint32_t align)
	146	{
	147	return ((sizeof(struct QVRingDesc) * num + sizeof(uint16_t) * (3 + num)
	148	+ align - 1) & ~(align - 1))
	149	+ sizeof(uint16_t) * 3 + sizeof(struct QVRingUsedElem) * num;
	150	}
	151
46e0cf76	152	uint8_t qvirtio_config_readb(const QVirtioBus bus, QVirtioDevice d,
728312b8	153	uint64_t addr);
46e0cf76	154	uint16_t qvirtio_config_readw(const QVirtioBus bus, QVirtioDevice d,
728312b8	155	uint64_t addr);
46e0cf76	156	uint32_t qvirtio_config_readl(const QVirtioBus bus, QVirtioDevice d,
728312b8	157	uint64_t addr);
46e0cf76	158	uint64_t qvirtio_config_readq(const QVirtioBus bus, QVirtioDevice d,
728312b8	159	uint64_t addr);
bf3c63d2 MM	160	uint32_t qvirtio_get_features(const QVirtioBus bus, QVirtioDevice d);
	161	void qvirtio_set_features(const QVirtioBus bus, QVirtioDevice d,
	162	uint32_t features);
46e0cf76 MM	163
	164	void qvirtio_reset(const QVirtioBus bus, QVirtioDevice d);
	165	void qvirtio_set_acknowledge(const QVirtioBus bus, QVirtioDevice d);
	166	void qvirtio_set_driver(const QVirtioBus bus, QVirtioDevice d);
bf3c63d2 MM	167	void qvirtio_set_driver_ok(const QVirtioBus bus, QVirtioDevice d);
bf3c63d2 MM	168
70556264 SH	169	void qvirtio_wait_queue_isr(const QVirtioBus bus, QVirtioDevice d,
70556264 SH	170	QVirtQueue *vq, gint64 timeout_us);
e8c81b4d SH	171	uint8_t qvirtio_wait_status_byte_no_isr(const QVirtioBus *bus,
	172	QVirtioDevice *d,
	173	QVirtQueue *vq,
	174	uint64_t addr,
	175	gint64 timeout_us);
70556264 SH	176	void qvirtio_wait_config_isr(const QVirtioBus bus, QVirtioDevice d,
70556264 SH	177	gint64 timeout_us);
bf3c63d2 MM	178	QVirtQueue qvirtqueue_setup(const QVirtioBus bus, QVirtioDevice *d,
	179	QGuestAllocator *alloc, uint16_t index);
	180
	181	void qvring_init(const QGuestAllocator alloc, QVirtQueue vq, uint64_t addr);
f294b029 MM	182	QVRingIndirectDesc qvring_indirect_desc_setup(QVirtioDevice d,
	183	QGuestAllocator *alloc, uint16_t elem);
	184	void qvring_indirect_desc_add(QVRingIndirectDesc *indirect, uint64_t data,
	185	uint32_t len, bool write);
bf3c63d2 MM	186	uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write,
bf3c63d2 MM	187	bool next);
f294b029	188	uint32_t qvirtqueue_add_indirect(QVirtQueue vq, QVRingIndirectDesc indirect);
bf3c63d2 MM	189	void qvirtqueue_kick(const QVirtioBus bus, QVirtioDevice d, QVirtQueue *vq,
bf3c63d2 MM	190	uint32_t free_head);
46e0cf76	191
1053587c	192	void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx);
311e666a	193	#endif