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 qvirtqueue_cleanup(const QVirtioBus
*bus
, QVirtQueue
*vq
,
58 QGuestAllocator
*alloc
)
60 return bus
->virtqueue_cleanup(vq
, alloc
);
63 void qvirtio_reset(const QVirtioBus
*bus
, QVirtioDevice
*d
)
65 bus
->set_status(d
, 0);
66 g_assert_cmphex(bus
->get_status(d
), ==, 0);
69 void qvirtio_set_acknowledge(const QVirtioBus
*bus
, QVirtioDevice
*d
)
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
);
75 void qvirtio_set_driver(const QVirtioBus
*bus
, QVirtioDevice
*d
)
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
);
82 void qvirtio_set_driver_ok(const QVirtioBus
*bus
, QVirtioDevice
*d
)
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
);
89 void qvirtio_wait_queue_isr(const QVirtioBus
*bus
, QVirtioDevice
*d
,
90 QVirtQueue
*vq
, gint64 timeout_us
)
92 gint64 start_time
= g_get_monotonic_time();
96 if (bus
->get_queue_isr_status(d
, vq
)) {
99 g_assert(g_get_monotonic_time() - start_time
<= timeout_us
);
103 /* Wait for the status byte at given guest memory address to be set
105 * The virtqueue interrupt must not be raised, making this useful for testing
106 * event_index functionality.
108 uint8_t qvirtio_wait_status_byte_no_isr(const QVirtioBus
*bus
,
114 gint64 start_time
= g_get_monotonic_time();
117 while ((val
= readb(addr
)) == 0xff) {
119 g_assert(!bus
->get_queue_isr_status(d
, vq
));
120 g_assert(g_get_monotonic_time() - start_time
<= timeout_us
);
125 void qvirtio_wait_config_isr(const QVirtioBus
*bus
, QVirtioDevice
*d
,
128 gint64 start_time
= g_get_monotonic_time();
132 if (bus
->get_config_isr_status(d
)) {
135 g_assert(g_get_monotonic_time() - start_time
<= timeout_us
);
139 void qvring_init(const QGuestAllocator
*alloc
, QVirtQueue
*vq
, uint64_t 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));
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);
155 /* vq->avail->flags */
156 writew(vq
->avail
, 0);
158 writew(vq
->avail
+ 2, 0);
159 /* vq->avail->used_event */
160 writew(vq
->avail
+ 4 + (2 * vq
->size
), 0);
162 /* vq->used->flags */
164 /* vq->used->avail_event */
165 writew(vq
->used
+ 2 + sizeof(struct vring_used_elem
) * vq
->size
, 0);
168 QVRingIndirectDesc
*qvring_indirect_desc_setup(QVirtioDevice
*d
,
169 QGuestAllocator
*alloc
, uint16_t elem
)
172 QVRingIndirectDesc
*indirect
= g_malloc(sizeof(*indirect
));
175 indirect
->elem
= elem
;
176 indirect
->desc
= guest_alloc(alloc
, sizeof(struct vring_desc
) * elem
);
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);
190 void qvring_indirect_desc_add(QVRingIndirectDesc
*indirect
, uint64_t data
,
191 uint32_t len
, bool write
)
195 g_assert_cmpint(indirect
->index
, <, indirect
->elem
);
197 flags
= readw(indirect
->desc
+ (16 * indirect
->index
) + 12);
200 flags
|= VRING_DESC_F_WRITE
;
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
);
213 uint32_t qvirtqueue_add(QVirtQueue
*vq
, uint64_t data
, uint32_t len
, bool write
,
220 flags
|= VRING_DESC_F_WRITE
;
224 flags
|= VRING_DESC_F_NEXT
;
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
);
234 return vq
->free_head
++; /* Return and increase, in this order */
237 uint32_t qvirtqueue_add_indirect(QVirtQueue
*vq
, QVRingIndirectDesc
*indirect
)
239 g_assert(vq
->indirect
);
240 g_assert_cmpint(vq
->size
, >=, indirect
->elem
);
241 g_assert_cmpint(indirect
->index
, ==, indirect
->elem
);
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
);
253 return vq
->free_head
++; /* Return and increase, in this order */
256 void qvirtqueue_kick(const QVirtioBus
*bus
, QVirtioDevice
*d
, QVirtQueue
*vq
,
260 uint16_t idx
= readl(vq
->avail
+ 2);
261 /* vq->used->flags */
263 /* vq->used->avail_event */
264 uint16_t avail_event
;
266 /* vq->avail->ring[idx % vq->size] */
267 writel(vq
->avail
+ 4 + (2 * (idx
% vq
->size
)), free_head
);
269 writel(vq
->avail
+ 2, idx
+ 1);
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
);
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
);
283 void qvirtqueue_set_used_event(QVirtQueue
*vq
, uint16_t idx
)
287 /* vq->avail->used_event */
288 writew(vq
->avail
+ 4 + (2 * vq
->size
), idx
);