include/uapi/linux/vfio.h

   1 /*
   2  * VFIO API definition
   3  *
   4  * Copyright (C) 2012 Red Hat, Inc.  All rights reserved.
   5  *     Author: Alex Williamson <alex.williamson@redhat.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #ifndef _UAPIVFIO_H
  12 #define _UAPIVFIO_H
  13
  14 #include <linux/types.h>
  15 #include <linux/ioctl.h>
  16
  17 #define VFIO_API_VERSION        0
  18
  19
  20 /* Kernel & User level defines for VFIO IOCTLs. */
  21
  22 /* Extensions */
  23
  24 #define VFIO_TYPE1_IOMMU                1
  25 #define VFIO_SPAPR_TCE_IOMMU            2
  26 #define VFIO_TYPE1v2_IOMMU              3
  27 /*
  28  * IOMMU enforces DMA cache coherence (ex. PCIe NoSnoop stripping).  This
  29  * capability is subject to change as groups are added or removed.
  30  */
  31 #define VFIO_DMA_CC_IOMMU               4
  32
  33 /* Check if EEH is supported */
  34 #define VFIO_EEH                        5
  35
  36 /*
  37  * The IOCTL interface is designed for extensibility by embedding the
  38  * structure length (argsz) and flags into structures passed between
  39  * kernel and userspace.  We therefore use the _IO() macro for these
  40  * defines to avoid implicitly embedding a size into the ioctl request.
  41  * As structure fields are added, argsz will increase to match and flag
  42  * bits will be defined to indicate additional fields with valid data.
  43  * It's *always* the caller's responsibility to indicate the size of
  44  * the structure passed by setting argsz appropriately.
  45  */
  46
  47 #define VFIO_TYPE       (';')
  48 #define VFIO_BASE       100
  49
  50 /* -------- IOCTLs for VFIO file descriptor (/dev/vfio/vfio) -------- */
  51
  52 /**
  53  * VFIO_GET_API_VERSION - _IO(VFIO_TYPE, VFIO_BASE + 0)
  54  *
  55  * Report the version of the VFIO API.  This allows us to bump the entire
  56  * API version should we later need to add or change features in incompatible
  57  * ways.
  58  * Return: VFIO_API_VERSION
  59  * Availability: Always
  60  */
  61 #define VFIO_GET_API_VERSION            _IO(VFIO_TYPE, VFIO_BASE + 0)
  62
  63 /**
  64  * VFIO_CHECK_EXTENSION - _IOW(VFIO_TYPE, VFIO_BASE + 1, __u32)
  65  *
  66  * Check whether an extension is supported.
  67  * Return: 0 if not supported, 1 (or some other positive integer) if supported.
  68  * Availability: Always
  69  */
  70 #define VFIO_CHECK_EXTENSION            _IO(VFIO_TYPE, VFIO_BASE + 1)
  71
  72 /**
  73  * VFIO_SET_IOMMU - _IOW(VFIO_TYPE, VFIO_BASE + 2, __s32)
  74  *
  75  * Set the iommu to the given type.  The type must be supported by an
  76  * iommu driver as verified by calling CHECK_EXTENSION using the same
  77  * type.  A group must be set to this file descriptor before this
  78  * ioctl is available.  The IOMMU interfaces enabled by this call are
  79  * specific to the value set.
  80  * Return: 0 on success, -errno on failure
  81  * Availability: When VFIO group attached
  82  */
  83 #define VFIO_SET_IOMMU                  _IO(VFIO_TYPE, VFIO_BASE + 2)
  84
  85 /* -------- IOCTLs for GROUP file descriptors (/dev/vfio/$GROUP) -------- */
  86
  87 /**
  88  * VFIO_GROUP_GET_STATUS - _IOR(VFIO_TYPE, VFIO_BASE + 3,
  89  *                                              struct vfio_group_status)
  90  *
  91  * Retrieve information about the group.  Fills in provided
  92  * struct vfio_group_info.  Caller sets argsz.
  93  * Return: 0 on succes, -errno on failure.
  94  * Availability: Always
  95  */
  96 struct vfio_group_status {
  97         __u32   argsz;
  98         __u32   flags;
  99 #define VFIO_GROUP_FLAGS_VIABLE         (1 << 0)
 100 #define VFIO_GROUP_FLAGS_CONTAINER_SET  (1 << 1)
 101 };
 102 #define VFIO_GROUP_GET_STATUS           _IO(VFIO_TYPE, VFIO_BASE + 3)
 103
 104 /**
 105  * VFIO_GROUP_SET_CONTAINER - _IOW(VFIO_TYPE, VFIO_BASE + 4, __s32)
 106  *
 107  * Set the container for the VFIO group to the open VFIO file
 108  * descriptor provided.  Groups may only belong to a single
 109  * container.  Containers may, at their discretion, support multiple
 110  * groups.  Only when a container is set are all of the interfaces
 111  * of the VFIO file descriptor and the VFIO group file descriptor
 112  * available to the user.
 113  * Return: 0 on success, -errno on failure.
 114  * Availability: Always
 115  */
 116 #define VFIO_GROUP_SET_CONTAINER        _IO(VFIO_TYPE, VFIO_BASE + 4)
 117
 118 /**
 119  * VFIO_GROUP_UNSET_CONTAINER - _IO(VFIO_TYPE, VFIO_BASE + 5)
 120  *
 121  * Remove the group from the attached container.  This is the
 122  * opposite of the SET_CONTAINER call and returns the group to
 123  * an initial state.  All device file descriptors must be released
 124  * prior to calling this interface.  When removing the last group
 125  * from a container, the IOMMU will be disabled and all state lost,
 126  * effectively also returning the VFIO file descriptor to an initial
 127  * state.
 128  * Return: 0 on success, -errno on failure.
 129  * Availability: When attached to container
 130  */
 131 #define VFIO_GROUP_UNSET_CONTAINER      _IO(VFIO_TYPE, VFIO_BASE + 5)
 132
 133 /**
 134  * VFIO_GROUP_GET_DEVICE_FD - _IOW(VFIO_TYPE, VFIO_BASE + 6, char)
 135  *
 136  * Return a new file descriptor for the device object described by
 137  * the provided string.  The string should match a device listed in
 138  * the devices subdirectory of the IOMMU group sysfs entry.  The
 139  * group containing the device must already be added to this context.
 140  * Return: new file descriptor on success, -errno on failure.
 141  * Availability: When attached to container
 142  */
 143 #define VFIO_GROUP_GET_DEVICE_FD        _IO(VFIO_TYPE, VFIO_BASE + 6)
 144
 145 /* --------------- IOCTLs for DEVICE file descriptors --------------- */
 146
 147 /**
 148  * VFIO_DEVICE_GET_INFO - _IOR(VFIO_TYPE, VFIO_BASE + 7,
 149  *                                              struct vfio_device_info)
 150  *
 151  * Retrieve information about the device.  Fills in provided
 152  * struct vfio_device_info.  Caller sets argsz.
 153  * Return: 0 on success, -errno on failure.
 154  */
 155 struct vfio_device_info {
 156         __u32   argsz;
 157         __u32   flags;
 158 #define VFIO_DEVICE_FLAGS_RESET (1 << 0)        /* Device supports reset */
 159 #define VFIO_DEVICE_FLAGS_PCI   (1 << 1)        /* vfio-pci device */
 160         __u32   num_regions;    /* Max region index + 1 */
 161         __u32   num_irqs;       /* Max IRQ index + 1 */
 162 };
 163 #define VFIO_DEVICE_GET_INFO            _IO(VFIO_TYPE, VFIO_BASE + 7)
 164
 165 /**
 166  * VFIO_DEVICE_GET_REGION_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 8,
 167  *                                     struct vfio_region_info)
 168  *
 169  * Retrieve information about a device region.  Caller provides
 170  * struct vfio_region_info with index value set.  Caller sets argsz.
 171  * Implementation of region mapping is bus driver specific.  This is
 172  * intended to describe MMIO, I/O port, as well as bus specific
 173  * regions (ex. PCI config space).  Zero sized regions may be used
 174  * to describe unimplemented regions (ex. unimplemented PCI BARs).
 175  * Return: 0 on success, -errno on failure.
 176  */
 177 struct vfio_region_info {
 178         __u32   argsz;
 179         __u32   flags;
 180 #define VFIO_REGION_INFO_FLAG_READ      (1 << 0) /* Region supports read */
 181 #define VFIO_REGION_INFO_FLAG_WRITE     (1 << 1) /* Region supports write */
 182 #define VFIO_REGION_INFO_FLAG_MMAP      (1 << 2) /* Region supports mmap */
 183         __u32   index;          /* Region index */
 184         __u32   resv;           /* Reserved for alignment */
 185         __u64   size;           /* Region size (bytes) */
 186         __u64   offset;         /* Region offset from start of device fd */
 187 };
 188 #define VFIO_DEVICE_GET_REGION_INFO     _IO(VFIO_TYPE, VFIO_BASE + 8)
 189
 190 /**
 191  * VFIO_DEVICE_GET_IRQ_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 9,
 192  *                                  struct vfio_irq_info)
 193  *
 194  * Retrieve information about a device IRQ.  Caller provides
 195  * struct vfio_irq_info with index value set.  Caller sets argsz.
 196  * Implementation of IRQ mapping is bus driver specific.  Indexes
 197  * using multiple IRQs are primarily intended to support MSI-like
 198  * interrupt blocks.  Zero count irq blocks may be used to describe
 199  * unimplemented interrupt types.
 200  *
 201  * The EVENTFD flag indicates the interrupt index supports eventfd based
 202  * signaling.
 203  *
 204  * The MASKABLE flags indicates the index supports MASK and UNMASK
 205  * actions described below.
 206  *
 207  * AUTOMASKED indicates that after signaling, the interrupt line is
 208  * automatically masked by VFIO and the user needs to unmask the line
 209  * to receive new interrupts.  This is primarily intended to distinguish
 210  * level triggered interrupts.
 211  *
 212  * The NORESIZE flag indicates that the interrupt lines within the index
 213  * are setup as a set and new subindexes cannot be enabled without first
 214  * disabling the entire index.  This is used for interrupts like PCI MSI
 215  * and MSI-X where the driver may only use a subset of the available
 216  * indexes, but VFIO needs to enable a specific number of vectors
 217  * upfront.  In the case of MSI-X, where the user can enable MSI-X and
 218  * then add and unmask vectors, it's up to userspace to make the decision
 219  * whether to allocate the maximum supported number of vectors or tear
 220  * down setup and incrementally increase the vectors as each is enabled.
 221  */
 222 struct vfio_irq_info {
 223         __u32   argsz;
 224         __u32   flags;
 225 #define VFIO_IRQ_INFO_EVENTFD           (1 << 0)
 226 #define VFIO_IRQ_INFO_MASKABLE          (1 << 1)
 227 #define VFIO_IRQ_INFO_AUTOMASKED        (1 << 2)
 228 #define VFIO_IRQ_INFO_NORESIZE          (1 << 3)
 229         __u32   index;          /* IRQ index */
 230         __u32   count;          /* Number of IRQs within this index */
 231 };
 232 #define VFIO_DEVICE_GET_IRQ_INFO        _IO(VFIO_TYPE, VFIO_BASE + 9)
 233
 234 /**
 235  * VFIO_DEVICE_SET_IRQS - _IOW(VFIO_TYPE, VFIO_BASE + 10, struct vfio_irq_set)
 236  *
 237  * Set signaling, masking, and unmasking of interrupts.  Caller provides
 238  * struct vfio_irq_set with all fields set.  'start' and 'count' indicate
 239  * the range of subindexes being specified.
 240  *
 241  * The DATA flags specify the type of data provided.  If DATA_NONE, the
 242  * operation performs the specified action immediately on the specified
 243  * interrupt(s).  For example, to unmask AUTOMASKED interrupt [0,0]:
 244  * flags = (DATA_NONE|ACTION_UNMASK), index = 0, start = 0, count = 1.
 245  *
 246  * DATA_BOOL allows sparse support for the same on arrays of interrupts.
 247  * For example, to mask interrupts [0,1] and [0,3] (but not [0,2]):
 248  * flags = (DATA_BOOL|ACTION_MASK), index = 0, start = 1, count = 3,
 249  * data = {1,0,1}
 250  *
 251  * DATA_EVENTFD binds the specified ACTION to the provided __s32 eventfd.
 252  * A value of -1 can be used to either de-assign interrupts if already
 253  * assigned or skip un-assigned interrupts.  For example, to set an eventfd
 254  * to be trigger for interrupts [0,0] and [0,2]:
 255  * flags = (DATA_EVENTFD|ACTION_TRIGGER), index = 0, start = 0, count = 3,
 256  * data = {fd1, -1, fd2}
 257  * If index [0,1] is previously set, two count = 1 ioctls calls would be
 258  * required to set [0,0] and [0,2] without changing [0,1].
 259  *
 260  * Once a signaling mechanism is set, DATA_BOOL or DATA_NONE can be used
 261  * with ACTION_TRIGGER to perform kernel level interrupt loopback testing
 262  * from userspace (ie. simulate hardware triggering).
 263  *
 264  * Setting of an event triggering mechanism to userspace for ACTION_TRIGGER
 265  * enables the interrupt index for the device.  Individual subindex interrupts
 266  * can be disabled using the -1 value for DATA_EVENTFD or the index can be
 267  * disabled as a whole with: flags = (DATA_NONE|ACTION_TRIGGER), count = 0.
 268  *
 269  * Note that ACTION_[UN]MASK specify user->kernel signaling (irqfds) while
 270  * ACTION_TRIGGER specifies kernel->user signaling.
 271  */
 272 struct vfio_irq_set {
 273         __u32   argsz;
 274         __u32   flags;
 275 #define VFIO_IRQ_SET_DATA_NONE          (1 << 0) /* Data not present */
 276 #define VFIO_IRQ_SET_DATA_BOOL          (1 << 1) /* Data is bool (u8) */
 277 #define VFIO_IRQ_SET_DATA_EVENTFD       (1 << 2) /* Data is eventfd (s32) */
 278 #define VFIO_IRQ_SET_ACTION_MASK        (1 << 3) /* Mask interrupt */
 279 #define VFIO_IRQ_SET_ACTION_UNMASK      (1 << 4) /* Unmask interrupt */
 280 #define VFIO_IRQ_SET_ACTION_TRIGGER     (1 << 5) /* Trigger interrupt */
 281         __u32   index;
 282         __u32   start;
 283         __u32   count;
 284         __u8    data[];
 285 };
 286 #define VFIO_DEVICE_SET_IRQS            _IO(VFIO_TYPE, VFIO_BASE + 10)
 287
 288 #define VFIO_IRQ_SET_DATA_TYPE_MASK     (VFIO_IRQ_SET_DATA_NONE | \
 289                                          VFIO_IRQ_SET_DATA_BOOL | \
 290                                          VFIO_IRQ_SET_DATA_EVENTFD)
 291 #define VFIO_IRQ_SET_ACTION_TYPE_MASK   (VFIO_IRQ_SET_ACTION_MASK | \
 292                                          VFIO_IRQ_SET_ACTION_UNMASK | \
 293                                          VFIO_IRQ_SET_ACTION_TRIGGER)
 294 /**
 295  * VFIO_DEVICE_RESET - _IO(VFIO_TYPE, VFIO_BASE + 11)
 296  *
 297  * Reset a device.
 298  */
 299 #define VFIO_DEVICE_RESET               _IO(VFIO_TYPE, VFIO_BASE + 11)
 300
 301 /*
 302  * The VFIO-PCI bus driver makes use of the following fixed region and
 303  * IRQ index mapping.  Unimplemented regions return a size of zero.
 304  * Unimplemented IRQ types return a count of zero.
 305  */
 306
 307 enum {
 308         VFIO_PCI_BAR0_REGION_INDEX,
 309         VFIO_PCI_BAR1_REGION_INDEX,
 310         VFIO_PCI_BAR2_REGION_INDEX,
 311         VFIO_PCI_BAR3_REGION_INDEX,
 312         VFIO_PCI_BAR4_REGION_INDEX,
 313         VFIO_PCI_BAR5_REGION_INDEX,
 314         VFIO_PCI_ROM_REGION_INDEX,
 315         VFIO_PCI_CONFIG_REGION_INDEX,
 316         /*
 317          * Expose VGA regions defined for PCI base class 03, subclass 00.
 318          * This includes I/O port ranges 0x3b0 to 0x3bb and 0x3c0 to 0x3df
 319          * as well as the MMIO range 0xa0000 to 0xbffff.  Each implemented
 320          * range is found at it's identity mapped offset from the region
 321          * offset, for example 0x3b0 is region_info.offset + 0x3b0.  Areas
 322          * between described ranges are unimplemented.
 323          */
 324         VFIO_PCI_VGA_REGION_INDEX,
 325         VFIO_PCI_NUM_REGIONS
 326 };
 327
 328 enum {
 329         VFIO_PCI_INTX_IRQ_INDEX,
 330         VFIO_PCI_MSI_IRQ_INDEX,
 331         VFIO_PCI_MSIX_IRQ_INDEX,
 332         VFIO_PCI_ERR_IRQ_INDEX,
 333         VFIO_PCI_NUM_IRQS
 334 };
 335
 336 /**
 337  * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IORW(VFIO_TYPE, VFIO_BASE + 12,
 338  *                                            struct vfio_pci_hot_reset_info)
 339  *
 340  * Return: 0 on success, -errno on failure:
 341  *      -enospc = insufficient buffer, -enodev = unsupported for device.
 342  */
 343 struct vfio_pci_dependent_device {
 344         __u32   group_id;
 345         __u16   segment;
 346         __u8    bus;
 347         __u8    devfn; /* Use PCI_SLOT/PCI_FUNC */
 348 };
 349
 350 struct vfio_pci_hot_reset_info {
 351         __u32   argsz;
 352         __u32   flags;
 353         __u32   count;
 354         struct vfio_pci_dependent_device        devices[];
 355 };
 356
 357 #define VFIO_DEVICE_GET_PCI_HOT_RESET_INFO      _IO(VFIO_TYPE, VFIO_BASE + 12)
 358
 359 /**
 360  * VFIO_DEVICE_PCI_HOT_RESET - _IOW(VFIO_TYPE, VFIO_BASE + 13,
 361  *                                  struct vfio_pci_hot_reset)
 362  *
 363  * Return: 0 on success, -errno on failure.
 364  */
 365 struct vfio_pci_hot_reset {
 366         __u32   argsz;
 367         __u32   flags;
 368         __u32   count;
 369         __s32   group_fds[];
 370 };
 371
 372 #define VFIO_DEVICE_PCI_HOT_RESET       _IO(VFIO_TYPE, VFIO_BASE + 13)
 373
 374 /* -------- API for Type1 VFIO IOMMU -------- */
 375
 376 /**
 377  * VFIO_IOMMU_GET_INFO - _IOR(VFIO_TYPE, VFIO_BASE + 12, struct vfio_iommu_info)
 378  *
 379  * Retrieve information about the IOMMU object. Fills in provided
 380  * struct vfio_iommu_info. Caller sets argsz.
 381  *
 382  * XXX Should we do these by CHECK_EXTENSION too?
 383  */
 384 struct vfio_iommu_type1_info {
 385         __u32   argsz;
 386         __u32   flags;
 387 #define VFIO_IOMMU_INFO_PGSIZES (1 << 0)        /* supported page sizes info */
 388         __u64   iova_pgsizes;           /* Bitmap of supported page sizes */
 389 };
 390
 391 #define VFIO_IOMMU_GET_INFO _IO(VFIO_TYPE, VFIO_BASE + 12)
 392
 393 /**
 394  * VFIO_IOMMU_MAP_DMA - _IOW(VFIO_TYPE, VFIO_BASE + 13, struct vfio_dma_map)
 395  *
 396  * Map process virtual addresses to IO virtual addresses using the
 397  * provided struct vfio_dma_map. Caller sets argsz. READ &/ WRITE required.
 398  */
 399 struct vfio_iommu_type1_dma_map {
 400         __u32   argsz;
 401         __u32   flags;
 402 #define VFIO_DMA_MAP_FLAG_READ (1 << 0)         /* readable from device */
 403 #define VFIO_DMA_MAP_FLAG_WRITE (1 << 1)        /* writable from device */
 404         __u64   vaddr;                          /* Process virtual address */
 405         __u64   iova;                           /* IO virtual address */
 406         __u64   size;                           /* Size of mapping (bytes) */
 407 };
 408
 409 #define VFIO_IOMMU_MAP_DMA _IO(VFIO_TYPE, VFIO_BASE + 13)
 410
 411 /**
 412  * VFIO_IOMMU_UNMAP_DMA - _IOWR(VFIO_TYPE, VFIO_BASE + 14,
 413  *                                                      struct vfio_dma_unmap)
 414  *
 415  * Unmap IO virtual addresses using the provided struct vfio_dma_unmap.
 416  * Caller sets argsz.  The actual unmapped size is returned in the size
 417  * field.  No guarantee is made to the user that arbitrary unmaps of iova
 418  * or size different from those used in the original mapping call will
 419  * succeed.
 420  */
 421 struct vfio_iommu_type1_dma_unmap {
 422         __u32   argsz;
 423         __u32   flags;
 424         __u64   iova;                           /* IO virtual address */
 425         __u64   size;                           /* Size of mapping (bytes) */
 426 };
 427
 428 #define VFIO_IOMMU_UNMAP_DMA _IO(VFIO_TYPE, VFIO_BASE + 14)
 429
 430 /*
 431  * IOCTLs to enable/disable IOMMU container usage.
 432  * No parameters are supported.
 433  */
 434 #define VFIO_IOMMU_ENABLE       _IO(VFIO_TYPE, VFIO_BASE + 15)
 435 #define VFIO_IOMMU_DISABLE      _IO(VFIO_TYPE, VFIO_BASE + 16)
 436
 437 /* -------- Additional API for SPAPR TCE (Server POWERPC) IOMMU -------- */
 438
 439 /*
 440  * The SPAPR TCE info struct provides the information about the PCI bus
 441  * address ranges available for DMA, these values are programmed into
 442  * the hardware so the guest has to know that information.
 443  *
 444  * The DMA 32 bit window start is an absolute PCI bus address.
 445  * The IOVA address passed via map/unmap ioctls are absolute PCI bus
 446  * addresses too so the window works as a filter rather than an offset
 447  * for IOVA addresses.
 448  *
 449  * A flag will need to be added if other page sizes are supported,
 450  * so as defined here, it is always 4k.
 451  */
 452 struct vfio_iommu_spapr_tce_info {
 453         __u32 argsz;
 454         __u32 flags;                    /* reserved for future use */
 455         __u32 dma32_window_start;       /* 32 bit window start (bytes) */
 456         __u32 dma32_window_size;        /* 32 bit window size (bytes) */
 457 };
 458
 459 #define VFIO_IOMMU_SPAPR_TCE_GET_INFO   _IO(VFIO_TYPE, VFIO_BASE + 12)
 460
 461 /*
 462  * EEH PE operation struct provides ways to:
 463  * - enable/disable EEH functionality;
 464  * - unfreeze IO/DMA for frozen PE;
 465  * - read PE state;
 466  * - reset PE;
 467  * - configure PE.
 468  */
 469 struct vfio_eeh_pe_op {
 470         __u32 argsz;
 471         __u32 flags;
 472         __u32 op;
 473 };
 474
 475 #define VFIO_EEH_PE_DISABLE             0       /* Disable EEH functionality */
 476 #define VFIO_EEH_PE_ENABLE              1       /* Enable EEH functionality  */
 477 #define VFIO_EEH_PE_UNFREEZE_IO         2       /* Enable IO for frozen PE   */
 478 #define VFIO_EEH_PE_UNFREEZE_DMA        3       /* Enable DMA for frozen PE  */
 479 #define VFIO_EEH_PE_GET_STATE           4       /* PE state retrieval        */
 480 #define  VFIO_EEH_PE_STATE_NORMAL       0       /* PE in functional state    */
 481 #define  VFIO_EEH_PE_STATE_RESET        1       /* PE reset in progress      */
 482 #define  VFIO_EEH_PE_STATE_STOPPED      2       /* Stopped DMA and IO        */
 483 #define  VFIO_EEH_PE_STATE_STOPPED_DMA  4       /* Stopped DMA only          */
 484 #define  VFIO_EEH_PE_STATE_UNAVAIL      5       /* State unavailable         */
 485 #define VFIO_EEH_PE_RESET_DEACTIVATE    5       /* Deassert PE reset         */
 486 #define VFIO_EEH_PE_RESET_HOT           6       /* Assert hot reset          */
 487 #define VFIO_EEH_PE_RESET_FUNDAMENTAL   7       /* Assert fundamental reset  */
 488 #define VFIO_EEH_PE_CONFIGURE           8       /* PE configuration          */
 489
 490 #define VFIO_EEH_PE_OP                  _IO(VFIO_TYPE, VFIO_BASE + 21)
 491
 492 /* ***************************************************************** */
 493
 494 #endif /* _UAPIVFIO_H */