4 * Copyright (c) 2014 Marc MarĂ
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.
10 #include "qemu/osdep.h"
12 #include "libqos/virtio.h"
13 #include "standard-headers/linux/virtio_config.h"
14 #include "standard-headers/linux/virtio_ring.h"
16 uint8_t qvirtio_config_readb(const QVirtioBus
*bus
, QVirtioDevice
*d
,
19 return bus
->config_readb(d
, addr
);
22 uint16_t qvirtio_config_readw(const QVirtioBus
*bus
, QVirtioDevice
*d
,
25 return bus
->config_readw(d
, addr
);
28 uint32_t qvirtio_config_readl(const QVirtioBus
*bus
, QVirtioDevice
*d
,
31 return bus
->config_readl(d
, addr
);
34 uint64_t qvirtio_config_readq(const QVirtioBus
*bus
, QVirtioDevice
*d
,
37 return bus
->config_readq(d
, addr
);
40 uint32_t qvirtio_get_features(const QVirtioBus
*bus
, QVirtioDevice
*d
)
42 return bus
->get_features(d
);
45 void qvirtio_set_features(const QVirtioBus
*bus
, QVirtioDevice
*d
,
48 bus
->set_features(d
, features
);
51 QVirtQueue
*qvirtqueue_setup(const QVirtioBus
*bus
, QVirtioDevice
*d
,
52 QGuestAllocator
*alloc
, uint16_t index
)
54 return bus
->virtqueue_setup(d
, alloc
, index
);
57 void qvirtio_reset(const QVirtioBus
*bus
, QVirtioDevice
*d
)
59 bus
->set_status(d
, 0);
60 g_assert_cmphex(bus
->get_status(d
), ==, 0);
63 void qvirtio_set_acknowledge(const QVirtioBus
*bus
, QVirtioDevice
*d
)
65 bus
->set_status(d
, bus
->get_status(d
) | VIRTIO_CONFIG_S_ACKNOWLEDGE
);
66 g_assert_cmphex(bus
->get_status(d
), ==, VIRTIO_CONFIG_S_ACKNOWLEDGE
);
69 void qvirtio_set_driver(const QVirtioBus
*bus
, QVirtioDevice
*d
)
71 bus
->set_status(d
, bus
->get_status(d
) | VIRTIO_CONFIG_S_DRIVER
);
72 g_assert_cmphex(bus
->get_status(d
), ==,
73 VIRTIO_CONFIG_S_DRIVER
| VIRTIO_CONFIG_S_ACKNOWLEDGE
);
76 void qvirtio_set_driver_ok(const QVirtioBus
*bus
, QVirtioDevice
*d
)
78 bus
->set_status(d
, bus
->get_status(d
) | VIRTIO_CONFIG_S_DRIVER_OK
);
79 g_assert_cmphex(bus
->get_status(d
), ==, VIRTIO_CONFIG_S_DRIVER_OK
|
80 VIRTIO_CONFIG_S_DRIVER
| VIRTIO_CONFIG_S_ACKNOWLEDGE
);
83 void qvirtio_wait_queue_isr(const QVirtioBus
*bus
, QVirtioDevice
*d
,
84 QVirtQueue
*vq
, gint64 timeout_us
)
86 gint64 start_time
= g_get_monotonic_time();
90 if (bus
->get_queue_isr_status(d
, vq
)) {
93 g_assert(g_get_monotonic_time() - start_time
<= timeout_us
);
97 /* Wait for the status byte at given guest memory address to be set
99 * The virtqueue interrupt must not be raised, making this useful for testing
100 * event_index functionality.
102 uint8_t qvirtio_wait_status_byte_no_isr(const QVirtioBus
*bus
,
108 gint64 start_time
= g_get_monotonic_time();
111 while ((val
= readb(addr
)) == 0xff) {
113 g_assert(!bus
->get_queue_isr_status(d
, vq
));
114 g_assert(g_get_monotonic_time() - start_time
<= timeout_us
);
119 void qvirtio_wait_config_isr(const QVirtioBus
*bus
, QVirtioDevice
*d
,
122 gint64 start_time
= g_get_monotonic_time();
126 if (bus
->get_config_isr_status(d
)) {
129 g_assert(g_get_monotonic_time() - start_time
<= timeout_us
);
133 void qvring_init(const QGuestAllocator
*alloc
, QVirtQueue
*vq
, uint64_t addr
)
138 vq
->avail
= vq
->desc
+ vq
->size
*sizeof(QVRingDesc
);
139 vq
->used
= (uint64_t)((vq
->avail
+ sizeof(uint16_t) * (3 + vq
->size
)
140 + vq
->align
- 1) & ~(vq
->align
- 1));
142 for (i
= 0; i
< vq
->size
- 1; i
++) {
143 /* vq->desc[i].addr */
144 writew(vq
->desc
+ (16 * i
), 0);
145 /* vq->desc[i].next */
146 writew(vq
->desc
+ (16 * i
) + 14, i
+ 1);
149 /* vq->avail->flags */
150 writew(vq
->avail
, 0);
152 writew(vq
->avail
+ 2, 0);
153 /* vq->avail->used_event */
154 writew(vq
->avail
+ 4 + (2 * vq
->size
), 0);
156 /* vq->used->flags */
158 /* vq->used->avail_event */
159 writew(vq
->used
+2+(sizeof(struct QVRingUsedElem
)*vq
->size
), 0);
162 QVRingIndirectDesc
*qvring_indirect_desc_setup(QVirtioDevice
*d
,
163 QGuestAllocator
*alloc
, uint16_t elem
)
166 QVRingIndirectDesc
*indirect
= g_malloc(sizeof(*indirect
));
169 indirect
->elem
= elem
;
170 indirect
->desc
= guest_alloc(alloc
, sizeof(QVRingDesc
)*elem
);
172 for (i
= 0; i
< elem
- 1; ++i
) {
173 /* indirect->desc[i].addr */
174 writeq(indirect
->desc
+ (16 * i
), 0);
175 /* indirect->desc[i].flags */
176 writew(indirect
->desc
+ (16 * i
) + 12, VRING_DESC_F_NEXT
);
177 /* indirect->desc[i].next */
178 writew(indirect
->desc
+ (16 * i
) + 14, i
+ 1);
184 void qvring_indirect_desc_add(QVRingIndirectDesc
*indirect
, uint64_t data
,
185 uint32_t len
, bool write
)
189 g_assert_cmpint(indirect
->index
, <, indirect
->elem
);
191 flags
= readw(indirect
->desc
+ (16 * indirect
->index
) + 12);
194 flags
|= VRING_DESC_F_WRITE
;
197 /* indirect->desc[indirect->index].addr */
198 writeq(indirect
->desc
+ (16 * indirect
->index
), data
);
199 /* indirect->desc[indirect->index].len */
200 writel(indirect
->desc
+ (16 * indirect
->index
) + 8, len
);
201 /* indirect->desc[indirect->index].flags */
202 writew(indirect
->desc
+ (16 * indirect
->index
) + 12, flags
);
207 uint32_t qvirtqueue_add(QVirtQueue
*vq
, uint64_t data
, uint32_t len
, bool write
,
214 flags
|= VRING_DESC_F_WRITE
;
218 flags
|= VRING_DESC_F_NEXT
;
221 /* vq->desc[vq->free_head].addr */
222 writeq(vq
->desc
+ (16 * vq
->free_head
), data
);
223 /* vq->desc[vq->free_head].len */
224 writel(vq
->desc
+ (16 * vq
->free_head
) + 8, len
);
225 /* vq->desc[vq->free_head].flags */
226 writew(vq
->desc
+ (16 * vq
->free_head
) + 12, flags
);
228 return vq
->free_head
++; /* Return and increase, in this order */
231 uint32_t qvirtqueue_add_indirect(QVirtQueue
*vq
, QVRingIndirectDesc
*indirect
)
233 g_assert(vq
->indirect
);
234 g_assert_cmpint(vq
->size
, >=, indirect
->elem
);
235 g_assert_cmpint(indirect
->index
, ==, indirect
->elem
);
239 /* vq->desc[vq->free_head].addr */
240 writeq(vq
->desc
+ (16 * vq
->free_head
), indirect
->desc
);
241 /* vq->desc[vq->free_head].len */
242 writel(vq
->desc
+ (16 * vq
->free_head
) + 8,
243 sizeof(QVRingDesc
) * indirect
->elem
);
244 /* vq->desc[vq->free_head].flags */
245 writew(vq
->desc
+ (16 * vq
->free_head
) + 12, VRING_DESC_F_INDIRECT
);
247 return vq
->free_head
++; /* Return and increase, in this order */
250 void qvirtqueue_kick(const QVirtioBus
*bus
, QVirtioDevice
*d
, QVirtQueue
*vq
,
254 uint16_t idx
= readl(vq
->avail
+ 2);
255 /* vq->used->flags */
257 /* vq->used->avail_event */
258 uint16_t avail_event
;
260 /* vq->avail->ring[idx % vq->size] */
261 writel(vq
->avail
+ 4 + (2 * (idx
% vq
->size
)), free_head
);
263 writel(vq
->avail
+ 2, idx
+ 1);
265 /* Must read after idx is updated */
266 flags
= readw(vq
->avail
);
267 avail_event
= readw(vq
->used
+ 4 +
268 (sizeof(struct QVRingUsedElem
) * vq
->size
));
270 /* < 1 because we add elements to avail queue one by one */
271 if ((flags
& VRING_USED_F_NO_NOTIFY
) == 0 &&
272 (!vq
->event
|| (uint16_t)(idx
-avail_event
) < 1)) {
273 bus
->virtqueue_kick(d
, vq
);
277 void qvirtqueue_set_used_event(QVirtQueue
*vq
, uint16_t idx
)
281 /* vq->avail->used_event */
282 writew(vq
->avail
+ 4 + (2 * vq
->size
), idx
);