tests/qtest/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 "virtio.h"
  14 #include "virtio-mmio.h"
  15 #include "malloc.h"
  16 #include "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 uint64_t qvirtio_mmio_get_features(QVirtioDevice *d)
  44 {
  45     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
  46     uint64_t lo;
  47     uint64_t hi = 0;
  48
  49     qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 0);
  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;
  58 }
  59
  60 static void qvirtio_mmio_set_features(QVirtioDevice *d, uint64_t features)
  61 {
  62     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
  63     dev->features = features;
  64     qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 0);
  65     qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES, features);
  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     }
  72 }
  73
  74 static uint64_t qvirtio_mmio_get_guest_features(QVirtioDevice *d)
  75 {
  76     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
  77     return dev->features;
  78 }
  79
  80 static uint8_t qvirtio_mmio_get_status(QVirtioDevice *d)
  81 {
  82     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
  83     return (uint8_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS);
  84 }
  85
  86 static void qvirtio_mmio_set_status(QVirtioDevice *d, uint8_t status)
  87 {
  88     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
  89     qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS, (uint32_t)status);
  90 }
  91
  92 static bool qvirtio_mmio_get_queue_isr_status(QVirtioDevice *d, QVirtQueue *vq)
  93 {
  94     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
  95     uint32_t isr;
  96
  97     isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 1;
  98     if (isr != 0) {
  99         qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 1);
 100         return true;
 101     }
 102
 103     return false;
 104 }
 105
 106 static bool qvirtio_mmio_get_config_isr_status(QVirtioDevice *d)
 107 {
 108     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
 109     uint32_t isr;
 110
 111     isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 2;
 112     if (isr != 0) {
 113         qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 2);
 114         return true;
 115     }
 116
 117     return false;
 118 }
 119
 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
 132 static void qvirtio_mmio_queue_select(QVirtioDevice *d, uint16_t index)
 133 {
 134     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
 135     qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_SEL, (uint32_t)index);
 136
 137     g_assert_cmphex(qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN), ==, 0);
 138 }
 139
 140 static uint16_t qvirtio_mmio_get_queue_size(QVirtioDevice *d)
 141 {
 142     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
 143     return (uint16_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM_MAX);
 144 }
 145
 146 static void qvirtio_mmio_set_queue_address(QVirtioDevice *d, QVirtQueue *vq)
 147 {
 148     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
 149     uint64_t pfn = vq->desc / dev->page_size;
 150
 151     qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN, pfn);
 152 }
 153
 154 static QVirtQueue *qvirtio_mmio_virtqueue_setup(QVirtioDevice *d,
 155                                         QGuestAllocator *alloc, uint16_t index)
 156 {
 157     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
 158     QVirtQueue *vq;
 159     uint64_t addr;
 160
 161     vq = g_malloc0(sizeof(*vq));
 162     vq->vdev = d;
 163     qvirtio_mmio_queue_select(d, index);
 164     qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_ALIGN, dev->page_size);
 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;
 171     vq->indirect = dev->features & (1ull << VIRTIO_RING_F_INDIRECT_DESC);
 172     vq->event = dev->features & (1ull << VIRTIO_RING_F_EVENT_IDX);
 173
 174     qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM, vq->size);
 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));
 183     qvring_init(dev->qts, alloc, vq, addr);
 184     qvirtio_mmio_set_queue_address(d, vq);
 185
 186     return vq;
 187 }
 188
 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
 196 static void qvirtio_mmio_virtqueue_kick(QVirtioDevice *d, QVirtQueue *vq)
 197 {
 198     QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
 199     qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NOTIFY, vq->index);
 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,
 213     .wait_config_isr_status = qvirtio_mmio_wait_config_isr_status,
 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,
 218     .virtqueue_cleanup = qvirtio_mmio_virtqueue_cleanup,
 219     .virtqueue_kick = qvirtio_mmio_virtqueue_kick,
 220 };
 221
 222 static void *qvirtio_mmio_get_driver(void *obj, const char *interface)
 223 {
 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 }
 237
 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);
 243     g_assert(magic == ('v' | 'i' << 8 | 'r' << 16 | 't' << 24));
 244
 245     dev->version = qtest_readl(qts, addr + QVIRTIO_MMIO_VERSION);
 246     g_assert(dev->version == 1 || dev->version == 2);
 247
 248     dev->qts = qts;
 249     dev->addr = addr;
 250     dev->page_size = page_size;
 251     dev->vdev.device_type = qtest_readl(qts, addr + QVIRTIO_MMIO_DEVICE_ID);
 252     dev->vdev.bus = &qvirtio_mmio;
 253
 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 }
 259
 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");
 264 }
 265
 266 libqos_init(virtio_mmio_register_nodes);