hw/virtio/virtio-pci.h

   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
  18 #include "hw/pci/msi.h"
  19 #include "hw/virtio/virtio-blk.h"
  20 #include "hw/virtio/virtio-net.h"
  21 #include "hw/virtio/virtio-serial.h"
  22 #include "hw/virtio/virtio-scsi.h"
  23 #include "hw/virtio/virtio-bus.h"
  24 #include "hw/virtio/virtio-gpu.h"
  25 #include "hw/virtio/virtio-crypto.h"
  26 #include "hw/virtio/vhost-user-scsi.h"
  27 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
  28 #include "hw/virtio/vhost-user-blk.h"
  29 #endif
  30
  31 #ifdef CONFIG_VIRTFS
  32 #include "hw/9pfs/virtio-9p.h"
  33 #endif
  34 #ifdef CONFIG_VHOST_SCSI
  35 #include "hw/virtio/vhost-scsi.h"
  36 #endif
  37
  38 typedef struct VirtIOPCIProxy VirtIOPCIProxy;
  39 typedef struct VirtIOBlkPCI VirtIOBlkPCI;
  40 typedef struct VirtIOSCSIPCI VirtIOSCSIPCI;
  41 typedef struct VirtIOSerialPCI VirtIOSerialPCI;
  42 typedef struct VirtIONetPCI VirtIONetPCI;
  43 typedef struct VHostSCSIPCI VHostSCSIPCI;
  44 typedef struct VHostUserSCSIPCI VHostUserSCSIPCI;
  45 typedef struct VHostUserBlkPCI VHostUserBlkPCI;
  46 typedef struct VirtIOGPUPCI VirtIOGPUPCI;
  47 typedef struct VirtIOCryptoPCI VirtIOCryptoPCI;
  48
  49 /* virtio-pci-bus */
  50
  51 typedef struct VirtioBusState VirtioPCIBusState;
  52 typedef struct VirtioBusClass VirtioPCIBusClass;
  53
  54 #define TYPE_VIRTIO_PCI_BUS "virtio-pci-bus"
  55 #define VIRTIO_PCI_BUS(obj) \
  56         OBJECT_CHECK(VirtioPCIBusState, (obj), TYPE_VIRTIO_PCI_BUS)
  57 #define VIRTIO_PCI_BUS_GET_CLASS(obj) \
  58         OBJECT_GET_CLASS(VirtioPCIBusClass, obj, TYPE_VIRTIO_PCI_BUS)
  59 #define VIRTIO_PCI_BUS_CLASS(klass) \
  60         OBJECT_CLASS_CHECK(VirtioPCIBusClass, klass, TYPE_VIRTIO_PCI_BUS)
  61
  62 enum {
  63     VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT,
  64     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT,
  65     VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT,
  66     VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT,
  67     VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT,
  68     VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT,
  69     VIRTIO_PCI_FLAG_ATS_BIT,
  70     VIRTIO_PCI_FLAG_INIT_DEVERR_BIT,
  71     VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT,
  72     VIRTIO_PCI_FLAG_INIT_PM_BIT,
  73 };
  74
  75 /* Need to activate work-arounds for buggy guests at vmstate load. */
  76 #define VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION \
  77     (1 << VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT)
  78
  79 /* Performance improves when virtqueue kick processing is decoupled from the
  80  * vcpu thread using ioeventfd for some devices. */
  81 #define VIRTIO_PCI_FLAG_USE_IOEVENTFD   (1 << VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT)
  82
  83 /* virtio version flags */
  84 #define VIRTIO_PCI_FLAG_DISABLE_PCIE (1 << VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT)
  85
  86 /* migrate extra state */
  87 #define VIRTIO_PCI_FLAG_MIGRATE_EXTRA (1 << VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT)
  88
  89 /* have pio notification for modern device ? */
  90 #define VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY \
  91     (1 << VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT)
  92
  93 /* page per vq flag to be used by split drivers within guests */
  94 #define VIRTIO_PCI_FLAG_PAGE_PER_VQ \
  95     (1 << VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT)
  96
  97 /* address space translation service */
  98 #define VIRTIO_PCI_FLAG_ATS (1 << VIRTIO_PCI_FLAG_ATS_BIT)
  99
 100 /* Init error enabling flags */
 101 #define VIRTIO_PCI_FLAG_INIT_DEVERR (1 << VIRTIO_PCI_FLAG_INIT_DEVERR_BIT)
 102
 103 /* Init Link Control register */
 104 #define VIRTIO_PCI_FLAG_INIT_LNKCTL (1 << VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT)
 105
 106 /* Init Power Management */
 107 #define VIRTIO_PCI_FLAG_INIT_PM (1 << VIRTIO_PCI_FLAG_INIT_PM_BIT)
 108
 109 typedef struct {
 110     MSIMessage msg;
 111     int virq;
 112     unsigned int users;
 113 } VirtIOIRQFD;
 114
 115 /*
 116  * virtio-pci: This is the PCIDevice which has a virtio-pci-bus.
 117  */
 118 #define TYPE_VIRTIO_PCI "virtio-pci"
 119 #define VIRTIO_PCI_GET_CLASS(obj) \
 120         OBJECT_GET_CLASS(VirtioPCIClass, obj, TYPE_VIRTIO_PCI)
 121 #define VIRTIO_PCI_CLASS(klass) \
 122         OBJECT_CLASS_CHECK(VirtioPCIClass, klass, TYPE_VIRTIO_PCI)
 123 #define VIRTIO_PCI(obj) \
 124         OBJECT_CHECK(VirtIOPCIProxy, (obj), TYPE_VIRTIO_PCI)
 125
 126 typedef struct VirtioPCIClass {
 127     PCIDeviceClass parent_class;
 128     DeviceRealize parent_dc_realize;
 129     void (*realize)(VirtIOPCIProxy *vpci_dev, Error **errp);
 130 } VirtioPCIClass;
 131
 132 typedef struct VirtIOPCIRegion {
 133     MemoryRegion mr;
 134     uint32_t offset;
 135     uint32_t size;
 136     uint32_t type;
 137 } VirtIOPCIRegion;
 138
 139 typedef struct VirtIOPCIQueue {
 140   uint16_t num;
 141   bool enabled;
 142   uint32_t desc[2];
 143   uint32_t avail[2];
 144   uint32_t used[2];
 145 } VirtIOPCIQueue;
 146
 147 struct VirtIOPCIProxy {
 148     PCIDevice pci_dev;
 149     MemoryRegion bar;
 150     union {
 151         struct {
 152             VirtIOPCIRegion common;
 153             VirtIOPCIRegion isr;
 154             VirtIOPCIRegion device;
 155             VirtIOPCIRegion notify;
 156             VirtIOPCIRegion notify_pio;
 157         };
 158         VirtIOPCIRegion regs[5];
 159     };
 160     MemoryRegion modern_bar;
 161     MemoryRegion io_bar;
 162     uint32_t legacy_io_bar_idx;
 163     uint32_t msix_bar_idx;
 164     uint32_t modern_io_bar_idx;
 165     uint32_t modern_mem_bar_idx;
 166     int config_cap;
 167     uint32_t flags;
 168     bool disable_modern;
 169     bool ignore_backend_features;
 170     OnOffAuto disable_legacy;
 171     uint32_t class_code;
 172     uint32_t nvectors;
 173     uint32_t dfselect;
 174     uint32_t gfselect;
 175     uint32_t guest_features[2];
 176     VirtIOPCIQueue vqs[VIRTIO_QUEUE_MAX];
 177
 178     VirtIOIRQFD *vector_irqfd;
 179     int nvqs_with_notifiers;
 180     VirtioBusState bus;
 181 };
 182
 183 static inline bool virtio_pci_modern(VirtIOPCIProxy *proxy)
 184 {
 185     return !proxy->disable_modern;
 186 }
 187
 188 static inline bool virtio_pci_legacy(VirtIOPCIProxy *proxy)
 189 {
 190     return proxy->disable_legacy == ON_OFF_AUTO_OFF;
 191 }
 192
 193 static inline void virtio_pci_force_virtio_1(VirtIOPCIProxy *proxy)
 194 {
 195     proxy->disable_modern = false;
 196     proxy->disable_legacy = ON_OFF_AUTO_ON;
 197 }
 198
 199 static inline void virtio_pci_disable_modern(VirtIOPCIProxy *proxy)
 200 {
 201     proxy->disable_modern = true;
 202 }
 203
 204 /*
 205  * virtio-scsi-pci: This extends VirtioPCIProxy.
 206  */
 207 #define TYPE_VIRTIO_SCSI_PCI "virtio-scsi-pci-base"
 208 #define VIRTIO_SCSI_PCI(obj) \
 209         OBJECT_CHECK(VirtIOSCSIPCI, (obj), TYPE_VIRTIO_SCSI_PCI)
 210
 211 struct VirtIOSCSIPCI {
 212     VirtIOPCIProxy parent_obj;
 213     VirtIOSCSI vdev;
 214 };
 215
 216 #ifdef CONFIG_VHOST_SCSI
 217 /*
 218  * vhost-scsi-pci: This extends VirtioPCIProxy.
 219  */
 220 #define TYPE_VHOST_SCSI_PCI "vhost-scsi-pci-base"
 221 #define VHOST_SCSI_PCI(obj) \
 222         OBJECT_CHECK(VHostSCSIPCI, (obj), TYPE_VHOST_SCSI_PCI)
 223
 224 struct VHostSCSIPCI {
 225     VirtIOPCIProxy parent_obj;
 226     VHostSCSI vdev;
 227 };
 228 #endif
 229
 230 #define TYPE_VHOST_USER_SCSI_PCI "vhost-user-scsi-pci-base"
 231 #define VHOST_USER_SCSI_PCI(obj) \
 232         OBJECT_CHECK(VHostUserSCSIPCI, (obj), TYPE_VHOST_USER_SCSI_PCI)
 233
 234 struct VHostUserSCSIPCI {
 235     VirtIOPCIProxy parent_obj;
 236     VHostUserSCSI vdev;
 237 };
 238
 239 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
 240 /*
 241  * vhost-user-blk-pci: This extends VirtioPCIProxy.
 242  */
 243 #define TYPE_VHOST_USER_BLK_PCI "vhost-user-blk-pci-base"
 244 #define VHOST_USER_BLK_PCI(obj) \
 245         OBJECT_CHECK(VHostUserBlkPCI, (obj), TYPE_VHOST_USER_BLK_PCI)
 246
 247 struct VHostUserBlkPCI {
 248     VirtIOPCIProxy parent_obj;
 249     VHostUserBlk vdev;
 250 };
 251 #endif
 252
 253 /*
 254  * virtio-blk-pci: This extends VirtioPCIProxy.
 255  */
 256 #define TYPE_VIRTIO_BLK_PCI "virtio-blk-pci-base"
 257 #define VIRTIO_BLK_PCI(obj) \
 258         OBJECT_CHECK(VirtIOBlkPCI, (obj), TYPE_VIRTIO_BLK_PCI)
 259
 260 struct VirtIOBlkPCI {
 261     VirtIOPCIProxy parent_obj;
 262     VirtIOBlock vdev;
 263 };
 264
 265 /*
 266  * virtio-serial-pci: This extends VirtioPCIProxy.
 267  */
 268 #define TYPE_VIRTIO_SERIAL_PCI "virtio-serial-pci-base"
 269 #define VIRTIO_SERIAL_PCI(obj) \
 270         OBJECT_CHECK(VirtIOSerialPCI, (obj), TYPE_VIRTIO_SERIAL_PCI)
 271
 272 struct VirtIOSerialPCI {
 273     VirtIOPCIProxy parent_obj;
 274     VirtIOSerial vdev;
 275 };
 276
 277 /*
 278  * virtio-net-pci: This extends VirtioPCIProxy.
 279  */
 280 #define TYPE_VIRTIO_NET_PCI "virtio-net-pci-base"
 281 #define VIRTIO_NET_PCI(obj) \
 282         OBJECT_CHECK(VirtIONetPCI, (obj), TYPE_VIRTIO_NET_PCI)
 283
 284 struct VirtIONetPCI {
 285     VirtIOPCIProxy parent_obj;
 286     VirtIONet vdev;
 287 };
 288
 289 /*
 290  * virtio-9p-pci: This extends VirtioPCIProxy.
 291  */
 292
 293 #ifdef CONFIG_VIRTFS
 294
 295 #define TYPE_VIRTIO_9P_PCI "virtio-9p-pci-base"
 296 #define VIRTIO_9P_PCI(obj) \
 297         OBJECT_CHECK(V9fsPCIState, (obj), TYPE_VIRTIO_9P_PCI)
 298
 299 typedef struct V9fsPCIState {
 300     VirtIOPCIProxy parent_obj;
 301     V9fsVirtioState vdev;
 302 } V9fsPCIState;
 303
 304 #endif
 305
 306 /*
 307  * virtio-input-pci: This extends VirtioPCIProxy.
 308  */
 309 #define TYPE_VIRTIO_INPUT_PCI "virtio-input-pci"
 310
 311 /*
 312  * virtio-gpu-pci: This extends VirtioPCIProxy.
 313  */
 314 #define TYPE_VIRTIO_GPU_PCI "virtio-gpu-pci"
 315 #define VIRTIO_GPU_PCI(obj) \
 316         OBJECT_CHECK(VirtIOGPUPCI, (obj), TYPE_VIRTIO_GPU_PCI)
 317
 318 struct VirtIOGPUPCI {
 319     VirtIOPCIProxy parent_obj;
 320     VirtIOGPU vdev;
 321 };
 322
 323 /*
 324  * virtio-crypto-pci: This extends VirtioPCIProxy.
 325  */
 326 #define TYPE_VIRTIO_CRYPTO_PCI "virtio-crypto-pci"
 327 #define VIRTIO_CRYPTO_PCI(obj) \
 328         OBJECT_CHECK(VirtIOCryptoPCI, (obj), TYPE_VIRTIO_CRYPTO_PCI)
 329
 330 struct VirtIOCryptoPCI {
 331     VirtIOPCIProxy parent_obj;
 332     VirtIOCrypto vdev;
 333 };
 334
 335 /* Virtio ABI version, if we increment this, we break the guest driver. */
 336 #define VIRTIO_PCI_ABI_VERSION          0
 337
 338 /* Input for virtio_pci_types_register() */
 339 typedef struct VirtioPCIDeviceTypeInfo {
 340     /*
 341      * Common base class for the subclasses below.
 342      *
 343      * Required only if transitional_name or non_transitional_name is set.
 344      *
 345      * We need a separate base type instead of making all types
 346      * inherit from generic_name for two reasons:
 347      * 1) generic_name implements INTERFACE_PCIE_DEVICE, but
 348      *    transitional_name does not.
 349      * 2) generic_name has the "disable-legacy" and "disable-modern"
 350      *    properties, transitional_name and non_transitional name don't.
 351      */
 352     const char *base_name;
 353     /*
 354      * Generic device type.  Optional.
 355      *
 356      * Supports both transitional and non-transitional modes,
 357      * using the disable-legacy and disable-modern properties.
 358      * If disable-legacy=auto, (non-)transitional mode is selected
 359      * depending on the bus where the device is plugged.
 360      *
 361      * Implements both INTERFACE_PCIE_DEVICE and INTERFACE_CONVENTIONAL_PCI_DEVICE,
 362      * but PCI Express is supported only in non-transitional mode.
 363      *
 364      * The only type implemented by QEMU 3.1 and older.
 365      */
 366     const char *generic_name;
 367     /*
 368      * The transitional device type.  Optional.
 369      *
 370      * Implements both INTERFACE_PCIE_DEVICE and INTERFACE_CONVENTIONAL_PCI_DEVICE.
 371      */
 372     const char *transitional_name;
 373     /*
 374      * The non-transitional device type.  Optional.
 375      *
 376      * Implements INTERFACE_CONVENTIONAL_PCI_DEVICE only.
 377      */
 378     const char *non_transitional_name;
 379
 380     /* Parent type.  If NULL, TYPE_VIRTIO_PCI is used */
 381     const char *parent;
 382
 383     /* Same as TypeInfo fields: */
 384     size_t instance_size;
 385     void (*instance_init)(Object *obj);
 386     void (*class_init)(ObjectClass *klass, void *data);
 387 } VirtioPCIDeviceTypeInfo;
 388
 389 /* Register virtio-pci type(s).  @t must be static. */
 390 void virtio_pci_types_register(const VirtioPCIDeviceTypeInfo *t);
 391
 392 #endif