1 /*

     2  * Virtio Support

     3  *

     4  * Copyright IBM, Corp. 2007

     5  *

     6  * Authors:

     7  *  Anthony Liguori   <aliguori@us.ibm.com>

     8  *

     9  * This work is licensed under the terms of the GNU GPL, version 2.  See

    10  * the COPYING file in the top-level directory.

    11  *

    12  */

    13 

    14 #ifndef _QEMU_VIRTIO_H

    15 #define _QEMU_VIRTIO_H

    16 

    17 #include "hw.h"

    18 

    19 /* from Linux's linux/virtio_config.h */

    20 

    21 /* Status byte for guest to report progress, and synchronize features. */

    22 /* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */

    23 #define VIRTIO_CONFIG_S_ACKNOWLEDGE     1

    24 /* We have found a driver for the device. */

    25 #define VIRTIO_CONFIG_S_DRIVER          2

    26 /* Driver has used its parts of the config, and is happy */

    27 #define VIRTIO_CONFIG_S_DRIVER_OK       4

    28 /* We've given up on this device. */

    29 #define VIRTIO_CONFIG_S_FAILED          0x80

    30 

    31 /* We notify when the ring is completely used, even if the guest is supressing

    32  * callbacks */

    33 #define VIRTIO_F_NOTIFY_ON_EMPTY        24

    34 

    35 /* from Linux's linux/virtio_ring.h */

    36 

    37 /* This marks a buffer as continuing via the next field. */

    38 #define VRING_DESC_F_NEXT       1

    39 /* This marks a buffer as write-only (otherwise read-only). */

    40 #define VRING_DESC_F_WRITE      2

    41 

    42 /* This means don't notify other side when buffer added. */

    43 #define VRING_USED_F_NO_NOTIFY  1

    44 /* This means don't interrupt guest when buffer consumed. */

    45 #define VRING_AVAIL_F_NO_INTERRUPT      1

    46 

    47 struct VirtQueue;

    48 

    49 static inline target_phys_addr_t vring_align(target_phys_addr_t addr,

    50                                              unsigned long align)

    51 {

    52     return (addr + align - 1) & ~(align - 1);

    53 }

    54 

    55 typedef struct VirtQueue VirtQueue;

    56 typedef struct VirtIODevice VirtIODevice;

    57 

    58 #define VIRTQUEUE_MAX_SIZE 1024

    59 

    60 typedef struct VirtQueueElement

    61 {

    62     unsigned int index;

    63     unsigned int out_num;

    64     unsigned int in_num;

    65     target_phys_addr_t in_addr[VIRTQUEUE_MAX_SIZE];

    66     struct iovec in_sg[VIRTQUEUE_MAX_SIZE];

    67     struct iovec out_sg[VIRTQUEUE_MAX_SIZE];

    68 } VirtQueueElement;

    69 

    70 #define VIRTIO_PCI_QUEUE_MAX 16

    71 

    72 struct VirtIODevice

    73 {

    74     const char *name;

    75     uint32_t addr;

    76     uint8_t status;

    77     uint8_t isr;

    78     uint16_t queue_sel;

    79     uint32_t features;

    80     size_t config_len;

    81     void *config;

    82     uint32_t (*get_features)(VirtIODevice *vdev);

    83     void (*set_features)(VirtIODevice *vdev, uint32_t val);

    84     void (*get_config)(VirtIODevice *vdev, uint8_t *config);

    85     void (*set_config)(VirtIODevice *vdev, const uint8_t *config);

    86     void (*reset)(VirtIODevice *vdev);

    87     VirtQueue *vq;

    88     /* Bus binding callbacks.  */

    89     void *binding_dev;

    90     void (*update_irq)(VirtIODevice *vdev);

    91     void (*save_binding)(VirtIODevice *vdev, QEMUFile *f);

    92     void (*load_binding)(VirtIODevice *vdev, QEMUFile *f);

    93 };

    94 

    95 typedef VirtIODevice *(*VirtIOBindFn)(void *args, const char *name,

    96                                       uint16_t vendor, uint16_t device,

    97                                       size_t config_size, size_t struct_size);

    98 

    99 VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,

   100                             void (*handle_output)(VirtIODevice *,

   101                                                   VirtQueue *));

   102 

   103 void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem,

   104                     unsigned int len);

   105 void virtqueue_flush(VirtQueue *vq, unsigned int count);

   106 void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,

   107                     unsigned int len, unsigned int idx);

   108 

   109 int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem);

   110 int virtqueue_avail_bytes(VirtQueue *vq, int in_bytes, int out_bytes);

   111 

   112 void virtio_notify(VirtIODevice *vdev, VirtQueue *vq);

   113 

   114 void virtio_save(VirtIODevice *vdev, QEMUFile *f);

   115 

   116 void virtio_load(VirtIODevice *vdev, QEMUFile *f);

   117 

   118 void virtio_notify_config(VirtIODevice *vdev);

   119 

   120 void virtio_queue_set_notification(VirtQueue *vq, int enable);

   121 

   122 int virtio_queue_ready(VirtQueue *vq);

   123 

   124 int virtio_queue_empty(VirtQueue *vq);

   125 

   126 /* Functions for use by VirtIO bus bindings.  */

   127 

   128 VirtIODevice *virtio_init_common(const char *name, size_t config_size,

   129                                  size_t struct_size);

   130 

   131 void virtio_set_vring_addr(VirtIODevice *vdev, int n, target_phys_addr_t pa);

   132 target_phys_addr_t virtio_get_vring_pa(VirtIODevice *vdev, int n);

   133 target_phys_addr_t virtio_get_vring_num(VirtIODevice *vdev, int n);

   134 void virtio_kick(VirtIODevice *vdev, int n);

   135 void virtio_reset(void *opaque);

   136 uint32_t virtio_config_readb(void *opaque, uint32_t addr);

   137 uint32_t virtio_config_readw(void *opaque, uint32_t addr);

   138 uint32_t virtio_config_readl(void *opaque, uint32_t addr);

   139 void virtio_config_writeb(void *opaque, uint32_t addr, uint32_t data);

   140 void virtio_config_writew(void *opaque, uint32_t addr, uint32_t data);

   141 void virtio_config_writel(void *opaque, uint32_t addr, uint32_t data);

   142 

   143 static inline void virtio_update_irq(VirtIODevice *dev)

   144 {

   145     dev->update_irq(dev);

   146 }

   147 

   148 #endif