Annotation of qemu/hw/virtio.h, revision 1.1.1.5

1.1       root        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"
1.1.1.5 ! root       18: #include "net.h"
1.1.1.4   root       19: #include "qdev.h"
1.1.1.5 ! root       20: #include "sysemu.h"
1.1       root       21: 
                     22: /* from Linux's linux/virtio_config.h */
                     23: 
                     24: /* Status byte for guest to report progress, and synchronize features. */
                     25: /* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
                     26: #define VIRTIO_CONFIG_S_ACKNOWLEDGE     1
                     27: /* We have found a driver for the device. */
                     28: #define VIRTIO_CONFIG_S_DRIVER          2
                     29: /* Driver has used its parts of the config, and is happy */
                     30: #define VIRTIO_CONFIG_S_DRIVER_OK       4
                     31: /* We've given up on this device. */
                     32: #define VIRTIO_CONFIG_S_FAILED          0x80
                     33: 
1.1.1.5 ! root       34: /* Some virtio feature bits (currently bits 28 through 31) are reserved for the
        !            35:  * transport being used (eg. virtio_ring), the rest are per-device feature bits. */
        !            36: #define VIRTIO_TRANSPORT_F_START        28
        !            37: #define VIRTIO_TRANSPORT_F_END          32
        !            38: 
        !            39: /* We notify when the ring is completely used, even if the guest is suppressing
1.1       root       40:  * callbacks */
                     41: #define VIRTIO_F_NOTIFY_ON_EMPTY        24
1.1.1.4   root       42: /* We support indirect buffer descriptors */
                     43: #define VIRTIO_RING_F_INDIRECT_DESC     28
1.1.1.2   root       44: /* A guest should never accept this.  It implies negotiation is broken. */
                     45: #define VIRTIO_F_BAD_FEATURE           30
1.1       root       46: 
                     47: /* from Linux's linux/virtio_ring.h */
                     48: 
                     49: /* This marks a buffer as continuing via the next field. */
                     50: #define VRING_DESC_F_NEXT       1
                     51: /* This marks a buffer as write-only (otherwise read-only). */
                     52: #define VRING_DESC_F_WRITE      2
1.1.1.4   root       53: /* This means the buffer contains a list of buffer descriptors. */
                     54: #define VRING_DESC_F_INDIRECT  4
1.1       root       55: 
                     56: /* This means don't notify other side when buffer added. */
                     57: #define VRING_USED_F_NO_NOTIFY  1
                     58: /* This means don't interrupt guest when buffer consumed. */
                     59: #define VRING_AVAIL_F_NO_INTERRUPT      1
                     60: 
                     61: struct VirtQueue;
                     62: 
                     63: static inline target_phys_addr_t vring_align(target_phys_addr_t addr,
                     64:                                              unsigned long align)
                     65: {
                     66:     return (addr + align - 1) & ~(align - 1);
                     67: }
                     68: 
                     69: typedef struct VirtQueue VirtQueue;
                     70: typedef struct VirtIODevice VirtIODevice;
                     71: 
                     72: #define VIRTQUEUE_MAX_SIZE 1024
                     73: 
                     74: typedef struct VirtQueueElement
                     75: {
                     76:     unsigned int index;
                     77:     unsigned int out_num;
                     78:     unsigned int in_num;
                     79:     target_phys_addr_t in_addr[VIRTQUEUE_MAX_SIZE];
                     80:     struct iovec in_sg[VIRTQUEUE_MAX_SIZE];
                     81:     struct iovec out_sg[VIRTQUEUE_MAX_SIZE];
                     82: } VirtQueueElement;
                     83: 
1.1.1.4   root       84: typedef struct {
                     85:     void (*notify)(void * opaque, uint16_t vector);
                     86:     void (*save_config)(void * opaque, QEMUFile *f);
                     87:     void (*save_queue)(void * opaque, int n, QEMUFile *f);
                     88:     int (*load_config)(void * opaque, QEMUFile *f);
                     89:     int (*load_queue)(void * opaque, int n, QEMUFile *f);
1.1.1.5 ! root       90:     unsigned (*get_features)(void * opaque);
1.1.1.4   root       91: } VirtIOBindings;
                     92: 
1.1       root       93: #define VIRTIO_PCI_QUEUE_MAX 16
                     94: 
1.1.1.4   root       95: #define VIRTIO_NO_VECTOR 0xffff
                     96: 
1.1       root       97: struct VirtIODevice
                     98: {
                     99:     const char *name;
                    100:     uint8_t status;
                    101:     uint8_t isr;
                    102:     uint16_t queue_sel;
                    103:     uint32_t features;
                    104:     size_t config_len;
                    105:     void *config;
1.1.1.4   root      106:     uint16_t config_vector;
                    107:     int nvectors;
1.1       root      108:     uint32_t (*get_features)(VirtIODevice *vdev);
1.1.1.2   root      109:     uint32_t (*bad_features)(VirtIODevice *vdev);
1.1       root      110:     void (*set_features)(VirtIODevice *vdev, uint32_t val);
                    111:     void (*get_config)(VirtIODevice *vdev, uint8_t *config);
                    112:     void (*set_config)(VirtIODevice *vdev, const uint8_t *config);
                    113:     void (*reset)(VirtIODevice *vdev);
                    114:     VirtQueue *vq;
1.1.1.4   root      115:     const VirtIOBindings *binding;
                    116:     void *binding_opaque;
                    117:     uint16_t device_id;
1.1       root      118: };
                    119: 
                    120: VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
                    121:                             void (*handle_output)(VirtIODevice *,
                    122:                                                   VirtQueue *));
                    123: 
                    124: void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem,
                    125:                     unsigned int len);
                    126: void virtqueue_flush(VirtQueue *vq, unsigned int count);
                    127: void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
                    128:                     unsigned int len, unsigned int idx);
                    129: 
                    130: int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem);
                    131: int virtqueue_avail_bytes(VirtQueue *vq, int in_bytes, int out_bytes);
                    132: 
                    133: void virtio_notify(VirtIODevice *vdev, VirtQueue *vq);
                    134: 
                    135: void virtio_save(VirtIODevice *vdev, QEMUFile *f);
                    136: 
1.1.1.4   root      137: int virtio_load(VirtIODevice *vdev, QEMUFile *f);
1.1       root      138: 
1.1.1.3   root      139: void virtio_cleanup(VirtIODevice *vdev);
                    140: 
1.1       root      141: void virtio_notify_config(VirtIODevice *vdev);
                    142: 
                    143: void virtio_queue_set_notification(VirtQueue *vq, int enable);
                    144: 
                    145: int virtio_queue_ready(VirtQueue *vq);
                    146: 
                    147: int virtio_queue_empty(VirtQueue *vq);
                    148: 
1.1.1.4   root      149: /* Host binding interface.  */
                    150: 
                    151: VirtIODevice *virtio_common_init(const char *name, uint16_t device_id,
                    152:                                  size_t config_size, size_t struct_size);
                    153: uint32_t virtio_config_readb(VirtIODevice *vdev, uint32_t addr);
                    154: uint32_t virtio_config_readw(VirtIODevice *vdev, uint32_t addr);
                    155: uint32_t virtio_config_readl(VirtIODevice *vdev, uint32_t addr);
                    156: void virtio_config_writeb(VirtIODevice *vdev, uint32_t addr, uint32_t data);
                    157: void virtio_config_writew(VirtIODevice *vdev, uint32_t addr, uint32_t data);
                    158: void virtio_config_writel(VirtIODevice *vdev, uint32_t addr, uint32_t data);
                    159: void virtio_queue_set_addr(VirtIODevice *vdev, int n, target_phys_addr_t addr);
                    160: target_phys_addr_t virtio_queue_get_addr(VirtIODevice *vdev, int n);
                    161: int virtio_queue_get_num(VirtIODevice *vdev, int n);
                    162: void virtio_queue_notify(VirtIODevice *vdev, int n);
                    163: uint16_t virtio_queue_vector(VirtIODevice *vdev, int n);
                    164: void virtio_queue_set_vector(VirtIODevice *vdev, int n, uint16_t vector);
                    165: void virtio_reset(void *opaque);
                    166: void virtio_update_irq(VirtIODevice *vdev);
                    167: 
                    168: void virtio_bind_device(VirtIODevice *vdev, const VirtIOBindings *binding,
                    169:                         void *opaque);
                    170: 
                    171: /* Base devices.  */
1.1.1.5 ! root      172: VirtIODevice *virtio_blk_init(DeviceState *dev, DriveInfo *dinfo);
        !           173: VirtIODevice *virtio_net_init(DeviceState *dev, NICConf *conf);
1.1.1.4   root      174: VirtIODevice *virtio_console_init(DeviceState *dev);
                    175: VirtIODevice *virtio_balloon_init(DeviceState *dev);
                    176: 
1.1.1.5 ! root      177: void virtio_net_exit(VirtIODevice *vdev);
        !           178: 
1.1       root      179: #endif

unix.superglobalmegacorp.com