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