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