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-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"
  26 #include "hw/virtio/virtio-input.h"
  27 #include "hw/virtio/virtio-gpu.h"
  28 #include "hw/virtio/virtio-crypto.h"
  29 #include "hw/virtio/vhost-user-scsi.h"
  30 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
  31 #include "hw/virtio/vhost-user-blk.h"
  32 #endif
  33
  34 #ifdef CONFIG_VIRTFS
  35 #include "hw/9pfs/virtio-9p.h"
  36 #endif
  37 #ifdef CONFIG_VHOST_SCSI
  38 #include "hw/virtio/vhost-scsi.h"
  39 #endif
  40 #ifdef CONFIG_VHOST_VSOCK
  41 #include "hw/virtio/vhost-vsock.h"
  42 #endif
  43
  44 typedef struct VirtIOPCIProxy VirtIOPCIProxy;
  45 typedef struct VirtIOBlkPCI VirtIOBlkPCI;
  46 typedef struct VirtIOSCSIPCI VirtIOSCSIPCI;
  47 typedef struct VirtIOBalloonPCI VirtIOBalloonPCI;
  48 typedef struct VirtIOSerialPCI VirtIOSerialPCI;
  49 typedef struct VirtIONetPCI VirtIONetPCI;
  50 typedef struct VHostSCSIPCI VHostSCSIPCI;
  51 typedef struct VHostUserSCSIPCI VHostUserSCSIPCI;
  52 typedef struct VHostUserBlkPCI VHostUserBlkPCI;
  53 typedef struct VirtIORngPCI VirtIORngPCI;
  54 typedef struct VirtIOInputPCI VirtIOInputPCI;
  55 typedef struct VirtIOInputHIDPCI VirtIOInputHIDPCI;
  56 typedef struct VirtIOInputHostPCI VirtIOInputHostPCI;
  57 typedef struct VirtIOGPUPCI VirtIOGPUPCI;
  58 typedef struct VHostVSockPCI VHostVSockPCI;
  59 typedef struct VirtIOCryptoPCI VirtIOCryptoPCI;
  60
  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)
  73
  74 enum {
  75     VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT,
  76     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT,
  77     VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT,
  78     VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT,
  79     VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT,
  80     VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT,
  81     VIRTIO_PCI_FLAG_ATS_BIT,
  82     VIRTIO_PCI_FLAG_INIT_DEVERR_BIT,
  83     VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT,
  84     VIRTIO_PCI_FLAG_INIT_PM_BIT,
  85 };
  86
  87 /* Need to activate work-arounds for buggy guests at vmstate load. */
  88 #define VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION \
  89     (1 << VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT)
  90
  91 /* Performance improves when virtqueue kick processing is decoupled from the
  92  * vcpu thread using ioeventfd for some devices. */
  93 #define VIRTIO_PCI_FLAG_USE_IOEVENTFD   (1 << VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT)
  94
  95 /* virtio version flags */
  96 #define VIRTIO_PCI_FLAG_DISABLE_PCIE (1 << VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT)
  97
  98 /* migrate extra state */
  99 #define VIRTIO_PCI_FLAG_MIGRATE_EXTRA (1 << VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT)
 100
 101 /* have pio notification for modern device ? */
 102 #define VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY \
 103     (1 << VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT)
 104
 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
 109 /* address space translation service */
 110 #define VIRTIO_PCI_FLAG_ATS (1 << VIRTIO_PCI_FLAG_ATS_BIT)
 111
 112 /* Init error enabling flags */
 113 #define VIRTIO_PCI_FLAG_INIT_DEVERR (1 << VIRTIO_PCI_FLAG_INIT_DEVERR_BIT)
 114
 115 /* Init Link Control register */
 116 #define VIRTIO_PCI_FLAG_INIT_LNKCTL (1 << VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT)
 117
 118 /* Init Power Management */
 119 #define VIRTIO_PCI_FLAG_INIT_PM (1 << VIRTIO_PCI_FLAG_INIT_PM_BIT)
 120
 121 typedef struct {
 122     MSIMessage msg;
 123     int virq;
 124     unsigned int users;
 125 } VirtIOIRQFD;
 126
 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;
 140     DeviceRealize parent_dc_realize;
 141     void (*realize)(VirtIOPCIProxy *vpci_dev, Error **errp);
 142 } VirtioPCIClass;
 143
 144 typedef struct VirtIOPCIRegion {
 145     MemoryRegion mr;
 146     uint32_t offset;
 147     uint32_t size;
 148     uint32_t type;
 149 } VirtIOPCIRegion;
 150
 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
 159 struct VirtIOPCIProxy {
 160     PCIDevice pci_dev;
 161     MemoryRegion bar;
 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     };
 172     MemoryRegion modern_bar;
 173     MemoryRegion io_bar;
 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;
 178     int config_cap;
 179     uint32_t flags;
 180     bool disable_modern;
 181     bool ignore_backend_features;
 182     OnOffAuto disable_legacy;
 183     uint32_t class_code;
 184     uint32_t nvectors;
 185     uint32_t dfselect;
 186     uint32_t gfselect;
 187     uint32_t guest_features[2];
 188     VirtIOPCIQueue vqs[VIRTIO_QUEUE_MAX];
 189
 190     VirtIOIRQFD *vector_irqfd;
 191     int nvqs_with_notifiers;
 192     VirtioBusState bus;
 193 };
 194
 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 }
 210
 211 static inline void virtio_pci_disable_modern(VirtIOPCIProxy *proxy)
 212 {
 213     proxy->disable_modern = true;
 214 }
 215
 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
 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
 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
 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
 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;
 275 };
 276
 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
 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
 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
 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;
 325     V9fsVirtioState vdev;
 326 } V9fsPCIState;
 327
 328 #endif
 329
 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
 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
 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
 366 #ifdef CONFIG_LINUX
 367
 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
 377 #endif
 378
 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
 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
 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
 417 /* Virtio ABI version, if we increment this, we break the guest driver. */
 418 #define VIRTIO_PCI_ABI_VERSION          0
 419
 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
 474 #endif