[qemu.git] / pc-bios / s390-ccw / virtio.h

/*
 * Virtio driver bits
 *
 * Copyright (c) 2013 Alexander Graf <agraf@suse.de>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or (at
 * your option) any later version. See the COPYING file in the top-level
 * directory.
 */

#ifndef VIRTIO_H
#define VIRTIO_H

#include "s390-ccw.h"

/* Status byte for guest to report progress, and synchronize features. */
/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
#define VIRTIO_CONFIG_S_ACKNOWLEDGE     1
/* We have found a driver for the device. */
#define VIRTIO_CONFIG_S_DRIVER          2
/* Driver has used its parts of the config, and is happy */
#define VIRTIO_CONFIG_S_DRIVER_OK       4
/* We've given up on this device. */
#define VIRTIO_CONFIG_S_FAILED          0x80

enum virtio_dev_type {
    VIRTIO_ID_NET = 1,
    VIRTIO_ID_BLOCK = 2,
    VIRTIO_ID_CONSOLE = 3,
    VIRTIO_ID_BALLOON = 5,
};

struct virtio_dev_header {
    enum virtio_dev_type type : 8;
    u8  num_vq;
    u8  feature_len;
    u8  config_len;
    u8  status;
    u8  vqconfig[];
} __attribute__((packed));

struct virtio_vqconfig {
    u64 token;
    u64 address;
    u16 num;
    u8  pad[6];
} __attribute__((packed));

struct vq_info_block {
    u64 queue;
    u32 align;
    u16 index;
    u16 num;
} __attribute__((packed));

struct vq_config_block {
    u16 index;
    u16 num;
} __attribute__((packed));

struct virtio_dev {
    struct virtio_dev_header *header;
    struct virtio_vqconfig *vqconfig;
    char *host_features;
    char *guest_features;
    char *config;
};

#define KVM_S390_VIRTIO_RING_ALIGN	4096

#define VRING_USED_F_NO_NOTIFY  1

/* This marks a buffer as continuing via the next field. */
#define VRING_DESC_F_NEXT       1
/* This marks a buffer as write-only (otherwise read-only). */
#define VRING_DESC_F_WRITE      2
/* This means the buffer contains a list of buffer descriptors. */
#define VRING_DESC_F_INDIRECT   4

/* Internal flag to mark follow-up segments as such */
#define VRING_HIDDEN_IS_CHAIN   256

/* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
struct vring_desc {
    /* Address (guest-physical). */
    u64 addr;
    /* Length. */
    u32 len;
    /* The flags as indicated above. */
    u16 flags;
    /* We chain unused descriptors via this, too */
    u16 next;
} __attribute__((packed));

struct vring_avail {
    u16 flags;
    u16 idx;
    u16 ring[];
} __attribute__((packed));

/* u32 is used here for ids for padding reasons. */
struct vring_used_elem {
    /* Index of start of used descriptor chain. */
    u32 id;
    /* Total length of the descriptor chain which was used (written to) */
    u32 len;
} __attribute__((packed));

struct vring_used {
    u16 flags;
    u16 idx;
    struct vring_used_elem ring[];
} __attribute__((packed));

struct vring {
    unsigned int num;
    int next_idx;
    int used_idx;
    struct vring_desc *desc;
    struct vring_avail *avail;
    struct vring_used *used;
    struct subchannel_id schid;
};


/***********************************************
 *               Virtio block                  *
 ***********************************************/

/*
 * Command types
 *
 * Usage is a bit tricky as some bits are used as flags and some are not.
 *
 * Rules:
 *   VIRTIO_BLK_T_OUT may be combined with VIRTIO_BLK_T_SCSI_CMD or
 *   VIRTIO_BLK_T_BARRIER.  VIRTIO_BLK_T_FLUSH is a command of its own
 *   and may not be combined with any of the other flags.
 */

/* These two define direction. */
#define VIRTIO_BLK_T_IN         0
#define VIRTIO_BLK_T_OUT        1

/* This bit says it's a scsi command, not an actual read or write. */
#define VIRTIO_BLK_T_SCSI_CMD   2

/* Cache flush command */
#define VIRTIO_BLK_T_FLUSH      4

/* Barrier before this op. */
#define VIRTIO_BLK_T_BARRIER    0x80000000

/* This is the first element of the read scatter-gather list. */
struct virtio_blk_outhdr {
        /* VIRTIO_BLK_T* */
        u32 type;
        /* io priority. */
        u32 ioprio;
        /* Sector (ie. 512 byte offset) */
        u64 sector;
};

#endif /* VIRTIO_H */
Commit	Line	Data
1e17c2c1 AG	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	#include "s390-ccw.h"
	15
	16	/* Status byte for guest to report progress, and synchronize features. */
	17	/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
	18	#define VIRTIO_CONFIG_S_ACKNOWLEDGE 1
	19	/* We have found a driver for the device. */
	20	#define VIRTIO_CONFIG_S_DRIVER 2
	21	/* Driver has used its parts of the config, and is happy */
	22	#define VIRTIO_CONFIG_S_DRIVER_OK 4
	23	/* We've given up on this device. */
	24	#define VIRTIO_CONFIG_S_FAILED 0x80
	25
	26	enum virtio_dev_type {
	27	VIRTIO_ID_NET = 1,
	28	VIRTIO_ID_BLOCK = 2,
	29	VIRTIO_ID_CONSOLE = 3,
	30	VIRTIO_ID_BALLOON = 5,
	31	};
	32
	33	struct virtio_dev_header {
	34	enum virtio_dev_type type : 8;
	35	u8 num_vq;
	36	u8 feature_len;
	37	u8 config_len;
	38	u8 status;
	39	u8 vqconfig[];
	40	} __attribute__((packed));
	41
	42	struct virtio_vqconfig {
	43	u64 token;
	44	u64 address;
	45	u16 num;
	46	u8 pad[6];
	47	} __attribute__((packed));
	48
	49	struct vq_info_block {
	50	u64 queue;
	51	u32 align;
	52	u16 index;
	53	u16 num;
	54	} __attribute__((packed));
	55
abbbe3de CH	56	struct vq_config_block {
	57	u16 index;
	58	u16 num;
	59	} __attribute__((packed));
	60
1e17c2c1 AG	61	struct virtio_dev {
	62	struct virtio_dev_header *header;
	63	struct virtio_vqconfig *vqconfig;
	64	char *host_features;
	65	char *guest_features;
	66	char *config;
	67	};
	68
	69	#define KVM_S390_VIRTIO_RING_ALIGN 4096
	70
	71	#define VRING_USED_F_NO_NOTIFY 1
	72
	73	/* This marks a buffer as continuing via the next field. */
	74	#define VRING_DESC_F_NEXT 1
	75	/* This marks a buffer as write-only (otherwise read-only). */
	76	#define VRING_DESC_F_WRITE 2
	77	/* This means the buffer contains a list of buffer descriptors. */
	78	#define VRING_DESC_F_INDIRECT 4
	79
	80	/* Internal flag to mark follow-up segments as such */
	81	#define VRING_HIDDEN_IS_CHAIN 256
	82
	83	/* Virtio ring descriptors: 16 bytes. These can chain together via "next". */
	84	struct vring_desc {
	85	/* Address (guest-physical). */
	86	u64 addr;
	87	/* Length. */
	88	u32 len;
	89	/* The flags as indicated above. */
	90	u16 flags;
	91	/* We chain unused descriptors via this, too */
	92	u16 next;
	93	} __attribute__((packed));
	94
	95	struct vring_avail {
	96	u16 flags;
	97	u16 idx;
	98	u16 ring[];
	99	} __attribute__((packed));
	100
	101	/* u32 is used here for ids for padding reasons. */
	102	struct vring_used_elem {
	103	/* Index of start of used descriptor chain. */
	104	u32 id;
	105	/* Total length of the descriptor chain which was used (written to) */
	106	u32 len;
	107	} __attribute__((packed));
	108
	109	struct vring_used {
	110	u16 flags;
	111	u16 idx;
	112	struct vring_used_elem ring[];
	113	} __attribute__((packed));
	114
	115	struct vring {
	116	unsigned int num;
	117	int next_idx;
441ea695	118	int used_idx;
1e17c2c1 AG	119	struct vring_desc *desc;
	120	struct vring_avail *avail;
	121	struct vring_used *used;
	122	struct subchannel_id schid;
	123	};
	124
	125
	126	/***********************************************
	127	* Virtio block *
	128	***********************************************/
	129
	130	/*
	131	* Command types
	132	*
	133	* Usage is a bit tricky as some bits are used as flags and some are not.
	134	*
	135	* Rules:
	136	* VIRTIO_BLK_T_OUT may be combined with VIRTIO_BLK_T_SCSI_CMD or
	137	* VIRTIO_BLK_T_BARRIER. VIRTIO_BLK_T_FLUSH is a command of its own
	138	* and may not be combined with any of the other flags.
	139	*/
	140
	141	/* These two define direction. */
	142	#define VIRTIO_BLK_T_IN 0
	143	#define VIRTIO_BLK_T_OUT 1
	144
	145	/* This bit says it's a scsi command, not an actual read or write. */
	146	#define VIRTIO_BLK_T_SCSI_CMD 2
	147
	148	/* Cache flush command */
	149	#define VIRTIO_BLK_T_FLUSH 4
	150
	151	/* Barrier before this op. */
	152	#define VIRTIO_BLK_T_BARRIER 0x80000000
	153
	154	/* This is the first element of the read scatter-gather list. */
	155	struct virtio_blk_outhdr {
	156	/* VIRTIO_BLK_T* */
	157	u32 type;
	158	/* io priority. */
	159	u32 ioprio;
	160	/* Sector (ie. 512 byte offset) */
	161	u64 sector;
	162	};
	163
	164	#endif /* VIRTIO_H */