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 "libqos/virtio.h"
14#include "libqos/virtio-mmio.h"
15#include "libqos/malloc.h"
16#include "libqos/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 uint32_t qvirtio_mmio_get_features(QVirtioDevice *d)
44{
45 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
46 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 0);
47 return qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES);
48}
49
50static void qvirtio_mmio_set_features(QVirtioDevice *d, uint32_t features)
51{
52 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
53 dev->features = features;
54 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 0);
55 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES, features);
56}
57
58static uint32_t qvirtio_mmio_get_guest_features(QVirtioDevice *d)
59{
60 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
61 return dev->features;
62}
63
64static uint8_t qvirtio_mmio_get_status(QVirtioDevice *d)
65{
66 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
67 return (uint8_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS);
68}
69
70static void qvirtio_mmio_set_status(QVirtioDevice *d, uint8_t status)
71{
72 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
73 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS, (uint32_t)status);
74}
75
76static bool qvirtio_mmio_get_queue_isr_status(QVirtioDevice *d, QVirtQueue *vq)
77{
78 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
79 uint32_t isr;
80
81 isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 1;
82 if (isr != 0) {
83 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 1);
84 return true;
85 }
86
87 return false;
88}
89
90static bool qvirtio_mmio_get_config_isr_status(QVirtioDevice *d)
91{
92 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
93 uint32_t isr;
94
95 isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 2;
96 if (isr != 0) {
97 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 2);
98 return true;
99 }
100
101 return false;
102}
103
104static void qvirtio_mmio_queue_select(QVirtioDevice *d, uint16_t index)
105{
106 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
107 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_SEL, (uint32_t)index);
108
109 g_assert_cmphex(qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN), ==, 0);
110}
111
112static uint16_t qvirtio_mmio_get_queue_size(QVirtioDevice *d)
113{
114 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
115 return (uint16_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM_MAX);
116}
117
118static void qvirtio_mmio_set_queue_address(QVirtioDevice *d, uint32_t pfn)
119{
120 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
121 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN, pfn);
122}
123
124static QVirtQueue *qvirtio_mmio_virtqueue_setup(QVirtioDevice *d,
125 QGuestAllocator *alloc, uint16_t index)
126{
127 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
128 QVirtQueue *vq;
129 uint64_t addr;
130
131 vq = g_malloc0(sizeof(*vq));
132 qvirtio_mmio_queue_select(d, index);
133 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_ALIGN, dev->page_size);
134
135 vq->index = index;
136 vq->size = qvirtio_mmio_get_queue_size(d);
137 vq->free_head = 0;
138 vq->num_free = vq->size;
139 vq->align = dev->page_size;
140 vq->indirect = (dev->features & (1u << VIRTIO_RING_F_INDIRECT_DESC)) != 0;
141 vq->event = (dev->features & (1u << VIRTIO_RING_F_EVENT_IDX)) != 0;
142
143 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM, vq->size);
144
145
146 g_assert_cmpint(vq->size, !=, 0);
147
148
149 g_assert_cmpint(vq->size & (vq->size - 1), ==, 0);
150
151 addr = guest_alloc(alloc, qvring_size(vq->size, dev->page_size));
152 qvring_init(dev->qts, alloc, vq, addr);
153 qvirtio_mmio_set_queue_address(d, vq->desc / dev->page_size);
154
155 return vq;
156}
157
158static void qvirtio_mmio_virtqueue_cleanup(QVirtQueue *vq,
159 QGuestAllocator *alloc)
160{
161 guest_free(alloc, vq->desc);
162 g_free(vq);
163}
164
165static void qvirtio_mmio_virtqueue_kick(QVirtioDevice *d, QVirtQueue *vq)
166{
167 QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
168 qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NOTIFY, vq->index);
169}
170
171const QVirtioBus qvirtio_mmio = {
172 .config_readb = qvirtio_mmio_config_readb,
173 .config_readw = qvirtio_mmio_config_readw,
174 .config_readl = qvirtio_mmio_config_readl,
175 .config_readq = qvirtio_mmio_config_readq,
176 .get_features = qvirtio_mmio_get_features,
177 .set_features = qvirtio_mmio_set_features,
178 .get_guest_features = qvirtio_mmio_get_guest_features,
179 .get_status = qvirtio_mmio_get_status,
180 .set_status = qvirtio_mmio_set_status,
181 .get_queue_isr_status = qvirtio_mmio_get_queue_isr_status,
182 .get_config_isr_status = qvirtio_mmio_get_config_isr_status,
183 .queue_select = qvirtio_mmio_queue_select,
184 .get_queue_size = qvirtio_mmio_get_queue_size,
185 .set_queue_address = qvirtio_mmio_set_queue_address,
186 .virtqueue_setup = qvirtio_mmio_virtqueue_setup,
187 .virtqueue_cleanup = qvirtio_mmio_virtqueue_cleanup,
188 .virtqueue_kick = qvirtio_mmio_virtqueue_kick,
189};
190
191static void *qvirtio_mmio_get_driver(void *obj, const char *interface)
192{
193 QVirtioMMIODevice *virtio_mmio = obj;
194 if (!g_strcmp0(interface, "virtio-bus")) {
195 return &virtio_mmio->vdev;
196 }
197 fprintf(stderr, "%s not present in virtio-mmio\n", interface);
198 g_assert_not_reached();
199}
200
201static void qvirtio_mmio_start_hw(QOSGraphObject *obj)
202{
203 QVirtioMMIODevice *dev = (QVirtioMMIODevice *) obj;
204 qvirtio_start_device(&dev->vdev);
205}
206
207void qvirtio_mmio_init_device(QVirtioMMIODevice *dev, QTestState *qts,
208 uint64_t addr, uint32_t page_size)
209{
210 uint32_t magic;
211 magic = qtest_readl(qts, addr + QVIRTIO_MMIO_MAGIC_VALUE);
212 g_assert(magic == ('v' | 'i' << 8 | 'r' << 16 | 't' << 24));
213
214 dev->qts = qts;
215 dev->addr = addr;
216 dev->page_size = page_size;
217 dev->vdev.device_type = qtest_readl(qts, addr + QVIRTIO_MMIO_DEVICE_ID);
218 dev->vdev.bus = &qvirtio_mmio;
219
220 qtest_writel(qts, addr + QVIRTIO_MMIO_GUEST_PAGE_SIZE, page_size);
221
222 dev->obj.get_driver = qvirtio_mmio_get_driver;
223 dev->obj.start_hw = qvirtio_mmio_start_hw;
224}
225
226static void virtio_mmio_register_nodes(void)
227{
228 qos_node_create_driver("virtio-mmio", NULL);
229 qos_node_produces("virtio-mmio", "virtio-bus");
230}
231
232libqos_init(virtio_mmio_register_nodes);
233
