pc-bios/s390-ccw/virtio.h

   1 /*
   2  * Virtio driver bits
   3  *
   4  * Copyright (c) 2013 Alexander Graf <agraf@suse.de>
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or (at
   7  * your option) any later version. See the COPYING file in the top-level
   8  * directory.
   9  */
  10
  11 #ifndef VIRTIO_H
  12 #define VIRTIO_H
  13
  14 /* Status byte for guest to report progress, and synchronize features. */
  15 /* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
  16 #define VIRTIO_CONFIG_S_ACKNOWLEDGE     1
  17 /* We have found a driver for the device. */
  18 #define VIRTIO_CONFIG_S_DRIVER          2
  19 /* Driver has used its parts of the config, and is happy */
  20 #define VIRTIO_CONFIG_S_DRIVER_OK       4
  21 /* We've given up on this device. */
  22 #define VIRTIO_CONFIG_S_FAILED          0x80
  23
  24 enum VirtioDevType {
  25     VIRTIO_ID_NET = 1,
  26     VIRTIO_ID_BLOCK = 2,
  27     VIRTIO_ID_CONSOLE = 3,
  28     VIRTIO_ID_BALLOON = 5,
  29     VIRTIO_ID_SCSI = 8,
  30 };
  31 typedef enum VirtioDevType VirtioDevType;
  32
  33 struct VqInfo {
  34     uint64_t queue;
  35     uint32_t align;
  36     uint16_t index;
  37     uint16_t num;
  38 } __attribute__((packed));
  39 typedef struct VqInfo VqInfo;
  40
  41 struct VqConfig {
  42     uint16_t index;
  43     uint16_t num;
  44 } __attribute__((packed));
  45 typedef struct VqConfig VqConfig;
  46
  47 #define VIRTIO_RING_SIZE            (PAGE_SIZE * 8)
  48 #define VIRTIO_MAX_VQS              3
  49 #define KVM_S390_VIRTIO_RING_ALIGN  4096
  50
  51 #define VRING_USED_F_NO_NOTIFY  1
  52
  53 /* This marks a buffer as continuing via the next field. */
  54 #define VRING_DESC_F_NEXT       1
  55 /* This marks a buffer as write-only (otherwise read-only). */
  56 #define VRING_DESC_F_WRITE      2
  57 /* This means the buffer contains a list of buffer descriptors. */
  58 #define VRING_DESC_F_INDIRECT   4
  59
  60 /* Internal flag to mark follow-up segments as such */
  61 #define VRING_HIDDEN_IS_CHAIN   256
  62
  63 /* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
  64 struct VRingDesc {
  65     /* Address (guest-physical). */
  66     uint64_t addr;
  67     /* Length. */
  68     uint32_t len;
  69     /* The flags as indicated above. */
  70     uint16_t flags;
  71     /* We chain unused descriptors via this, too */
  72     uint16_t next;
  73 } __attribute__((packed));
  74 typedef struct VRingDesc VRingDesc;
  75
  76 struct VRingAvail {
  77     uint16_t flags;
  78     uint16_t idx;
  79     uint16_t ring[];
  80 } __attribute__((packed));
  81 typedef struct VRingAvail VRingAvail;
  82
  83 /* uint32_t is used here for ids for padding reasons. */
  84 struct VRingUsedElem {
  85     /* Index of start of used descriptor chain. */
  86     uint32_t id;
  87     /* Total length of the descriptor chain which was used (written to) */
  88     uint32_t len;
  89 } __attribute__((packed));
  90 typedef struct VRingUsedElem VRingUsedElem;
  91
  92 struct VRingUsed {
  93     uint16_t flags;
  94     uint16_t idx;
  95     VRingUsedElem ring[];
  96 } __attribute__((packed));
  97 typedef struct VRingUsed VRingUsed;
  98
  99 struct VRing {
 100     unsigned int num;
 101     int next_idx;
 102     int used_idx;
 103     VRingDesc *desc;
 104     VRingAvail *avail;
 105     VRingUsed *used;
 106     SubChannelId schid;
 107     long cookie;
 108     int id;
 109 };
 110 typedef struct VRing VRing;
 111
 112
 113 /***********************************************
 114  *               Virtio block                  *
 115  ***********************************************/
 116
 117 /*
 118  * Command types
 119  *
 120  * Usage is a bit tricky as some bits are used as flags and some are not.
 121  *
 122  * Rules:
 123  *   VIRTIO_BLK_T_OUT may be combined with VIRTIO_BLK_T_SCSI_CMD or
 124  *   VIRTIO_BLK_T_BARRIER.  VIRTIO_BLK_T_FLUSH is a command of its own
 125  *   and may not be combined with any of the other flags.
 126  */
 127
 128 /* These two define direction. */
 129 #define VIRTIO_BLK_T_IN         0
 130 #define VIRTIO_BLK_T_OUT        1
 131
 132 /* This bit says it's a scsi command, not an actual read or write. */
 133 #define VIRTIO_BLK_T_SCSI_CMD   2
 134
 135 /* Cache flush command */
 136 #define VIRTIO_BLK_T_FLUSH      4
 137
 138 /* Barrier before this op. */
 139 #define VIRTIO_BLK_T_BARRIER    0x80000000
 140
 141 /* This is the first element of the read scatter-gather list. */
 142 struct VirtioBlkOuthdr {
 143         /* VIRTIO_BLK_T* */
 144         uint32_t type;
 145         /* io priority. */
 146         uint32_t ioprio;
 147         /* Sector (ie. 512 byte offset) */
 148         uint64_t sector;
 149 };
 150 typedef struct VirtioBlkOuthdr VirtioBlkOuthdr;
 151
 152 struct VirtioBlkConfig {
 153     uint64_t capacity; /* in 512-byte sectors */
 154     uint32_t size_max; /* max segment size (if VIRTIO_BLK_F_SIZE_MAX) */
 155     uint32_t seg_max;  /* max number of segments (if VIRTIO_BLK_F_SEG_MAX) */
 156
 157     struct VirtioBlkGeometry {
 158         uint16_t cylinders;
 159         uint8_t heads;
 160         uint8_t sectors;
 161     } geometry; /* (if VIRTIO_BLK_F_GEOMETRY) */
 162
 163     uint32_t blk_size; /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */
 164
 165     /* the next 4 entries are guarded by VIRTIO_BLK_F_TOPOLOGY  */
 166     uint8_t physical_block_exp; /* exponent for physical blk per logical blk */
 167     uint8_t alignment_offset;   /* alignment offset in logical blocks */
 168     uint16_t min_io_size;       /* min I/O size without performance penalty
 169                               in logical blocks */
 170     uint32_t opt_io_size;       /* optimal sustained I/O size in logical blks */
 171
 172     uint8_t wce; /* writeback mode (if VIRTIO_BLK_F_CONFIG_WCE) */
 173 } __attribute__((packed));
 174 typedef struct VirtioBlkConfig VirtioBlkConfig;
 175
 176 enum guessed_disk_nature_type {
 177     VIRTIO_GDN_NONE     = 0,
 178     VIRTIO_GDN_DASD     = 1,
 179     VIRTIO_GDN_CDROM    = 2,
 180     VIRTIO_GDN_SCSI     = 3,
 181 };
 182 typedef enum guessed_disk_nature_type VirtioGDN;
 183
 184 VirtioGDN virtio_guessed_disk_nature(void);
 185 void virtio_assume_scsi(void);
 186 void virtio_assume_eckd(void);
 187 void virtio_assume_iso9660(void);
 188
 189 extern bool virtio_disk_is_scsi(void);
 190 extern bool virtio_disk_is_eckd(void);
 191 extern bool virtio_ipl_disk_is_valid(void);
 192 extern int virtio_get_block_size(void);
 193 extern uint8_t virtio_get_heads(void);
 194 extern uint8_t virtio_get_sectors(void);
 195 extern uint64_t virtio_get_blocks(void);
 196 extern int virtio_read_many(ulong sector, void *load_addr, int sec_num);
 197
 198 #define VIRTIO_SECTOR_SIZE 512
 199 #define VIRTIO_ISO_BLOCK_SIZE 2048
 200 #define VIRTIO_SCSI_BLOCK_SIZE 512
 201
 202 static inline ulong virtio_sector_adjust(ulong sector)
 203 {
 204     return sector * (virtio_get_block_size() / VIRTIO_SECTOR_SIZE);
 205 }
 206
 207 struct VirtioScsiConfig {
 208     uint32_t num_queues;
 209     uint32_t seg_max;
 210     uint32_t max_sectors;
 211     uint32_t cmd_per_lun;
 212     uint32_t event_info_size;
 213     uint32_t sense_size;
 214     uint32_t cdb_size;
 215     uint16_t max_channel;
 216     uint16_t max_target;
 217     uint32_t max_lun;
 218 } __attribute__((packed));
 219 typedef struct VirtioScsiConfig VirtioScsiConfig;
 220
 221 struct ScsiDevice {
 222     uint16_t channel;   /* Always 0 in QEMU     */
 223     uint16_t target;    /* will be scanned over */
 224     uint32_t lun;       /* will be reported     */
 225 };
 226 typedef struct ScsiDevice ScsiDevice;
 227
 228 struct VirtioNetConfig {
 229     uint8_t mac[6];
 230     /* uint16_t status; */               /* Only with VIRTIO_NET_F_STATUS */
 231     /* uint16_t max_virtqueue_pairs; */  /* Only with VIRTIO_NET_F_MQ */
 232 };
 233 typedef struct VirtioNetConfig VirtioNetConfig;
 234
 235 struct VDev {
 236     int nr_vqs;
 237     VRing *vrings;
 238     int cmd_vr_idx;
 239     void *ring_area;
 240     long wait_reply_timeout;
 241     VirtioGDN guessed_disk_nature;
 242     SubChannelId schid;
 243     SenseId senseid;
 244     union {
 245         VirtioBlkConfig blk;
 246         VirtioScsiConfig scsi;
 247         VirtioNetConfig net;
 248     } config;
 249     ScsiDevice *scsi_device;
 250     bool is_cdrom;
 251     int scsi_block_size;
 252     int blk_factor;
 253     uint64_t scsi_last_block;
 254     uint32_t scsi_dev_cyls;
 255     uint8_t scsi_dev_heads;
 256     bool scsi_device_selected;
 257     ScsiDevice selected_scsi_device;
 258     uint64_t netboot_start_addr;
 259     uint32_t max_transfer;
 260     uint32_t guest_features[2];
 261 };
 262 typedef struct VDev VDev;
 263
 264 VDev *virtio_get_device(void);
 265 VirtioDevType virtio_get_device_type(void);
 266
 267 struct VirtioCmd {
 268     void *data;
 269     int size;
 270     int flags;
 271 };
 272 typedef struct VirtioCmd VirtioCmd;
 273
 274 bool vring_notify(VRing *vr);
 275 int drain_irqs(SubChannelId schid);
 276 void vring_send_buf(VRing *vr, void *p, int len, int flags);
 277 int vr_poll(VRing *vr);
 278 int vring_wait_reply(void);
 279 int virtio_run(VDev *vdev, int vqid, VirtioCmd *cmd);
 280 void virtio_setup_ccw(VDev *vdev);
 281
 282 int virtio_net_init(void *mac_addr);
 283
 284 #endif /* VIRTIO_H */