/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2019 Joyent, Inc.
 * Copyright 2020 Oxide Computer Company
 */

/*
 * VIRTIO BLOCK DRIVER
 */

#ifndef _VIOBLK_H
#define	_VIOBLK_H

#include "virtio.h"

#ifdef __cplusplus
extern "C" {
#endif

/*
 * VIRTIO BLOCK CONFIGURATION REGISTERS
 *
 * These are offsets into the device-specific configuration space available
 * through the virtio_dev_*() family of functions.
 */
#define	VIRTIO_BLK_CONFIG_CAPACITY		0x00	/* 64 R   */
#define	VIRTIO_BLK_CONFIG_SIZE_MAX		0x08	/* 32 R   */
#define	VIRTIO_BLK_CONFIG_SEG_MAX		0x0C	/* 32 R   */
#define	VIRTIO_BLK_CONFIG_GEOMETRY_C		0x10	/* 16 R   */
#define	VIRTIO_BLK_CONFIG_GEOMETRY_H		0x12	/*  8 R   */
#define	VIRTIO_BLK_CONFIG_GEOMETRY_S		0x13	/*  8 R   */
#define	VIRTIO_BLK_CONFIG_BLK_SIZE		0x14	/* 32 R   */
#define	VIRTIO_BLK_CONFIG_TOPO_PBEXP		0x18	/*  8 R   */
#define	VIRTIO_BLK_CONFIG_TOPO_ALIGN		0x19	/*  8 R   */
#define	VIRTIO_BLK_CONFIG_TOPO_MIN_SZ		0x1A	/* 16 R   */
#define	VIRTIO_BLK_CONFIG_TOPO_OPT_SZ		0x1C	/* 32 R   */
#define	VIRTIO_BLK_CONFIG_WRITEBACK		0x20	/*  8 R	  */
				/* unused	0x21 */ /*  8 R   */
#define	VIRTIO_BLK_CONFIG_NUM_QUEUES		0x22	/* 16 R   */
#define	VIRTIO_BLK_CONFIG_MAX_DISCARD_SECT	0x24	/* 32 R   */
#define	VIRTIO_BLK_CONFIG_MAX_DISCARD_SEG	0x28	/* 32 R   */
#define	VIRTIO_BLK_CONFIG_DISCARD_ALIGN		0x2C	/* 32 R   */
#define	VIRTIO_BLK_CONFIG_MAX_WRITE_ZERO_SECT	0x30	/* 32 R   */
#define	VIRTIO_BLK_CONFIG_MAX_WRITE_ZERO_SEG	0x34	/* 32 R   */
#define	VIRTIO_BLK_CONFIG_WRITE_ZERO_UNMAP	0x38	/*  8 R   */

/*
 * VIRTIO BLOCK VIRTQUEUES
 *
 * Virtio block devices have just one queue which is used to make the various
 * supported I/O requests.
 */
#define	VIRTIO_BLK_VIRTQ_IO		0

/*
 * VIRTIO BLOCK FEATURE BITS
 */
#define	VIRTIO_BLK_F_BARRIER		(1ULL << 0)
#define	VIRTIO_BLK_F_SIZE_MAX		(1ULL << 1)
#define	VIRTIO_BLK_F_SEG_MAX		(1ULL << 2)
#define	VIRTIO_BLK_F_GEOMETRY		(1ULL << 4)
#define	VIRTIO_BLK_F_RO			(1ULL << 5)
#define	VIRTIO_BLK_F_BLK_SIZE		(1ULL << 6)
#define	VIRTIO_BLK_F_SCSI		(1ULL << 7)
#define	VIRTIO_BLK_F_FLUSH		(1ULL << 9)
#define	VIRTIO_BLK_F_TOPOLOGY		(1ULL << 10)
#define	VIRTIO_BLK_F_CONFIG_WCE		(1ULL << 11)
#define	VIRTIO_BLK_F_MQ			(1ULL << 12)
#define	VIRTIO_BLK_F_DISCARD		(1ULL << 13)
#define	VIRTIO_BLK_F_WRITE_ZEROES	(1ULL << 14)

/*
 * These features are supported by the driver and we will request them from the
 * device.
 */
#define	VIRTIO_BLK_WANTED_FEATURES	(VIRTIO_BLK_F_RO |		\
					VIRTIO_BLK_F_BLK_SIZE |		\
					VIRTIO_BLK_F_FLUSH |		\
					VIRTIO_BLK_F_TOPOLOGY |		\
					VIRTIO_BLK_F_SEG_MAX |		\
					VIRTIO_BLK_F_SIZE_MAX |		\
					VIRTIO_BLK_F_DISCARD)

/*
 * VIRTIO BLOCK REQUEST HEADER
 *
 * This structure appears at the start of each I/O request buffer.  Note that
 * neither the data payload nor the status byte appear in this structure as
 * both are handled in separate descriptor entries.
 */
struct vioblk_req_hdr {
	uint32_t			vbh_type;
	uint32_t			vbh_ioprio;
	uint64_t			vbh_sector;
} __packed;

/*
 * VIRTIO BLOCK REQUEST HEADER: COMMANDS (vbh_type)
 *
 * Each of these is a command type, except for BARRIER which is logically
 * OR-ed with one of the other types.
 */
#define	VIRTIO_BLK_T_IN			0
#define	VIRTIO_BLK_T_OUT		1
#define	VIRTIO_BLK_T_SCSI_CMD		2
#define	VIRTIO_BLK_T_SCSI_CMD_OUT	3
#define	VIRTIO_BLK_T_FLUSH		4
#define	VIRTIO_BLK_T_FLUSH_OUT		5
#define	VIRTIO_BLK_T_GET_ID		8
#define	VIRTIO_BLK_T_DISCARD		11
#define	VIRTIO_BLK_T_WRITE_ZEROES	13
#define	VIRTIO_BLK_T_BARRIER		0x80000000

/*
 * VIRTIO BLOCK DISCARD/WRITE ZEROS DATA
 *
 * For hosts that support the DISCARD or WRITE ZEROES features, instead of
 * data, the vioblk_discard_write_zeros struct is used as the 'data' for
 * the request.
 */
struct vioblk_discard_write_zeroes {
	uint64_t	vdwz_sector;
	uint32_t	vdwz_num_sectors;
	uint32_t	vdwz_flags;
} __packed;

/*
 * vdwz_flags values
 */

/* For a WRITE ZEROES request, also unmap the block */
#define	VIRTIO_BLK_WRITE_ZEROS_UNMAP	(1U << 0)

/*
 * The GET_ID command type does not appear in the specification, but
 * implementations in the wild use a 20 byte buffer into which the device will
 * write an ASCII string.  The string should not be assumed to be
 * NUL-terminated.
 */
#define	VIRTIO_BLK_ID_BYTES		20

/*
 * VIRTIO BLOCK REQUEST HEADER: STATUS CODES
 *
 * These are returned in the writeable status byte descriptor included at the
 * end of each request passed to the device.
 */
#define	VIRTIO_BLK_S_OK			0
#define	VIRTIO_BLK_S_IOERR		1
#define	VIRTIO_BLK_S_UNSUPP		2

/*
 * DRIVER PARAMETERS
 */

/*
 * In the event that the device does not negotiate DMA parameters, we have to
 * make a best guess.
 */
#define	VIRTIO_BLK_DEFAULT_MAX_SEG	128
#define	VIRTIO_BLK_DEFAULT_MAX_SIZE	4096

/*
 * We allocate a fixed number of request buffers in advance and place them in a
 * per-instance free list.
 */
#define	VIRTIO_BLK_REQ_BUFS		256

/*
 * TYPE DEFINITIONS
 */

typedef enum vioblk_req_status {
	VIOBLK_REQSTAT_ALLOCATED =	(0x1 << 0),
	VIOBLK_REQSTAT_INFLIGHT =	(0x1 << 1),
	VIOBLK_REQSTAT_COMPLETE =	(0x1 << 2),
	VIOBLK_REQSTAT_POLLED =		(0x1 << 3),
	VIOBLK_REQSTAT_POLL_COMPLETE =	(0x1 << 4),
} vioblk_req_status_t;

typedef struct vioblk_req {
	vioblk_req_status_t		vbr_status;
	uint64_t			vbr_seqno;
	int				vbr_type;
	int				vbr_error;
	virtio_dma_t			*vbr_dma;
	virtio_chain_t			*vbr_chain;
	bd_xfer_t			*vbr_xfer;
	list_node_t			vbr_link;
} vioblk_req_t;

typedef struct vioblk_stats {
	struct kstat_named		vbs_rw_outofmemory;
	struct kstat_named		vbs_rw_badoffset;
	struct kstat_named		vbs_rw_queuemax;
	struct kstat_named		vbs_rw_cookiesmax;
	struct kstat_named		vbs_rw_cacheflush;
	struct kstat_named		vbs_intr_queuemax;
	struct kstat_named		vbs_intr_total;
	struct kstat_named		vbs_io_errors;
	struct kstat_named		vbs_unsupp_errors;
	struct kstat_named		vbs_nxio_errors;
} vioblk_stats_t;

typedef struct vioblk {
	dev_info_t			*vib_dip;
	virtio_t			*vib_virtio;
	virtio_queue_t			*vib_vq;

	kmutex_t			vib_mutex;
	kcondvar_t			vib_cv;

	bd_handle_t			vib_bd_h;
	ddi_dma_attr_t			vib_bd_dma_attr;

	list_t				vib_reqs;
	uint_t				vib_nreqs_alloc;
	uint_t				vib_reqs_capacity;
	vioblk_req_t			*vib_reqs_mem;

	kstat_t				*vib_kstat;
	vioblk_stats_t			*vib_stats;

	uint64_t			vib_nblks;
	boolean_t			vib_readonly;
	uint_t				vib_blk_size;
	uint_t				vib_pblk_size;
	uint_t				vib_seg_max;
	uint_t				vib_seg_size_max;

	boolean_t			vib_can_discard;	/* Write Once */
	uint_t				vib_max_discard_sectors;	/* WO */
	uint_t				vib_max_discard_seg;		/* WO */
	uint_t				vib_discard_sector_align;	/* WO */

	boolean_t			vib_devid_fetched;
	char				vib_devid[VIRTIO_BLK_ID_BYTES + 1];
	uint8_t				vib_rawid[VIRTIO_BLK_ID_BYTES];
} vioblk_t;

#ifdef __cplusplus
}
#endif

#endif /* _VIOBLK_H */