1 /* 2 * libqos virtio 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 "libqos/virtio.h" 13 #include "standard-headers/linux/virtio_config.h" 14 #include "standard-headers/linux/virtio_ring.h" 15 16 uint8_t qvirtio_config_readb(const QVirtioBus *bus, QVirtioDevice *d, 17 uint64_t addr) 18 { 19 return bus->config_readb(d, addr); 20 } 21 22 uint16_t qvirtio_config_readw(const QVirtioBus *bus, QVirtioDevice *d, 23 uint64_t addr) 24 { 25 return bus->config_readw(d, addr); 26 } 27 28 uint32_t qvirtio_config_readl(const QVirtioBus *bus, QVirtioDevice *d, 29 uint64_t addr) 30 { 31 return bus->config_readl(d, addr); 32 } 33 34 uint64_t qvirtio_config_readq(const QVirtioBus *bus, QVirtioDevice *d, 35 uint64_t addr) 36 { 37 return bus->config_readq(d, addr); 38 } 39 40 uint32_t qvirtio_get_features(const QVirtioBus *bus, QVirtioDevice *d) 41 { 42 return bus->get_features(d); 43 } 44 45 void qvirtio_set_features(const QVirtioBus *bus, QVirtioDevice *d, 46 uint32_t features) 47 { 48 bus->set_features(d, features); 49 } 50 51 QVirtQueue *qvirtqueue_setup(const QVirtioBus *bus, QVirtioDevice *d, 52 QGuestAllocator *alloc, uint16_t index) 53 { 54 return bus->virtqueue_setup(d, alloc, index); 55 } 56 57 void qvirtqueue_cleanup(const QVirtioBus *bus, QVirtQueue *vq, 58 QGuestAllocator *alloc) 59 { 60 return bus->virtqueue_cleanup(vq, alloc); 61 } 62 63 void qvirtio_reset(const QVirtioBus *bus, QVirtioDevice *d) 64 { 65 bus->set_status(d, 0); 66 g_assert_cmphex(bus->get_status(d), ==, 0); 67 } 68 69 void qvirtio_set_acknowledge(const QVirtioBus *bus, QVirtioDevice *d) 70 { 71 bus->set_status(d, bus->get_status(d) | VIRTIO_CONFIG_S_ACKNOWLEDGE); 72 g_assert_cmphex(bus->get_status(d), ==, VIRTIO_CONFIG_S_ACKNOWLEDGE); 73 } 74 75 void qvirtio_set_driver(const QVirtioBus *bus, QVirtioDevice *d) 76 { 77 bus->set_status(d, bus->get_status(d) | VIRTIO_CONFIG_S_DRIVER); 78 g_assert_cmphex(bus->get_status(d), ==, 79 VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_ACKNOWLEDGE); 80 } 81 82 void qvirtio_set_driver_ok(const QVirtioBus *bus, QVirtioDevice *d) 83 { 84 bus->set_status(d, bus->get_status(d) | VIRTIO_CONFIG_S_DRIVER_OK); 85 g_assert_cmphex(bus->get_status(d), ==, VIRTIO_CONFIG_S_DRIVER_OK | 86 VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_ACKNOWLEDGE); 87 } 88 89 void qvirtio_wait_queue_isr(const QVirtioBus *bus, QVirtioDevice *d, 90 QVirtQueue *vq, gint64 timeout_us) 91 { 92 gint64 start_time = g_get_monotonic_time(); 93 94 for (;;) { 95 clock_step(100); 96 if (bus->get_queue_isr_status(d, vq)) { 97 return; 98 } 99 g_assert(g_get_monotonic_time() - start_time <= timeout_us); 100 } 101 } 102 103 /* Wait for the status byte at given guest memory address to be set 104 * 105 * The virtqueue interrupt must not be raised, making this useful for testing 106 * event_index functionality. 107 */ 108 uint8_t qvirtio_wait_status_byte_no_isr(const QVirtioBus *bus, 109 QVirtioDevice *d, 110 QVirtQueue *vq, 111 uint64_t addr, 112 gint64 timeout_us) 113 { 114 gint64 start_time = g_get_monotonic_time(); 115 uint8_t val; 116 117 while ((val = readb(addr)) == 0xff) { 118 clock_step(100); 119 g_assert(!bus->get_queue_isr_status(d, vq)); 120 g_assert(g_get_monotonic_time() - start_time <= timeout_us); 121 } 122 return val; 123 } 124 125 void qvirtio_wait_config_isr(const QVirtioBus *bus, QVirtioDevice *d, 126 gint64 timeout_us) 127 { 128 gint64 start_time = g_get_monotonic_time(); 129 130 for (;;) { 131 clock_step(100); 132 if (bus->get_config_isr_status(d)) { 133 return; 134 } 135 g_assert(g_get_monotonic_time() - start_time <= timeout_us); 136 } 137 } 138 139 void qvring_init(const QGuestAllocator *alloc, QVirtQueue *vq, uint64_t addr) 140 { 141 int i; 142 143 vq->desc = addr; 144 vq->avail = vq->desc + vq->size * sizeof(struct vring_desc); 145 vq->used = (uint64_t)((vq->avail + sizeof(uint16_t) * (3 + vq->size) 146 + vq->align - 1) & ~(vq->align - 1)); 147 148 for (i = 0; i < vq->size - 1; i++) { 149 /* vq->desc[i].addr */ 150 writew(vq->desc + (16 * i), 0); 151 /* vq->desc[i].next */ 152 writew(vq->desc + (16 * i) + 14, i + 1); 153 } 154 155 /* vq->avail->flags */ 156 writew(vq->avail, 0); 157 /* vq->avail->idx */ 158 writew(vq->avail + 2, 0); 159 /* vq->avail->used_event */ 160 writew(vq->avail + 4 + (2 * vq->size), 0); 161 162 /* vq->used->flags */ 163 writew(vq->used, 0); 164 /* vq->used->avail_event */ 165 writew(vq->used + 2 + sizeof(struct vring_used_elem) * vq->size, 0); 166 } 167 168 QVRingIndirectDesc *qvring_indirect_desc_setup(QVirtioDevice *d, 169 QGuestAllocator *alloc, uint16_t elem) 170 { 171 int i; 172 QVRingIndirectDesc *indirect = g_malloc(sizeof(*indirect)); 173 174 indirect->index = 0; 175 indirect->elem = elem; 176 indirect->desc = guest_alloc(alloc, sizeof(struct vring_desc) * elem); 177 178 for (i = 0; i < elem - 1; ++i) { 179 /* indirect->desc[i].addr */ 180 writeq(indirect->desc + (16 * i), 0); 181 /* indirect->desc[i].flags */ 182 writew(indirect->desc + (16 * i) + 12, VRING_DESC_F_NEXT); 183 /* indirect->desc[i].next */ 184 writew(indirect->desc + (16 * i) + 14, i + 1); 185 } 186 187 return indirect; 188 } 189 190 void qvring_indirect_desc_add(QVRingIndirectDesc *indirect, uint64_t data, 191 uint32_t len, bool write) 192 { 193 uint16_t flags; 194 195 g_assert_cmpint(indirect->index, <, indirect->elem); 196 197 flags = readw(indirect->desc + (16 * indirect->index) + 12); 198 199 if (write) { 200 flags |= VRING_DESC_F_WRITE; 201 } 202 203 /* indirect->desc[indirect->index].addr */ 204 writeq(indirect->desc + (16 * indirect->index), data); 205 /* indirect->desc[indirect->index].len */ 206 writel(indirect->desc + (16 * indirect->index) + 8, len); 207 /* indirect->desc[indirect->index].flags */ 208 writew(indirect->desc + (16 * indirect->index) + 12, flags); 209 210 indirect->index++; 211 } 212 213 uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write, 214 bool next) 215 { 216 uint16_t flags = 0; 217 vq->num_free--; 218 219 if (write) { 220 flags |= VRING_DESC_F_WRITE; 221 } 222 223 if (next) { 224 flags |= VRING_DESC_F_NEXT; 225 } 226 227 /* vq->desc[vq->free_head].addr */ 228 writeq(vq->desc + (16 * vq->free_head), data); 229 /* vq->desc[vq->free_head].len */ 230 writel(vq->desc + (16 * vq->free_head) + 8, len); 231 /* vq->desc[vq->free_head].flags */ 232 writew(vq->desc + (16 * vq->free_head) + 12, flags); 233 234 return vq->free_head++; /* Return and increase, in this order */ 235 } 236 237 uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect) 238 { 239 g_assert(vq->indirect); 240 g_assert_cmpint(vq->size, >=, indirect->elem); 241 g_assert_cmpint(indirect->index, ==, indirect->elem); 242 243 vq->num_free--; 244 245 /* vq->desc[vq->free_head].addr */ 246 writeq(vq->desc + (16 * vq->free_head), indirect->desc); 247 /* vq->desc[vq->free_head].len */ 248 writel(vq->desc + (16 * vq->free_head) + 8, 249 sizeof(struct vring_desc) * indirect->elem); 250 /* vq->desc[vq->free_head].flags */ 251 writew(vq->desc + (16 * vq->free_head) + 12, VRING_DESC_F_INDIRECT); 252 253 return vq->free_head++; /* Return and increase, in this order */ 254 } 255 256 void qvirtqueue_kick(const QVirtioBus *bus, QVirtioDevice *d, QVirtQueue *vq, 257 uint32_t free_head) 258 { 259 /* vq->avail->idx */ 260 uint16_t idx = readw(vq->avail + 2); 261 /* vq->used->flags */ 262 uint16_t flags; 263 /* vq->used->avail_event */ 264 uint16_t avail_event; 265 266 /* vq->avail->ring[idx % vq->size] */ 267 writew(vq->avail + 4 + (2 * (idx % vq->size)), free_head); 268 /* vq->avail->idx */ 269 writew(vq->avail + 2, idx + 1); 270 271 /* Must read after idx is updated */ 272 flags = readw(vq->avail); 273 avail_event = readw(vq->used + 4 + 274 sizeof(struct vring_used_elem) * vq->size); 275 276 /* < 1 because we add elements to avail queue one by one */ 277 if ((flags & VRING_USED_F_NO_NOTIFY) == 0 && 278 (!vq->event || (uint16_t)(idx-avail_event) < 1)) { 279 bus->virtqueue_kick(d, vq); 280 } 281 } 282 283 void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx) 284 { 285 g_assert(vq->event); 286 287 /* vq->avail->used_event */ 288 writew(vq->avail + 4 + (2 * vq->size), idx); 289 } 290