tests/libqos/virtio-mmio.c

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