[linux-block.git] / drivers / virtio / virtio_pci_common.h

/* SPDX-License-Identifier: GPL-2.0-or-later */
#ifndef _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H
#define _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H
/*
 * Virtio PCI driver - APIs for common functionality for all device versions
 *
 * This module allows virtio devices to be used over a virtual PCI device.
 * This can be used with QEMU based VMMs like KVM or Xen.
 *
 * Copyright IBM Corp. 2007
 * Copyright Red Hat, Inc. 2014
 *
 * Authors:
 *  Anthony Liguori  <aliguori@us.ibm.com>
 *  Rusty Russell <rusty@rustcorp.com.au>
 *  Michael S. Tsirkin <mst@redhat.com>
 */

#include <linux/module.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/virtio.h>
#include <linux/virtio_config.h>
#include <linux/virtio_ring.h>
#include <linux/virtio_pci.h>
#include <linux/virtio_pci_legacy.h>
#include <linux/virtio_pci_modern.h>
#include <linux/highmem.h>
#include <linux/spinlock.h>

struct virtio_pci_vq_info {
	/* the actual virtqueue */
	struct virtqueue *vq;

	/* the list node for the virtqueues list */
	struct list_head node;

	/* MSI-X vector (or none) */
	unsigned int msix_vector;
};

/* Our device structure */
struct virtio_pci_device {
	struct virtio_device vdev;
	struct pci_dev *pci_dev;
	union {
		struct virtio_pci_legacy_device ldev;
		struct virtio_pci_modern_device mdev;
	};
	bool is_legacy;

	/* Where to read and clear interrupt */
	u8 __iomem *isr;

	/* a list of queues so we can dispatch IRQs */
	spinlock_t lock;
	struct list_head virtqueues;

	/* array of all queues for house-keeping */
	struct virtio_pci_vq_info **vqs;

	/* MSI-X support */
	int msix_enabled;
	int intx_enabled;
	cpumask_var_t *msix_affinity_masks;
	/* Name strings for interrupts. This size should be enough,
	 * and I'm too lazy to allocate each name separately. */
	char (*msix_names)[256];
	/* Number of available vectors */
	unsigned int msix_vectors;
	/* Vectors allocated, excluding per-vq vectors if any */
	unsigned int msix_used_vectors;

	/* Whether we have vector per vq */
	bool per_vq_vectors;

	struct virtqueue *(*setup_vq)(struct virtio_pci_device *vp_dev,
				      struct virtio_pci_vq_info *info,
				      unsigned int idx,
				      void (*callback)(struct virtqueue *vq),
				      const char *name,
				      bool ctx,
				      u16 msix_vec);
	void (*del_vq)(struct virtio_pci_vq_info *info);

	u16 (*config_vector)(struct virtio_pci_device *vp_dev, u16 vector);
};

/* Constants for MSI-X */
/* Use first vector for configuration changes, second and the rest for
 * virtqueues Thus, we need at least 2 vectors for MSI. */
enum {
	VP_MSIX_CONFIG_VECTOR = 0,
	VP_MSIX_VQ_VECTOR = 1,
};

/* Convert a generic virtio device to our structure */
static struct virtio_pci_device *to_vp_device(struct virtio_device *vdev)
{
	return container_of(vdev, struct virtio_pci_device, vdev);
}

/* wait for pending irq handlers */
void vp_synchronize_vectors(struct virtio_device *vdev);
/* the notify function used when creating a virt queue */
bool vp_notify(struct virtqueue *vq);
/* the config->del_vqs() implementation */
void vp_del_vqs(struct virtio_device *vdev);
/* the config->find_vqs() implementation */
int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
		struct virtqueue *vqs[], vq_callback_t *callbacks[],
		const char * const names[], const bool *ctx,
		struct irq_affinity *desc);
const char *vp_bus_name(struct virtio_device *vdev);

/* Setup the affinity for a virtqueue:
 * - force the affinity for per vq vector
 * - OR over all affinities for shared MSI
 * - ignore the affinity request if we're using INTX
 */
int vp_set_vq_affinity(struct virtqueue *vq, const struct cpumask *cpu_mask);

const struct cpumask *vp_get_vq_affinity(struct virtio_device *vdev, int index);

#if IS_ENABLED(CONFIG_VIRTIO_PCI_LEGACY)
int virtio_pci_legacy_probe(struct virtio_pci_device *);
void virtio_pci_legacy_remove(struct virtio_pci_device *);
#else
static inline int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev)
{
	return -ENODEV;
}
static inline void virtio_pci_legacy_remove(struct virtio_pci_device *vp_dev)
{
}
#endif
int virtio_pci_modern_probe(struct virtio_pci_device *);
void virtio_pci_modern_remove(struct virtio_pci_device *);

#endif
Commit	Line	Data
f33f5fe2	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
5f4c9760 MT	2	#ifndef _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H
5f4c9760 MT	3	#define _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H
38eb4a29	4	/*
a90fdce9	5	* Virtio PCI driver - APIs for common functionality for all device versions
38eb4a29 MT	6	*
	7	* This module allows virtio devices to be used over a virtual PCI device.
	8	* This can be used with QEMU based VMMs like KVM or Xen.
	9	*
	10	* Copyright IBM Corp. 2007
a90fdce9	11	* Copyright Red Hat, Inc. 2014
38eb4a29 MT	12	*
	13	* Authors:
	14	* Anthony Liguori <aliguori@us.ibm.com>
a90fdce9 MT	15	* Rusty Russell <rusty@rustcorp.com.au>
a90fdce9 MT	16	* Michael S. Tsirkin <mst@redhat.com>
38eb4a29 MT	17	*/
	18
	19	#include <linux/module.h>
	20	#include <linux/list.h>
	21	#include <linux/pci.h>
	22	#include <linux/slab.h>
	23	#include <linux/interrupt.h>
	24	#include <linux/virtio.h>
	25	#include <linux/virtio_config.h>
	26	#include <linux/virtio_ring.h>
38eb4a29	27	#include <linux/virtio_pci.h>
d89c8169	28	#include <linux/virtio_pci_legacy.h>
fd502729	29	#include <linux/virtio_pci_modern.h>
38eb4a29 MT	30	#include <linux/highmem.h>
	31	#include <linux/spinlock.h>
	32
0a9b3f47 MT	33	struct virtio_pci_vq_info {
	34	/* the actual virtqueue */
	35	struct virtqueue *vq;
	36
	37	/* the list node for the virtqueues list */
	38	struct list_head node;
	39
	40	/* MSI-X vector (or none) */
31532340	41	unsigned int msix_vector;
0a9b3f47 MT	42	};
0a9b3f47 MT	43
b5d58094 JW	44	/* Our device structure */
	45	struct virtio_pci_device {
	46	struct virtio_device vdev;
	47	struct pci_dev *pci_dev;
4f0fc225 FL	48	union {
	49	struct virtio_pci_legacy_device ldev;
	50	struct virtio_pci_modern_device mdev;
	51	};
d89c8169 WZ	52	bool is_legacy;
d89c8169 WZ	53
b5d58094 JW	54	/* Where to read and clear interrupt */
	55	u8 __iomem *isr;
	56
0a9b3f47 MT	57	/* a list of queues so we can dispatch IRQs */
	58	spinlock_t lock;
	59	struct list_head virtqueues;
	60
	61	/* array of all queues for house-keeping */
	62	struct virtio_pci_vq_info **vqs;
	63
2008c154 MT	64	/* MSI-X support */
2008c154 MT	65	int msix_enabled;
0b0f9dc5	66	int intx_enabled;
38eb4a29 MT	67	cpumask_var_t *msix_affinity_masks;
	68	/* Name strings for interrupts. This size should be enough,
	69	* and I'm too lazy to allocate each name separately. */
	70	char (*msix_names)[256];
0b0f9dc5	71	/* Number of available vectors */
31532340	72	unsigned int msix_vectors;
0b0f9dc5	73	/* Vectors allocated, excluding per-vq vectors if any */
31532340	74	unsigned int msix_used_vectors;
0b0f9dc5	75
0a9b3f47 MT	76	/* Whether we have vector per vq */
0a9b3f47 MT	77	bool per_vq_vectors;
38eb4a29 MT	78
38eb4a29 MT	79	struct virtqueue (setup_vq)(struct virtio_pci_device *vp_dev,
0a9b3f47	80	struct virtio_pci_vq_info *info,
31532340	81	unsigned int idx,
38eb4a29 MT	82	void (callback)(struct virtqueue vq),
38eb4a29 MT	83	const char *name,
f94682dd	84	bool ctx,
38eb4a29	85	u16 msix_vec);
0a9b3f47	86	void (del_vq)(struct virtio_pci_vq_info info);
38eb4a29 MT	87
	88	u16 (config_vector)(struct virtio_pci_device vp_dev, u16 vector);
	89	};
	90
0b0f9dc5 MT	91	/* Constants for MSI-X */
	92	/* Use first vector for configuration changes, second and the rest for
	93	* virtqueues Thus, we need at least 2 vectors for MSI. */
	94	enum {
	95	VP_MSIX_CONFIG_VECTOR = 0,
	96	VP_MSIX_VQ_VECTOR = 1,
	97	};
	98
38eb4a29 MT	99	/* Convert a generic virtio device to our structure */
	100	static struct virtio_pci_device to_vp_device(struct virtio_device vdev)
	101	{
	102	return container_of(vdev, struct virtio_pci_device, vdev);
	103	}
	104
eb4cecb4 JW	105	/* wait for pending irq handlers */
eb4cecb4 JW	106	void vp_synchronize_vectors(struct virtio_device *vdev);
38eb4a29 MT	107	/* the notify function used when creating a virt queue */
	108	bool vp_notify(struct virtqueue *vq);
	109	/* the config->del_vqs() implementation */
	110	void vp_del_vqs(struct virtio_device *vdev);
	111	/* the config->find_vqs() implementation */
31532340	112	int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
fb5e31d9	113	struct virtqueue vqs[], vq_callback_t callbacks[],
9993a4f9	114	const char * const names[], const bool *ctx,
f94682dd	115	struct irq_affinity *desc);
38eb4a29 MT	116	const char vp_bus_name(struct virtio_device vdev);
	117
	118	/* Setup the affinity for a virtqueue:
	119	* - force the affinity for per vq vector
	120	* - OR over all affinities for shared MSI
	121	* - ignore the affinity request if we're using INTX
	122	*/
19e226e8	123	int vp_set_vq_affinity(struct virtqueue vq, const struct cpumask cpu_mask);
38eb4a29	124
bbaba479 CH	125	const struct cpumask vp_get_vq_affinity(struct virtio_device vdev, int index);
bbaba479 CH	126
46506da5	127	#if IS_ENABLED(CONFIG_VIRTIO_PCI_LEGACY)
ff31d2e2 MT	128	int virtio_pci_legacy_probe(struct virtio_pci_device *);
ff31d2e2 MT	129	void virtio_pci_legacy_remove(struct virtio_pci_device *);
46506da5 MT	130	#else
	131	static inline int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev)
	132	{
	133	return -ENODEV;
	134	}
	135	static inline void virtio_pci_legacy_remove(struct virtio_pci_device *vp_dev)
	136	{
	137	}
	138	#endif
1fcf0512 MT	139	int virtio_pci_modern_probe(struct virtio_pci_device *);
1fcf0512 MT	140	void virtio_pci_modern_remove(struct virtio_pci_device *);
38eb4a29 MT	141
38eb4a29 MT	142	#endif