virtio-mmio.c (8953B)
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 "libqos-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);