[mirror_qemu.git] / hw / virtio / virtio-pci.h

/*
 * Virtio PCI Bindings
 *
 * Copyright IBM, Corp. 2007
 * Copyright (c) 2009 CodeSourcery
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *  Paul Brook        <paul@codesourcery.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 */

#ifndef QEMU_VIRTIO_PCI_H
#define QEMU_VIRTIO_PCI_H

#include "hw/pci/msi.h"
#include "hw/virtio/virtio-blk.h"
#include "hw/virtio/virtio-net.h"
#include "hw/virtio/virtio-rng.h"
#include "hw/virtio/virtio-serial.h"
#include "hw/virtio/virtio-scsi.h"
#include "hw/virtio/virtio-balloon.h"
#include "hw/virtio/virtio-bus.h"
#include "hw/virtio/virtio-input.h"
#include "hw/virtio/virtio-gpu.h"
#include "hw/virtio/virtio-crypto.h"
#include "hw/virtio/vhost-user-scsi.h"
#if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
#include "hw/virtio/vhost-user-blk.h"
#endif

#ifdef CONFIG_VIRTFS
#include "hw/9pfs/virtio-9p.h"
#endif
#ifdef CONFIG_VHOST_SCSI
#include "hw/virtio/vhost-scsi.h"
#endif
#ifdef CONFIG_VHOST_VSOCK
#include "hw/virtio/vhost-vsock.h"
#endif

typedef struct VirtIOPCIProxy VirtIOPCIProxy;
typedef struct VirtIOBlkPCI VirtIOBlkPCI;
typedef struct VirtIOSCSIPCI VirtIOSCSIPCI;
typedef struct VirtIOBalloonPCI VirtIOBalloonPCI;
typedef struct VirtIOSerialPCI VirtIOSerialPCI;
typedef struct VirtIONetPCI VirtIONetPCI;
typedef struct VHostSCSIPCI VHostSCSIPCI;
typedef struct VHostUserSCSIPCI VHostUserSCSIPCI;
typedef struct VHostUserBlkPCI VHostUserBlkPCI;
typedef struct VirtIORngPCI VirtIORngPCI;
typedef struct VirtIOInputPCI VirtIOInputPCI;
typedef struct VirtIOInputHIDPCI VirtIOInputHIDPCI;
typedef struct VirtIOInputHostPCI VirtIOInputHostPCI;
typedef struct VirtIOGPUPCI VirtIOGPUPCI;
typedef struct VHostVSockPCI VHostVSockPCI;
typedef struct VirtIOCryptoPCI VirtIOCryptoPCI;

/* virtio-pci-bus */

typedef struct VirtioBusState VirtioPCIBusState;
typedef struct VirtioBusClass VirtioPCIBusClass;

#define TYPE_VIRTIO_PCI_BUS "virtio-pci-bus"
#define VIRTIO_PCI_BUS(obj) \
        OBJECT_CHECK(VirtioPCIBusState, (obj), TYPE_VIRTIO_PCI_BUS)
#define VIRTIO_PCI_BUS_GET_CLASS(obj) \
        OBJECT_GET_CLASS(VirtioPCIBusClass, obj, TYPE_VIRTIO_PCI_BUS)
#define VIRTIO_PCI_BUS_CLASS(klass) \
        OBJECT_CLASS_CHECK(VirtioPCIBusClass, klass, TYPE_VIRTIO_PCI_BUS)

enum {
    VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT,
    VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT,
    VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT,
    VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT,
    VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT,
    VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT,
    VIRTIO_PCI_FLAG_ATS_BIT,
    VIRTIO_PCI_FLAG_INIT_DEVERR_BIT,
    VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT,
    VIRTIO_PCI_FLAG_INIT_PM_BIT,
};

/* Need to activate work-arounds for buggy guests at vmstate load. */
#define VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION \
    (1 << VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT)

/* Performance improves when virtqueue kick processing is decoupled from the
 * vcpu thread using ioeventfd for some devices. */
#define VIRTIO_PCI_FLAG_USE_IOEVENTFD   (1 << VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT)

/* virtio version flags */
#define VIRTIO_PCI_FLAG_DISABLE_PCIE (1 << VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT)

/* migrate extra state */
#define VIRTIO_PCI_FLAG_MIGRATE_EXTRA (1 << VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT)

/* have pio notification for modern device ? */
#define VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY \
    (1 << VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT)

/* page per vq flag to be used by split drivers within guests */
#define VIRTIO_PCI_FLAG_PAGE_PER_VQ \
    (1 << VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT)

/* address space translation service */
#define VIRTIO_PCI_FLAG_ATS (1 << VIRTIO_PCI_FLAG_ATS_BIT)

/* Init error enabling flags */
#define VIRTIO_PCI_FLAG_INIT_DEVERR (1 << VIRTIO_PCI_FLAG_INIT_DEVERR_BIT)

/* Init Link Control register */
#define VIRTIO_PCI_FLAG_INIT_LNKCTL (1 << VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT)

/* Init Power Management */
#define VIRTIO_PCI_FLAG_INIT_PM (1 << VIRTIO_PCI_FLAG_INIT_PM_BIT)

typedef struct {
    MSIMessage msg;
    int virq;
    unsigned int users;
} VirtIOIRQFD;

/*
 * virtio-pci: This is the PCIDevice which has a virtio-pci-bus.
 */
#define TYPE_VIRTIO_PCI "virtio-pci"
#define VIRTIO_PCI_GET_CLASS(obj) \
        OBJECT_GET_CLASS(VirtioPCIClass, obj, TYPE_VIRTIO_PCI)
#define VIRTIO_PCI_CLASS(klass) \
        OBJECT_CLASS_CHECK(VirtioPCIClass, klass, TYPE_VIRTIO_PCI)
#define VIRTIO_PCI(obj) \
        OBJECT_CHECK(VirtIOPCIProxy, (obj), TYPE_VIRTIO_PCI)

typedef struct VirtioPCIClass {
    PCIDeviceClass parent_class;
    DeviceRealize parent_dc_realize;
    void (*realize)(VirtIOPCIProxy *vpci_dev, Error **errp);
} VirtioPCIClass;

typedef struct VirtIOPCIRegion {
    MemoryRegion mr;
    uint32_t offset;
    uint32_t size;
    uint32_t type;
} VirtIOPCIRegion;

typedef struct VirtIOPCIQueue {
  uint16_t num;
  bool enabled;
  uint32_t desc[2];
  uint32_t avail[2];
  uint32_t used[2];
} VirtIOPCIQueue;

struct VirtIOPCIProxy {
    PCIDevice pci_dev;
    MemoryRegion bar;
    union {
        struct {
            VirtIOPCIRegion common;
            VirtIOPCIRegion isr;
            VirtIOPCIRegion device;
            VirtIOPCIRegion notify;
            VirtIOPCIRegion notify_pio;
        };
        VirtIOPCIRegion regs[5];
    };
    MemoryRegion modern_bar;
    MemoryRegion io_bar;
    uint32_t legacy_io_bar_idx;
    uint32_t msix_bar_idx;
    uint32_t modern_io_bar_idx;
    uint32_t modern_mem_bar_idx;
    int config_cap;
    uint32_t flags;
    bool disable_modern;
    bool ignore_backend_features;
    OnOffAuto disable_legacy;
    uint32_t class_code;
    uint32_t nvectors;
    uint32_t dfselect;
    uint32_t gfselect;
    uint32_t guest_features[2];
    VirtIOPCIQueue vqs[VIRTIO_QUEUE_MAX];

    VirtIOIRQFD *vector_irqfd;
    int nvqs_with_notifiers;
    VirtioBusState bus;
};

static inline bool virtio_pci_modern(VirtIOPCIProxy *proxy)
{
    return !proxy->disable_modern;
}

static inline bool virtio_pci_legacy(VirtIOPCIProxy *proxy)
{
    return proxy->disable_legacy == ON_OFF_AUTO_OFF;
}

static inline void virtio_pci_force_virtio_1(VirtIOPCIProxy *proxy)
{
    proxy->disable_modern = false;
    proxy->disable_legacy = ON_OFF_AUTO_ON;
}

static inline void virtio_pci_disable_modern(VirtIOPCIProxy *proxy)
{
    proxy->disable_modern = true;
}

/*
 * virtio-scsi-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VIRTIO_SCSI_PCI "virtio-scsi-pci"
#define VIRTIO_SCSI_PCI(obj) \
        OBJECT_CHECK(VirtIOSCSIPCI, (obj), TYPE_VIRTIO_SCSI_PCI)

struct VirtIOSCSIPCI {
    VirtIOPCIProxy parent_obj;
    VirtIOSCSI vdev;
};

#ifdef CONFIG_VHOST_SCSI
/*
 * vhost-scsi-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VHOST_SCSI_PCI "vhost-scsi-pci"
#define VHOST_SCSI_PCI(obj) \
        OBJECT_CHECK(VHostSCSIPCI, (obj), TYPE_VHOST_SCSI_PCI)

struct VHostSCSIPCI {
    VirtIOPCIProxy parent_obj;
    VHostSCSI vdev;
};
#endif

#define TYPE_VHOST_USER_SCSI_PCI "vhost-user-scsi-pci"
#define VHOST_USER_SCSI_PCI(obj) \
        OBJECT_CHECK(VHostUserSCSIPCI, (obj), TYPE_VHOST_USER_SCSI_PCI)

struct VHostUserSCSIPCI {
    VirtIOPCIProxy parent_obj;
    VHostUserSCSI vdev;
};

#if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
/*
 * vhost-user-blk-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VHOST_USER_BLK_PCI "vhost-user-blk-pci"
#define VHOST_USER_BLK_PCI(obj) \
        OBJECT_CHECK(VHostUserBlkPCI, (obj), TYPE_VHOST_USER_BLK_PCI)

struct VHostUserBlkPCI {
    VirtIOPCIProxy parent_obj;
    VHostUserBlk vdev;
};
#endif

/*
 * virtio-blk-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VIRTIO_BLK_PCI "virtio-blk-pci"
#define VIRTIO_BLK_PCI(obj) \
        OBJECT_CHECK(VirtIOBlkPCI, (obj), TYPE_VIRTIO_BLK_PCI)

struct VirtIOBlkPCI {
    VirtIOPCIProxy parent_obj;
    VirtIOBlock vdev;
};

/*
 * virtio-balloon-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VIRTIO_BALLOON_PCI "virtio-balloon-pci"
#define VIRTIO_BALLOON_PCI(obj) \
        OBJECT_CHECK(VirtIOBalloonPCI, (obj), TYPE_VIRTIO_BALLOON_PCI)

struct VirtIOBalloonPCI {
    VirtIOPCIProxy parent_obj;
    VirtIOBalloon vdev;
};

/*
 * virtio-serial-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VIRTIO_SERIAL_PCI "virtio-serial-pci"
#define VIRTIO_SERIAL_PCI(obj) \
        OBJECT_CHECK(VirtIOSerialPCI, (obj), TYPE_VIRTIO_SERIAL_PCI)

struct VirtIOSerialPCI {
    VirtIOPCIProxy parent_obj;
    VirtIOSerial vdev;
};

/*
 * virtio-net-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VIRTIO_NET_PCI "virtio-net-pci"
#define VIRTIO_NET_PCI(obj) \
        OBJECT_CHECK(VirtIONetPCI, (obj), TYPE_VIRTIO_NET_PCI)

struct VirtIONetPCI {
    VirtIOPCIProxy parent_obj;
    VirtIONet vdev;
};

/*
 * virtio-9p-pci: This extends VirtioPCIProxy.
 */

#ifdef CONFIG_VIRTFS

#define TYPE_VIRTIO_9P_PCI "virtio-9p-pci"
#define VIRTIO_9P_PCI(obj) \
        OBJECT_CHECK(V9fsPCIState, (obj), TYPE_VIRTIO_9P_PCI)

typedef struct V9fsPCIState {
    VirtIOPCIProxy parent_obj;
    V9fsVirtioState vdev;
} V9fsPCIState;

#endif

/*
 * virtio-rng-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VIRTIO_RNG_PCI "virtio-rng-pci"
#define VIRTIO_RNG_PCI(obj) \
        OBJECT_CHECK(VirtIORngPCI, (obj), TYPE_VIRTIO_RNG_PCI)

struct VirtIORngPCI {
    VirtIOPCIProxy parent_obj;
    VirtIORNG vdev;
};

/*
 * virtio-input-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VIRTIO_INPUT_PCI "virtio-input-pci"
#define VIRTIO_INPUT_PCI(obj) \
        OBJECT_CHECK(VirtIOInputPCI, (obj), TYPE_VIRTIO_INPUT_PCI)

struct VirtIOInputPCI {
    VirtIOPCIProxy parent_obj;
    VirtIOInput vdev;
};

#define TYPE_VIRTIO_INPUT_HID_PCI "virtio-input-hid-pci"
#define TYPE_VIRTIO_KEYBOARD_PCI  "virtio-keyboard-pci"
#define TYPE_VIRTIO_MOUSE_PCI     "virtio-mouse-pci"
#define TYPE_VIRTIO_TABLET_PCI    "virtio-tablet-pci"
#define VIRTIO_INPUT_HID_PCI(obj) \
        OBJECT_CHECK(VirtIOInputHIDPCI, (obj), TYPE_VIRTIO_INPUT_HID_PCI)

struct VirtIOInputHIDPCI {
    VirtIOPCIProxy parent_obj;
    VirtIOInputHID vdev;
};

#ifdef CONFIG_LINUX

#define TYPE_VIRTIO_INPUT_HOST_PCI "virtio-input-host-pci"
#define VIRTIO_INPUT_HOST_PCI(obj) \
        OBJECT_CHECK(VirtIOInputHostPCI, (obj), TYPE_VIRTIO_INPUT_HOST_PCI)

struct VirtIOInputHostPCI {
    VirtIOPCIProxy parent_obj;
    VirtIOInputHost vdev;
};

#endif

/*
 * virtio-gpu-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VIRTIO_GPU_PCI "virtio-gpu-pci"
#define VIRTIO_GPU_PCI(obj) \
        OBJECT_CHECK(VirtIOGPUPCI, (obj), TYPE_VIRTIO_GPU_PCI)

struct VirtIOGPUPCI {
    VirtIOPCIProxy parent_obj;
    VirtIOGPU vdev;
};

#ifdef CONFIG_VHOST_VSOCK
/*
 * vhost-vsock-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VHOST_VSOCK_PCI "vhost-vsock-pci"
#define VHOST_VSOCK_PCI(obj) \
        OBJECT_CHECK(VHostVSockPCI, (obj), TYPE_VHOST_VSOCK_PCI)

struct VHostVSockPCI {
    VirtIOPCIProxy parent_obj;
    VHostVSock vdev;
};
#endif

/*
 * virtio-crypto-pci: This extends VirtioPCIProxy.
 */
#define TYPE_VIRTIO_CRYPTO_PCI "virtio-crypto-pci"
#define VIRTIO_CRYPTO_PCI(obj) \
        OBJECT_CHECK(VirtIOCryptoPCI, (obj), TYPE_VIRTIO_CRYPTO_PCI)

struct VirtIOCryptoPCI {
    VirtIOPCIProxy parent_obj;
    VirtIOCrypto vdev;
};

/* Virtio ABI version, if we increment this, we break the guest driver. */
#define VIRTIO_PCI_ABI_VERSION          0

/* Input for virtio_pci_types_register() */
typedef struct VirtioPCIDeviceTypeInfo {
    /*
     * Common base class for the subclasses below.
     *
     * Required only if transitional_name or non_transitional_name is set.
     *
     * We need a separate base type instead of making all types
     * inherit from generic_name for two reasons:
     * 1) generic_name implements INTERFACE_PCIE_DEVICE, but
     *    transitional_name does not.
     * 2) generic_name has the "disable-legacy" and "disable-modern"
     *    properties, transitional_name and non_transitional name don't.
     */
    const char *base_name;
    /*
     * Generic device type.  Optional.
     *
     * Supports both transitional and non-transitional modes,
     * using the disable-legacy and disable-modern properties.
     * If disable-legacy=auto, (non-)transitional mode is selected
     * depending on the bus where the device is plugged.
     *
     * Implements both INTERFACE_PCIE_DEVICE and INTERFACE_CONVENTIONAL_PCI_DEVICE,
     * but PCI Express is supported only in non-transitional mode.
     *
     * The only type implemented by QEMU 3.1 and older.
     */
    const char *generic_name;
    /*
     * The transitional device type.  Optional.
     *
     * Implements both INTERFACE_PCIE_DEVICE and INTERFACE_CONVENTIONAL_PCI_DEVICE.
     */
    const char *transitional_name;
    /*
     * The non-transitional device type.  Optional.
     *
     * Implements INTERFACE_CONVENTIONAL_PCI_DEVICE only.
     */
    const char *non_transitional_name;

    /* Parent type.  If NULL, TYPE_VIRTIO_PCI is used */
    const char *parent;

    /* Same as TypeInfo fields: */
    size_t instance_size;
    void (*instance_init)(Object *obj);
    void (*class_init)(ObjectClass *klass, void *data);
} VirtioPCIDeviceTypeInfo;

/* Register virtio-pci type(s).  @t must be static. */
void virtio_pci_types_register(const VirtioPCIDeviceTypeInfo *t);

#endif
Commit	Line	Data
9fe1ebeb AK	1	/*
	2	* Virtio PCI Bindings
	3	*
	4	* Copyright IBM, Corp. 2007
	5	* Copyright (c) 2009 CodeSourcery
	6	*
	7	* Authors:
	8	* Anthony Liguori <aliguori@us.ibm.com>
	9	* Paul Brook <paul@codesourcery.com>
	10	*
	11	* This work is licensed under the terms of the GNU GPL, version 2. See
	12	* the COPYING file in the top-level directory.
	13	*/
	14
	15	#ifndef QEMU_VIRTIO_PCI_H
	16	#define QEMU_VIRTIO_PCI_H
	17
cf7c3f0c	18	#include "hw/pci/msi.h"
0d09e41a PB	19	#include "hw/virtio/virtio-blk.h"
	20	#include "hw/virtio/virtio-net.h"
	21	#include "hw/virtio/virtio-rng.h"
	22	#include "hw/virtio/virtio-serial.h"
	23	#include "hw/virtio/virtio-scsi.h"
	24	#include "hw/virtio/virtio-balloon.h"
	25	#include "hw/virtio/virtio-bus.h"
f958c8aa	26	#include "hw/virtio/virtio-input.h"
9eafb62d	27	#include "hw/virtio/virtio-gpu.h"
b307d308	28	#include "hw/virtio/virtio-crypto.h"
f12c1ebd	29	#include "hw/virtio/vhost-user-scsi.h"
00343e4b CL	30	#if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
	31	#include "hw/virtio/vhost-user-blk.h"
	32	#endif
b307d308	33
234a336f FK	34	#ifdef CONFIG_VIRTFS
	35	#include "hw/9pfs/virtio-9p.h"
	36	#endif
50787628 NB	37	#ifdef CONFIG_VHOST_SCSI
	38	#include "hw/virtio/vhost-scsi.h"
	39	#endif
fc0b9b0e SH	40	#ifdef CONFIG_VHOST_VSOCK
	41	#include "hw/virtio/vhost-vsock.h"
	42	#endif
0a2acf5e	43
085bccb7	44	typedef struct VirtIOPCIProxy VirtIOPCIProxy;
653ced07	45	typedef struct VirtIOBlkPCI VirtIOBlkPCI;
bc7b90a0	46	typedef struct VirtIOSCSIPCI VirtIOSCSIPCI;
e378e88d	47	typedef struct VirtIOBalloonPCI VirtIOBalloonPCI;
f7f7464a	48	typedef struct VirtIOSerialPCI VirtIOSerialPCI;
e37da394	49	typedef struct VirtIONetPCI VirtIONetPCI;
50787628	50	typedef struct VHostSCSIPCI VHostSCSIPCI;
f12c1ebd	51	typedef struct VHostUserSCSIPCI VHostUserSCSIPCI;
00343e4b	52	typedef struct VHostUserBlkPCI VHostUserBlkPCI;
59ccd20a	53	typedef struct VirtIORngPCI VirtIORngPCI;
f958c8aa	54	typedef struct VirtIOInputPCI VirtIOInputPCI;
710e2d90	55	typedef struct VirtIOInputHIDPCI VirtIOInputHIDPCI;
006a5ede	56	typedef struct VirtIOInputHostPCI VirtIOInputHostPCI;
9eafb62d	57	typedef struct VirtIOGPUPCI VirtIOGPUPCI;
fc0b9b0e	58	typedef struct VHostVSockPCI VHostVSockPCI;
b307d308	59	typedef struct VirtIOCryptoPCI VirtIOCryptoPCI;
085bccb7	60
0a2acf5e FK	61	/* virtio-pci-bus */
	62
	63	typedef struct VirtioBusState VirtioPCIBusState;
	64	typedef struct VirtioBusClass VirtioPCIBusClass;
	65
	66	#define TYPE_VIRTIO_PCI_BUS "virtio-pci-bus"
	67	#define VIRTIO_PCI_BUS(obj) \
	68	OBJECT_CHECK(VirtioPCIBusState, (obj), TYPE_VIRTIO_PCI_BUS)
	69	#define VIRTIO_PCI_BUS_GET_CLASS(obj) \
	70	OBJECT_GET_CLASS(VirtioPCIBusClass, obj, TYPE_VIRTIO_PCI_BUS)
	71	#define VIRTIO_PCI_BUS_CLASS(klass) \
	72	OBJECT_CLASS_CHECK(VirtioPCIBusClass, klass, TYPE_VIRTIO_PCI_BUS)
9fe1ebeb	73
fc1769b7 MA	74	enum {
	75	VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT,
	76	VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT,
fc1769b7 MA	77	VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT,
	78	VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT,
	79	VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT,
d9997d89	80	VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT,
615c4ed2	81	VIRTIO_PCI_FLAG_ATS_BIT,
c2cabb34	82	VIRTIO_PCI_FLAG_INIT_DEVERR_BIT,
d584f1b9	83	VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT,
27ce0f3a	84	VIRTIO_PCI_FLAG_INIT_PM_BIT,
fc1769b7 MA	85	};
fc1769b7 MA	86
68a27b20	87	/* Need to activate work-arounds for buggy guests at vmstate load. */
68a27b20 MT	88	#define VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION \
	89	(1 << VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT)
	90
5745e38a AK	91	/* Performance improves when virtqueue kick processing is decoupled from the
5745e38a AK	92	* vcpu thread using ioeventfd for some devices. */
5745e38a AK	93	#define VIRTIO_PCI_FLAG_USE_IOEVENTFD (1 << VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT)
5745e38a AK	94
e266d421	95	/* virtio version flags */
1811e64c	96	#define VIRTIO_PCI_FLAG_DISABLE_PCIE (1 << VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT)
e266d421	97
a6df8adf	98	/* migrate extra state */
a6df8adf JW	99	#define VIRTIO_PCI_FLAG_MIGRATE_EXTRA (1 << VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT)
a6df8adf JW	100
9824d2a3	101	/* have pio notification for modern device ? */
9824d2a3 JW	102	#define VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY \
	103	(1 << VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT)
	104
d9997d89 MA	105	/* page per vq flag to be used by split drivers within guests */
	106	#define VIRTIO_PCI_FLAG_PAGE_PER_VQ \
	107	(1 << VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT)
	108
615c4ed2 JW	109	/* address space translation service */
	110	#define VIRTIO_PCI_FLAG_ATS (1 << VIRTIO_PCI_FLAG_ATS_BIT)
	111
c2cabb34 MA	112	/* Init error enabling flags */
	113	#define VIRTIO_PCI_FLAG_INIT_DEVERR (1 << VIRTIO_PCI_FLAG_INIT_DEVERR_BIT)
	114
d584f1b9 MA	115	/* Init Link Control register */
	116	#define VIRTIO_PCI_FLAG_INIT_LNKCTL (1 << VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT)
	117
27ce0f3a MA	118	/* Init Power Management */
	119	#define VIRTIO_PCI_FLAG_INIT_PM (1 << VIRTIO_PCI_FLAG_INIT_PM_BIT)
	120
7d37d351	121	typedef struct {
774345f9	122	MSIMessage msg;
7d37d351 JK	123	int virq;
	124	unsigned int users;
	125	} VirtIOIRQFD;
	126
085bccb7 FK	127	/*
	128	* virtio-pci: This is the PCIDevice which has a virtio-pci-bus.
	129	*/
	130	#define TYPE_VIRTIO_PCI "virtio-pci"
	131	#define VIRTIO_PCI_GET_CLASS(obj) \
	132	OBJECT_GET_CLASS(VirtioPCIClass, obj, TYPE_VIRTIO_PCI)
	133	#define VIRTIO_PCI_CLASS(klass) \
	134	OBJECT_CLASS_CHECK(VirtioPCIClass, klass, TYPE_VIRTIO_PCI)
	135	#define VIRTIO_PCI(obj) \
	136	OBJECT_CHECK(VirtIOPCIProxy, (obj), TYPE_VIRTIO_PCI)
	137
	138	typedef struct VirtioPCIClass {
	139	PCIDeviceClass parent_class;
0560b0e9	140	DeviceRealize parent_dc_realize;
fc079951	141	void (realize)(VirtIOPCIProxy vpci_dev, Error **errp);
085bccb7 FK	142	} VirtioPCIClass;
085bccb7 FK	143
588255ad GH	144	typedef struct VirtIOPCIRegion {
588255ad GH	145	MemoryRegion mr;
a3cc2e81	146	uint32_t offset;
b6ce27a5	147	uint32_t size;
fc004905	148	uint32_t type;
588255ad GH	149	} VirtIOPCIRegion;
588255ad GH	150
a6df8adf JW	151	typedef struct VirtIOPCIQueue {
	152	uint16_t num;
	153	bool enabled;
	154	uint32_t desc[2];
	155	uint32_t avail[2];
	156	uint32_t used[2];
	157	} VirtIOPCIQueue;
	158
085bccb7	159	struct VirtIOPCIProxy {
9fe1ebeb	160	PCIDevice pci_dev;
da146d0a	161	MemoryRegion bar;
a93c8d82 AK	162	union {
	163	struct {
	164	VirtIOPCIRegion common;
	165	VirtIOPCIRegion isr;
	166	VirtIOPCIRegion device;
	167	VirtIOPCIRegion notify;
	168	VirtIOPCIRegion notify_pio;
	169	};
	170	VirtIOPCIRegion regs[5];
	171	};
dfb8e184	172	MemoryRegion modern_bar;
9824d2a3	173	MemoryRegion io_bar;
7a25126d CF	174	uint32_t legacy_io_bar_idx;
	175	uint32_t msix_bar_idx;
	176	uint32_t modern_io_bar_idx;
	177	uint32_t modern_mem_bar_idx;
ada434cd	178	int config_cap;
9fe1ebeb	179	uint32_t flags;
9a4c0e22	180	bool disable_modern;
66d1c4c1	181	bool ignore_backend_features;
9a4c0e22	182	OnOffAuto disable_legacy;
9fe1ebeb AK	183	uint32_t class_code;
9fe1ebeb AK	184	uint32_t nvectors;
dfb8e184 MT	185	uint32_t dfselect;
	186	uint32_t gfselect;
	187	uint32_t guest_features[2];
a6df8adf	188	VirtIOPCIQueue vqs[VIRTIO_QUEUE_MAX];
dfb8e184	189
7d37d351	190	VirtIOIRQFD *vector_irqfd;
2d620f59	191	int nvqs_with_notifiers;
085bccb7 FK	192	VirtioBusState bus;
085bccb7 FK	193	};
9fe1ebeb	194
9a4c0e22 MA	195	static inline bool virtio_pci_modern(VirtIOPCIProxy *proxy)
	196	{
	197	return !proxy->disable_modern;
	198	}
	199
	200	static inline bool virtio_pci_legacy(VirtIOPCIProxy *proxy)
	201	{
	202	return proxy->disable_legacy == ON_OFF_AUTO_OFF;
	203	}
	204
	205	static inline void virtio_pci_force_virtio_1(VirtIOPCIProxy *proxy)
	206	{
	207	proxy->disable_modern = false;
	208	proxy->disable_legacy = ON_OFF_AUTO_ON;
	209	}
bc7b90a0	210
d1b4259f MC	211	static inline void virtio_pci_disable_modern(VirtIOPCIProxy *proxy)
	212	{
	213	proxy->disable_modern = true;
	214	}
	215
bc7b90a0 FK	216	/*
	217	* virtio-scsi-pci: This extends VirtioPCIProxy.
	218	*/
	219	#define TYPE_VIRTIO_SCSI_PCI "virtio-scsi-pci"
	220	#define VIRTIO_SCSI_PCI(obj) \
	221	OBJECT_CHECK(VirtIOSCSIPCI, (obj), TYPE_VIRTIO_SCSI_PCI)
	222
	223	struct VirtIOSCSIPCI {
	224	VirtIOPCIProxy parent_obj;
	225	VirtIOSCSI vdev;
	226	};
	227
50787628 NB	228	#ifdef CONFIG_VHOST_SCSI
	229	/*
	230	* vhost-scsi-pci: This extends VirtioPCIProxy.
	231	*/
	232	#define TYPE_VHOST_SCSI_PCI "vhost-scsi-pci"
	233	#define VHOST_SCSI_PCI(obj) \
	234	OBJECT_CHECK(VHostSCSIPCI, (obj), TYPE_VHOST_SCSI_PCI)
	235
	236	struct VHostSCSIPCI {
	237	VirtIOPCIProxy parent_obj;
	238	VHostSCSI vdev;
	239	};
	240	#endif
	241
f12c1ebd FF	242	#define TYPE_VHOST_USER_SCSI_PCI "vhost-user-scsi-pci"
	243	#define VHOST_USER_SCSI_PCI(obj) \
	244	OBJECT_CHECK(VHostUserSCSIPCI, (obj), TYPE_VHOST_USER_SCSI_PCI)
	245
	246	struct VHostUserSCSIPCI {
	247	VirtIOPCIProxy parent_obj;
	248	VHostUserSCSI vdev;
	249	};
	250
00343e4b CL	251	#if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
	252	/*
	253	* vhost-user-blk-pci: This extends VirtioPCIProxy.
	254	*/
	255	#define TYPE_VHOST_USER_BLK_PCI "vhost-user-blk-pci"
	256	#define VHOST_USER_BLK_PCI(obj) \
	257	OBJECT_CHECK(VHostUserBlkPCI, (obj), TYPE_VHOST_USER_BLK_PCI)
	258
	259	struct VHostUserBlkPCI {
	260	VirtIOPCIProxy parent_obj;
	261	VHostUserBlk vdev;
	262	};
	263	#endif
	264
653ced07 FK	265	/*
	266	* virtio-blk-pci: This extends VirtioPCIProxy.
	267	*/
	268	#define TYPE_VIRTIO_BLK_PCI "virtio-blk-pci"
	269	#define VIRTIO_BLK_PCI(obj) \
	270	OBJECT_CHECK(VirtIOBlkPCI, (obj), TYPE_VIRTIO_BLK_PCI)
	271
	272	struct VirtIOBlkPCI {
	273	VirtIOPCIProxy parent_obj;
	274	VirtIOBlock vdev;
653ced07 FK	275	};
653ced07 FK	276
e378e88d FK	277	/*
	278	* virtio-balloon-pci: This extends VirtioPCIProxy.
	279	*/
	280	#define TYPE_VIRTIO_BALLOON_PCI "virtio-balloon-pci"
	281	#define VIRTIO_BALLOON_PCI(obj) \
	282	OBJECT_CHECK(VirtIOBalloonPCI, (obj), TYPE_VIRTIO_BALLOON_PCI)
	283
	284	struct VirtIOBalloonPCI {
	285	VirtIOPCIProxy parent_obj;
	286	VirtIOBalloon vdev;
	287	};
	288
f7f7464a FK	289	/*
	290	* virtio-serial-pci: This extends VirtioPCIProxy.
	291	*/
	292	#define TYPE_VIRTIO_SERIAL_PCI "virtio-serial-pci"
	293	#define VIRTIO_SERIAL_PCI(obj) \
	294	OBJECT_CHECK(VirtIOSerialPCI, (obj), TYPE_VIRTIO_SERIAL_PCI)
	295
	296	struct VirtIOSerialPCI {
	297	VirtIOPCIProxy parent_obj;
	298	VirtIOSerial vdev;
	299	};
	300
e37da394 FK	301	/*
	302	* virtio-net-pci: This extends VirtioPCIProxy.
	303	*/
	304	#define TYPE_VIRTIO_NET_PCI "virtio-net-pci"
	305	#define VIRTIO_NET_PCI(obj) \
	306	OBJECT_CHECK(VirtIONetPCI, (obj), TYPE_VIRTIO_NET_PCI)
	307
	308	struct VirtIONetPCI {
	309	VirtIOPCIProxy parent_obj;
	310	VirtIONet vdev;
	311	};
	312
234a336f FK	313	/*
	314	* virtio-9p-pci: This extends VirtioPCIProxy.
	315	*/
	316
	317	#ifdef CONFIG_VIRTFS
	318
	319	#define TYPE_VIRTIO_9P_PCI "virtio-9p-pci"
	320	#define VIRTIO_9P_PCI(obj) \
	321	OBJECT_CHECK(V9fsPCIState, (obj), TYPE_VIRTIO_9P_PCI)
	322
	323	typedef struct V9fsPCIState {
	324	VirtIOPCIProxy parent_obj;
00588a0a	325	V9fsVirtioState vdev;
234a336f FK	326	} V9fsPCIState;
	327
	328	#endif
	329
59ccd20a FK	330	/*
	331	* virtio-rng-pci: This extends VirtioPCIProxy.
	332	*/
	333	#define TYPE_VIRTIO_RNG_PCI "virtio-rng-pci"
	334	#define VIRTIO_RNG_PCI(obj) \
	335	OBJECT_CHECK(VirtIORngPCI, (obj), TYPE_VIRTIO_RNG_PCI)
	336
	337	struct VirtIORngPCI {
	338	VirtIOPCIProxy parent_obj;
	339	VirtIORNG vdev;
	340	};
	341
f958c8aa GH	342	/*
	343	* virtio-input-pci: This extends VirtioPCIProxy.
	344	*/
	345	#define TYPE_VIRTIO_INPUT_PCI "virtio-input-pci"
	346	#define VIRTIO_INPUT_PCI(obj) \
	347	OBJECT_CHECK(VirtIOInputPCI, (obj), TYPE_VIRTIO_INPUT_PCI)
	348
	349	struct VirtIOInputPCI {
	350	VirtIOPCIProxy parent_obj;
	351	VirtIOInput vdev;
	352	};
	353
710e2d90 GH	354	#define TYPE_VIRTIO_INPUT_HID_PCI "virtio-input-hid-pci"
	355	#define TYPE_VIRTIO_KEYBOARD_PCI "virtio-keyboard-pci"
	356	#define TYPE_VIRTIO_MOUSE_PCI "virtio-mouse-pci"
	357	#define TYPE_VIRTIO_TABLET_PCI "virtio-tablet-pci"
	358	#define VIRTIO_INPUT_HID_PCI(obj) \
	359	OBJECT_CHECK(VirtIOInputHIDPCI, (obj), TYPE_VIRTIO_INPUT_HID_PCI)
	360
	361	struct VirtIOInputHIDPCI {
	362	VirtIOPCIProxy parent_obj;
	363	VirtIOInputHID vdev;
	364	};
	365
c6047e96 MA	366	#ifdef CONFIG_LINUX
c6047e96 MA	367
006a5ede GH	368	#define TYPE_VIRTIO_INPUT_HOST_PCI "virtio-input-host-pci"
	369	#define VIRTIO_INPUT_HOST_PCI(obj) \
	370	OBJECT_CHECK(VirtIOInputHostPCI, (obj), TYPE_VIRTIO_INPUT_HOST_PCI)
	371
	372	struct VirtIOInputHostPCI {
	373	VirtIOPCIProxy parent_obj;
	374	VirtIOInputHost vdev;
	375	};
	376
c6047e96 MA	377	#endif
c6047e96 MA	378
9eafb62d GH	379	/*
	380	* virtio-gpu-pci: This extends VirtioPCIProxy.
	381	*/
	382	#define TYPE_VIRTIO_GPU_PCI "virtio-gpu-pci"
	383	#define VIRTIO_GPU_PCI(obj) \
	384	OBJECT_CHECK(VirtIOGPUPCI, (obj), TYPE_VIRTIO_GPU_PCI)
	385
	386	struct VirtIOGPUPCI {
	387	VirtIOPCIProxy parent_obj;
	388	VirtIOGPU vdev;
	389	};
	390
fc0b9b0e SH	391	#ifdef CONFIG_VHOST_VSOCK
	392	/*
	393	* vhost-vsock-pci: This extends VirtioPCIProxy.
	394	*/
	395	#define TYPE_VHOST_VSOCK_PCI "vhost-vsock-pci"
	396	#define VHOST_VSOCK_PCI(obj) \
	397	OBJECT_CHECK(VHostVSockPCI, (obj), TYPE_VHOST_VSOCK_PCI)
	398
	399	struct VHostVSockPCI {
	400	VirtIOPCIProxy parent_obj;
	401	VHostVSock vdev;
	402	};
	403	#endif
	404
b307d308 GA	405	/*
	406	* virtio-crypto-pci: This extends VirtioPCIProxy.
	407	*/
	408	#define TYPE_VIRTIO_CRYPTO_PCI "virtio-crypto-pci"
	409	#define VIRTIO_CRYPTO_PCI(obj) \
	410	OBJECT_CHECK(VirtIOCryptoPCI, (obj), TYPE_VIRTIO_CRYPTO_PCI)
	411
	412	struct VirtIOCryptoPCI {
	413	VirtIOPCIProxy parent_obj;
	414	VirtIOCrypto vdev;
	415	};
	416
befeac45 MT	417	/* Virtio ABI version, if we increment this, we break the guest driver. */
	418	#define VIRTIO_PCI_ABI_VERSION 0
	419
a4ee4c8b EH	420	/* Input for virtio_pci_types_register() */
	421	typedef struct VirtioPCIDeviceTypeInfo {
	422	/*
	423	* Common base class for the subclasses below.
	424	*
	425	* Required only if transitional_name or non_transitional_name is set.
	426	*
	427	* We need a separate base type instead of making all types
	428	* inherit from generic_name for two reasons:
	429	* 1) generic_name implements INTERFACE_PCIE_DEVICE, but
	430	* transitional_name does not.
	431	* 2) generic_name has the "disable-legacy" and "disable-modern"
	432	* properties, transitional_name and non_transitional name don't.
	433	*/
	434	const char *base_name;
	435	/*
	436	* Generic device type. Optional.
	437	*
	438	* Supports both transitional and non-transitional modes,
	439	* using the disable-legacy and disable-modern properties.
	440	* If disable-legacy=auto, (non-)transitional mode is selected
	441	* depending on the bus where the device is plugged.
	442	*
	443	* Implements both INTERFACE_PCIE_DEVICE and INTERFACE_CONVENTIONAL_PCI_DEVICE,
	444	* but PCI Express is supported only in non-transitional mode.
	445	*
	446	* The only type implemented by QEMU 3.1 and older.
	447	*/
	448	const char *generic_name;
	449	/*
	450	* The transitional device type. Optional.
	451	*
	452	* Implements both INTERFACE_PCIE_DEVICE and INTERFACE_CONVENTIONAL_PCI_DEVICE.
	453	*/
	454	const char *transitional_name;
	455	/*
	456	* The non-transitional device type. Optional.
	457	*
	458	* Implements INTERFACE_CONVENTIONAL_PCI_DEVICE only.
	459	*/
	460	const char *non_transitional_name;
	461
	462	/* Parent type. If NULL, TYPE_VIRTIO_PCI is used */
	463	const char *parent;
	464
	465	/* Same as TypeInfo fields: */
	466	size_t instance_size;
	467	void (instance_init)(Object obj);
	468	void (class_init)(ObjectClass klass, void *data);
	469	} VirtioPCIDeviceTypeInfo;
	470
	471	/* Register virtio-pci type(s). @t must be static. */
	472	void virtio_pci_types_register(const VirtioPCIDeviceTypeInfo *t);
	473
9fe1ebeb	474	#endif