virtio.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*-
    2  * This header is BSD licensed so anyone can use the definitions to implement
    3  * compatible drivers/servers.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. Neither the name of IBM nor the names of its contributors
   14  *    may be used to endorse or promote products derived from this software
   15  *    without specific prior written permission.
   16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  *
   28  * $FreeBSD: releng/8.4/sys/dev/virtio/virtio.h 247907 2013-03-07 06:53:25Z bryanv $
   29  */
   30 
   31 #ifndef _VIRTIO_H_
   32 #define _VIRTIO_H_
   33 
   34 struct vq_alloc_info;
   35 
   36 /* VirtIO device IDs. */
   37 #define VIRTIO_ID_NETWORK       0x01
   38 #define VIRTIO_ID_BLOCK         0x02
   39 #define VIRTIO_ID_CONSOLE       0x03
   40 #define VIRTIO_ID_ENTROPY       0x04
   41 #define VIRTIO_ID_BALLOON       0x05
   42 #define VIRTIO_ID_IOMEMORY      0x06
   43 #define VIRTIO_ID_SCSI          0x08
   44 #define VIRTIO_ID_9P            0x09
   45 
   46 /* Status byte for guest to report progress. */
   47 #define VIRTIO_CONFIG_STATUS_RESET      0x00
   48 #define VIRTIO_CONFIG_STATUS_ACK        0x01
   49 #define VIRTIO_CONFIG_STATUS_DRIVER     0x02
   50 #define VIRTIO_CONFIG_STATUS_DRIVER_OK  0x04
   51 #define VIRTIO_CONFIG_STATUS_FAILED     0x80
   52 
   53 /*
   54  * Generate interrupt when the virtqueue ring is
   55  * completely used, even if we've suppressed them.
   56  */
   57 #define VIRTIO_F_NOTIFY_ON_EMPTY (1 << 24)
   58 
   59 /*
   60  * The guest should never negotiate this feature; it
   61  * is used to detect faulty drivers.
   62  */
   63 #define VIRTIO_F_BAD_FEATURE (1 << 30)
   64 
   65 /*
   66  * Some VirtIO feature bits (currently bits 28 through 31) are
   67  * reserved for the transport being used (eg. virtio_ring), the
   68  * rest are per-device feature bits.
   69  */
   70 #define VIRTIO_TRANSPORT_F_START        28
   71 #define VIRTIO_TRANSPORT_F_END          32
   72 
   73 /*
   74  * Maximum number of virtqueues per device.
   75  */
   76 #define VIRTIO_MAX_VIRTQUEUES 8
   77 
   78 /*
   79  * Each virtqueue indirect descriptor list must be physically contiguous.
   80  * To allow us to malloc(9) each list individually, limit the number
   81  * supported to what will fit in one page. With 4KB pages, this is a limit
   82  * of 256 descriptors. If there is ever a need for more, we can switch to
   83  * contigmalloc(9) for the larger allocations, similar to what
   84  * bus_dmamem_alloc(9) does.
   85  *
   86  * Note the sizeof(struct vring_desc) is 16 bytes.
   87  */
   88 #define VIRTIO_MAX_INDIRECT ((int) (PAGE_SIZE / 16))
   89 
   90 /*
   91  * VirtIO instance variables indices.
   92  */
   93 #define VIRTIO_IVAR_DEVTYPE             1
   94 #define VIRTIO_IVAR_FEATURE_DESC        2
   95 #define VIRTIO_IVAR_VENDOR              3
   96 #define VIRTIO_IVAR_DEVICE              4
   97 #define VIRTIO_IVAR_SUBVENDOR           5
   98 #define VIRTIO_IVAR_SUBDEVICE           6
   99 
  100 struct virtio_feature_desc {
  101         uint64_t         vfd_val;
  102         char            *vfd_str;
  103 };
  104 
  105 const char *virtio_device_name(uint16_t devid);
  106 void     virtio_describe(device_t dev, const char *msg,
  107              uint64_t features, struct virtio_feature_desc *feature_desc);
  108 
  109 /*
  110  * VirtIO Bus Methods.
  111  */
  112 void     virtio_read_ivar(device_t dev, int ivar, uintptr_t *val);
  113 void     virtio_write_ivar(device_t dev, int ivar, uintptr_t val);
  114 uint64_t virtio_negotiate_features(device_t dev, uint64_t child_features);
  115 int      virtio_alloc_virtqueues(device_t dev, int flags, int nvqs,
  116              struct vq_alloc_info *info);
  117 int      virtio_setup_intr(device_t dev, enum intr_type type);
  118 int      virtio_with_feature(device_t dev, uint64_t feature);
  119 void     virtio_stop(device_t dev);
  120 int      virtio_reinit(device_t dev, uint64_t features);
  121 void     virtio_reinit_complete(device_t dev);
  122 
  123 /*
  124  * Read/write a variable amount from the device specific (ie, network)
  125  * configuration region. This region is encoded in the same endian as
  126  * the guest.
  127  */
  128 void     virtio_read_device_config(device_t dev, bus_size_t offset,
  129              void *dst, int length);
  130 void     virtio_write_device_config(device_t dev, bus_size_t offset,
  131              void *src, int length);
  132 
  133 /* Inlined device specific read/write functions for common lengths. */
  134 #define VIRTIO_RDWR_DEVICE_CONFIG(size, type)                           \
  135 static inline type                                                      \
  136 __CONCAT(virtio_read_dev_config_,size)(device_t dev,                    \
  137     bus_size_t offset)                                                  \
  138 {                                                                       \
  139         type val;                                                       \
  140         virtio_read_device_config(dev, offset, &val, sizeof(type));     \
  141         return (val);                                                   \
  142 }                                                                       \
  143                                                                         \
  144 static inline void                                                      \
  145 __CONCAT(virtio_write_dev_config_,size)(device_t dev,                   \
  146     bus_size_t offset, type val)                                        \
  147 {                                                                       \
  148         virtio_write_device_config(dev, offset, &val, sizeof(type));    \
  149 }
  150 
  151 VIRTIO_RDWR_DEVICE_CONFIG(1, uint8_t);
  152 VIRTIO_RDWR_DEVICE_CONFIG(2, uint16_t);
  153 VIRTIO_RDWR_DEVICE_CONFIG(4, uint32_t);
  154 
  155 #undef VIRTIO_RDWR_DEVICE_CONFIG
  156 
  157 #define VIRTIO_READ_IVAR(name, ivar)                                    \
  158 static inline int                                                       \
  159 __CONCAT(virtio_get_,name)(device_t dev)                                \
  160 {                                                                       \
  161         uintptr_t val;                                                  \
  162         virtio_read_ivar(dev, ivar, &val);                              \
  163         return ((int) val);                                             \
  164 }
  165 
  166 VIRTIO_READ_IVAR(device_type,   VIRTIO_IVAR_DEVTYPE);
  167 VIRTIO_READ_IVAR(vendor,        VIRTIO_IVAR_VENDOR);
  168 VIRTIO_READ_IVAR(device,        VIRTIO_IVAR_DEVICE);
  169 VIRTIO_READ_IVAR(subvendor,     VIRTIO_IVAR_SUBVENDOR);
  170 VIRTIO_READ_IVAR(subdevice,     VIRTIO_IVAR_SUBDEVICE);
  171 
  172 #undef VIRTIO_READ_IVAR
  173 
  174 #define VIRTIO_WRITE_IVAR(name, ivar)                                   \
  175 static inline void                                                      \
  176 __CONCAT(virtio_set_,name)(device_t dev, void *val)                     \
  177 {                                                                       \
  178         virtio_write_ivar(dev, ivar, (uintptr_t) val);                  \
  179 }
  180 
  181 VIRTIO_WRITE_IVAR(feature_desc, VIRTIO_IVAR_FEATURE_DESC);
  182 
  183 #undef VIRTIO_WRITE_IVAR
  184 
  185 #endif /* _VIRTIO_H_ */

Cache object: 1f1837baa81f14f7b1ccebb2a9327262

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/virtio/virtio.h

FreeBSD/Linux Kernel Cross Reference
sys/dev/virtio/virtio.h