1
2
3
4
5
6
7
8
9
10#include "qemu/osdep.h"
11#include "../libqtest.h"
12#include "qemu/module.h"
13#include "virtio.h"
14#include "virtio-mmio.h"
15#include "libqos-malloc.h"
16#include "qgraph.h"
17#include "standard-headers/linux/virtio_ring.h"
18
19static uint8_t qvirtio_mmio_config_readb(QVirtioDevice *d, uint64_t off)
20{
21 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
22 return qtest_readb(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
23}
24
25static uint16_t qvirtio_mmio_config_readw(QVirtioDevice *d, uint64_t off)
26{
27 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
28 return qtest_readw(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
29}
30
31static uint32_t qvirtio_mmio_config_readl(QVirtioDevice *d, uint64_t off)
32{
33 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
34 return qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
35}
36
37static uint64_t qvirtio_mmio_config_readq(QVirtioDevice *d, uint64_t off)
38{
39 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
40 return qtest_readq(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
41}
42
43static uint64_t qvirtio_mmio_get_features(QVirtioDevice *d)
44{
45 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
46 uint64_t lo;
47 uint64_t hi = 0;
48
49 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 0);
50 lo = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES);
51
52 if (dev->version >= 2) {
53 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 1);
54 hi = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES);
55 }
56
57 return (hi << 32) | lo;
58}
59
60static void qvirtio_mmio_set_features(QVirtioDevice *d, uint64_t features)
61{
62 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
63 dev->features = features;
64 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 0);
65 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES, features);
66
67 if (dev->version >= 2) {
68 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 1);
69 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES,
70 features >> 32);
71 }
72}
73
74static uint64_t qvirtio_mmio_get_guest_features(QVirtioDevice *d)
75{
76 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
77 return dev->features;
78}
79
80static uint8_t qvirtio_mmio_get_status(QVirtioDevice *d)
81{
82 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
83 return (uint8_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS);
84}
85
86static void qvirtio_mmio_set_status(QVirtioDevice *d, uint8_t status)
87{
88 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
89 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS, (uint32_t)status);
90}
91
92static bool qvirtio_mmio_get_queue_isr_status(QVirtioDevice *d, QVirtQueue *vq)
93{
94 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
95 uint32_t isr;
96
97 isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 1;
98 if (isr != 0) {
99 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 1);
100 return true;
101 }
102
103 return false;
104}
105
106static bool qvirtio_mmio_get_config_isr_status(QVirtioDevice *d)
107{
108 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
109 uint32_t isr;
110
111 isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 2;
112 if (isr != 0) {
113 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 2);
114 return true;
115 }
116
117 return false;
118}
119
120static void qvirtio_mmio_wait_config_isr_status(QVirtioDevice *d,
121 gint64 timeout_us)
122{
123 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
124 gint64 start_time = g_get_monotonic_time();
125
126 do {
127 g_assert(g_get_monotonic_time() - start_time <= timeout_us);
128 qtest_clock_step(dev->qts, 100);
129 } while (!qvirtio_mmio_get_config_isr_status(d));
130}
131
132static void qvirtio_mmio_queue_select(QVirtioDevice *d, uint16_t index)
133{
134 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
135 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_SEL, (uint32_t)index);
136
137 g_assert_cmphex(qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN), ==, 0);
138}
139
140static uint16_t qvirtio_mmio_get_queue_size(QVirtioDevice *d)
141{
142 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
143 return (uint16_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM_MAX);
144}
145
146static void qvirtio_mmio_set_queue_address(QVirtioDevice *d, QVirtQueue *vq)
147{
148 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
149 uint64_t pfn = vq->desc / dev->page_size;
150
151 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN, pfn);
152}
153
154static QVirtQueue *qvirtio_mmio_virtqueue_setup(QVirtioDevice *d,
155 QGuestAllocator *alloc, uint16_t index)
156{
157 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
158 QVirtQueue *vq;
159 uint64_t addr;
160
161 vq = g_malloc0(sizeof(*vq));
162 vq->vdev = d;
163 qvirtio_mmio_queue_select(d, index);
164 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_ALIGN, dev->page_size);
165
166 vq->index = index;
167 vq->size = qvirtio_mmio_get_queue_size(d);
168 vq->free_head = 0;
169 vq->num_free = vq->size;
170 vq->align = dev->page_size;
171 vq->indirect = dev->features & (1ull << VIRTIO_RING_F_INDIRECT_DESC);
172 vq->event = dev->features & (1ull << VIRTIO_RING_F_EVENT_IDX);
173
174 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM, vq->size);
175
176
177 g_assert_cmpint(vq->size, !=, 0);
178
179
180 g_assert_cmpint(vq->size & (vq->size - 1), ==, 0);
181
182 addr = guest_alloc(alloc, qvring_size(vq->size, dev->page_size));
183 qvring_init(dev->qts, alloc, vq, addr);
184 qvirtio_mmio_set_queue_address(d, vq);
185
186 return vq;
187}
188
189static void qvirtio_mmio_virtqueue_cleanup(QVirtQueue *vq,
190 QGuestAllocator *alloc)
191{
192 guest_free(alloc, vq->desc);
193 g_free(vq);
194}
195
196static void qvirtio_mmio_virtqueue_kick(QVirtioDevice *d, QVirtQueue *vq)
197{
198 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
199 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NOTIFY, vq->index);
200}
201
202const QVirtioBus qvirtio_mmio = {
203 .config_readb = qvirtio_mmio_config_readb,
204 .config_readw = qvirtio_mmio_config_readw,
205 .config_readl = qvirtio_mmio_config_readl,
206 .config_readq = qvirtio_mmio_config_readq,
207 .get_features = qvirtio_mmio_get_features,
208 .set_features = qvirtio_mmio_set_features,
209 .get_guest_features = qvirtio_mmio_get_guest_features,
210 .get_status = qvirtio_mmio_get_status,
211 .set_status = qvirtio_mmio_set_status,
212 .get_queue_isr_status = qvirtio_mmio_get_queue_isr_status,
213 .wait_config_isr_status = qvirtio_mmio_wait_config_isr_status,
214 .queue_select = qvirtio_mmio_queue_select,
215 .get_queue_size = qvirtio_mmio_get_queue_size,
216 .set_queue_address = qvirtio_mmio_set_queue_address,
217 .virtqueue_setup = qvirtio_mmio_virtqueue_setup,
218 .virtqueue_cleanup = qvirtio_mmio_virtqueue_cleanup,
219 .virtqueue_kick = qvirtio_mmio_virtqueue_kick,
220};
221
222static void *qvirtio_mmio_get_driver(void *obj, const char *interface)
223{
224 QVirtioMMIODevice *virtio_mmio = obj;
225 if (!g_strcmp0(interface, "virtio-bus")) {
226 return &virtio_mmio->vdev;
227 }
228 fprintf(stderr, "%s not present in virtio-mmio\n", interface);
229 g_assert_not_reached();
230}
231
232static void qvirtio_mmio_start_hw(QOSGraphObject *obj)
233{
234 QVirtioMMIODevice *dev = (QVirtioMMIODevice *) obj;
235 qvirtio_start_device(&dev->vdev);
236}
237
238void qvirtio_mmio_init_device(QVirtioMMIODevice *dev, QTestState *qts,
239 uint64_t addr, uint32_t page_size)
240{
241 uint32_t magic;
242 magic = qtest_readl(qts, addr + QVIRTIO_MMIO_MAGIC_VALUE);
243 g_assert(magic == ('v' | 'i' << 8 | 'r' << 16 | 't' << 24));
244
245 dev->version = qtest_readl(qts, addr + QVIRTIO_MMIO_VERSION);
246 g_assert(dev->version == 1 || dev->version == 2);
247
248 dev->qts = qts;
249 dev->addr = addr;
250 dev->page_size = page_size;
251 dev->vdev.device_type = qtest_readl(qts, addr + QVIRTIO_MMIO_DEVICE_ID);
252 dev->vdev.bus = &qvirtio_mmio;
253
254 qtest_writel(qts, addr + QVIRTIO_MMIO_GUEST_PAGE_SIZE, page_size);
255
256 dev->obj.get_driver = qvirtio_mmio_get_driver;
257 dev->obj.start_hw = qvirtio_mmio_start_hw;
258}
259
260static void virtio_mmio_register_nodes(void)
261{
262 qos_node_create_driver("virtio-mmio", NULL);
263 qos_node_produces("virtio-mmio", "virtio-bus");
264}
265
266libqos_init(virtio_mmio_register_nodes);
267
