1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include "qemu/osdep.h"
23#include "hw/sysbus.h"
24#include "hw/virtio/virtio.h"
25#include "qemu/host-utils.h"
26#include "sysemu/kvm.h"
27#include "hw/virtio/virtio-bus.h"
28#include "qemu/error-report.h"
29
30
31
32#ifdef DEBUG_VIRTIO_MMIO
33
34#define DPRINTF(fmt, ...) \
35do { printf("virtio_mmio: " fmt , ## __VA_ARGS__); } while (0)
36#else
37#define DPRINTF(fmt, ...) do {} while (0)
38#endif
39
40
41
42#define TYPE_VIRTIO_MMIO_BUS "virtio-mmio-bus"
43#define VIRTIO_MMIO_BUS(obj) \
44 OBJECT_CHECK(VirtioBusState, (obj), TYPE_VIRTIO_MMIO_BUS)
45#define VIRTIO_MMIO_BUS_GET_CLASS(obj) \
46 OBJECT_GET_CLASS(VirtioBusClass, (obj), TYPE_VIRTIO_MMIO_BUS)
47#define VIRTIO_MMIO_BUS_CLASS(klass) \
48 OBJECT_CLASS_CHECK(VirtioBusClass, (klass), TYPE_VIRTIO_MMIO_BUS)
49
50
51#define TYPE_VIRTIO_MMIO "virtio-mmio"
52#define VIRTIO_MMIO(obj) \
53 OBJECT_CHECK(VirtIOMMIOProxy, (obj), TYPE_VIRTIO_MMIO)
54
55
56#define VIRTIO_MMIO_MAGIC 0x0
57#define VIRTIO_MMIO_VERSION 0x4
58#define VIRTIO_MMIO_DEVICEID 0x8
59#define VIRTIO_MMIO_VENDORID 0xc
60#define VIRTIO_MMIO_HOSTFEATURES 0x10
61#define VIRTIO_MMIO_HOSTFEATURESSEL 0x14
62#define VIRTIO_MMIO_GUESTFEATURES 0x20
63#define VIRTIO_MMIO_GUESTFEATURESSEL 0x24
64#define VIRTIO_MMIO_GUESTPAGESIZE 0x28
65#define VIRTIO_MMIO_QUEUESEL 0x30
66#define VIRTIO_MMIO_QUEUENUMMAX 0x34
67#define VIRTIO_MMIO_QUEUENUM 0x38
68#define VIRTIO_MMIO_QUEUEALIGN 0x3c
69#define VIRTIO_MMIO_QUEUEPFN 0x40
70#define VIRTIO_MMIO_QUEUENOTIFY 0x50
71#define VIRTIO_MMIO_INTERRUPTSTATUS 0x60
72#define VIRTIO_MMIO_INTERRUPTACK 0x64
73#define VIRTIO_MMIO_STATUS 0x70
74
75#define VIRTIO_MMIO_CONFIG 0x100
76
77#define VIRT_MAGIC 0x74726976
78#define VIRT_VERSION 1
79#define VIRT_VENDOR 0x554D4551
80
81typedef struct {
82
83 SysBusDevice parent_obj;
84 MemoryRegion iomem;
85 qemu_irq irq;
86
87 uint32_t host_features_sel;
88 uint32_t guest_features_sel;
89 uint32_t guest_page_shift;
90
91 VirtioBusState bus;
92 bool ioeventfd_disabled;
93 bool ioeventfd_started;
94 bool format_transport_address;
95} VirtIOMMIOProxy;
96
97static bool virtio_mmio_ioeventfd_started(DeviceState *d)
98{
99 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
100
101 return proxy->ioeventfd_started;
102}
103
104static void virtio_mmio_ioeventfd_set_started(DeviceState *d, bool started,
105 bool err)
106{
107 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
108
109 proxy->ioeventfd_started = started;
110}
111
112static bool virtio_mmio_ioeventfd_disabled(DeviceState *d)
113{
114 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
115
116 return !kvm_eventfds_enabled() || proxy->ioeventfd_disabled;
117}
118
119static void virtio_mmio_ioeventfd_set_disabled(DeviceState *d, bool disabled)
120{
121 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
122
123 proxy->ioeventfd_disabled = disabled;
124}
125
126static int virtio_mmio_ioeventfd_assign(DeviceState *d,
127 EventNotifier *notifier,
128 int n, bool assign)
129{
130 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
131
132 if (assign) {
133 memory_region_add_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUENOTIFY, 4,
134 true, n, notifier);
135 } else {
136 memory_region_del_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUENOTIFY, 4,
137 true, n, notifier);
138 }
139 return 0;
140}
141
142static void virtio_mmio_start_ioeventfd(VirtIOMMIOProxy *proxy)
143{
144 virtio_bus_start_ioeventfd(&proxy->bus);
145}
146
147static void virtio_mmio_stop_ioeventfd(VirtIOMMIOProxy *proxy)
148{
149 virtio_bus_stop_ioeventfd(&proxy->bus);
150}
151
152static uint64_t virtio_mmio_read(void *opaque, hwaddr offset, unsigned size)
153{
154 VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque;
155 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
156
157 DPRINTF("virtio_mmio_read offset 0x%x\n", (int)offset);
158
159 if (!vdev) {
160
161
162
163
164
165
166
167
168 switch (offset) {
169 case VIRTIO_MMIO_MAGIC:
170 return VIRT_MAGIC;
171 case VIRTIO_MMIO_VERSION:
172 return VIRT_VERSION;
173 case VIRTIO_MMIO_VENDORID:
174 return VIRT_VENDOR;
175 default:
176 return 0;
177 }
178 }
179
180 if (offset >= VIRTIO_MMIO_CONFIG) {
181 offset -= VIRTIO_MMIO_CONFIG;
182 switch (size) {
183 case 1:
184 return virtio_config_readb(vdev, offset);
185 case 2:
186 return virtio_config_readw(vdev, offset);
187 case 4:
188 return virtio_config_readl(vdev, offset);
189 default:
190 abort();
191 }
192 }
193 if (size != 4) {
194 DPRINTF("wrong size access to register!\n");
195 return 0;
196 }
197 switch (offset) {
198 case VIRTIO_MMIO_MAGIC:
199 return VIRT_MAGIC;
200 case VIRTIO_MMIO_VERSION:
201 return VIRT_VERSION;
202 case VIRTIO_MMIO_DEVICEID:
203 return vdev->device_id;
204 case VIRTIO_MMIO_VENDORID:
205 return VIRT_VENDOR;
206 case VIRTIO_MMIO_HOSTFEATURES:
207 if (proxy->host_features_sel) {
208 return 0;
209 }
210 return vdev->host_features;
211 case VIRTIO_MMIO_QUEUENUMMAX:
212 if (!virtio_queue_get_num(vdev, vdev->queue_sel)) {
213 return 0;
214 }
215 return VIRTQUEUE_MAX_SIZE;
216 case VIRTIO_MMIO_QUEUEPFN:
217 return virtio_queue_get_addr(vdev, vdev->queue_sel)
218 >> proxy->guest_page_shift;
219 case VIRTIO_MMIO_INTERRUPTSTATUS:
220 return vdev->isr;
221 case VIRTIO_MMIO_STATUS:
222 return vdev->status;
223 case VIRTIO_MMIO_HOSTFEATURESSEL:
224 case VIRTIO_MMIO_GUESTFEATURES:
225 case VIRTIO_MMIO_GUESTFEATURESSEL:
226 case VIRTIO_MMIO_GUESTPAGESIZE:
227 case VIRTIO_MMIO_QUEUESEL:
228 case VIRTIO_MMIO_QUEUENUM:
229 case VIRTIO_MMIO_QUEUEALIGN:
230 case VIRTIO_MMIO_QUEUENOTIFY:
231 case VIRTIO_MMIO_INTERRUPTACK:
232 DPRINTF("read of write-only register\n");
233 return 0;
234 default:
235 DPRINTF("bad register offset\n");
236 return 0;
237 }
238 return 0;
239}
240
241static void virtio_mmio_write(void *opaque, hwaddr offset, uint64_t value,
242 unsigned size)
243{
244 VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque;
245 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
246
247 DPRINTF("virtio_mmio_write offset 0x%x value 0x%" PRIx64 "\n",
248 (int)offset, value);
249
250 if (!vdev) {
251
252
253
254
255 return;
256 }
257
258 if (offset >= VIRTIO_MMIO_CONFIG) {
259 offset -= VIRTIO_MMIO_CONFIG;
260 switch (size) {
261 case 1:
262 virtio_config_writeb(vdev, offset, value);
263 break;
264 case 2:
265 virtio_config_writew(vdev, offset, value);
266 break;
267 case 4:
268 virtio_config_writel(vdev, offset, value);
269 break;
270 default:
271 abort();
272 }
273 return;
274 }
275 if (size != 4) {
276 DPRINTF("wrong size access to register!\n");
277 return;
278 }
279 switch (offset) {
280 case VIRTIO_MMIO_HOSTFEATURESSEL:
281 proxy->host_features_sel = value;
282 break;
283 case VIRTIO_MMIO_GUESTFEATURES:
284 if (!proxy->guest_features_sel) {
285 virtio_set_features(vdev, value);
286 }
287 break;
288 case VIRTIO_MMIO_GUESTFEATURESSEL:
289 proxy->guest_features_sel = value;
290 break;
291 case VIRTIO_MMIO_GUESTPAGESIZE:
292 proxy->guest_page_shift = ctz32(value);
293 if (proxy->guest_page_shift > 31) {
294 proxy->guest_page_shift = 0;
295 }
296 DPRINTF("guest page size %" PRIx64 " shift %d\n", value,
297 proxy->guest_page_shift);
298 break;
299 case VIRTIO_MMIO_QUEUESEL:
300 if (value < VIRTIO_QUEUE_MAX) {
301 vdev->queue_sel = value;
302 }
303 break;
304 case VIRTIO_MMIO_QUEUENUM:
305 DPRINTF("mmio_queue write %d max %d\n", (int)value, VIRTQUEUE_MAX_SIZE);
306 virtio_queue_set_num(vdev, vdev->queue_sel, value);
307
308 virtio_queue_update_rings(vdev, vdev->queue_sel);
309 break;
310 case VIRTIO_MMIO_QUEUEALIGN:
311
312 virtio_queue_set_align(vdev, vdev->queue_sel, value);
313 break;
314 case VIRTIO_MMIO_QUEUEPFN:
315 if (value == 0) {
316 virtio_reset(vdev);
317 } else {
318 virtio_queue_set_addr(vdev, vdev->queue_sel,
319 value << proxy->guest_page_shift);
320 }
321 break;
322 case VIRTIO_MMIO_QUEUENOTIFY:
323 if (value < VIRTIO_QUEUE_MAX) {
324 virtio_queue_notify(vdev, value);
325 }
326 break;
327 case VIRTIO_MMIO_INTERRUPTACK:
328 vdev->isr &= ~value;
329 virtio_update_irq(vdev);
330 break;
331 case VIRTIO_MMIO_STATUS:
332 if (!(value & VIRTIO_CONFIG_S_DRIVER_OK)) {
333 virtio_mmio_stop_ioeventfd(proxy);
334 }
335
336 virtio_set_status(vdev, value & 0xff);
337
338 if (value & VIRTIO_CONFIG_S_DRIVER_OK) {
339 virtio_mmio_start_ioeventfd(proxy);
340 }
341
342 if (vdev->status == 0) {
343 virtio_reset(vdev);
344 }
345 break;
346 case VIRTIO_MMIO_MAGIC:
347 case VIRTIO_MMIO_VERSION:
348 case VIRTIO_MMIO_DEVICEID:
349 case VIRTIO_MMIO_VENDORID:
350 case VIRTIO_MMIO_HOSTFEATURES:
351 case VIRTIO_MMIO_QUEUENUMMAX:
352 case VIRTIO_MMIO_INTERRUPTSTATUS:
353 DPRINTF("write to readonly register\n");
354 break;
355
356 default:
357 DPRINTF("bad register offset\n");
358 }
359}
360
361static const MemoryRegionOps virtio_mem_ops = {
362 .read = virtio_mmio_read,
363 .write = virtio_mmio_write,
364 .endianness = DEVICE_NATIVE_ENDIAN,
365};
366
367static void virtio_mmio_update_irq(DeviceState *opaque, uint16_t vector)
368{
369 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
370 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
371 int level;
372
373 if (!vdev) {
374 return;
375 }
376 level = (vdev->isr != 0);
377 DPRINTF("virtio_mmio setting IRQ %d\n", level);
378 qemu_set_irq(proxy->irq, level);
379}
380
381static int virtio_mmio_load_config(DeviceState *opaque, QEMUFile *f)
382{
383 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
384
385 proxy->host_features_sel = qemu_get_be32(f);
386 proxy->guest_features_sel = qemu_get_be32(f);
387 proxy->guest_page_shift = qemu_get_be32(f);
388 return 0;
389}
390
391static void virtio_mmio_save_config(DeviceState *opaque, QEMUFile *f)
392{
393 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
394
395 qemu_put_be32(f, proxy->host_features_sel);
396 qemu_put_be32(f, proxy->guest_features_sel);
397 qemu_put_be32(f, proxy->guest_page_shift);
398}
399
400static void virtio_mmio_reset(DeviceState *d)
401{
402 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
403
404 virtio_mmio_stop_ioeventfd(proxy);
405 virtio_bus_reset(&proxy->bus);
406 proxy->host_features_sel = 0;
407 proxy->guest_features_sel = 0;
408 proxy->guest_page_shift = 0;
409}
410
411static int virtio_mmio_set_guest_notifier(DeviceState *d, int n, bool assign,
412 bool with_irqfd)
413{
414 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
415 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
416 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
417 VirtQueue *vq = virtio_get_queue(vdev, n);
418 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
419
420 if (assign) {
421 int r = event_notifier_init(notifier, 0);
422 if (r < 0) {
423 return r;
424 }
425 virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd);
426 } else {
427 virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd);
428 event_notifier_cleanup(notifier);
429 }
430
431 if (vdc->guest_notifier_mask) {
432 vdc->guest_notifier_mask(vdev, n, !assign);
433 }
434
435 return 0;
436}
437
438static int virtio_mmio_set_guest_notifiers(DeviceState *d, int nvqs,
439 bool assign)
440{
441 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
442 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
443
444 bool with_irqfd = false;
445 int r, n;
446
447 nvqs = MIN(nvqs, VIRTIO_QUEUE_MAX);
448
449 for (n = 0; n < nvqs; n++) {
450 if (!virtio_queue_get_num(vdev, n)) {
451 break;
452 }
453
454 r = virtio_mmio_set_guest_notifier(d, n, assign, with_irqfd);
455 if (r < 0) {
456 goto assign_error;
457 }
458 }
459
460 return 0;
461
462assign_error:
463
464 assert(assign);
465 while (--n >= 0) {
466 virtio_mmio_set_guest_notifier(d, n, !assign, false);
467 }
468 return r;
469}
470
471
472
473static Property virtio_mmio_properties[] = {
474 DEFINE_PROP_BOOL("format_transport_address", VirtIOMMIOProxy,
475 format_transport_address, true),
476 DEFINE_PROP_END_OF_LIST(),
477};
478
479static void virtio_mmio_realizefn(DeviceState *d, Error **errp)
480{
481 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
482 SysBusDevice *sbd = SYS_BUS_DEVICE(d);
483
484 qbus_create_inplace(&proxy->bus, sizeof(proxy->bus), TYPE_VIRTIO_MMIO_BUS,
485 d, NULL);
486 sysbus_init_irq(sbd, &proxy->irq);
487 memory_region_init_io(&proxy->iomem, OBJECT(d), &virtio_mem_ops, proxy,
488 TYPE_VIRTIO_MMIO, 0x200);
489 sysbus_init_mmio(sbd, &proxy->iomem);
490}
491
492static void virtio_mmio_class_init(ObjectClass *klass, void *data)
493{
494 DeviceClass *dc = DEVICE_CLASS(klass);
495
496 dc->realize = virtio_mmio_realizefn;
497 dc->reset = virtio_mmio_reset;
498 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
499 dc->props = virtio_mmio_properties;
500}
501
502static const TypeInfo virtio_mmio_info = {
503 .name = TYPE_VIRTIO_MMIO,
504 .parent = TYPE_SYS_BUS_DEVICE,
505 .instance_size = sizeof(VirtIOMMIOProxy),
506 .class_init = virtio_mmio_class_init,
507};
508
509
510
511static char *virtio_mmio_bus_get_dev_path(DeviceState *dev)
512{
513 BusState *virtio_mmio_bus;
514 VirtIOMMIOProxy *virtio_mmio_proxy;
515 char *proxy_path;
516 SysBusDevice *proxy_sbd;
517 char *path;
518
519 virtio_mmio_bus = qdev_get_parent_bus(dev);
520 virtio_mmio_proxy = VIRTIO_MMIO(virtio_mmio_bus->parent);
521 proxy_path = qdev_get_dev_path(DEVICE(virtio_mmio_proxy));
522
523
524
525
526
527
528
529
530
531 if (!virtio_mmio_proxy->format_transport_address) {
532 return proxy_path;
533 }
534
535
536 proxy_sbd = SYS_BUS_DEVICE(virtio_mmio_proxy);
537 assert(proxy_sbd->num_mmio == 1);
538 assert(proxy_sbd->mmio[0].memory == &virtio_mmio_proxy->iomem);
539
540 if (proxy_path) {
541 path = g_strdup_printf("%s/virtio-mmio@" TARGET_FMT_plx, proxy_path,
542 proxy_sbd->mmio[0].addr);
543 } else {
544 path = g_strdup_printf("virtio-mmio@" TARGET_FMT_plx,
545 proxy_sbd->mmio[0].addr);
546 }
547 g_free(proxy_path);
548 return path;
549}
550
551static void virtio_mmio_bus_class_init(ObjectClass *klass, void *data)
552{
553 BusClass *bus_class = BUS_CLASS(klass);
554 VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
555
556 k->notify = virtio_mmio_update_irq;
557 k->save_config = virtio_mmio_save_config;
558 k->load_config = virtio_mmio_load_config;
559 k->set_guest_notifiers = virtio_mmio_set_guest_notifiers;
560 k->ioeventfd_started = virtio_mmio_ioeventfd_started;
561 k->ioeventfd_set_started = virtio_mmio_ioeventfd_set_started;
562 k->ioeventfd_disabled = virtio_mmio_ioeventfd_disabled;
563 k->ioeventfd_set_disabled = virtio_mmio_ioeventfd_set_disabled;
564 k->ioeventfd_assign = virtio_mmio_ioeventfd_assign;
565 k->has_variable_vring_alignment = true;
566 bus_class->max_dev = 1;
567 bus_class->get_dev_path = virtio_mmio_bus_get_dev_path;
568}
569
570static const TypeInfo virtio_mmio_bus_info = {
571 .name = TYPE_VIRTIO_MMIO_BUS,
572 .parent = TYPE_VIRTIO_BUS,
573 .instance_size = sizeof(VirtioBusState),
574 .class_init = virtio_mmio_bus_class_init,
575};
576
577static void virtio_mmio_register_types(void)
578{
579 type_register_static(&virtio_mmio_bus_info);
580 type_register_static(&virtio_mmio_info);
581}
582
583type_init(virtio_mmio_register_types)
584
