]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Virtio MMIO bindings | |
3 | * | |
4 | * Copyright (c) 2011 Linaro Limited | |
5 | * | |
6 | * Author: | |
7 | * Peter Maydell <peter.maydell@linaro.org> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License; either version 2 | |
11 | * of the License, or (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License along | |
19 | * with this program; if not, see <http://www.gnu.org/licenses/>. | |
20 | */ | |
21 | ||
22 | #include "qemu/osdep.h" | |
23 | #include "standard-headers/linux/virtio_mmio.h" | |
24 | #include "hw/sysbus.h" | |
25 | #include "hw/virtio/virtio.h" | |
26 | #include "qemu/host-utils.h" | |
27 | #include "qemu/module.h" | |
28 | #include "sysemu/kvm.h" | |
29 | #include "hw/virtio/virtio-bus.h" | |
30 | #include "qemu/error-report.h" | |
31 | #include "qemu/log.h" | |
32 | #include "trace.h" | |
33 | ||
34 | /* QOM macros */ | |
35 | /* virtio-mmio-bus */ | |
36 | #define TYPE_VIRTIO_MMIO_BUS "virtio-mmio-bus" | |
37 | #define VIRTIO_MMIO_BUS(obj) \ | |
38 | OBJECT_CHECK(VirtioBusState, (obj), TYPE_VIRTIO_MMIO_BUS) | |
39 | #define VIRTIO_MMIO_BUS_GET_CLASS(obj) \ | |
40 | OBJECT_GET_CLASS(VirtioBusClass, (obj), TYPE_VIRTIO_MMIO_BUS) | |
41 | #define VIRTIO_MMIO_BUS_CLASS(klass) \ | |
42 | OBJECT_CLASS_CHECK(VirtioBusClass, (klass), TYPE_VIRTIO_MMIO_BUS) | |
43 | ||
44 | /* virtio-mmio */ | |
45 | #define TYPE_VIRTIO_MMIO "virtio-mmio" | |
46 | #define VIRTIO_MMIO(obj) \ | |
47 | OBJECT_CHECK(VirtIOMMIOProxy, (obj), TYPE_VIRTIO_MMIO) | |
48 | ||
49 | #define VIRT_MAGIC 0x74726976 /* 'virt' */ | |
50 | #define VIRT_VERSION 1 | |
51 | #define VIRT_VENDOR 0x554D4551 /* 'QEMU' */ | |
52 | ||
53 | typedef struct { | |
54 | /* Generic */ | |
55 | SysBusDevice parent_obj; | |
56 | MemoryRegion iomem; | |
57 | qemu_irq irq; | |
58 | /* Guest accessible state needing migration and reset */ | |
59 | uint32_t host_features_sel; | |
60 | uint32_t guest_features_sel; | |
61 | uint32_t guest_page_shift; | |
62 | /* virtio-bus */ | |
63 | VirtioBusState bus; | |
64 | bool format_transport_address; | |
65 | } VirtIOMMIOProxy; | |
66 | ||
67 | static bool virtio_mmio_ioeventfd_enabled(DeviceState *d) | |
68 | { | |
69 | return kvm_eventfds_enabled(); | |
70 | } | |
71 | ||
72 | static int virtio_mmio_ioeventfd_assign(DeviceState *d, | |
73 | EventNotifier *notifier, | |
74 | int n, bool assign) | |
75 | { | |
76 | VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); | |
77 | ||
78 | if (assign) { | |
79 | memory_region_add_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUE_NOTIFY, 4, | |
80 | true, n, notifier); | |
81 | } else { | |
82 | memory_region_del_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUE_NOTIFY, 4, | |
83 | true, n, notifier); | |
84 | } | |
85 | return 0; | |
86 | } | |
87 | ||
88 | static void virtio_mmio_start_ioeventfd(VirtIOMMIOProxy *proxy) | |
89 | { | |
90 | virtio_bus_start_ioeventfd(&proxy->bus); | |
91 | } | |
92 | ||
93 | static void virtio_mmio_stop_ioeventfd(VirtIOMMIOProxy *proxy) | |
94 | { | |
95 | virtio_bus_stop_ioeventfd(&proxy->bus); | |
96 | } | |
97 | ||
98 | static uint64_t virtio_mmio_read(void *opaque, hwaddr offset, unsigned size) | |
99 | { | |
100 | VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque; | |
101 | VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); | |
102 | ||
103 | trace_virtio_mmio_read(offset); | |
104 | ||
105 | if (!vdev) { | |
106 | /* If no backend is present, we treat most registers as | |
107 | * read-as-zero, except for the magic number, version and | |
108 | * vendor ID. This is not strictly sanctioned by the virtio | |
109 | * spec, but it allows us to provide transports with no backend | |
110 | * plugged in which don't confuse Linux's virtio code: the | |
111 | * probe won't complain about the bad magic number, but the | |
112 | * device ID of zero means no backend will claim it. | |
113 | */ | |
114 | switch (offset) { | |
115 | case VIRTIO_MMIO_MAGIC_VALUE: | |
116 | return VIRT_MAGIC; | |
117 | case VIRTIO_MMIO_VERSION: | |
118 | return VIRT_VERSION; | |
119 | case VIRTIO_MMIO_VENDOR_ID: | |
120 | return VIRT_VENDOR; | |
121 | default: | |
122 | return 0; | |
123 | } | |
124 | } | |
125 | ||
126 | if (offset >= VIRTIO_MMIO_CONFIG) { | |
127 | offset -= VIRTIO_MMIO_CONFIG; | |
128 | switch (size) { | |
129 | case 1: | |
130 | return virtio_config_readb(vdev, offset); | |
131 | case 2: | |
132 | return virtio_config_readw(vdev, offset); | |
133 | case 4: | |
134 | return virtio_config_readl(vdev, offset); | |
135 | default: | |
136 | abort(); | |
137 | } | |
138 | } | |
139 | if (size != 4) { | |
140 | qemu_log_mask(LOG_GUEST_ERROR, | |
141 | "%s: wrong size access to register!\n", | |
142 | __func__); | |
143 | return 0; | |
144 | } | |
145 | switch (offset) { | |
146 | case VIRTIO_MMIO_MAGIC_VALUE: | |
147 | return VIRT_MAGIC; | |
148 | case VIRTIO_MMIO_VERSION: | |
149 | return VIRT_VERSION; | |
150 | case VIRTIO_MMIO_DEVICE_ID: | |
151 | return vdev->device_id; | |
152 | case VIRTIO_MMIO_VENDOR_ID: | |
153 | return VIRT_VENDOR; | |
154 | case VIRTIO_MMIO_DEVICE_FEATURES: | |
155 | if (proxy->host_features_sel) { | |
156 | return 0; | |
157 | } | |
158 | return vdev->host_features; | |
159 | case VIRTIO_MMIO_QUEUE_NUM_MAX: | |
160 | if (!virtio_queue_get_num(vdev, vdev->queue_sel)) { | |
161 | return 0; | |
162 | } | |
163 | return VIRTQUEUE_MAX_SIZE; | |
164 | case VIRTIO_MMIO_QUEUE_PFN: | |
165 | return virtio_queue_get_addr(vdev, vdev->queue_sel) | |
166 | >> proxy->guest_page_shift; | |
167 | case VIRTIO_MMIO_INTERRUPT_STATUS: | |
168 | return atomic_read(&vdev->isr); | |
169 | case VIRTIO_MMIO_STATUS: | |
170 | return vdev->status; | |
171 | case VIRTIO_MMIO_DEVICE_FEATURES_SEL: | |
172 | case VIRTIO_MMIO_DRIVER_FEATURES: | |
173 | case VIRTIO_MMIO_DRIVER_FEATURES_SEL: | |
174 | case VIRTIO_MMIO_GUEST_PAGE_SIZE: | |
175 | case VIRTIO_MMIO_QUEUE_SEL: | |
176 | case VIRTIO_MMIO_QUEUE_NUM: | |
177 | case VIRTIO_MMIO_QUEUE_ALIGN: | |
178 | case VIRTIO_MMIO_QUEUE_NOTIFY: | |
179 | case VIRTIO_MMIO_INTERRUPT_ACK: | |
180 | qemu_log_mask(LOG_GUEST_ERROR, | |
181 | "%s: read of write-only register\n", | |
182 | __func__); | |
183 | return 0; | |
184 | default: | |
185 | qemu_log_mask(LOG_GUEST_ERROR, "%s: bad register offset\n", __func__); | |
186 | return 0; | |
187 | } | |
188 | return 0; | |
189 | } | |
190 | ||
191 | static void virtio_mmio_write(void *opaque, hwaddr offset, uint64_t value, | |
192 | unsigned size) | |
193 | { | |
194 | VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque; | |
195 | VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); | |
196 | ||
197 | trace_virtio_mmio_write_offset(offset, value); | |
198 | ||
199 | if (!vdev) { | |
200 | /* If no backend is present, we just make all registers | |
201 | * write-ignored. This allows us to provide transports with | |
202 | * no backend plugged in. | |
203 | */ | |
204 | return; | |
205 | } | |
206 | ||
207 | if (offset >= VIRTIO_MMIO_CONFIG) { | |
208 | offset -= VIRTIO_MMIO_CONFIG; | |
209 | switch (size) { | |
210 | case 1: | |
211 | virtio_config_writeb(vdev, offset, value); | |
212 | break; | |
213 | case 2: | |
214 | virtio_config_writew(vdev, offset, value); | |
215 | break; | |
216 | case 4: | |
217 | virtio_config_writel(vdev, offset, value); | |
218 | break; | |
219 | default: | |
220 | abort(); | |
221 | } | |
222 | return; | |
223 | } | |
224 | if (size != 4) { | |
225 | qemu_log_mask(LOG_GUEST_ERROR, | |
226 | "%s: wrong size access to register!\n", | |
227 | __func__); | |
228 | return; | |
229 | } | |
230 | switch (offset) { | |
231 | case VIRTIO_MMIO_DEVICE_FEATURES_SEL: | |
232 | proxy->host_features_sel = value; | |
233 | break; | |
234 | case VIRTIO_MMIO_DRIVER_FEATURES: | |
235 | if (!proxy->guest_features_sel) { | |
236 | virtio_set_features(vdev, value); | |
237 | } | |
238 | break; | |
239 | case VIRTIO_MMIO_DRIVER_FEATURES_SEL: | |
240 | proxy->guest_features_sel = value; | |
241 | break; | |
242 | case VIRTIO_MMIO_GUEST_PAGE_SIZE: | |
243 | proxy->guest_page_shift = ctz32(value); | |
244 | if (proxy->guest_page_shift > 31) { | |
245 | proxy->guest_page_shift = 0; | |
246 | } | |
247 | trace_virtio_mmio_guest_page(value, proxy->guest_page_shift); | |
248 | break; | |
249 | case VIRTIO_MMIO_QUEUE_SEL: | |
250 | if (value < VIRTIO_QUEUE_MAX) { | |
251 | vdev->queue_sel = value; | |
252 | } | |
253 | break; | |
254 | case VIRTIO_MMIO_QUEUE_NUM: | |
255 | trace_virtio_mmio_queue_write(value, VIRTQUEUE_MAX_SIZE); | |
256 | virtio_queue_set_num(vdev, vdev->queue_sel, value); | |
257 | /* Note: only call this function for legacy devices */ | |
258 | virtio_queue_update_rings(vdev, vdev->queue_sel); | |
259 | break; | |
260 | case VIRTIO_MMIO_QUEUE_ALIGN: | |
261 | /* Note: this is only valid for legacy devices */ | |
262 | virtio_queue_set_align(vdev, vdev->queue_sel, value); | |
263 | break; | |
264 | case VIRTIO_MMIO_QUEUE_PFN: | |
265 | if (value == 0) { | |
266 | virtio_reset(vdev); | |
267 | } else { | |
268 | virtio_queue_set_addr(vdev, vdev->queue_sel, | |
269 | value << proxy->guest_page_shift); | |
270 | } | |
271 | break; | |
272 | case VIRTIO_MMIO_QUEUE_NOTIFY: | |
273 | if (value < VIRTIO_QUEUE_MAX) { | |
274 | virtio_queue_notify(vdev, value); | |
275 | } | |
276 | break; | |
277 | case VIRTIO_MMIO_INTERRUPT_ACK: | |
278 | atomic_and(&vdev->isr, ~value); | |
279 | virtio_update_irq(vdev); | |
280 | break; | |
281 | case VIRTIO_MMIO_STATUS: | |
282 | if (!(value & VIRTIO_CONFIG_S_DRIVER_OK)) { | |
283 | virtio_mmio_stop_ioeventfd(proxy); | |
284 | } | |
285 | ||
286 | virtio_set_status(vdev, value & 0xff); | |
287 | ||
288 | if (value & VIRTIO_CONFIG_S_DRIVER_OK) { | |
289 | virtio_mmio_start_ioeventfd(proxy); | |
290 | } | |
291 | ||
292 | if (vdev->status == 0) { | |
293 | virtio_reset(vdev); | |
294 | } | |
295 | break; | |
296 | case VIRTIO_MMIO_MAGIC_VALUE: | |
297 | case VIRTIO_MMIO_VERSION: | |
298 | case VIRTIO_MMIO_DEVICE_ID: | |
299 | case VIRTIO_MMIO_VENDOR_ID: | |
300 | case VIRTIO_MMIO_DEVICE_FEATURES: | |
301 | case VIRTIO_MMIO_QUEUE_NUM_MAX: | |
302 | case VIRTIO_MMIO_INTERRUPT_STATUS: | |
303 | qemu_log_mask(LOG_GUEST_ERROR, | |
304 | "%s: write to readonly register\n", | |
305 | __func__); | |
306 | break; | |
307 | ||
308 | default: | |
309 | qemu_log_mask(LOG_GUEST_ERROR, "%s: bad register offset\n", __func__); | |
310 | } | |
311 | } | |
312 | ||
313 | static const MemoryRegionOps virtio_mem_ops = { | |
314 | .read = virtio_mmio_read, | |
315 | .write = virtio_mmio_write, | |
316 | .endianness = DEVICE_NATIVE_ENDIAN, | |
317 | }; | |
318 | ||
319 | static void virtio_mmio_update_irq(DeviceState *opaque, uint16_t vector) | |
320 | { | |
321 | VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); | |
322 | VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); | |
323 | int level; | |
324 | ||
325 | if (!vdev) { | |
326 | return; | |
327 | } | |
328 | level = (atomic_read(&vdev->isr) != 0); | |
329 | trace_virtio_mmio_setting_irq(level); | |
330 | qemu_set_irq(proxy->irq, level); | |
331 | } | |
332 | ||
333 | static int virtio_mmio_load_config(DeviceState *opaque, QEMUFile *f) | |
334 | { | |
335 | VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); | |
336 | ||
337 | proxy->host_features_sel = qemu_get_be32(f); | |
338 | proxy->guest_features_sel = qemu_get_be32(f); | |
339 | proxy->guest_page_shift = qemu_get_be32(f); | |
340 | return 0; | |
341 | } | |
342 | ||
343 | static void virtio_mmio_save_config(DeviceState *opaque, QEMUFile *f) | |
344 | { | |
345 | VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); | |
346 | ||
347 | qemu_put_be32(f, proxy->host_features_sel); | |
348 | qemu_put_be32(f, proxy->guest_features_sel); | |
349 | qemu_put_be32(f, proxy->guest_page_shift); | |
350 | } | |
351 | ||
352 | static void virtio_mmio_reset(DeviceState *d) | |
353 | { | |
354 | VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); | |
355 | ||
356 | virtio_mmio_stop_ioeventfd(proxy); | |
357 | virtio_bus_reset(&proxy->bus); | |
358 | proxy->host_features_sel = 0; | |
359 | proxy->guest_features_sel = 0; | |
360 | proxy->guest_page_shift = 0; | |
361 | } | |
362 | ||
363 | static int virtio_mmio_set_guest_notifier(DeviceState *d, int n, bool assign, | |
364 | bool with_irqfd) | |
365 | { | |
366 | VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); | |
367 | VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); | |
368 | VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev); | |
369 | VirtQueue *vq = virtio_get_queue(vdev, n); | |
370 | EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); | |
371 | ||
372 | if (assign) { | |
373 | int r = event_notifier_init(notifier, 0); | |
374 | if (r < 0) { | |
375 | return r; | |
376 | } | |
377 | virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd); | |
378 | } else { | |
379 | virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd); | |
380 | event_notifier_cleanup(notifier); | |
381 | } | |
382 | ||
383 | if (vdc->guest_notifier_mask && vdev->use_guest_notifier_mask) { | |
384 | vdc->guest_notifier_mask(vdev, n, !assign); | |
385 | } | |
386 | ||
387 | return 0; | |
388 | } | |
389 | ||
390 | static int virtio_mmio_set_guest_notifiers(DeviceState *d, int nvqs, | |
391 | bool assign) | |
392 | { | |
393 | VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); | |
394 | VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); | |
395 | /* TODO: need to check if kvm-arm supports irqfd */ | |
396 | bool with_irqfd = false; | |
397 | int r, n; | |
398 | ||
399 | nvqs = MIN(nvqs, VIRTIO_QUEUE_MAX); | |
400 | ||
401 | for (n = 0; n < nvqs; n++) { | |
402 | if (!virtio_queue_get_num(vdev, n)) { | |
403 | break; | |
404 | } | |
405 | ||
406 | r = virtio_mmio_set_guest_notifier(d, n, assign, with_irqfd); | |
407 | if (r < 0) { | |
408 | goto assign_error; | |
409 | } | |
410 | } | |
411 | ||
412 | return 0; | |
413 | ||
414 | assign_error: | |
415 | /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */ | |
416 | assert(assign); | |
417 | while (--n >= 0) { | |
418 | virtio_mmio_set_guest_notifier(d, n, !assign, false); | |
419 | } | |
420 | return r; | |
421 | } | |
422 | ||
423 | /* virtio-mmio device */ | |
424 | ||
425 | static Property virtio_mmio_properties[] = { | |
426 | DEFINE_PROP_BOOL("format_transport_address", VirtIOMMIOProxy, | |
427 | format_transport_address, true), | |
428 | DEFINE_PROP_END_OF_LIST(), | |
429 | }; | |
430 | ||
431 | static void virtio_mmio_realizefn(DeviceState *d, Error **errp) | |
432 | { | |
433 | VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); | |
434 | SysBusDevice *sbd = SYS_BUS_DEVICE(d); | |
435 | ||
436 | qbus_create_inplace(&proxy->bus, sizeof(proxy->bus), TYPE_VIRTIO_MMIO_BUS, | |
437 | d, NULL); | |
438 | sysbus_init_irq(sbd, &proxy->irq); | |
439 | memory_region_init_io(&proxy->iomem, OBJECT(d), &virtio_mem_ops, proxy, | |
440 | TYPE_VIRTIO_MMIO, 0x200); | |
441 | sysbus_init_mmio(sbd, &proxy->iomem); | |
442 | } | |
443 | ||
444 | static void virtio_mmio_class_init(ObjectClass *klass, void *data) | |
445 | { | |
446 | DeviceClass *dc = DEVICE_CLASS(klass); | |
447 | ||
448 | dc->realize = virtio_mmio_realizefn; | |
449 | dc->reset = virtio_mmio_reset; | |
450 | set_bit(DEVICE_CATEGORY_MISC, dc->categories); | |
451 | dc->props = virtio_mmio_properties; | |
452 | } | |
453 | ||
454 | static const TypeInfo virtio_mmio_info = { | |
455 | .name = TYPE_VIRTIO_MMIO, | |
456 | .parent = TYPE_SYS_BUS_DEVICE, | |
457 | .instance_size = sizeof(VirtIOMMIOProxy), | |
458 | .class_init = virtio_mmio_class_init, | |
459 | }; | |
460 | ||
461 | /* virtio-mmio-bus. */ | |
462 | ||
463 | static char *virtio_mmio_bus_get_dev_path(DeviceState *dev) | |
464 | { | |
465 | BusState *virtio_mmio_bus; | |
466 | VirtIOMMIOProxy *virtio_mmio_proxy; | |
467 | char *proxy_path; | |
468 | SysBusDevice *proxy_sbd; | |
469 | char *path; | |
470 | ||
471 | virtio_mmio_bus = qdev_get_parent_bus(dev); | |
472 | virtio_mmio_proxy = VIRTIO_MMIO(virtio_mmio_bus->parent); | |
473 | proxy_path = qdev_get_dev_path(DEVICE(virtio_mmio_proxy)); | |
474 | ||
475 | /* | |
476 | * If @format_transport_address is false, then we just perform the same as | |
477 | * virtio_bus_get_dev_path(): we delegate the address formatting for the | |
478 | * device on the virtio-mmio bus to the bus that the virtio-mmio proxy | |
479 | * (i.e., the device that implements the virtio-mmio bus) resides on. In | |
480 | * this case the base address of the virtio-mmio transport will be | |
481 | * invisible. | |
482 | */ | |
483 | if (!virtio_mmio_proxy->format_transport_address) { | |
484 | return proxy_path; | |
485 | } | |
486 | ||
487 | /* Otherwise, we append the base address of the transport. */ | |
488 | proxy_sbd = SYS_BUS_DEVICE(virtio_mmio_proxy); | |
489 | assert(proxy_sbd->num_mmio == 1); | |
490 | assert(proxy_sbd->mmio[0].memory == &virtio_mmio_proxy->iomem); | |
491 | ||
492 | if (proxy_path) { | |
493 | path = g_strdup_printf("%s/virtio-mmio@" TARGET_FMT_plx, proxy_path, | |
494 | proxy_sbd->mmio[0].addr); | |
495 | } else { | |
496 | path = g_strdup_printf("virtio-mmio@" TARGET_FMT_plx, | |
497 | proxy_sbd->mmio[0].addr); | |
498 | } | |
499 | g_free(proxy_path); | |
500 | return path; | |
501 | } | |
502 | ||
503 | static void virtio_mmio_bus_class_init(ObjectClass *klass, void *data) | |
504 | { | |
505 | BusClass *bus_class = BUS_CLASS(klass); | |
506 | VirtioBusClass *k = VIRTIO_BUS_CLASS(klass); | |
507 | ||
508 | k->notify = virtio_mmio_update_irq; | |
509 | k->save_config = virtio_mmio_save_config; | |
510 | k->load_config = virtio_mmio_load_config; | |
511 | k->set_guest_notifiers = virtio_mmio_set_guest_notifiers; | |
512 | k->ioeventfd_enabled = virtio_mmio_ioeventfd_enabled; | |
513 | k->ioeventfd_assign = virtio_mmio_ioeventfd_assign; | |
514 | k->has_variable_vring_alignment = true; | |
515 | bus_class->max_dev = 1; | |
516 | bus_class->get_dev_path = virtio_mmio_bus_get_dev_path; | |
517 | } | |
518 | ||
519 | static const TypeInfo virtio_mmio_bus_info = { | |
520 | .name = TYPE_VIRTIO_MMIO_BUS, | |
521 | .parent = TYPE_VIRTIO_BUS, | |
522 | .instance_size = sizeof(VirtioBusState), | |
523 | .class_init = virtio_mmio_bus_class_init, | |
524 | }; | |
525 | ||
526 | static void virtio_mmio_register_types(void) | |
527 | { | |
528 | type_register_static(&virtio_mmio_bus_info); | |
529 | type_register_static(&virtio_mmio_info); | |
530 | } | |
531 | ||
532 | type_init(virtio_mmio_register_types) |