d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

virtio: Add VirtIO PCI modern (V1) support

Browse Source 
Use the existing legacy PCI driver as the basis for shared code
between the legacy and modern PCI drivers. The existing virtio_pci
kernel module will contain both the legacy and modern drivers.

Changes to the virtqueue and each device driver (network, block, etc)
for V1 support come in later commits.

Update the MMIO driver to reflect the VirtIO bus method changes, but
the modern compliance can be improved on later.

Note that the modern PCI driver requires bus_map_resource() to be
implemented, which is not the case on all archs.

The hw.virtio.pci.transitional tunable default value is zero so
transitional devices will continue to be driven via the legacy
driver.

Reviewed by: grehan (mentor)
Differential Revision: https://reviews.freebsd.org/D27856
This commit is contained in:
Bryan Venteicher 2021-01-19 04:55:23 +00:00
parent 1cd1ed3f5d
commit 9da9560c4d
17 changed files with 3347 additions and 999 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sys/conf/files
View File

@ -3457,6 +3457,9 @@ dev/virtio/virtqueue.c optional virtio
dev/virtio/virtio_bus_if.m optional virtio
dev/virtio/virtio_if.m optional virtio
dev/virtio/pci/virtio_pci.c optional virtio_pci
dev/virtio/pci/virtio_pci_if.m optional virtio_pci
dev/virtio/pci/virtio_pci_legacy.c optional virtio_pci
dev/virtio/pci/virtio_pci_modern.c optional virtio_pci
dev/virtio/mmio/virtio_mmio.c optional virtio_mmio
dev/virtio/mmio/virtio_mmio_acpi.c optional virtio_mmio acpi
dev/virtio/mmio/virtio_mmio_fdt.c optional virtio_mmio fdt

23
sys/dev/virtio/mmio/virtio_mmio.c
View File

@ -84,7 +84,7 @@ static void vtmmio_stop(device_t);
static void vtmmio_poll(device_t);
static int vtmmio_reinit(device_t, uint64_t);
static void vtmmio_reinit_complete(device_t);
static void vtmmio_notify_virtqueue(device_t, uint16_t);
static void vtmmio_notify_virtqueue(device_t, uint16_t, bus_size_t);
static uint8_t vtmmio_get_status(device_t);
static void vtmmio_set_status(device_t, uint8_t);
static void vtmmio_read_dev_config(device_t, bus_size_t, void *, int);
@ -352,6 +352,13 @@ vtmmio_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
*/
*result = 0;
break;
case VIRTIO_IVAR_MODERN:
/*
* There are several modern (aka MMIO v2) spec compliance
* issues with this driver, but keep the status quo.
*/
*result = sc->vtmmio_version > 1;
break;
default:
return (ENOENT);
}
@ -388,6 +395,10 @@ vtmmio_negotiate_features(device_t dev, uint64_t child_features)
sc = device_get_softc(dev);
if (sc->vtmmio_version > 1) {
child_features |= VIRTIO_F_VERSION_1;
}
vtmmio_write_config_4(sc, VIRTIO_MMIO_HOST_FEATURES_SEL, 1);
host_features = vtmmio_read_config_4(sc, VIRTIO_MMIO_HOST_FEATURES);
host_features <<= 32;
@ -402,7 +413,7 @@ vtmmio_negotiate_features(device_t dev, uint64_t child_features)
* host all support.
*/
features = host_features & child_features;
features = virtqueue_filter_features(features);
features = virtio_filter_transport_features(features);
sc->vtmmio_features = features;
vtmmio_describe_features(sc, "negotiated", features);
@ -504,7 +515,8 @@ vtmmio_alloc_virtqueues(device_t dev, int flags, int nvqs,
size = vtmmio_read_config_4(sc, VIRTIO_MMIO_QUEUE_NUM_MAX);
error = virtqueue_alloc(dev, idx, size,
VIRTIO_MMIO_VRING_ALIGN, ~(vm_paddr_t)0, info, &vq);
VIRTIO_MMIO_QUEUE_NOTIFY, VIRTIO_MMIO_VRING_ALIGN,
~(vm_paddr_t)0, info, &vq);
if (error) {
device_printf(dev,
"cannot allocate virtqueue %d: %d\n",
@ -586,13 +598,14 @@ vtmmio_reinit_complete(device_t dev)
}
static void
vtmmio_notify_virtqueue(device_t dev, uint16_t queue)
vtmmio_notify_virtqueue(device_t dev, uint16_t queue, bus_size_t offset)
{
struct vtmmio_softc *sc;
sc = device_get_softc(dev);
MPASS(offset == VIRTIO_MMIO_QUEUE_NOTIFY);
vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_NOTIFY, queue);
vtmmio_write_config_4(sc, offset, queue);
}
static uint8_t

1411
sys/dev/virtio/pci/virtio_pci.c
View File

File diff suppressed because it is too large Load Diff

169
sys/dev/virtio/pci/virtio_pci.h
View File

@ -1,36 +1,29 @@
/*-
* SPDX-License-Identifier: BSD-3-Clause
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* Copyright IBM Corp. 2007
*
* Authors:
* Anthony Liguori <aliguori@us.ibm.com>
*
* This header is BSD licensed so anyone can use the definitions to implement
* compatible drivers/servers.
* Copyright (c) 2017, Bryan Venteicher <bryanv@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* notice unmodified, this list of conditions, and the following
* disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of IBM nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD$
*/
@ -38,51 +31,101 @@
#ifndef _VIRTIO_PCI_H
#define _VIRTIO_PCI_H
/* VirtIO PCI vendor/device ID. */
#define VIRTIO_PCI_VENDORID 0x1AF4
#define VIRTIO_PCI_DEVICEID_MIN 0x1000
#define VIRTIO_PCI_DEVICEID_MAX 0x103F
struct vtpci_interrupt {
struct resource *vti_irq;
int vti_rid;
void *vti_handler;
};
/* VirtIO ABI version, this must match exactly. */
#define VIRTIO_PCI_ABI_VERSION 0
struct vtpci_virtqueue {
struct virtqueue *vtv_vq;
int vtv_no_intr;
int vtv_notify_offset;
};
/*
* VirtIO Header, located in BAR 0.
*/
#define VIRTIO_PCI_HOST_FEATURES 0 /* host's supported features (32bit, RO)*/
#define VIRTIO_PCI_GUEST_FEATURES 4 /* guest's supported features (32, RW) */
#define VIRTIO_PCI_QUEUE_PFN 8 /* physical address of VQ (32, RW) */
#define VIRTIO_PCI_QUEUE_NUM 12 /* number of ring entries (16, RO) */
#define VIRTIO_PCI_QUEUE_SEL 14 /* current VQ selection (16, RW) */
#define VIRTIO_PCI_QUEUE_NOTIFY 16 /* notify host regarding VQ (16, RW) */
#define VIRTIO_PCI_STATUS 18 /* device status register (8, RW) */
#define VIRTIO_PCI_ISR 19 /* interrupt status register, reading
* also clears the register (8, RO) */
/* Only if MSIX is enabled: */
#define VIRTIO_MSI_CONFIG_VECTOR 20 /* configuration change vector (16, RW) */
#define VIRTIO_MSI_QUEUE_VECTOR 22 /* vector for selected VQ notifications
(16, RW) */
struct vtpci_common {
device_t vtpci_dev;
uint64_t vtpci_features;
struct vtpci_virtqueue *vtpci_vqs;
int vtpci_nvqs;
/* The bit of the ISR which indicates a device has an interrupt. */
#define VIRTIO_PCI_ISR_INTR 0x1
/* The bit of the ISR which indicates a device configuration change. */
#define VIRTIO_PCI_ISR_CONFIG 0x2
/* Vector value used to disable MSI for queue. */
#define VIRTIO_MSI_NO_VECTOR 0xFFFF
uint32_t vtpci_flags;
#define VTPCI_FLAG_NO_MSI 0x0001
#define VTPCI_FLAG_NO_MSIX 0x0002
#define VTPCI_FLAG_MODERN 0x0004
#define VTPCI_FLAG_INTX 0x1000
#define VTPCI_FLAG_MSI 0x2000
#define VTPCI_FLAG_MSIX 0x4000
#define VTPCI_FLAG_SHARED_MSIX 0x8000
#define VTPCI_FLAG_ITYPE_MASK 0xF000
/*
* The remaining space is defined by each driver as the per-driver
* configuration space.
*/
#define VIRTIO_PCI_CONFIG_OFF(msix_enabled) ((msix_enabled) ? 24 : 20)
/* The VirtIO PCI "bus" will only ever have one child. */
device_t vtpci_child_dev;
struct virtio_feature_desc *vtpci_child_feat_desc;
/*
* How many bits to shift physical queue address written to QUEUE_PFN.
* 12 is historical, and due to x86 page size.
*/
#define VIRTIO_PCI_QUEUE_ADDR_SHIFT 12
/*
* Ideally, each virtqueue that the driver provides a callback for will
* receive its own MSIX vector. If there are not sufficient vectors
* available, then attempt to have all the VQs share one vector. For
* MSIX, the configuration changed notifications must be on their own
* vector.
*
* If MSIX is not available, attempt to have the whole device share
* one MSI vector, and then, finally, one intx interrupt.
*/
struct vtpci_interrupt vtpci_device_interrupt;
struct vtpci_interrupt *vtpci_msix_vq_interrupts;
int vtpci_nmsix_resources;
};
/* The alignment to use between consumer and producer parts of vring. */
#define VIRTIO_PCI_VRING_ALIGN 4096
extern int vtpci_disable_msix;
static inline device_t
vtpci_child_device(struct vtpci_common *cn)
{
return (cn->vtpci_child_dev);
}
static inline bool
vtpci_is_msix_available(struct vtpci_common *cn)
{
return ((cn->vtpci_flags & VTPCI_FLAG_NO_MSIX) == 0);
}
static inline bool
vtpci_is_msix_enabled(struct vtpci_common *cn)
{
return ((cn->vtpci_flags & VTPCI_FLAG_MSIX) != 0);
}
static inline bool
vtpci_is_modern(struct vtpci_common *cn)
{
return ((cn->vtpci_flags & VTPCI_FLAG_MODERN) != 0);
}
static inline int
vtpci_virtqueue_count(struct vtpci_common *cn)
{
return (cn->vtpci_nvqs);
}
void vtpci_init(struct vtpci_common *cn, device_t dev, bool modern);
int vtpci_add_child(struct vtpci_common *cn);
int vtpci_delete_child(struct vtpci_common *cn);
void vtpci_child_detached(struct vtpci_common *cn);
int vtpci_reinit(struct vtpci_common *cn);
uint64_t vtpci_negotiate_features(struct vtpci_common *cn,
uint64_t child_features, uint64_t host_features);
int vtpci_with_feature(struct vtpci_common *cn, uint64_t feature);
int vtpci_read_ivar(struct vtpci_common *cn, int index, uintptr_t *result);
int vtpci_write_ivar(struct vtpci_common *cn, int index, uintptr_t value);
int vtpci_alloc_virtqueues(struct vtpci_common *cn, int flags, int nvqs,
struct vq_alloc_info *vq_info);
int vtpci_setup_interrupts(struct vtpci_common *cn, enum intr_type type);
void vtpci_release_child_resources(struct vtpci_common *cn);
#endif /* _VIRTIO_PCI_H */

71
sys/dev/virtio/pci/virtio_pci_if.m Normal file
View File

@ -0,0 +1,71 @@
#-
# Copyright (c) 2017, Bryan Venteicher <bryanv@FreeBSD.org>
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
#
# $FreeBSD$
#include <sys/bus.h>
#include <machine/bus.h>
INTERFACE virtio_pci;
HEADER {
struct virtqueue;
struct vtpci_interrupt;
};
METHOD uint8_t read_isr {
device_t dev;
};
METHOD uint16_t get_vq_size {
device_t dev;
int idx;
};
METHOD bus_size_t get_vq_notify_off {
device_t dev;
int idx;
};
METHOD void set_vq {
device_t dev;
struct virtqueue *vq;
};
METHOD void disable_vq {
device_t dev;
int idx;
};
METHOD int register_cfg_msix {
device_t dev;
struct vtpci_interrupt *intr;
};
METHOD int register_vq_msix {
device_t dev;
int idx;
struct vtpci_interrupt *intr;
};

733
sys/dev/virtio/pci/virtio_pci_legacy.c Normal file
View File

@ -0,0 +1,733 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice unmodified, this list of conditions, and the following
* disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* Driver for the legacy VirtIO PCI interface. */
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/lock.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/endian.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/bus.h>
#include <sys/rman.h>
#include <dev/pci/pcivar.h>
#include <dev/pci/pcireg.h>
#include <dev/virtio/virtio.h>
#include <dev/virtio/virtqueue.h>
#include <dev/virtio/pci/virtio_pci.h>
#include <dev/virtio/pci/virtio_pci_legacy_var.h>
#include "virtio_bus_if.h"
#include "virtio_pci_if.h"
#include "virtio_if.h"
struct vtpci_legacy_softc {
device_t vtpci_dev;
struct vtpci_common vtpci_common;
struct resource *vtpci_res;
struct resource *vtpci_msix_res;
};
static int vtpci_legacy_probe(device_t);
static int vtpci_legacy_attach(device_t);
static int vtpci_legacy_detach(device_t);
static int vtpci_legacy_suspend(device_t);
static int vtpci_legacy_resume(device_t);
static int vtpci_legacy_shutdown(device_t);
static void vtpci_legacy_driver_added(device_t, driver_t *);
static void vtpci_legacy_child_detached(device_t, device_t);
static int vtpci_legacy_read_ivar(device_t, device_t, int, uintptr_t *);
static int vtpci_legacy_write_ivar(device_t, device_t, int, uintptr_t);
static uint8_t vtpci_legacy_read_isr(device_t);
static uint16_t vtpci_legacy_get_vq_size(device_t, int);
static bus_size_t vtpci_legacy_get_vq_notify_off(device_t, int);
static void vtpci_legacy_set_vq(device_t, struct virtqueue *);
static void vtpci_legacy_disable_vq(device_t, int);
static int vtpci_legacy_register_cfg_msix(device_t,
struct vtpci_interrupt *);
static int vtpci_legacy_register_vq_msix(device_t, int idx,
struct vtpci_interrupt *);
static uint64_t vtpci_legacy_negotiate_features(device_t, uint64_t);
static int vtpci_legacy_with_feature(device_t, uint64_t);
static int vtpci_legacy_alloc_virtqueues(device_t, int, int,
struct vq_alloc_info *);
static int vtpci_legacy_setup_interrupts(device_t, enum intr_type);
static void vtpci_legacy_stop(device_t);
static int vtpci_legacy_reinit(device_t, uint64_t);
static void vtpci_legacy_reinit_complete(device_t);
static void vtpci_legacy_notify_vq(device_t, uint16_t, bus_size_t);
static void vtpci_legacy_read_dev_config(device_t, bus_size_t, void *, int);
static void vtpci_legacy_write_dev_config(device_t, bus_size_t, void *, int);
static int vtpci_legacy_alloc_resources(struct vtpci_legacy_softc *);
static void vtpci_legacy_free_resources(struct vtpci_legacy_softc *);
static void vtpci_legacy_probe_and_attach_child(struct vtpci_legacy_softc *);
static uint8_t vtpci_legacy_get_status(struct vtpci_legacy_softc *);
static void vtpci_legacy_set_status(struct vtpci_legacy_softc *, uint8_t);
static void vtpci_legacy_select_virtqueue(struct vtpci_legacy_softc *, int);
static void vtpci_legacy_reset(struct vtpci_legacy_softc *);
#define VIRTIO_PCI_LEGACY_CONFIG(_sc) \
VIRTIO_PCI_CONFIG_OFF(vtpci_is_msix_enabled(&(_sc)->vtpci_common))
#define vtpci_legacy_read_config_1(sc, o) \
bus_read_1((sc)->vtpci_res, (o))
#define vtpci_legacy_write_config_1(sc, o, v) \
bus_write_1((sc)->vtpci_res, (o), (v))
/*
* VirtIO specifies that PCI Configuration area is guest endian. However,
* since PCI devices are inherently little-endian, on big-endian systems
* the bus layer transparently converts it to BE. For virtio-legacy, this
* conversion is undesired, so an extra byte swap is required to fix it.
*/
#define vtpci_legacy_read_config_2(sc, o) \
le16toh(bus_read_2((sc)->vtpci_res, (o)))
#define vtpci_legacy_read_config_4(sc, o) \
le32toh(bus_read_4((sc)->vtpci_res, (o)))
#define vtpci_legacy_write_config_2(sc, o, v) \
bus_write_2((sc)->vtpci_res, (o), (htole16(v)))
#define vtpci_legacy_write_config_4(sc, o, v) \
bus_write_4((sc)->vtpci_res, (o), (htole32(v)))
/* PCI Header LE. On BE systems the bus layer takes care of byte swapping. */
#define vtpci_legacy_read_header_2(sc, o) \
bus_read_2((sc)->vtpci_res, (o))
#define vtpci_legacy_read_header_4(sc, o) \
bus_read_4((sc)->vtpci_res, (o))
#define vtpci_legacy_write_header_2(sc, o, v) \
bus_write_2((sc)->vtpci_res, (o), (v))
#define vtpci_legacy_write_header_4(sc, o, v) \
bus_write_4((sc)->vtpci_res, (o), (v))
static device_method_t vtpci_legacy_methods[] = {
/* Device interface. */
DEVMETHOD(device_probe, vtpci_legacy_probe),
DEVMETHOD(device_attach, vtpci_legacy_attach),
DEVMETHOD(device_detach, vtpci_legacy_detach),
DEVMETHOD(device_suspend, vtpci_legacy_suspend),
DEVMETHOD(device_resume, vtpci_legacy_resume),
DEVMETHOD(device_shutdown, vtpci_legacy_shutdown),
/* Bus interface. */
DEVMETHOD(bus_driver_added, vtpci_legacy_driver_added),
DEVMETHOD(bus_child_detached, vtpci_legacy_child_detached),
DEVMETHOD(bus_child_pnpinfo_str, virtio_child_pnpinfo_str),
DEVMETHOD(bus_read_ivar, vtpci_legacy_read_ivar),
DEVMETHOD(bus_write_ivar, vtpci_legacy_write_ivar),
/* VirtIO PCI interface. */
DEVMETHOD(virtio_pci_read_isr, vtpci_legacy_read_isr),
DEVMETHOD(virtio_pci_get_vq_size, vtpci_legacy_get_vq_size),
DEVMETHOD(virtio_pci_get_vq_notify_off, vtpci_legacy_get_vq_notify_off),
DEVMETHOD(virtio_pci_set_vq, vtpci_legacy_set_vq),
DEVMETHOD(virtio_pci_disable_vq, vtpci_legacy_disable_vq),
DEVMETHOD(virtio_pci_register_cfg_msix, vtpci_legacy_register_cfg_msix),
DEVMETHOD(virtio_pci_register_vq_msix, vtpci_legacy_register_vq_msix),
/* VirtIO bus interface. */
DEVMETHOD(virtio_bus_negotiate_features, vtpci_legacy_negotiate_features),
DEVMETHOD(virtio_bus_with_feature, vtpci_legacy_with_feature),
DEVMETHOD(virtio_bus_alloc_virtqueues, vtpci_legacy_alloc_virtqueues),
DEVMETHOD(virtio_bus_setup_intr, vtpci_legacy_setup_interrupts),
DEVMETHOD(virtio_bus_stop, vtpci_legacy_stop),
DEVMETHOD(virtio_bus_reinit, vtpci_legacy_reinit),
DEVMETHOD(virtio_bus_reinit_complete, vtpci_legacy_reinit_complete),
DEVMETHOD(virtio_bus_notify_vq, vtpci_legacy_notify_vq),
DEVMETHOD(virtio_bus_read_device_config, vtpci_legacy_read_dev_config),
DEVMETHOD(virtio_bus_write_device_config, vtpci_legacy_write_dev_config),
DEVMETHOD_END
};
static driver_t vtpci_legacy_driver = {
.name = "virtio_pci",
.methods = vtpci_legacy_methods,
.size = sizeof(struct vtpci_legacy_softc)
};
devclass_t vtpci_legacy_devclass;
DRIVER_MODULE(virtio_pci_legacy, pci, vtpci_legacy_driver,
vtpci_legacy_devclass, 0, 0);
static int
vtpci_legacy_probe(device_t dev)
{
char desc[64];
const char *name;
if (pci_get_vendor(dev) != VIRTIO_PCI_VENDORID)
return (ENXIO);
if (pci_get_device(dev) < VIRTIO_PCI_DEVICEID_MIN ||
pci_get_device(dev) > VIRTIO_PCI_DEVICEID_LEGACY_MAX)
return (ENXIO);
if (pci_get_revid(dev) != VIRTIO_PCI_ABI_VERSION)
return (ENXIO);
name = virtio_device_name(pci_get_subdevice(dev));
if (name == NULL)
name = "Unknown";
snprintf(desc, sizeof(desc), "VirtIO PCI (legacy) %s adapter", name);
device_set_desc_copy(dev, desc);
/* Prefer transitional modern VirtIO PCI. */
return (BUS_PROBE_LOW_PRIORITY);
}
static int
vtpci_legacy_attach(device_t dev)
{
struct vtpci_legacy_softc *sc;
int error;
sc = device_get_softc(dev);
sc->vtpci_dev = dev;
vtpci_init(&sc->vtpci_common, dev, false);
error = vtpci_legacy_alloc_resources(sc);
if (error) {
device_printf(dev, "cannot map I/O space\n");
return (error);
}
vtpci_legacy_reset(sc);
/* Tell the host we've noticed this device. */
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_ACK);
error = vtpci_add_child(&sc->vtpci_common);
if (error)
goto fail;
vtpci_legacy_probe_and_attach_child(sc);
return (0);
fail:
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_FAILED);
vtpci_legacy_detach(dev);
return (error);
}
static int
vtpci_legacy_detach(device_t dev)
{
struct vtpci_legacy_softc *sc;
int error;
sc = device_get_softc(dev);
error = vtpci_delete_child(&sc->vtpci_common);
if (error)
return (error);
vtpci_legacy_reset(sc);
vtpci_legacy_free_resources(sc);
return (0);
}
static int
vtpci_legacy_suspend(device_t dev)
{
return (bus_generic_suspend(dev));
}
static int
vtpci_legacy_resume(device_t dev)
{
return (bus_generic_resume(dev));
}
static int
vtpci_legacy_shutdown(device_t dev)
{
(void) bus_generic_shutdown(dev);
/* Forcibly stop the host device. */
vtpci_legacy_stop(dev);
return (0);
}
static void
vtpci_legacy_driver_added(device_t dev, driver_t *driver)
{
vtpci_legacy_probe_and_attach_child(device_get_softc(dev));
}
static void
vtpci_legacy_child_detached(device_t dev, device_t child)
{
struct vtpci_legacy_softc *sc;
sc = device_get_softc(dev);
vtpci_legacy_reset(sc);
vtpci_child_detached(&sc->vtpci_common);
/* After the reset, retell the host we've noticed this device. */
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_ACK);
}
static int
vtpci_legacy_read_ivar(device_t dev, device_t child, int index,
uintptr_t *result)
{
struct vtpci_legacy_softc *sc;
struct vtpci_common *cn;
sc = device_get_softc(dev);
cn = &sc->vtpci_common;
if (vtpci_child_device(cn) != child)
return (ENOENT);
switch (index) {
case VIRTIO_IVAR_DEVTYPE:
*result = pci_get_subdevice(dev);
break;
default:
return (vtpci_read_ivar(cn, index, result));
}
return (0);
}
static int
vtpci_legacy_write_ivar(device_t dev, device_t child, int index, uintptr_t value)
{
struct vtpci_legacy_softc *sc;
struct vtpci_common *cn;
sc = device_get_softc(dev);
cn = &sc->vtpci_common;
if (vtpci_child_device(cn) != child)
return (ENOENT);
switch (index) {
default:
return (vtpci_write_ivar(cn, index, value));
}
return (0);
}
static uint64_t
vtpci_legacy_negotiate_features(device_t dev, uint64_t child_features)
{
struct vtpci_legacy_softc *sc;
uint64_t host_features, features;
sc = device_get_softc(dev);
host_features = vtpci_legacy_read_header_4(sc, VIRTIO_PCI_HOST_FEATURES);
features = vtpci_negotiate_features(&sc->vtpci_common,
child_features, host_features);
vtpci_legacy_write_header_4(sc, VIRTIO_PCI_GUEST_FEATURES, features);
return (features);
}
static int
vtpci_legacy_with_feature(device_t dev, uint64_t feature)
{
struct vtpci_legacy_softc *sc;
sc = device_get_softc(dev);
return (vtpci_with_feature(&sc->vtpci_common, feature));
}
static int
vtpci_legacy_alloc_virtqueues(device_t dev, int flags, int nvqs,
struct vq_alloc_info *vq_info)
{
struct vtpci_legacy_softc *sc;
struct vtpci_common *cn;
sc = device_get_softc(dev);
cn = &sc->vtpci_common;
return (vtpci_alloc_virtqueues(cn, flags, nvqs, vq_info));
}
static int
vtpci_legacy_setup_interrupts(device_t dev, enum intr_type type)
{
struct vtpci_legacy_softc *sc;
sc = device_get_softc(dev);
return (vtpci_setup_interrupts(&sc->vtpci_common, type));
}
static void
vtpci_legacy_stop(device_t dev)
{
vtpci_legacy_reset(device_get_softc(dev));
}
static int
vtpci_legacy_reinit(device_t dev, uint64_t features)
{
struct vtpci_legacy_softc *sc;
struct vtpci_common *cn;
int error;
sc = device_get_softc(dev);
cn = &sc->vtpci_common;
/*
* Redrive the device initialization. This is a bit of an abuse of
* the specification, but VirtualBox, QEMU/KVM, and BHyVe seem to
* play nice.
*
* We do not allow the host device to change from what was originally
* negotiated beyond what the guest driver changed. MSIX state should
* not change, number of virtqueues and their size remain the same, etc.
* This will need to be rethought when we want to support migration.
*/
if (vtpci_legacy_get_status(sc) != VIRTIO_CONFIG_STATUS_RESET)
vtpci_legacy_stop(dev);
/*
* Quickly drive the status through ACK and DRIVER. The device does
* not become usable again until DRIVER_OK in reinit complete.
*/
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_ACK);
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_DRIVER);
vtpci_legacy_negotiate_features(dev, features);
error = vtpci_reinit(cn);
if (error)
return (error);
return (0);
}
static void
vtpci_legacy_reinit_complete(device_t dev)
{
struct vtpci_legacy_softc *sc;
sc = device_get_softc(dev);
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_DRIVER_OK);
}
static void
vtpci_legacy_notify_vq(device_t dev, uint16_t queue, bus_size_t offset)
{
struct vtpci_legacy_softc *sc;
sc = device_get_softc(dev);
MPASS(offset == VIRTIO_PCI_QUEUE_NOTIFY);
vtpci_legacy_write_header_2(sc, offset, queue);
}
static uint8_t
vtpci_legacy_get_status(struct vtpci_legacy_softc *sc)
{
return (vtpci_legacy_read_config_1(sc, VIRTIO_PCI_STATUS));
}
static void
vtpci_legacy_set_status(struct vtpci_legacy_softc *sc, uint8_t status)
{
if (status != VIRTIO_CONFIG_STATUS_RESET)
status |= vtpci_legacy_get_status(sc);
vtpci_legacy_write_config_1(sc, VIRTIO_PCI_STATUS, status);
}
static void
vtpci_legacy_read_dev_config(device_t dev, bus_size_t offset,
void *dst, int length)
{
struct vtpci_legacy_softc *sc;
bus_size_t off;
uint8_t *d;
int size;
sc = device_get_softc(dev);
off = VIRTIO_PCI_LEGACY_CONFIG(sc) + offset;
for (d = dst; length > 0; d += size, off += size, length -= size) {
if (length >= 4) {
size = 4;
*(uint32_t *)d = vtpci_legacy_read_config_4(sc, off);
} else if (length >= 2) {
size = 2;
*(uint16_t *)d = vtpci_legacy_read_config_2(sc, off);
} else {
size = 1;
*d = vtpci_legacy_read_config_1(sc, off);
}
}
}
static void
vtpci_legacy_write_dev_config(device_t dev, bus_size_t offset,
void *src, int length)
{
struct vtpci_legacy_softc *sc;
bus_size_t off;
uint8_t *s;
int size;
sc = device_get_softc(dev);
off = VIRTIO_PCI_LEGACY_CONFIG(sc) + offset;
for (s = src; length > 0; s += size, off += size, length -= size) {
if (length >= 4) {
size = 4;
vtpci_legacy_write_config_4(sc, off, *(uint32_t *)s);
} else if (length >= 2) {
size = 2;
vtpci_legacy_write_config_2(sc, off, *(uint16_t *)s);
} else {
size = 1;
vtpci_legacy_write_config_1(sc, off, *s);
}
}
}
static int
vtpci_legacy_alloc_resources(struct vtpci_legacy_softc *sc)
{
device_t dev;
int rid;
dev = sc->vtpci_dev;
rid = PCIR_BAR(0);
if ((sc->vtpci_res = bus_alloc_resource_any(dev, SYS_RES_IOPORT,
&rid, RF_ACTIVE)) == NULL)
return (ENXIO);
if (vtpci_is_msix_available(&sc->vtpci_common)) {
rid = PCIR_BAR(1);
if ((sc->vtpci_msix_res = bus_alloc_resource_any(dev,
SYS_RES_MEMORY, &rid, RF_ACTIVE)) == NULL)
return (ENXIO);
}
return (0);
}
static void
vtpci_legacy_free_resources(struct vtpci_legacy_softc *sc)
{
device_t dev;
dev = sc->vtpci_dev;
if (sc->vtpci_msix_res != NULL) {
bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(1),
sc->vtpci_msix_res);
sc->vtpci_msix_res = NULL;
}
if (sc->vtpci_res != NULL) {
bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0),
sc->vtpci_res);
sc->vtpci_res = NULL;
}
}
static void
vtpci_legacy_probe_and_attach_child(struct vtpci_legacy_softc *sc)
{
device_t dev, child;
dev = sc->vtpci_dev;
child = vtpci_child_device(&sc->vtpci_common);
if (child == NULL || device_get_state(child) != DS_NOTPRESENT)
return;
if (device_probe(child) != 0)
return;
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_DRIVER);
if (device_attach(child) != 0) {
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_FAILED);
/* Reset status for future attempt. */
vtpci_legacy_child_detached(dev, child);
} else {
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_DRIVER_OK);
VIRTIO_ATTACH_COMPLETED(child);
}
}
static int
vtpci_legacy_register_msix(struct vtpci_legacy_softc *sc, int offset,
struct vtpci_interrupt *intr)
{
device_t dev;
uint16_t vector;
dev = sc->vtpci_dev;
if (intr != NULL) {
/* Map from guest rid to host vector. */
vector = intr->vti_rid - 1;
} else
vector = VIRTIO_MSI_NO_VECTOR;
vtpci_legacy_write_header_2(sc, offset, vector);
return (vtpci_legacy_read_header_2(sc, offset) == vector ? 0 : ENODEV);
}
static int
vtpci_legacy_register_cfg_msix(device_t dev, struct vtpci_interrupt *intr)
{
struct vtpci_legacy_softc *sc;
int error;
sc = device_get_softc(dev);
error = vtpci_legacy_register_msix(sc, VIRTIO_MSI_CONFIG_VECTOR, intr);
if (error) {
device_printf(dev,
"unable to register config MSIX interrupt\n");
return (error);
}
return (0);
}
static int
vtpci_legacy_register_vq_msix(device_t dev, int idx,
struct vtpci_interrupt *intr)
{
struct vtpci_legacy_softc *sc;
int error;
sc = device_get_softc(dev);
vtpci_legacy_select_virtqueue(sc, idx);
error = vtpci_legacy_register_msix(sc, VIRTIO_MSI_QUEUE_VECTOR, intr);
if (error) {
device_printf(dev,
"unable to register virtqueue MSIX interrupt\n");
return (error);
}
return (0);
}
static void
vtpci_legacy_reset(struct vtpci_legacy_softc *sc)
{
/*
* Setting the status to RESET sets the host device to the
* original, uninitialized state.
*/
vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_RESET);
(void) vtpci_legacy_get_status(sc);
}
static void
vtpci_legacy_select_virtqueue(struct vtpci_legacy_softc *sc, int idx)
{
vtpci_legacy_write_header_2(sc, VIRTIO_PCI_QUEUE_SEL, idx);
}
static uint8_t
vtpci_legacy_read_isr(device_t dev)
{
struct vtpci_legacy_softc *sc;
sc = device_get_softc(dev);
return (vtpci_legacy_read_config_1(sc, VIRTIO_PCI_ISR));
}
static uint16_t
vtpci_legacy_get_vq_size(device_t dev, int idx)
{
struct vtpci_legacy_softc *sc;
sc = device_get_softc(dev);
vtpci_legacy_select_virtqueue(sc, idx);
return (vtpci_legacy_read_header_2(sc, VIRTIO_PCI_QUEUE_NUM));
}
static bus_size_t
vtpci_legacy_get_vq_notify_off(device_t dev, int idx)
{
return (VIRTIO_PCI_QUEUE_NOTIFY);
}
static void
vtpci_legacy_set_vq(device_t dev, struct virtqueue *vq)
{
struct vtpci_legacy_softc *sc;
sc = device_get_softc(dev);
vtpci_legacy_select_virtqueue(sc, virtqueue_index(vq));
vtpci_legacy_write_header_4(sc, VIRTIO_PCI_QUEUE_PFN,
virtqueue_paddr(vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT);
}
static void
vtpci_legacy_disable_vq(device_t dev, int idx)
{
struct vtpci_legacy_softc *sc;
sc = device_get_softc(dev);
vtpci_legacy_select_virtqueue(sc, idx);
vtpci_legacy_write_header_4(sc, VIRTIO_PCI_QUEUE_PFN, 0);
}

78
sys/dev/virtio/pci/virtio_pci_legacy_var.h Normal file
View File

@ -0,0 +1,78 @@
/*-
* SPDX-License-Identifier: BSD-3-Clause
*
* Copyright IBM Corp. 2007
*
* Authors:
* Anthony Liguori <aliguori@us.ibm.com>
*
* This header is BSD licensed so anyone can use the definitions to implement
* compatible drivers/servers.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of IBM nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#ifndef _VIRTIO_PCI_LEGACY_VAR_H
#define _VIRTIO_PCI_LEGACY_VAR_H
#include <dev/virtio/pci/virtio_pci_var.h>
/* VirtIO ABI version, this must match exactly. */
#define VIRTIO_PCI_ABI_VERSION 0
/*
* VirtIO Header, located in BAR 0.
*/
#define VIRTIO_PCI_HOST_FEATURES 0 /* host's supported features (32bit, RO)*/
#define VIRTIO_PCI_GUEST_FEATURES 4 /* guest's supported features (32, RW) */
#define VIRTIO_PCI_QUEUE_PFN 8 /* physical address of VQ (32, RW) */
#define VIRTIO_PCI_QUEUE_NUM 12 /* number of ring entries (16, RO) */
#define VIRTIO_PCI_QUEUE_SEL 14 /* current VQ selection (16, RW) */
#define VIRTIO_PCI_QUEUE_NOTIFY 16 /* notify host regarding VQ (16, RW) */
#define VIRTIO_PCI_STATUS 18 /* device status register (8, RW) */
#define VIRTIO_PCI_ISR 19 /* interrupt status register, reading
* also clears the register (8, RO) */
/* Only if MSIX is enabled: */
#define VIRTIO_MSI_CONFIG_VECTOR 20 /* configuration change vector (16, RW) */
#define VIRTIO_MSI_QUEUE_VECTOR 22 /* vector for selected VQ notifications
(16, RW) */
/*
* The remaining space is defined by each driver as the per-driver
* configuration space.
*/
#define VIRTIO_PCI_CONFIG_OFF(msix_enabled) ((msix_enabled) ? 24 : 20)
/*
* How many bits to shift physical queue address written to QUEUE_PFN.
* 12 is historical, and due to x86 page size.
*/
#define VIRTIO_PCI_QUEUE_ADDR_SHIFT 12
/* The alignment to use between consumer and producer parts of vring. */
#define VIRTIO_PCI_VRING_ALIGN 4096
#endif /* _VIRTIO_PCI_LEGACY_VAR_H */

1448
sys/dev/virtio/pci/virtio_pci_modern.c Normal file
View File

File diff suppressed because it is too large Load Diff

135
sys/dev/virtio/pci/virtio_pci_modern_var.h Normal file
View File

@ -0,0 +1,135 @@
/*
* SPDX-License-Identifier: BSD-3-Clause
*
* Copyright IBM Corp. 2007
*
* Authors:
* Anthony Liguori <aliguori@us.ibm.com>
*
* This header is BSD licensed so anyone can use the definitions to implement
* compatible drivers/servers.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of IBM nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#ifndef _VIRTIO_PCI_MODERN_VAR_H
#define _VIRTIO_PCI_MODERN_VAR_H
#include <dev/virtio/pci/virtio_pci_var.h>
/* IDs for different capabilities. Must all exist. */
/* Common configuration */
#define VIRTIO_PCI_CAP_COMMON_CFG 1
/* Notifications */
#define VIRTIO_PCI_CAP_NOTIFY_CFG 2
/* ISR access */
#define VIRTIO_PCI_CAP_ISR_CFG 3
/* Device specific configuration */
#define VIRTIO_PCI_CAP_DEVICE_CFG 4
/* PCI configuration access */
#define VIRTIO_PCI_CAP_PCI_CFG 5
/* This is the PCI capability header: */
struct virtio_pci_cap {
uint8_t cap_vndr; /* Generic PCI field: PCI_CAP_ID_VNDR */
uint8_t cap_next; /* Generic PCI field: next ptr. */
uint8_t cap_len; /* Generic PCI field: capability length */
uint8_t cfg_type; /* Identifies the structure. */
uint8_t bar; /* Where to find it. */
uint8_t padding[3]; /* Pad to full dword. */
uint32_t offset; /* Offset within bar. */
uint32_t length; /* Length of the structure, in bytes. */
};
struct virtio_pci_notify_cap {
struct virtio_pci_cap cap;
uint32_t notify_off_multiplier; /* Multiplier for queue_notify_off. */
};
/* Fields in VIRTIO_PCI_CAP_COMMON_CFG: */
struct virtio_pci_common_cfg {
/* About the whole device. */
uint32_t device_feature_select; /* read-write */
uint32_t device_feature; /* read-only */
uint32_t guest_feature_select; /* read-write */
uint32_t guest_feature; /* read-write */
uint16_t msix_config; /* read-write */
uint16_t num_queues; /* read-only */
uint8_t device_status; /* read-write */
uint8_t config_generation; /* read-only */
/* About a specific virtqueue. */
uint16_t queue_select; /* read-write */
uint16_t queue_size; /* read-write, power of 2. */
uint16_t queue_msix_vector; /* read-write */
uint16_t queue_enable; /* read-write */
uint16_t queue_notify_off; /* read-only */
uint32_t queue_desc_lo; /* read-write */
uint32_t queue_desc_hi; /* read-write */
uint32_t queue_avail_lo; /* read-write */
uint32_t queue_avail_hi; /* read-write */
uint32_t queue_used_lo; /* read-write */
uint32_t queue_used_hi; /* read-write */
};
/* Fields in VIRTIO_PCI_CAP_PCI_CFG: */
struct virtio_pci_cfg_cap {
struct virtio_pci_cap cap;
uint8_t pci_cfg_data[4]; /* Data for BAR access. */
};
/* Macro versions of offsets for the Old Timers! */
#define VIRTIO_PCI_CAP_VNDR 0
#define VIRTIO_PCI_CAP_NEXT 1
#define VIRTIO_PCI_CAP_LEN 2
#define VIRTIO_PCI_CAP_CFG_TYPE 3
#define VIRTIO_PCI_CAP_BAR 4
#define VIRTIO_PCI_CAP_OFFSET 8
#define VIRTIO_PCI_CAP_LENGTH 12
#define VIRTIO_PCI_NOTIFY_CAP_MULT 16
#define VIRTIO_PCI_COMMON_DFSELECT 0
#define VIRTIO_PCI_COMMON_DF 4
#define VIRTIO_PCI_COMMON_GFSELECT 8
#define VIRTIO_PCI_COMMON_GF 12
#define VIRTIO_PCI_COMMON_MSIX 16
#define VIRTIO_PCI_COMMON_NUMQ 18
#define VIRTIO_PCI_COMMON_STATUS 20
#define VIRTIO_PCI_COMMON_CFGGENERATION 21
#define VIRTIO_PCI_COMMON_Q_SELECT 22
#define VIRTIO_PCI_COMMON_Q_SIZE 24
#define VIRTIO_PCI_COMMON_Q_MSIX 26
#define VIRTIO_PCI_COMMON_Q_ENABLE 28
#define VIRTIO_PCI_COMMON_Q_NOFF 30
#define VIRTIO_PCI_COMMON_Q_DESCLO 32
#define VIRTIO_PCI_COMMON_Q_DESCHI 36
#define VIRTIO_PCI_COMMON_Q_AVAILLO 40
#define VIRTIO_PCI_COMMON_Q_AVAILHI 44
#define VIRTIO_PCI_COMMON_Q_USEDLO 48
#define VIRTIO_PCI_COMMON_Q_USEDHI 52
#endif /* _VIRTIO_PCI_MODERN_VAR_H */

55
sys/dev/virtio/pci/virtio_pci_var.h Normal file
View File

@ -0,0 +1,55 @@
/*-
* SPDX-License-Identifier: BSD-3-Clause
*
* Copyright IBM Corp. 2007
*
* Authors:
* Anthony Liguori <aliguori@us.ibm.com>
*
* This header is BSD licensed so anyone can use the definitions to implement
* compatible drivers/servers.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of IBM nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#ifndef _VIRTIO_PCI_VAR_H
#define _VIRTIO_PCI_VAR_H
/* VirtIO PCI vendor/device ID. */
#define VIRTIO_PCI_VENDORID 0x1AF4
#define VIRTIO_PCI_DEVICEID_MIN 0x1000
#define VIRTIO_PCI_DEVICEID_LEGACY_MAX 0x103F
#define VIRTIO_PCI_DEVICEID_MODERN_MIN 0x1040
#define VIRTIO_PCI_DEVICEID_MODERN_MAX 0x107F
/* The bit of the ISR which indicates a device has an interrupt. */
#define VIRTIO_PCI_ISR_INTR 0x1
/* The bit of the ISR which indicates a device configuration change. */
#define VIRTIO_PCI_ISR_CONFIG 0x2
/* Vector value used to disable MSI for queue. */
#define VIRTIO_MSI_NO_VECTOR 0xFFFF
#endif /* _VIRTIO_PCI_VAR_H */

76
sys/dev/virtio/virtio.c
View File

@ -60,24 +60,28 @@ static struct virtio_ident {
{ VIRTIO_ID_ENTROPY, "Entropy" },
{ VIRTIO_ID_BALLOON, "Balloon" },
{ VIRTIO_ID_IOMEMORY, "IOMemory" },
{ VIRTIO_ID_RPMSG, "Remote Processor Messaging" },
{ VIRTIO_ID_RPMSG, "Remote Processor Messaging" },
{ VIRTIO_ID_SCSI, "SCSI" },
{ VIRTIO_ID_9P, "9P Transport" },
{ VIRTIO_ID_RPROC_SERIAL, "Remote Processor Serial" },
{ VIRTIO_ID_CAIF, "CAIF" },
{ VIRTIO_ID_GPU, "GPU" },
{ VIRTIO_ID_INPUT, "Input" },
{ VIRTIO_ID_VSOCK, "VSOCK Transport" },
{ VIRTIO_ID_CRYPTO, "Crypto" },
{ VIRTIO_ID_INPUT, "Input" },
{ VIRTIO_ID_VSOCK, "VSOCK Transport" },
{ VIRTIO_ID_CRYPTO, "Crypto" },
{ 0, NULL }
};
/* Device independent features. */
static struct virtio_feature_desc virtio_common_feature_desc[] = {
{ VIRTIO_F_NOTIFY_ON_EMPTY, "NotifyOnEmpty" },
{ VIRTIO_RING_F_INDIRECT_DESC, "RingIndirect" },
{ VIRTIO_RING_F_EVENT_IDX, "EventIdx" },
{ VIRTIO_F_BAD_FEATURE, "BadFeature" },
{ VIRTIO_F_NOTIFY_ON_EMPTY, "NotifyOnEmpty" }, /* Legacy */
{ VIRTIO_F_ANY_LAYOUT, "AnyLayout" }, /* Legacy */
{ VIRTIO_RING_F_INDIRECT_DESC, "RingIndirectDesc" },
{ VIRTIO_RING_F_EVENT_IDX, "RingEventIdx" },
{ VIRTIO_F_BAD_FEATURE, "BadFeature" }, /* Legacy */
{ VIRTIO_F_VERSION_1, "Version1" },
{ VIRTIO_F_IOMMU_PLATFORM, "IOMMUPlatform" },
{ 0, NULL }
};
@ -125,12 +129,13 @@ virtio_describe(device_t dev, const char *msg,
const char *name;
int n;
if ((buf = malloc(512, M_TEMP, M_NOWAIT)) == NULL) {
device_printf(dev, "%s features: %#jx\n", msg, (uintmax_t) features);
if ((buf = malloc(1024, M_TEMP, M_NOWAIT)) == NULL) {
device_printf(dev, "%s features: %#jx\n",
msg, (uintmax_t) features);
return;
}
sbuf_new(&sb, buf, 512, SBUF_FIXEDLEN);
sbuf_new(&sb, buf, 1024, SBUF_FIXEDLEN);
sbuf_printf(&sb, "%s features: %#jx", msg, (uintmax_t) features);
for (n = 0, val = 1ULL << 63; val != 0; val >>= 1) {
@ -163,6 +168,48 @@ virtio_describe(device_t dev, const char *msg,
free(buf, M_TEMP);
}
uint64_t
virtio_filter_transport_features(uint64_t features)
{
uint64_t transport, mask;
transport = (1ULL <<
(VIRTIO_TRANSPORT_F_END - VIRTIO_TRANSPORT_F_START)) - 1;
transport <<= VIRTIO_TRANSPORT_F_START;
mask = -1ULL & ~transport;
mask |= VIRTIO_RING_F_INDIRECT_DESC;
mask |= VIRTIO_RING_F_EVENT_IDX;
mask |= VIRTIO_F_VERSION_1;
return (features & mask);
}
int
virtio_bus_is_modern(device_t dev)
{
uintptr_t modern;
virtio_read_ivar(dev, VIRTIO_IVAR_MODERN, &modern);
return (modern != 0);
}
void
virtio_read_device_config_array(device_t dev, bus_size_t offset, void *dst,
int size, int count)
{
int i, gen;
do {
gen = virtio_config_generation(dev);
for (i = 0; i < count; i++) {
virtio_read_device_config(dev, offset + i * size,
(uint8_t *) dst + i * size, size);
}
} while (gen != virtio_config_generation(dev));
}
/*
* VirtIO bus method wrappers.
*/
@ -190,6 +237,13 @@ virtio_negotiate_features(device_t dev, uint64_t child_features)
child_features));
}
int
virtio_finalize_features(device_t dev)
{
return (VIRTIO_BUS_FINALIZE_FEATURES(device_get_parent(dev)));
}
int
virtio_alloc_virtqueues(device_t dev, int flags, int nvqs,
struct vq_alloc_info *info)

8
sys/dev/virtio/virtio.h
View File

@ -31,6 +31,7 @@
#ifndef _VIRTIO_H_
#define _VIRTIO_H_
#include <dev/virtio/virtio_endian.h>
#include <dev/virtio/virtio_ids.h>
#include <dev/virtio/virtio_config.h>
@ -57,6 +58,7 @@ struct vq_alloc_info;
#define VIRTIO_IVAR_DEVICE 4
#define VIRTIO_IVAR_SUBVENDOR 5
#define VIRTIO_IVAR_SUBDEVICE 6
#define VIRTIO_IVAR_MODERN 7
struct virtio_feature_desc {
uint64_t vfd_val;
@ -81,6 +83,10 @@ struct virtio_pnp_match {
const char *virtio_device_name(uint16_t devid);
void virtio_describe(device_t dev, const char *msg,
uint64_t features, struct virtio_feature_desc *feature_desc);
uint64_t virtio_filter_transport_features(uint64_t features);
int virtio_bus_is_modern(device_t dev);
void virtio_read_device_config_array(device_t dev, bus_size_t offset,
void *dst, int size, int count);
/*
* VirtIO Bus Methods.
@ -88,6 +94,7 @@ void virtio_describe(device_t dev, const char *msg,
void virtio_read_ivar(device_t dev, int ivar, uintptr_t *val);
void virtio_write_ivar(device_t dev, int ivar, uintptr_t val);
uint64_t virtio_negotiate_features(device_t dev, uint64_t child_features);
int virtio_finalize_features(device_t dev);
int virtio_alloc_virtqueues(device_t dev, int flags, int nvqs,
struct vq_alloc_info *info);
int virtio_setup_intr(device_t dev, enum intr_type type);
@ -147,6 +154,7 @@ VIRTIO_READ_IVAR(vendor, VIRTIO_IVAR_VENDOR);
VIRTIO_READ_IVAR(device, VIRTIO_IVAR_DEVICE);
VIRTIO_READ_IVAR(subvendor, VIRTIO_IVAR_SUBVENDOR);
VIRTIO_READ_IVAR(subdevice, VIRTIO_IVAR_SUBDEVICE);
VIRTIO_READ_IVAR(modern, VIRTIO_IVAR_MODERN);
#undef VIRTIO_READ_IVAR

11
sys/dev/virtio/virtio_bus_if.m
View File

@ -35,6 +35,12 @@ struct vq_alloc_info;
};
CODE {
static int
virtio_bus_default_finalize_features(device_t dev)
{
return (0);
}
static int
virtio_bus_default_config_generation(device_t dev)
{
@ -47,6 +53,10 @@ METHOD uint64_t negotiate_features {
uint64_t child_features;
};
METHOD int finalize_features {
device_t dev;
} DEFAULT virtio_bus_default_finalize_features;
METHOD int with_feature {
device_t dev;
uint64_t feature;
@ -80,6 +90,7 @@ METHOD void reinit_complete {
METHOD void notify_vq {
device_t dev;
uint16_t queue;
bus_size_t offset;
};
METHOD int config_generation {

106
sys/dev/virtio/virtio_endian.h Normal file
View File

@ -0,0 +1,106 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause
*
* Copyright (c) 2017, Bryan Venteicher <bryanv@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice unmodified, this list of conditions, and the following
* disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD$
*/
#ifndef _VIRTIO_ENDIAN_H_
#define _VIRTIO_ENDIAN_H_
#include <sys/endian.h>
/*
* VirtIO V1 (modern) uses little endian, while legacy VirtIO uses the guest's
* native endian. These functions convert to and from the Guest's (driver's)
* and the Host's (device's) endianness when needed.
*/
static inline bool
virtio_swap_endian(bool modern)
{
#if _BYTE_ORDER == _LITTLE_ENDIAN
return (false);
#else
return (modern);
#endif
}
static inline uint16_t
virtio_htog16(bool modern, uint16_t val)
{
if (virtio_swap_endian(modern))
return (le16toh(val));
else
return (val);
}
static inline uint16_t
virtio_gtoh16(bool modern, uint16_t val)
{
if (virtio_swap_endian(modern))
return (htole16(val));
else
return (val);
}
static inline uint32_t
virtio_htog32(bool modern, uint32_t val)
{
if (virtio_swap_endian(modern))
return (le32toh(val));
else
return (val);
}
static inline uint32_t
virtio_gtoh32(bool modern, uint32_t val)
{
if (virtio_swap_endian(modern))
return (htole32(val));
else
return (val);
}
static inline uint64_t
virtio_htog64(bool modern, uint64_t val)
{
if (virtio_swap_endian(modern))
return (le64toh(val));
else
return (val);
}
static inline uint64_t
virtio_gtoh64(bool modern, uint64_t val)
{
if (virtio_swap_endian(modern))
return (htole64(val));
else
return (val);
}
#endif /* _VIRTIO_ENDIAN_H_ */

10
sys/dev/virtio/virtqueue.c
View File

@ -64,6 +64,7 @@ struct virtqueue {
#define VIRTQUEUE_FLAG_INDIRECT 0x0001
#define VIRTQUEUE_FLAG_EVENT_IDX 0x0002
bus_size_t vq_notify_offset;
int vq_alignment;
int vq_ring_size;
void *vq_ring_mem;
@ -147,8 +148,9 @@ virtqueue_filter_features(uint64_t features)
}
int
virtqueue_alloc(device_t dev, uint16_t queue, uint16_t size, int align,
vm_paddr_t highaddr, struct vq_alloc_info *info, struct virtqueue **vqp)
virtqueue_alloc(device_t dev, uint16_t queue, uint16_t size,
bus_size_t notify_offset, int align, vm_paddr_t highaddr,
struct vq_alloc_info *info, struct virtqueue **vqp)
{
struct virtqueue *vq;
int error;
@ -184,6 +186,7 @@ virtqueue_alloc(device_t dev, uint16_t queue, uint16_t size, int align,
vq->vq_dev = dev;
strlcpy(vq->vq_name, info->vqai_name, sizeof(vq->vq_name));
vq->vq_queue_index = queue;
vq->vq_notify_offset = notify_offset;
vq->vq_alignment = align;
vq->vq_nentries = size;
vq->vq_free_cnt = size;
@ -820,7 +823,8 @@ static void
vq_ring_notify_host(struct virtqueue *vq)
{
VIRTIO_BUS_NOTIFY_VQ(vq->vq_dev, vq->vq_queue_index);
VIRTIO_BUS_NOTIFY_VQ(vq->vq_dev, vq->vq_queue_index,
vq->vq_notify_offset);
}
static void

4
sys/dev/virtio/virtqueue.h
View File

@ -70,8 +70,8 @@ struct vq_alloc_info {
uint64_t virtqueue_filter_features(uint64_t features);
int virtqueue_alloc(device_t dev, uint16_t queue, uint16_t size,
int align, vm_paddr_t highaddr, struct vq_alloc_info *info,
struct virtqueue **vqp);
bus_size_t notify_offset, int align, vm_paddr_t highaddr,
struct vq_alloc_info *info, struct virtqueue **vqp);
void *virtqueue_drain(struct virtqueue *vq, int *last);
void virtqueue_free(struct virtqueue *vq);
int virtqueue_reinit(struct virtqueue *vq, uint16_t size);

5
sys/modules/virtio/pci/Makefile
View File

@ -26,8 +26,9 @@
.PATH: ${SRCTOP}/sys/dev/virtio/pci
KMOD= virtio_pci
SRCS= virtio_pci.c
SRCS+= virtio_bus_if.h virtio_if.h
SRCS= virtio_pci.c virtio_pci_legacy.c virtio_pci_modern.c
SRCS+= virtio_pci_if.c virtio_pci_if.h
SRCS+= virtio_bus_if.h virtio_if.h
SRCS+= bus_if.h device_if.h pci_if.h
.include <bsd.kmod.mk>