[linux-block.git] / include / linux / virtio_pci_modern.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_VIRTIO_PCI_MODERN_H
#define _LINUX_VIRTIO_PCI_MODERN_H

#include <linux/pci.h>
#include <linux/virtio_pci.h>

struct virtio_pci_modern_common_cfg {
	struct virtio_pci_common_cfg cfg;

	__le16 queue_notify_data;	/* read-write */
	__le16 queue_reset;		/* read-write */
};

struct virtio_pci_modern_device {
	struct pci_dev *pci_dev;

	struct virtio_pci_common_cfg __iomem *common;
	/* Device-specific data (non-legacy mode)  */
	void __iomem *device;
	/* Base of vq notifications (non-legacy mode). */
	void __iomem *notify_base;
	/* Physical base of vq notifications */
	resource_size_t notify_pa;
	/* Where to read and clear interrupt */
	u8 __iomem *isr;

	/* So we can sanity-check accesses. */
	size_t notify_len;
	size_t device_len;

	/* Capability for when we need to map notifications per-vq. */
	int notify_map_cap;

	/* Multiply queue_notify_off by this value. (non-legacy mode). */
	u32 notify_offset_multiplier;

	int modern_bars;

	struct virtio_device_id id;
};

/*
 * Type-safe wrappers for io accesses.
 * Use these to enforce at compile time the following spec requirement:
 *
 * The driver MUST access each field using the “natural” access
 * method, i.e. 32-bit accesses for 32-bit fields, 16-bit accesses
 * for 16-bit fields and 8-bit accesses for 8-bit fields.
 */
static inline u8 vp_ioread8(const u8 __iomem *addr)
{
	return ioread8(addr);
}
static inline u16 vp_ioread16 (const __le16 __iomem *addr)
{
	return ioread16(addr);
}

static inline u32 vp_ioread32(const __le32 __iomem *addr)
{
	return ioread32(addr);
}

static inline void vp_iowrite8(u8 value, u8 __iomem *addr)
{
	iowrite8(value, addr);
}

static inline void vp_iowrite16(u16 value, __le16 __iomem *addr)
{
	iowrite16(value, addr);
}

static inline void vp_iowrite32(u32 value, __le32 __iomem *addr)
{
	iowrite32(value, addr);
}

static inline void vp_iowrite64_twopart(u64 val,
					__le32 __iomem *lo,
					__le32 __iomem *hi)
{
	vp_iowrite32((u32)val, lo);
	vp_iowrite32(val >> 32, hi);
}

u64 vp_modern_get_features(struct virtio_pci_modern_device *mdev);
u64 vp_modern_get_driver_features(struct virtio_pci_modern_device *mdev);
void vp_modern_set_features(struct virtio_pci_modern_device *mdev,
		     u64 features);
u32 vp_modern_generation(struct virtio_pci_modern_device *mdev);
u8 vp_modern_get_status(struct virtio_pci_modern_device *mdev);
void vp_modern_set_status(struct virtio_pci_modern_device *mdev,
		   u8 status);
u16 vp_modern_queue_vector(struct virtio_pci_modern_device *mdev,
			   u16 idx, u16 vector);
u16 vp_modern_config_vector(struct virtio_pci_modern_device *mdev,
		     u16 vector);
void vp_modern_queue_address(struct virtio_pci_modern_device *mdev,
			     u16 index, u64 desc_addr, u64 driver_addr,
			     u64 device_addr);
void vp_modern_set_queue_enable(struct virtio_pci_modern_device *mdev,
				u16 idx, bool enable);
bool vp_modern_get_queue_enable(struct virtio_pci_modern_device *mdev,
				u16 idx);
void vp_modern_set_queue_size(struct virtio_pci_modern_device *mdev,
			      u16 idx, u16 size);
u16 vp_modern_get_queue_size(struct virtio_pci_modern_device *mdev,
			     u16 idx);
u16 vp_modern_get_num_queues(struct virtio_pci_modern_device *mdev);
void __iomem * vp_modern_map_vq_notify(struct virtio_pci_modern_device *mdev,
				       u16 index, resource_size_t *pa);
int vp_modern_probe(struct virtio_pci_modern_device *mdev);
void vp_modern_remove(struct virtio_pci_modern_device *mdev);
int vp_modern_get_queue_reset(struct virtio_pci_modern_device *mdev, u16 index);
void vp_modern_set_queue_reset(struct virtio_pci_modern_device *mdev, u16 index);
#endif
Commit	Line	Data
fd502729 JW	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _LINUX_VIRTIO_PCI_MODERN_H
	3	#define _LINUX_VIRTIO_PCI_MODERN_H
	4
	5	#include <linux/pci.h>
	6	#include <linux/virtio_pci.h>
	7
ea024594 XZ	8	struct virtio_pci_modern_common_cfg {
	9	struct virtio_pci_common_cfg cfg;
	10
	11	__le16 queue_notify_data; /* read-write */
0cdd450e	12	__le16 queue_reset; /* read-write */
ea024594 XZ	13	};
ea024594 XZ	14
fd502729 JW	15	struct virtio_pci_modern_device {
	16	struct pci_dev *pci_dev;
	17
	18	struct virtio_pci_common_cfg __iomem *common;
	19	/* Device-specific data (non-legacy mode) */
	20	void __iomem *device;
	21	/* Base of vq notifications (non-legacy mode). */
	22	void __iomem *notify_base;
9e311bca JW	23	/* Physical base of vq notifications */
9e311bca JW	24	resource_size_t notify_pa;
fd502729 JW	25	/* Where to read and clear interrupt */
	26	u8 __iomem *isr;
	27
	28	/* So we can sanity-check accesses. */
	29	size_t notify_len;
	30	size_t device_len;
	31
	32	/* Capability for when we need to map notifications per-vq. */
	33	int notify_map_cap;
	34
	35	/* Multiply queue_notify_off by this value. (non-legacy mode). */
	36	u32 notify_offset_multiplier;
	37
	38	int modern_bars;
	39
	40	struct virtio_device_id id;
	41	};
	42
	43	/*
	44	* Type-safe wrappers for io accesses.
	45	* Use these to enforce at compile time the following spec requirement:
	46	*
	47	* The driver MUST access each field using the “natural” access
	48	* method, i.e. 32-bit accesses for 32-bit fields, 16-bit accesses
	49	* for 16-bit fields and 8-bit accesses for 8-bit fields.
	50	*/
	51	static inline u8 vp_ioread8(const u8 __iomem *addr)
	52	{
	53	return ioread8(addr);
	54	}
	55	static inline u16 vp_ioread16 (const __le16 __iomem *addr)
	56	{
	57	return ioread16(addr);
	58	}
	59
	60	static inline u32 vp_ioread32(const __le32 __iomem *addr)
	61	{
	62	return ioread32(addr);
	63	}
	64
	65	static inline void vp_iowrite8(u8 value, u8 __iomem *addr)
	66	{
	67	iowrite8(value, addr);
	68	}
	69
	70	static inline void vp_iowrite16(u16 value, __le16 __iomem *addr)
	71	{
	72	iowrite16(value, addr);
	73	}
	74
	75	static inline void vp_iowrite32(u32 value, __le32 __iomem *addr)
	76	{
	77	iowrite32(value, addr);
	78	}
	79
	80	static inline void vp_iowrite64_twopart(u64 val,
	81	__le32 __iomem *lo,
	82	__le32 __iomem *hi)
	83	{
	84	vp_iowrite32((u32)val, lo);
	85	vp_iowrite32(val >> 32, hi);
	86	}
	87
	88	u64 vp_modern_get_features(struct virtio_pci_modern_device *mdev);
0140b3d0	89	u64 vp_modern_get_driver_features(struct virtio_pci_modern_device *mdev);
fd502729 JW	90	void vp_modern_set_features(struct virtio_pci_modern_device *mdev,
	91	u64 features);
	92	u32 vp_modern_generation(struct virtio_pci_modern_device *mdev);
	93	u8 vp_modern_get_status(struct virtio_pci_modern_device *mdev);
	94	void vp_modern_set_status(struct virtio_pci_modern_device *mdev,
	95	u8 status);
	96	u16 vp_modern_queue_vector(struct virtio_pci_modern_device *mdev,
	97	u16 idx, u16 vector);
	98	u16 vp_modern_config_vector(struct virtio_pci_modern_device *mdev,
	99	u16 vector);
	100	void vp_modern_queue_address(struct virtio_pci_modern_device *mdev,
	101	u16 index, u64 desc_addr, u64 driver_addr,
	102	u64 device_addr);
	103	void vp_modern_set_queue_enable(struct virtio_pci_modern_device *mdev,
	104	u16 idx, bool enable);
	105	bool vp_modern_get_queue_enable(struct virtio_pci_modern_device *mdev,
	106	u16 idx);
	107	void vp_modern_set_queue_size(struct virtio_pci_modern_device *mdev,
	108	u16 idx, u16 size);
	109	u16 vp_modern_get_queue_size(struct virtio_pci_modern_device *mdev,
	110	u16 idx);
	111	u16 vp_modern_get_num_queues(struct virtio_pci_modern_device *mdev);
d7bce85a MT	112	void __iomem * vp_modern_map_vq_notify(struct virtio_pci_modern_device *mdev,
d7bce85a MT	113	u16 index, resource_size_t *pa);
fd502729 JW	114	int vp_modern_probe(struct virtio_pci_modern_device *mdev);
fd502729 JW	115	void vp_modern_remove(struct virtio_pci_modern_device *mdev);
0b50cece XZ	116	int vp_modern_get_queue_reset(struct virtio_pci_modern_device *mdev, u16 index);
0b50cece XZ	117	void vp_modern_set_queue_reset(struct virtio_pci_modern_device *mdev, u16 index);
fd502729	118	#endif