]>
git.proxmox.com Git - mirror_qemu.git/blob - tests/libqos/virtio.c
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.
12 #include "libqos/virtio.h"
14 uint8_t qvirtio_config_readb(const QVirtioBus
*bus
, QVirtioDevice
*d
,
17 return bus
->config_readb(d
, addr
);
20 uint16_t qvirtio_config_readw(const QVirtioBus
*bus
, QVirtioDevice
*d
,
23 return bus
->config_readw(d
, addr
);
26 uint32_t qvirtio_config_readl(const QVirtioBus
*bus
, QVirtioDevice
*d
,
29 return bus
->config_readl(d
, addr
);
32 uint64_t qvirtio_config_readq(const QVirtioBus
*bus
, QVirtioDevice
*d
,
35 return bus
->config_readq(d
, addr
);
38 uint32_t qvirtio_get_features(const QVirtioBus
*bus
, QVirtioDevice
*d
)
40 return bus
->get_features(d
);
43 void qvirtio_set_features(const QVirtioBus
*bus
, QVirtioDevice
*d
,
46 bus
->set_features(d
, features
);
49 QVirtQueue
*qvirtqueue_setup(const QVirtioBus
*bus
, QVirtioDevice
*d
,
50 QGuestAllocator
*alloc
, uint16_t index
)
52 return bus
->virtqueue_setup(d
, alloc
, index
);
55 void qvirtio_reset(const QVirtioBus
*bus
, QVirtioDevice
*d
)
57 bus
->set_status(d
, QVIRTIO_RESET
);
58 g_assert_cmphex(bus
->get_status(d
), ==, QVIRTIO_RESET
);
61 void qvirtio_set_acknowledge(const QVirtioBus
*bus
, QVirtioDevice
*d
)
63 bus
->set_status(d
, bus
->get_status(d
) | QVIRTIO_ACKNOWLEDGE
);
64 g_assert_cmphex(bus
->get_status(d
), ==, QVIRTIO_ACKNOWLEDGE
);
67 void qvirtio_set_driver(const QVirtioBus
*bus
, QVirtioDevice
*d
)
69 bus
->set_status(d
, bus
->get_status(d
) | QVIRTIO_DRIVER
);
70 g_assert_cmphex(bus
->get_status(d
), ==,
71 QVIRTIO_DRIVER
| QVIRTIO_ACKNOWLEDGE
);
74 void qvirtio_set_driver_ok(const QVirtioBus
*bus
, QVirtioDevice
*d
)
76 bus
->set_status(d
, bus
->get_status(d
) | QVIRTIO_DRIVER_OK
);
77 g_assert_cmphex(bus
->get_status(d
), ==,
78 QVIRTIO_DRIVER_OK
| QVIRTIO_DRIVER
| QVIRTIO_ACKNOWLEDGE
);
81 bool qvirtio_wait_queue_isr(const QVirtioBus
*bus
, QVirtioDevice
*d
,
82 QVirtQueue
*vq
, uint64_t timeout
)
86 if (bus
->get_queue_isr_status(d
, vq
)) {
87 break; /* It has ended */
94 /* Wait for the status byte at given guest memory address to be set
96 * The virtqueue interrupt must not be raised, making this useful for testing
97 * event_index functionality.
99 uint8_t qvirtio_wait_status_byte_no_isr(const QVirtioBus
*bus
,
105 gint64 start_time
= g_get_monotonic_time();
108 while ((val
= readb(addr
)) == 0xff) {
110 g_assert(!bus
->get_queue_isr_status(d
, vq
));
111 g_assert(g_get_monotonic_time() - start_time
<= timeout_us
);
116 bool qvirtio_wait_config_isr(const QVirtioBus
*bus
, QVirtioDevice
*d
,
121 if (bus
->get_config_isr_status(d
)) {
122 break; /* It has ended */
129 void qvring_init(const QGuestAllocator
*alloc
, QVirtQueue
*vq
, uint64_t addr
)
134 vq
->avail
= vq
->desc
+ vq
->size
*sizeof(QVRingDesc
);
135 vq
->used
= (uint64_t)((vq
->avail
+ sizeof(uint16_t) * (3 + vq
->size
)
136 + vq
->align
- 1) & ~(vq
->align
- 1));
138 for (i
= 0; i
< vq
->size
- 1; i
++) {
139 /* vq->desc[i].addr */
140 writew(vq
->desc
+ (16 * i
), 0);
141 /* vq->desc[i].next */
142 writew(vq
->desc
+ (16 * i
) + 14, i
+ 1);
145 /* vq->avail->flags */
146 writew(vq
->avail
, 0);
148 writew(vq
->avail
+ 2, 0);
149 /* vq->avail->used_event */
150 writew(vq
->avail
+ 4 + (2 * vq
->size
), 0);
152 /* vq->used->flags */
154 /* vq->used->avail_event */
155 writew(vq
->used
+2+(sizeof(struct QVRingUsedElem
)*vq
->size
), 0);
158 QVRingIndirectDesc
*qvring_indirect_desc_setup(QVirtioDevice
*d
,
159 QGuestAllocator
*alloc
, uint16_t elem
)
162 QVRingIndirectDesc
*indirect
= g_malloc(sizeof(*indirect
));
165 indirect
->elem
= elem
;
166 indirect
->desc
= guest_alloc(alloc
, sizeof(QVRingDesc
)*elem
);
168 for (i
= 0; i
< elem
- 1; ++i
) {
169 /* indirect->desc[i].addr */
170 writeq(indirect
->desc
+ (16 * i
), 0);
171 /* indirect->desc[i].flags */
172 writew(indirect
->desc
+ (16 * i
) + 12, QVRING_DESC_F_NEXT
);
173 /* indirect->desc[i].next */
174 writew(indirect
->desc
+ (16 * i
) + 14, i
+ 1);
180 void qvring_indirect_desc_add(QVRingIndirectDesc
*indirect
, uint64_t data
,
181 uint32_t len
, bool write
)
185 g_assert_cmpint(indirect
->index
, <, indirect
->elem
);
187 flags
= readw(indirect
->desc
+ (16 * indirect
->index
) + 12);
190 flags
|= QVRING_DESC_F_WRITE
;
193 /* indirect->desc[indirect->index].addr */
194 writeq(indirect
->desc
+ (16 * indirect
->index
), data
);
195 /* indirect->desc[indirect->index].len */
196 writel(indirect
->desc
+ (16 * indirect
->index
) + 8, len
);
197 /* indirect->desc[indirect->index].flags */
198 writew(indirect
->desc
+ (16 * indirect
->index
) + 12, flags
);
203 uint32_t qvirtqueue_add(QVirtQueue
*vq
, uint64_t data
, uint32_t len
, bool write
,
210 flags
|= QVRING_DESC_F_WRITE
;
214 flags
|= QVRING_DESC_F_NEXT
;
217 /* vq->desc[vq->free_head].addr */
218 writeq(vq
->desc
+ (16 * vq
->free_head
), data
);
219 /* vq->desc[vq->free_head].len */
220 writel(vq
->desc
+ (16 * vq
->free_head
) + 8, len
);
221 /* vq->desc[vq->free_head].flags */
222 writew(vq
->desc
+ (16 * vq
->free_head
) + 12, flags
);
224 return vq
->free_head
++; /* Return and increase, in this order */
227 uint32_t qvirtqueue_add_indirect(QVirtQueue
*vq
, QVRingIndirectDesc
*indirect
)
229 g_assert(vq
->indirect
);
230 g_assert_cmpint(vq
->size
, >=, indirect
->elem
);
231 g_assert_cmpint(indirect
->index
, ==, indirect
->elem
);
235 /* vq->desc[vq->free_head].addr */
236 writeq(vq
->desc
+ (16 * vq
->free_head
), indirect
->desc
);
237 /* vq->desc[vq->free_head].len */
238 writel(vq
->desc
+ (16 * vq
->free_head
) + 8,
239 sizeof(QVRingDesc
) * indirect
->elem
);
240 /* vq->desc[vq->free_head].flags */
241 writew(vq
->desc
+ (16 * vq
->free_head
) + 12, QVRING_DESC_F_INDIRECT
);
243 return vq
->free_head
++; /* Return and increase, in this order */
246 void qvirtqueue_kick(const QVirtioBus
*bus
, QVirtioDevice
*d
, QVirtQueue
*vq
,
250 uint16_t idx
= readl(vq
->avail
+ 2);
251 /* vq->used->flags */
253 /* vq->used->avail_event */
254 uint16_t avail_event
;
256 /* vq->avail->ring[idx % vq->size] */
257 writel(vq
->avail
+ 4 + (2 * (idx
% vq
->size
)), free_head
);
259 writel(vq
->avail
+ 2, idx
+ 1);
261 /* Must read after idx is updated */
262 flags
= readw(vq
->avail
);
263 avail_event
= readw(vq
->used
+ 4 +
264 (sizeof(struct QVRingUsedElem
) * vq
->size
));
266 /* < 1 because we add elements to avail queue one by one */
267 if ((flags
& QVRING_USED_F_NO_NOTIFY
) == 0 &&
268 (!vq
->event
|| (uint16_t)(idx
-avail_event
) < 1)) {
269 bus
->virtqueue_kick(d
, vq
);
273 void qvirtqueue_set_used_event(QVirtQueue
*vq
, uint16_t idx
)
277 /* vq->avail->used_event */
278 writew(vq
->avail
+ 4 + (2 * vq
->size
), idx
);