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

/*
 * Virtio PCI Bindings
 *
 * Copyright IBM, Corp. 2007
 * Copyright (c) 2009 CodeSourcery
 *
 * Authors:
 *  Anthony Liguori   <[email protected]>
 *  Paul Brook        <[email protected]>
 *
 * 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

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 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-base"
#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-base"
#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-base"
#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-base"
#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-base"
#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-base"
#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-base"
#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-base"
#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-base"
#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-base"
#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-base"
#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;
};

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