2 * Copyright (c) 2014 Ruslan Bukin <br@bsdpad.com>
3 * Copyright (c) 2014 The FreeBSD Foundation
6 * This software was developed by SRI International and the University of
7 * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
8 * ("CTSRD"), as part of the DARPA CRASH research programme.
10 * Portions of this software were developed by Andrew Turner
11 * under sponsorship from the FreeBSD Foundation.
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * VirtIO MMIO interface.
37 * This driver is heavily based on VirtIO PCI interface driver.
40 #include <sys/cdefs.h>
41 __FBSDID("$FreeBSD$");
43 #include <sys/param.h>
44 #include <sys/systm.h>
46 #include <sys/kernel.h>
47 #include <sys/module.h>
48 #include <sys/malloc.h>
50 #include <sys/endian.h>
52 #include <machine/bus.h>
53 #include <machine/resource.h>
55 #include <dev/virtio/virtio.h>
56 #include <dev/virtio/virtqueue.h>
57 #include <dev/virtio/mmio/virtio_mmio.h>
59 #include "virtio_mmio_if.h"
60 #include "virtio_bus_if.h"
61 #include "virtio_if.h"
63 struct vtmmio_virtqueue {
64 struct virtqueue *vtv_vq;
68 static int vtmmio_detach(device_t);
69 static int vtmmio_suspend(device_t);
70 static int vtmmio_resume(device_t);
71 static int vtmmio_shutdown(device_t);
72 static void vtmmio_driver_added(device_t, driver_t *);
73 static void vtmmio_child_detached(device_t, device_t);
74 static int vtmmio_read_ivar(device_t, device_t, int, uintptr_t *);
75 static int vtmmio_write_ivar(device_t, device_t, int, uintptr_t);
76 static uint64_t vtmmio_negotiate_features(device_t, uint64_t);
77 static int vtmmio_with_feature(device_t, uint64_t);
78 static void vtmmio_set_virtqueue(struct vtmmio_softc *sc,
79 struct virtqueue *vq, uint32_t size);
80 static int vtmmio_alloc_virtqueues(device_t, int, int,
81 struct vq_alloc_info *);
82 static int vtmmio_setup_intr(device_t, enum intr_type);
83 static void vtmmio_stop(device_t);
84 static void vtmmio_poll(device_t);
85 static int vtmmio_reinit(device_t, uint64_t);
86 static void vtmmio_reinit_complete(device_t);
87 static void vtmmio_notify_virtqueue(device_t, uint16_t, bus_size_t);
88 static uint8_t vtmmio_get_status(device_t);
89 static void vtmmio_set_status(device_t, uint8_t);
90 static void vtmmio_read_dev_config(device_t, bus_size_t, void *, int);
91 static void vtmmio_write_dev_config(device_t, bus_size_t, void *, int);
92 static void vtmmio_describe_features(struct vtmmio_softc *, const char *,
94 static void vtmmio_probe_and_attach_child(struct vtmmio_softc *);
95 static int vtmmio_reinit_virtqueue(struct vtmmio_softc *, int);
96 static void vtmmio_free_interrupts(struct vtmmio_softc *);
97 static void vtmmio_free_virtqueues(struct vtmmio_softc *);
98 static void vtmmio_release_child_resources(struct vtmmio_softc *);
99 static void vtmmio_reset(struct vtmmio_softc *);
100 static void vtmmio_select_virtqueue(struct vtmmio_softc *, int);
101 static void vtmmio_vq_intr(void *);
104 * I/O port read/write wrappers.
106 #define vtmmio_write_config_1(sc, o, v) \
108 if (sc->platform != NULL) \
109 VIRTIO_MMIO_PREWRITE(sc->platform, (o), (v)); \
110 bus_write_1((sc)->res[0], (o), (v)); \
111 if (sc->platform != NULL) \
112 VIRTIO_MMIO_NOTE(sc->platform, (o), (v)); \
114 #define vtmmio_write_config_2(sc, o, v) \
116 if (sc->platform != NULL) \
117 VIRTIO_MMIO_PREWRITE(sc->platform, (o), (v)); \
118 bus_write_2((sc)->res[0], (o), (v)); \
119 if (sc->platform != NULL) \
120 VIRTIO_MMIO_NOTE(sc->platform, (o), (v)); \
122 #define vtmmio_write_config_4(sc, o, v) \
124 if (sc->platform != NULL) \
125 VIRTIO_MMIO_PREWRITE(sc->platform, (o), (v)); \
126 bus_write_4((sc)->res[0], (o), (v)); \
127 if (sc->platform != NULL) \
128 VIRTIO_MMIO_NOTE(sc->platform, (o), (v)); \
131 #define vtmmio_read_config_1(sc, o) \
132 bus_read_1((sc)->res[0], (o))
133 #define vtmmio_read_config_2(sc, o) \
134 bus_read_2((sc)->res[0], (o))
135 #define vtmmio_read_config_4(sc, o) \
136 bus_read_4((sc)->res[0], (o))
138 static device_method_t vtmmio_methods[] = {
139 /* Device interface. */
140 DEVMETHOD(device_attach, vtmmio_attach),
141 DEVMETHOD(device_detach, vtmmio_detach),
142 DEVMETHOD(device_suspend, vtmmio_suspend),
143 DEVMETHOD(device_resume, vtmmio_resume),
144 DEVMETHOD(device_shutdown, vtmmio_shutdown),
147 DEVMETHOD(bus_driver_added, vtmmio_driver_added),
148 DEVMETHOD(bus_child_detached, vtmmio_child_detached),
149 DEVMETHOD(bus_child_pnpinfo, virtio_child_pnpinfo),
150 DEVMETHOD(bus_read_ivar, vtmmio_read_ivar),
151 DEVMETHOD(bus_write_ivar, vtmmio_write_ivar),
153 /* VirtIO bus interface. */
154 DEVMETHOD(virtio_bus_negotiate_features, vtmmio_negotiate_features),
155 DEVMETHOD(virtio_bus_with_feature, vtmmio_with_feature),
156 DEVMETHOD(virtio_bus_alloc_virtqueues, vtmmio_alloc_virtqueues),
157 DEVMETHOD(virtio_bus_setup_intr, vtmmio_setup_intr),
158 DEVMETHOD(virtio_bus_stop, vtmmio_stop),
159 DEVMETHOD(virtio_bus_poll, vtmmio_poll),
160 DEVMETHOD(virtio_bus_reinit, vtmmio_reinit),
161 DEVMETHOD(virtio_bus_reinit_complete, vtmmio_reinit_complete),
162 DEVMETHOD(virtio_bus_notify_vq, vtmmio_notify_virtqueue),
163 DEVMETHOD(virtio_bus_read_device_config, vtmmio_read_dev_config),
164 DEVMETHOD(virtio_bus_write_device_config, vtmmio_write_dev_config),
169 DEFINE_CLASS_0(virtio_mmio, vtmmio_driver, vtmmio_methods,
170 sizeof(struct vtmmio_softc));
172 MODULE_VERSION(virtio_mmio, 1);
175 vtmmio_probe(device_t dev)
177 struct vtmmio_softc *sc;
179 uint32_t magic, version;
181 sc = device_get_softc(dev);
184 sc->res[0] = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
186 if (sc->res[0] == NULL) {
187 device_printf(dev, "Cannot allocate memory window.\n");
191 magic = vtmmio_read_config_4(sc, VIRTIO_MMIO_MAGIC_VALUE);
192 if (magic != VIRTIO_MMIO_MAGIC_VIRT) {
193 device_printf(dev, "Bad magic value %#x\n", magic);
194 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->res[0]);
198 version = vtmmio_read_config_4(sc, VIRTIO_MMIO_VERSION);
199 if (version < 1 || version > 2) {
200 device_printf(dev, "Unsupported version: %#x\n", version);
201 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->res[0]);
205 if (vtmmio_read_config_4(sc, VIRTIO_MMIO_DEVICE_ID) == 0) {
206 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->res[0]);
210 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->res[0]);
212 device_set_desc(dev, "VirtIO MMIO adapter");
213 return (BUS_PROBE_DEFAULT);
217 vtmmio_setup_intr(device_t dev, enum intr_type type)
219 struct vtmmio_softc *sc;
223 sc = device_get_softc(dev);
225 if (sc->platform != NULL) {
226 err = VIRTIO_MMIO_SETUP_INTR(sc->platform, sc->dev,
229 /* Okay we have backend-specific interrupts */
235 sc->res[1] = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
238 device_printf(dev, "Can't allocate interrupt\n");
242 if (bus_setup_intr(dev, sc->res[1], type | INTR_MPSAFE,
243 NULL, vtmmio_vq_intr, sc, &sc->ih)) {
244 device_printf(dev, "Can't setup the interrupt\n");
252 vtmmio_attach(device_t dev)
254 struct vtmmio_softc *sc;
258 sc = device_get_softc(dev);
262 sc->res[0] = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
264 if (sc->res[0] == NULL) {
265 device_printf(dev, "Cannot allocate memory window.\n");
269 sc->vtmmio_version = vtmmio_read_config_4(sc, VIRTIO_MMIO_VERSION);
273 /* Tell the host we've noticed this device. */
274 vtmmio_set_status(dev, VIRTIO_CONFIG_STATUS_ACK);
276 if ((child = device_add_child(dev, NULL, -1)) == NULL) {
277 device_printf(dev, "Cannot create child device.\n");
278 vtmmio_set_status(dev, VIRTIO_CONFIG_STATUS_FAILED);
283 sc->vtmmio_child_dev = child;
284 vtmmio_probe_and_attach_child(sc);
290 vtmmio_detach(device_t dev)
292 struct vtmmio_softc *sc;
296 sc = device_get_softc(dev);
298 if ((child = sc->vtmmio_child_dev) != NULL) {
299 error = device_delete_child(dev, child);
302 sc->vtmmio_child_dev = NULL;
307 if (sc->res[0] != NULL) {
308 bus_release_resource(dev, SYS_RES_MEMORY, 0,
317 vtmmio_suspend(device_t dev)
320 return (bus_generic_suspend(dev));
324 vtmmio_resume(device_t dev)
327 return (bus_generic_resume(dev));
331 vtmmio_shutdown(device_t dev)
334 (void) bus_generic_shutdown(dev);
336 /* Forcibly stop the host device. */
343 vtmmio_driver_added(device_t dev, driver_t *driver)
345 struct vtmmio_softc *sc;
347 sc = device_get_softc(dev);
349 vtmmio_probe_and_attach_child(sc);
353 vtmmio_child_detached(device_t dev, device_t child)
355 struct vtmmio_softc *sc;
357 sc = device_get_softc(dev);
360 vtmmio_release_child_resources(sc);
364 vtmmio_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
366 struct vtmmio_softc *sc;
368 sc = device_get_softc(dev);
370 if (sc->vtmmio_child_dev != child)
374 case VIRTIO_IVAR_DEVTYPE:
375 case VIRTIO_IVAR_SUBDEVICE:
376 *result = vtmmio_read_config_4(sc, VIRTIO_MMIO_DEVICE_ID);
378 case VIRTIO_IVAR_VENDOR:
379 *result = vtmmio_read_config_4(sc, VIRTIO_MMIO_VENDOR_ID);
381 case VIRTIO_IVAR_SUBVENDOR:
382 case VIRTIO_IVAR_DEVICE:
384 * Dummy value for fields not present in this bus. Used by
385 * bus-agnostic virtio_child_pnpinfo.
389 case VIRTIO_IVAR_MODERN:
391 * There are several modern (aka MMIO v2) spec compliance
392 * issues with this driver, but keep the status quo.
394 *result = sc->vtmmio_version > 1;
404 vtmmio_write_ivar(device_t dev, device_t child, int index, uintptr_t value)
406 struct vtmmio_softc *sc;
408 sc = device_get_softc(dev);
410 if (sc->vtmmio_child_dev != child)
414 case VIRTIO_IVAR_FEATURE_DESC:
415 sc->vtmmio_child_feat_desc = (void *) value;
425 vtmmio_negotiate_features(device_t dev, uint64_t child_features)
427 struct vtmmio_softc *sc;
428 uint64_t host_features, features;
430 sc = device_get_softc(dev);
432 if (sc->vtmmio_version > 1) {
433 child_features |= VIRTIO_F_VERSION_1;
436 vtmmio_write_config_4(sc, VIRTIO_MMIO_HOST_FEATURES_SEL, 1);
437 host_features = vtmmio_read_config_4(sc, VIRTIO_MMIO_HOST_FEATURES);
438 host_features <<= 32;
440 vtmmio_write_config_4(sc, VIRTIO_MMIO_HOST_FEATURES_SEL, 0);
441 host_features |= vtmmio_read_config_4(sc, VIRTIO_MMIO_HOST_FEATURES);
443 vtmmio_describe_features(sc, "host", host_features);
446 * Limit negotiated features to what the driver, virtqueue, and
449 features = host_features & child_features;
450 features = virtio_filter_transport_features(features);
451 sc->vtmmio_features = features;
453 vtmmio_describe_features(sc, "negotiated", features);
455 vtmmio_write_config_4(sc, VIRTIO_MMIO_GUEST_FEATURES_SEL, 1);
456 vtmmio_write_config_4(sc, VIRTIO_MMIO_GUEST_FEATURES, features >> 32);
458 vtmmio_write_config_4(sc, VIRTIO_MMIO_GUEST_FEATURES_SEL, 0);
459 vtmmio_write_config_4(sc, VIRTIO_MMIO_GUEST_FEATURES, features);
465 vtmmio_with_feature(device_t dev, uint64_t feature)
467 struct vtmmio_softc *sc;
469 sc = device_get_softc(dev);
471 return ((sc->vtmmio_features & feature) != 0);
475 vtmmio_set_virtqueue(struct vtmmio_softc *sc, struct virtqueue *vq,
480 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_NUM, size);
482 if (sc->vtmmio_version == 1) {
483 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_ALIGN,
484 VIRTIO_MMIO_VRING_ALIGN);
485 paddr = virtqueue_paddr(vq);
486 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_PFN,
487 paddr >> PAGE_SHIFT);
489 paddr = virtqueue_desc_paddr(vq);
490 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_DESC_LOW,
492 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_DESC_HIGH,
493 ((uint64_t)paddr) >> 32);
495 paddr = virtqueue_avail_paddr(vq);
496 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_AVAIL_LOW,
498 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_AVAIL_HIGH,
499 ((uint64_t)paddr) >> 32);
501 paddr = virtqueue_used_paddr(vq);
502 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_USED_LOW,
504 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_USED_HIGH,
505 ((uint64_t)paddr) >> 32);
507 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_READY, 1);
512 vtmmio_alloc_virtqueues(device_t dev, int flags, int nvqs,
513 struct vq_alloc_info *vq_info)
515 struct vtmmio_virtqueue *vqx;
516 struct vq_alloc_info *info;
517 struct vtmmio_softc *sc;
518 struct virtqueue *vq;
522 sc = device_get_softc(dev);
524 if (sc->vtmmio_nvqs != 0)
529 sc->vtmmio_vqs = malloc(nvqs * sizeof(struct vtmmio_virtqueue),
530 M_DEVBUF, M_NOWAIT | M_ZERO);
531 if (sc->vtmmio_vqs == NULL)
534 if (sc->vtmmio_version == 1) {
535 vtmmio_write_config_4(sc, VIRTIO_MMIO_GUEST_PAGE_SIZE,
539 for (idx = 0; idx < nvqs; idx++) {
540 vqx = &sc->vtmmio_vqs[idx];
541 info = &vq_info[idx];
543 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_SEL, idx);
545 vtmmio_select_virtqueue(sc, idx);
546 size = vtmmio_read_config_4(sc, VIRTIO_MMIO_QUEUE_NUM_MAX);
548 error = virtqueue_alloc(dev, idx, size,
549 VIRTIO_MMIO_QUEUE_NOTIFY, VIRTIO_MMIO_VRING_ALIGN,
550 ~(vm_paddr_t)0, info, &vq);
553 "cannot allocate virtqueue %d: %d\n",
558 vtmmio_set_virtqueue(sc, vq, size);
560 vqx->vtv_vq = *info->vqai_vq = vq;
561 vqx->vtv_no_intr = info->vqai_intr == NULL;
567 vtmmio_free_virtqueues(sc);
573 vtmmio_stop(device_t dev)
576 vtmmio_reset(device_get_softc(dev));
580 vtmmio_poll(device_t dev)
582 struct vtmmio_softc *sc;
584 sc = device_get_softc(dev);
586 if (sc->platform != NULL)
587 VIRTIO_MMIO_POLL(sc->platform);
591 vtmmio_reinit(device_t dev, uint64_t features)
593 struct vtmmio_softc *sc;
596 sc = device_get_softc(dev);
598 if (vtmmio_get_status(dev) != VIRTIO_CONFIG_STATUS_RESET)
602 * Quickly drive the status through ACK and DRIVER. The device
603 * does not become usable again until vtmmio_reinit_complete().
605 vtmmio_set_status(dev, VIRTIO_CONFIG_STATUS_ACK);
606 vtmmio_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER);
608 vtmmio_negotiate_features(dev, features);
610 if (sc->vtmmio_version == 1) {
611 vtmmio_write_config_4(sc, VIRTIO_MMIO_GUEST_PAGE_SIZE,
615 for (idx = 0; idx < sc->vtmmio_nvqs; idx++) {
616 error = vtmmio_reinit_virtqueue(sc, idx);
625 vtmmio_reinit_complete(device_t dev)
628 vtmmio_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER_OK);
632 vtmmio_notify_virtqueue(device_t dev, uint16_t queue, bus_size_t offset)
634 struct vtmmio_softc *sc;
636 sc = device_get_softc(dev);
637 MPASS(offset == VIRTIO_MMIO_QUEUE_NOTIFY);
639 vtmmio_write_config_4(sc, offset, queue);
643 vtmmio_get_status(device_t dev)
645 struct vtmmio_softc *sc;
647 sc = device_get_softc(dev);
649 return (vtmmio_read_config_4(sc, VIRTIO_MMIO_STATUS));
653 vtmmio_set_status(device_t dev, uint8_t status)
655 struct vtmmio_softc *sc;
657 sc = device_get_softc(dev);
659 if (status != VIRTIO_CONFIG_STATUS_RESET)
660 status |= vtmmio_get_status(dev);
662 vtmmio_write_config_4(sc, VIRTIO_MMIO_STATUS, status);
666 vtmmio_read_dev_config(device_t dev, bus_size_t offset,
667 void *dst, int length)
669 struct vtmmio_softc *sc;
673 uint64_t low32, high32;
675 sc = device_get_softc(dev);
676 off = VIRTIO_MMIO_CONFIG + offset;
679 * The non-legacy MMIO specification adds the following restriction:
681 * 4.2.2.2: For the device-specific configuration space, the driver
682 * MUST use 8 bit wide accesses for 8 bit wide fields, 16 bit wide
683 * and aligned accesses for 16 bit wide fields and 32 bit wide and
684 * aligned accesses for 32 and 64 bit wide fields.
686 * The endianness also varies between non-legacy and legacy:
688 * 2.4: Note: The device configuration space uses the little-endian
689 * format for multi-byte fields.
691 * 2.4.3: Note that for legacy interfaces, device configuration space
692 * is generally the guest’s native endian, rather than PCI’s
693 * little-endian. The correct endian-ness is documented for each
696 if (sc->vtmmio_version > 1) {
699 *(uint8_t *)dst = vtmmio_read_config_1(sc, off);
703 le16toh(vtmmio_read_config_2(sc, off));
707 le32toh(vtmmio_read_config_4(sc, off));
710 low32 = le32toh(vtmmio_read_config_4(sc, off));
711 high32 = le32toh(vtmmio_read_config_4(sc, off + 4));
712 *(uint64_t *)dst = (high32 << 32) | low32;
715 panic("%s: invalid length %d\n", __func__, length);
721 for (d = dst; length > 0; d += size, off += size, length -= size) {
722 #ifdef ALLOW_WORD_ALIGNED_ACCESS
725 *(uint32_t *)d = vtmmio_read_config_4(sc, off);
726 } else if (length >= 2) {
728 *(uint16_t *)d = vtmmio_read_config_2(sc, off);
733 *d = vtmmio_read_config_1(sc, off);
739 vtmmio_write_dev_config(device_t dev, bus_size_t offset,
740 void *src, int length)
742 struct vtmmio_softc *sc;
747 sc = device_get_softc(dev);
748 off = VIRTIO_MMIO_CONFIG + offset;
751 * The non-legacy MMIO specification adds size and alignment
752 * restrctions. It also changes the endianness from native-endian to
753 * little-endian. See vtmmio_read_dev_config.
755 if (sc->vtmmio_version > 1) {
758 vtmmio_write_config_1(sc, off, *(uint8_t *)src);
761 vtmmio_write_config_2(sc, off,
762 htole16(*(uint16_t *)src));
765 vtmmio_write_config_4(sc, off,
766 htole32(*(uint32_t *)src));
769 vtmmio_write_config_4(sc, off,
770 htole32(*(uint64_t *)src));
771 vtmmio_write_config_4(sc, off + 4,
772 htole32((*(uint64_t *)src) >> 32));
775 panic("%s: invalid length %d\n", __func__, length);
781 for (s = src; length > 0; s += size, off += size, length -= size) {
782 #ifdef ALLOW_WORD_ALIGNED_ACCESS
785 vtmmio_write_config_4(sc, off, *(uint32_t *)s);
786 } else if (length >= 2) {
788 vtmmio_write_config_2(sc, off, *(uint16_t *)s);
793 vtmmio_write_config_1(sc, off, *s);
799 vtmmio_describe_features(struct vtmmio_softc *sc, const char *msg,
805 child = sc->vtmmio_child_dev;
807 if (device_is_attached(child) || bootverbose == 0)
810 virtio_describe(dev, msg, features, sc->vtmmio_child_feat_desc);
814 vtmmio_probe_and_attach_child(struct vtmmio_softc *sc)
819 child = sc->vtmmio_child_dev;
824 if (device_get_state(child) != DS_NOTPRESENT) {
828 if (device_probe(child) != 0) {
832 vtmmio_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER);
833 if (device_attach(child) != 0) {
834 vtmmio_set_status(dev, VIRTIO_CONFIG_STATUS_FAILED);
836 vtmmio_release_child_resources(sc);
837 /* Reset status for future attempt. */
838 vtmmio_set_status(dev, VIRTIO_CONFIG_STATUS_ACK);
840 vtmmio_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER_OK);
841 VIRTIO_ATTACH_COMPLETED(child);
846 vtmmio_reinit_virtqueue(struct vtmmio_softc *sc, int idx)
848 struct vtmmio_virtqueue *vqx;
849 struct virtqueue *vq;
853 vqx = &sc->vtmmio_vqs[idx];
856 KASSERT(vq != NULL, ("%s: vq %d not allocated", __func__, idx));
858 vtmmio_select_virtqueue(sc, idx);
859 size = vtmmio_read_config_4(sc, VIRTIO_MMIO_QUEUE_NUM_MAX);
861 error = virtqueue_reinit(vq, size);
865 vtmmio_set_virtqueue(sc, vq, size);
871 vtmmio_free_interrupts(struct vtmmio_softc *sc)
875 bus_teardown_intr(sc->dev, sc->res[1], sc->ih);
877 if (sc->res[1] != NULL)
878 bus_release_resource(sc->dev, SYS_RES_IRQ, 0, sc->res[1]);
882 vtmmio_free_virtqueues(struct vtmmio_softc *sc)
884 struct vtmmio_virtqueue *vqx;
887 for (idx = 0; idx < sc->vtmmio_nvqs; idx++) {
888 vqx = &sc->vtmmio_vqs[idx];
890 vtmmio_select_virtqueue(sc, idx);
891 if (sc->vtmmio_version == 1)
892 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_PFN, 0);
894 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_READY, 0);
896 virtqueue_free(vqx->vtv_vq);
900 free(sc->vtmmio_vqs, M_DEVBUF);
901 sc->vtmmio_vqs = NULL;
906 vtmmio_release_child_resources(struct vtmmio_softc *sc)
909 vtmmio_free_interrupts(sc);
910 vtmmio_free_virtqueues(sc);
914 vtmmio_reset(struct vtmmio_softc *sc)
918 * Setting the status to RESET sets the host device to
919 * the original, uninitialized state.
921 vtmmio_set_status(sc->dev, VIRTIO_CONFIG_STATUS_RESET);
925 vtmmio_select_virtqueue(struct vtmmio_softc *sc, int idx)
928 vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_SEL, idx);
932 vtmmio_vq_intr(void *arg)
934 struct vtmmio_virtqueue *vqx;
935 struct vtmmio_softc *sc;
936 struct virtqueue *vq;
942 status = vtmmio_read_config_4(sc, VIRTIO_MMIO_INTERRUPT_STATUS);
943 vtmmio_write_config_4(sc, VIRTIO_MMIO_INTERRUPT_ACK, status);
945 /* The config changed */
946 if (status & VIRTIO_MMIO_INT_CONFIG)
947 if (sc->vtmmio_child_dev != NULL)
948 VIRTIO_CONFIG_CHANGE(sc->vtmmio_child_dev);
950 /* Notify all virtqueues. */
951 if (status & VIRTIO_MMIO_INT_VRING) {
952 for (idx = 0; idx < sc->vtmmio_nvqs; idx++) {
953 vqx = &sc->vtmmio_vqs[idx];
954 if (vqx->vtv_no_intr == 0) {