[qemu.git] / tests / libqos / virtio-mmio.c

/*
 * libqos virtio MMIO driver
 *
 * 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.
 */

#include "qemu/osdep.h"
#include "libqtest.h"
#include "qemu/module.h"
#include "libqos/virtio.h"
#include "libqos/virtio-mmio.h"
#include "libqos/malloc.h"
#include "libqos/qgraph.h"
#include "standard-headers/linux/virtio_ring.h"

static uint8_t qvirtio_mmio_config_readb(QVirtioDevice *d, uint64_t off)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    return qtest_readb(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
}

static uint16_t qvirtio_mmio_config_readw(QVirtioDevice *d, uint64_t off)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    return qtest_readw(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
}

static uint32_t qvirtio_mmio_config_readl(QVirtioDevice *d, uint64_t off)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    return qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
}

static uint64_t qvirtio_mmio_config_readq(QVirtioDevice *d, uint64_t off)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    return qtest_readq(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
}

static uint64_t qvirtio_mmio_get_features(QVirtioDevice *d)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    uint64_t lo;
    uint64_t hi = 0;

    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 0);
    lo = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES);

    if (dev->version >= 2) {
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 1);
        hi = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES);
    }

    return (hi << 32) | lo;
}

static void qvirtio_mmio_set_features(QVirtioDevice *d, uint64_t features)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    dev->features = features;
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 0);
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES, features);

    if (dev->version >= 2) {
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 1);
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES,
                     features >> 32);
    }
}

static uint64_t qvirtio_mmio_get_guest_features(QVirtioDevice *d)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    return dev->features;
}

static uint8_t qvirtio_mmio_get_status(QVirtioDevice *d)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    return (uint8_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS);
}

static void qvirtio_mmio_set_status(QVirtioDevice *d, uint8_t status)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS, (uint32_t)status);
}

static bool qvirtio_mmio_get_queue_isr_status(QVirtioDevice *d, QVirtQueue *vq)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    uint32_t isr;

    isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 1;
    if (isr != 0) {
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 1);
        return true;
    }

    return false;
}

static bool qvirtio_mmio_get_config_isr_status(QVirtioDevice *d)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    uint32_t isr;

    isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 2;
    if (isr != 0) {
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 2);
        return true;
    }

    return false;
}

static void qvirtio_mmio_wait_config_isr_status(QVirtioDevice *d,
                                                gint64 timeout_us)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    gint64 start_time = g_get_monotonic_time();

    do {
        g_assert(g_get_monotonic_time() - start_time <= timeout_us);
        qtest_clock_step(dev->qts, 100);
    } while (!qvirtio_mmio_get_config_isr_status(d));
}

static void qvirtio_mmio_queue_select(QVirtioDevice *d, uint16_t index)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_SEL, (uint32_t)index);

    g_assert_cmphex(qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN), ==, 0);
}

static uint16_t qvirtio_mmio_get_queue_size(QVirtioDevice *d)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    return (uint16_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM_MAX);
}

static void qvirtio_mmio_set_queue_address(QVirtioDevice *d, QVirtQueue *vq)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    uint64_t pfn = vq->desc / dev->page_size;

    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN, pfn);
}

static QVirtQueue *qvirtio_mmio_virtqueue_setup(QVirtioDevice *d,
                                        QGuestAllocator *alloc, uint16_t index)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    QVirtQueue *vq;
    uint64_t addr;

    vq = g_malloc0(sizeof(*vq));
    vq->vdev = d;
    qvirtio_mmio_queue_select(d, index);
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_ALIGN, dev->page_size);

    vq->index = index;
    vq->size = qvirtio_mmio_get_queue_size(d);
    vq->free_head = 0;
    vq->num_free = vq->size;
    vq->align = dev->page_size;
    vq->indirect = dev->features & (1ull << VIRTIO_RING_F_INDIRECT_DESC);
    vq->event = dev->features & (1ull << VIRTIO_RING_F_EVENT_IDX);

    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM, vq->size);

    /* Check different than 0 */
    g_assert_cmpint(vq->size, !=, 0);

    /* Check power of 2 */
    g_assert_cmpint(vq->size & (vq->size - 1), ==, 0);

    addr = guest_alloc(alloc, qvring_size(vq->size, dev->page_size));
    qvring_init(dev->qts, alloc, vq, addr);
    qvirtio_mmio_set_queue_address(d, vq);

    return vq;
}

static void qvirtio_mmio_virtqueue_cleanup(QVirtQueue *vq,
                                           QGuestAllocator *alloc)
{
    guest_free(alloc, vq->desc);
    g_free(vq);
}

static void qvirtio_mmio_virtqueue_kick(QVirtioDevice *d, QVirtQueue *vq)
{
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NOTIFY, vq->index);
}

const QVirtioBus qvirtio_mmio = {
    .config_readb = qvirtio_mmio_config_readb,
    .config_readw = qvirtio_mmio_config_readw,
    .config_readl = qvirtio_mmio_config_readl,
    .config_readq = qvirtio_mmio_config_readq,
    .get_features = qvirtio_mmio_get_features,
    .set_features = qvirtio_mmio_set_features,
    .get_guest_features = qvirtio_mmio_get_guest_features,
    .get_status = qvirtio_mmio_get_status,
    .set_status = qvirtio_mmio_set_status,
    .get_queue_isr_status = qvirtio_mmio_get_queue_isr_status,
    .wait_config_isr_status = qvirtio_mmio_wait_config_isr_status,
    .queue_select = qvirtio_mmio_queue_select,
    .get_queue_size = qvirtio_mmio_get_queue_size,
    .set_queue_address = qvirtio_mmio_set_queue_address,
    .virtqueue_setup = qvirtio_mmio_virtqueue_setup,
    .virtqueue_cleanup = qvirtio_mmio_virtqueue_cleanup,
    .virtqueue_kick = qvirtio_mmio_virtqueue_kick,
};

static void *qvirtio_mmio_get_driver(void *obj, const char *interface)
{
    QVirtioMMIODevice *virtio_mmio = obj;
    if (!g_strcmp0(interface, "virtio-bus")) {
        return &virtio_mmio->vdev;
    }
    fprintf(stderr, "%s not present in virtio-mmio\n", interface);
    g_assert_not_reached();
}

static void qvirtio_mmio_start_hw(QOSGraphObject *obj)
{
    QVirtioMMIODevice *dev = (QVirtioMMIODevice *) obj;
    qvirtio_start_device(&dev->vdev);
}

void qvirtio_mmio_init_device(QVirtioMMIODevice *dev, QTestState *qts,
                              uint64_t addr, uint32_t page_size)
{
    uint32_t magic;
    magic = qtest_readl(qts, addr + QVIRTIO_MMIO_MAGIC_VALUE);
    g_assert(magic == ('v' | 'i' << 8 | 'r' << 16 | 't' << 24));

    dev->version = qtest_readl(qts, addr + QVIRTIO_MMIO_VERSION);
    g_assert(dev->version == 1 || dev->version == 2);

    dev->qts = qts;
    dev->addr = addr;
    dev->page_size = page_size;
    dev->vdev.device_type = qtest_readl(qts, addr + QVIRTIO_MMIO_DEVICE_ID);
    dev->vdev.bus = &qvirtio_mmio;

    qtest_writel(qts, addr + QVIRTIO_MMIO_GUEST_PAGE_SIZE, page_size);

    dev->obj.get_driver = qvirtio_mmio_get_driver;
    dev->obj.start_hw = qvirtio_mmio_start_hw;
}

static void virtio_mmio_register_nodes(void)
{
    qos_node_create_driver("virtio-mmio", NULL);
    qos_node_produces("virtio-mmio", "virtio-bus");
}

libqos_init(virtio_mmio_register_nodes);
Commit	Line	Data
0a6ed700 MM	1	/*
	2	* libqos virtio MMIO driver
	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
681c28a3	10	#include "qemu/osdep.h"
0a6ed700	11	#include "libqtest.h"
0b8fa32f	12	#include "qemu/module.h"
0a6ed700 MM	13	#include "libqos/virtio.h"
	14	#include "libqos/virtio-mmio.h"
	15	#include "libqos/malloc.h"
57ed038a	16	#include "libqos/qgraph.h"
ee3b850a	17	#include "standard-headers/linux/virtio_ring.h"
0a6ed700	18
246fc0fb	19	static uint8_t qvirtio_mmio_config_readb(QVirtioDevice *d, uint64_t off)
0a6ed700	20	{
57ed038a EGE	21	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
57ed038a EGE	22	return qtest_readb(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
0a6ed700 MM	23	}
0a6ed700 MM	24
246fc0fb	25	static uint16_t qvirtio_mmio_config_readw(QVirtioDevice *d, uint64_t off)
0a6ed700	26	{
57ed038a EGE	27	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
57ed038a EGE	28	return qtest_readw(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
0a6ed700 MM	29	}
0a6ed700 MM	30
246fc0fb	31	static uint32_t qvirtio_mmio_config_readl(QVirtioDevice *d, uint64_t off)
0a6ed700	32	{
57ed038a EGE	33	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
57ed038a EGE	34	return qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
0a6ed700 MM	35	}
0a6ed700 MM	36
246fc0fb	37	static uint64_t qvirtio_mmio_config_readq(QVirtioDevice *d, uint64_t off)
0a6ed700	38	{
57ed038a EGE	39	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
57ed038a EGE	40	return qtest_readq(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
0a6ed700 MM	41	}
0a6ed700 MM	42
a9340358	43	static uint64_t qvirtio_mmio_get_features(QVirtioDevice *d)
0a6ed700	44	{
57ed038a	45	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
a9340358 SH	46	uint64_t lo;
	47	uint64_t hi = 0;
	48
57ed038a	49	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 0);
a9340358 SH	50	lo = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES);
	51
	52	if (dev->version >= 2) {
	53	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 1);
	54	hi = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES);
	55	}
	56
	57	return (hi << 32) \| lo;
0a6ed700 MM	58	}
0a6ed700 MM	59
a9340358	60	static void qvirtio_mmio_set_features(QVirtioDevice *d, uint64_t features)
0a6ed700	61	{
57ed038a	62	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
0a6ed700	63	dev->features = features;
57ed038a EGE	64	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 0);
57ed038a EGE	65	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES, features);
a9340358 SH	66
	67	if (dev->version >= 2) {
	68	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 1);
	69	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES,
	70	features >> 32);
	71	}
0a6ed700 MM	72	}
0a6ed700 MM	73
a9340358	74	static uint64_t qvirtio_mmio_get_guest_features(QVirtioDevice *d)
0a6ed700	75	{
57ed038a	76	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
0a6ed700 MM	77	return dev->features;
	78	}
	79
	80	static uint8_t qvirtio_mmio_get_status(QVirtioDevice *d)
	81	{
57ed038a EGE	82	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
57ed038a EGE	83	return (uint8_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS);
0a6ed700 MM	84	}
	85
	86	static void qvirtio_mmio_set_status(QVirtioDevice *d, uint8_t status)
	87	{
57ed038a EGE	88	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
57ed038a EGE	89	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS, (uint32_t)status);
0a6ed700 MM	90	}
	91
	92	static bool qvirtio_mmio_get_queue_isr_status(QVirtioDevice d, QVirtQueue vq)
	93	{
57ed038a	94	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
0a6ed700 MM	95	uint32_t isr;
0a6ed700 MM	96
57ed038a	97	isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 1;
0a6ed700	98	if (isr != 0) {
57ed038a	99	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 1);
0a6ed700 MM	100	return true;
	101	}
	102
	103	return false;
	104	}
	105
	106	static bool qvirtio_mmio_get_config_isr_status(QVirtioDevice *d)
	107	{
57ed038a	108	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
0a6ed700 MM	109	uint32_t isr;
0a6ed700 MM	110
57ed038a	111	isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 2;
0a6ed700	112	if (isr != 0) {
57ed038a	113	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 2);
0a6ed700 MM	114	return true;
	115	}
	116
	117	return false;
	118	}
	119
b57ebd57 TH	120	static void qvirtio_mmio_wait_config_isr_status(QVirtioDevice *d,
	121	gint64 timeout_us)
	122	{
	123	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
	124	gint64 start_time = g_get_monotonic_time();
	125
	126	do {
	127	g_assert(g_get_monotonic_time() - start_time <= timeout_us);
	128	qtest_clock_step(dev->qts, 100);
	129	} while (!qvirtio_mmio_get_config_isr_status(d));
	130	}
	131
0a6ed700 MM	132	static void qvirtio_mmio_queue_select(QVirtioDevice *d, uint16_t index)
0a6ed700 MM	133	{
57ed038a EGE	134	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
57ed038a EGE	135	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_SEL, (uint32_t)index);
0a6ed700	136
57ed038a	137	g_assert_cmphex(qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN), ==, 0);
0a6ed700 MM	138	}
	139
	140	static uint16_t qvirtio_mmio_get_queue_size(QVirtioDevice *d)
	141	{
57ed038a EGE	142	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
57ed038a EGE	143	return (uint16_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM_MAX);
0a6ed700 MM	144	}
0a6ed700 MM	145
1e59a866	146	static void qvirtio_mmio_set_queue_address(QVirtioDevice d, QVirtQueue vq)
0a6ed700	147	{
57ed038a	148	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
1e59a866 SH	149	uint64_t pfn = vq->desc / dev->page_size;
1e59a866 SH	150
57ed038a	151	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN, pfn);
0a6ed700 MM	152	}
	153
	154	static QVirtQueue qvirtio_mmio_virtqueue_setup(QVirtioDevice d,
	155	QGuestAllocator *alloc, uint16_t index)
	156	{
57ed038a	157	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
0a6ed700 MM	158	QVirtQueue *vq;
	159	uint64_t addr;
	160
	161	vq = g_malloc0(sizeof(*vq));
bccd82b4	162	vq->vdev = d;
0a6ed700	163	qvirtio_mmio_queue_select(d, index);
57ed038a	164	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_ALIGN, dev->page_size);
0a6ed700 MM	165
	166	vq->index = index;
	167	vq->size = qvirtio_mmio_get_queue_size(d);
	168	vq->free_head = 0;
	169	vq->num_free = vq->size;
	170	vq->align = dev->page_size;
a9340358 SH	171	vq->indirect = dev->features & (1ull << VIRTIO_RING_F_INDIRECT_DESC);
a9340358 SH	172	vq->event = dev->features & (1ull << VIRTIO_RING_F_EVENT_IDX);
0a6ed700	173
57ed038a	174	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM, vq->size);
0a6ed700 MM	175
	176	/* Check different than 0 */
	177	g_assert_cmpint(vq->size, !=, 0);
	178
	179	/* Check power of 2 */
	180	g_assert_cmpint(vq->size & (vq->size - 1), ==, 0);
	181
	182	addr = guest_alloc(alloc, qvring_size(vq->size, dev->page_size));
8b898f59	183	qvring_init(dev->qts, alloc, vq, addr);
1e59a866	184	qvirtio_mmio_set_queue_address(d, vq);
0a6ed700 MM	185
	186	return vq;
	187	}
	188
f1d3b991 SH	189	static void qvirtio_mmio_virtqueue_cleanup(QVirtQueue *vq,
	190	QGuestAllocator *alloc)
	191	{
	192	guest_free(alloc, vq->desc);
	193	g_free(vq);
	194	}
	195
0a6ed700 MM	196	static void qvirtio_mmio_virtqueue_kick(QVirtioDevice d, QVirtQueue vq)
0a6ed700 MM	197	{
57ed038a EGE	198	QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
57ed038a EGE	199	qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NOTIFY, vq->index);
0a6ed700 MM	200	}
	201
	202	const QVirtioBus qvirtio_mmio = {
	203	.config_readb = qvirtio_mmio_config_readb,
	204	.config_readw = qvirtio_mmio_config_readw,
	205	.config_readl = qvirtio_mmio_config_readl,
	206	.config_readq = qvirtio_mmio_config_readq,
	207	.get_features = qvirtio_mmio_get_features,
	208	.set_features = qvirtio_mmio_set_features,
	209	.get_guest_features = qvirtio_mmio_get_guest_features,
	210	.get_status = qvirtio_mmio_get_status,
	211	.set_status = qvirtio_mmio_set_status,
	212	.get_queue_isr_status = qvirtio_mmio_get_queue_isr_status,
b57ebd57	213	.wait_config_isr_status = qvirtio_mmio_wait_config_isr_status,
0a6ed700 MM	214	.queue_select = qvirtio_mmio_queue_select,
	215	.get_queue_size = qvirtio_mmio_get_queue_size,
	216	.set_queue_address = qvirtio_mmio_set_queue_address,
	217	.virtqueue_setup = qvirtio_mmio_virtqueue_setup,
f1d3b991	218	.virtqueue_cleanup = qvirtio_mmio_virtqueue_cleanup,
0a6ed700 MM	219	.virtqueue_kick = qvirtio_mmio_virtqueue_kick,
	220	};
	221
57ed038a	222	static void qvirtio_mmio_get_driver(void obj, const char *interface)
0a6ed700	223	{
57ed038a EGE	224	QVirtioMMIODevice *virtio_mmio = obj;
	225	if (!g_strcmp0(interface, "virtio-bus")) {
	226	return &virtio_mmio->vdev;
	227	}
	228	fprintf(stderr, "%s not present in virtio-mmio\n", interface);
	229	g_assert_not_reached();
	230	}
	231
	232	static void qvirtio_mmio_start_hw(QOSGraphObject *obj)
	233	{
	234	QVirtioMMIODevice dev = (QVirtioMMIODevice ) obj;
	235	qvirtio_start_device(&dev->vdev);
	236	}
0a6ed700	237
57ed038a EGE	238	void qvirtio_mmio_init_device(QVirtioMMIODevice dev, QTestState qts,
	239	uint64_t addr, uint32_t page_size)
	240	{
	241	uint32_t magic;
	242	magic = qtest_readl(qts, addr + QVIRTIO_MMIO_MAGIC_VALUE);
0a6ed700 MM	243	g_assert(magic == ('v' \| 'i' << 8 \| 'r' << 16 \| 't' << 24));
0a6ed700 MM	244
60ce3a40 SH	245	dev->version = qtest_readl(qts, addr + QVIRTIO_MMIO_VERSION);
	246	g_assert(dev->version == 1 \|\| dev->version == 2);
	247
57ed038a	248	dev->qts = qts;
0a6ed700 MM	249	dev->addr = addr;
0a6ed700 MM	250	dev->page_size = page_size;
57ed038a	251	dev->vdev.device_type = qtest_readl(qts, addr + QVIRTIO_MMIO_DEVICE_ID);
6b9cdf4c	252	dev->vdev.bus = &qvirtio_mmio;
0a6ed700	253
57ed038a EGE	254	qtest_writel(qts, addr + QVIRTIO_MMIO_GUEST_PAGE_SIZE, page_size);
	255
	256	dev->obj.get_driver = qvirtio_mmio_get_driver;
	257	dev->obj.start_hw = qvirtio_mmio_start_hw;
	258	}
0a6ed700	259
57ed038a EGE	260	static void virtio_mmio_register_nodes(void)
	261	{
	262	qos_node_create_driver("virtio-mmio", NULL);
	263	qos_node_produces("virtio-mmio", "virtio-bus");
0a6ed700	264	}
57ed038a EGE	265
57ed038a EGE	266	libqos_init(virtio_mmio_register_nodes);