[mirror_ubuntu-bionic-kernel.git] / include / linux / virtio_config.h

#ifndef _LINUX_VIRTIO_CONFIG_H
#define _LINUX_VIRTIO_CONFIG_H
/* This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so
 * anyone can use the definitions to implement compatible drivers/servers.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of IBM nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE. */

/* Virtio devices use a standardized configuration space to define their
 * features and pass configuration information, but each implementation can
 * store and access that space differently. */
#include <linux/types.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

/* Some virtio feature bits (currently bits 28 through 31) are reserved for the
 * transport being used (eg. virtio_ring), the rest are per-device feature
 * bits. */
#define VIRTIO_TRANSPORT_F_START	28
#define VIRTIO_TRANSPORT_F_END		32

/* Do we get callbacks when the ring is completely used, even if we've
 * suppressed them? */
#define VIRTIO_F_NOTIFY_ON_EMPTY	24

#ifdef __KERNEL__
#include <linux/err.h>
#include <linux/virtio.h>

/**
 * virtio_config_ops - operations for configuring a virtio device
 * @get: read the value of a configuration field
 *	vdev: the virtio_device
 *	offset: the offset of the configuration field
 *	buf: the buffer to write the field value into.
 *	len: the length of the buffer
 * @set: write the value of a configuration field
 *	vdev: the virtio_device
 *	offset: the offset of the configuration field
 *	buf: the buffer to read the field value from.
 *	len: the length of the buffer
 * @get_status: read the status byte
 *	vdev: the virtio_device
 *	Returns the status byte
 * @set_status: write the status byte
 *	vdev: the virtio_device
 *	status: the new status byte
 * @request_vqs: request the specified number of virtqueues
 *	vdev: the virtio_device
 *	max_vqs: the max number of virtqueues we want
 *      If supplied, must call before any virtqueues are instantiated.
 *      To modify the max number of virtqueues after request_vqs has been
 *      called, call free_vqs and then request_vqs with a new value.
 * @free_vqs: cleanup resources allocated by request_vqs
 *	vdev: the virtio_device
 *      If supplied, must call after all virtqueues have been deleted.
 * @reset: reset the device
 *	vdev: the virtio device
 *	After this, status and feature negotiation must be done again
 * @find_vqs: find virtqueues and instantiate them.
 *	vdev: the virtio_device
 *	nvqs: the number of virtqueues to find
 *	vqs: on success, includes new virtqueues
 *	callbacks: array of callbacks, for each virtqueue
 *	names: array of virtqueue names (mainly for debugging)
 *	Returns 0 on success or error status
 * @del_vqs: free virtqueues found by find_vqs().
 * @get_features: get the array of feature bits for this device.
 *	vdev: the virtio_device
 *	Returns the first 32 feature bits (all we currently need).
 * @finalize_features: confirm what device features we'll be using.
 *	vdev: the virtio_device
 *	This gives the final feature bits for the device: it can change
 *	the dev->feature bits if it wants.
 */
typedef void vq_callback_t(struct virtqueue *);
struct virtio_config_ops {
	void (*get)(struct virtio_device *vdev, unsigned offset,
		    void *buf, unsigned len);
	void (*set)(struct virtio_device *vdev, unsigned offset,
		    const void *buf, unsigned len);
	u8 (*get_status)(struct virtio_device *vdev);
	void (*set_status)(struct virtio_device *vdev, u8 status);
	void (*reset)(struct virtio_device *vdev);
	int (*find_vqs)(struct virtio_device *, unsigned nvqs,
			struct virtqueue *vqs[],
			vq_callback_t *callbacks[],
			const char *names[]);
	void (*del_vqs)(struct virtio_device *);
	u32 (*get_features)(struct virtio_device *vdev);
	void (*finalize_features)(struct virtio_device *vdev);
};

/* If driver didn't advertise the feature, it will never appear. */
void virtio_check_driver_offered_feature(const struct virtio_device *vdev,
					 unsigned int fbit);

/**
 * virtio_has_feature - helper to determine if this device has this feature.
 * @vdev: the device
 * @fbit: the feature bit
 */
static inline bool virtio_has_feature(const struct virtio_device *vdev,
				      unsigned int fbit)
{
	/* Did you forget to fix assumptions on max features? */
	if (__builtin_constant_p(fbit))
		BUILD_BUG_ON(fbit >= 32);
	else
		BUG_ON(fbit >= 32);

	if (fbit < VIRTIO_TRANSPORT_F_START)
		virtio_check_driver_offered_feature(vdev, fbit);

	return test_bit(fbit, vdev->features);
}

/**
 * virtio_config_val - look for a feature and get a virtio config entry.
 * @vdev: the virtio device
 * @fbit: the feature bit
 * @offset: the type to search for.
 * @val: a pointer to the value to fill in.
 *
 * The return value is -ENOENT if the feature doesn't exist.  Otherwise
 * the config value is copied into whatever is pointed to by v. */
#define virtio_config_val(vdev, fbit, offset, v) \
	virtio_config_buf((vdev), (fbit), (offset), (v), sizeof(*v))

#define virtio_config_val_len(vdev, fbit, offset, v, len) \
	virtio_config_buf((vdev), (fbit), (offset), (v), (len))

static inline int virtio_config_buf(struct virtio_device *vdev,
				    unsigned int fbit,
				    unsigned int offset,
				    void *buf, unsigned len)
{
	if (!virtio_has_feature(vdev, fbit))
		return -ENOENT;

	vdev->config->get(vdev, offset, buf, len);
	return 0;
}

static inline
struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev,
					vq_callback_t *c, const char *n)
{
	vq_callback_t *callbacks[] = { c };
	const char *names[] = { n };
	struct virtqueue *vq;
	int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names);
	if (err < 0)
		return ERR_PTR(err);
	return vq;
}
#endif /* __KERNEL__ */
#endif /* _LINUX_VIRTIO_CONFIG_H */
Commit	Line	Data
ec3d41c4 RR	1	#ifndef _LINUX_VIRTIO_CONFIG_H
ec3d41c4 RR	2	#define _LINUX_VIRTIO_CONFIG_H
674bfc23	3	/* This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so
a1b38387 RR	4	* anyone can use the definitions to implement compatible drivers/servers.
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions
	8	* are met:
	9	* 1. Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* 2. Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* 3. Neither the name of IBM nor the names of its contributors
	15	* may be used to endorse or promote products derived from this software
	16	* without specific prior written permission.
	17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
	18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	20	* ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
	21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	27	* SUCH DAMAGE. */
674bfc23	28
ec3d41c4 RR	29	/* Virtio devices use a standardized configuration space to define their
	30	* features and pass configuration information, but each implementation can
	31	* store and access that space differently. */
	32	#include <linux/types.h>
	33
a586d4f6	34	/* Status byte for guest to report progress, and synchronize features. */
ec3d41c4 RR	35	/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
	36	#define VIRTIO_CONFIG_S_ACKNOWLEDGE 1
	37	/* We have found a driver for the device. */
	38	#define VIRTIO_CONFIG_S_DRIVER 2
	39	/* Driver has used its parts of the config, and is happy */
	40	#define VIRTIO_CONFIG_S_DRIVER_OK 4
	41	/* We've given up on this device. */
	42	#define VIRTIO_CONFIG_S_FAILED 0x80
	43
dd7c7bc4 RR	44	/* Some virtio feature bits (currently bits 28 through 31) are reserved for the
	45	* transport being used (eg. virtio_ring), the rest are per-device feature
	46	* bits. */
	47	#define VIRTIO_TRANSPORT_F_START 28
	48	#define VIRTIO_TRANSPORT_F_END 32
	49
b4f68be6 RR	50	/* Do we get callbacks when the ring is completely used, even if we've
	51	* suppressed them? */
	52	#define VIRTIO_F_NOTIFY_ON_EMPTY 24
	53
ec3d41c4	54	#ifdef __KERNEL__
d2a7ddda	55	#include <linux/err.h>
72e61eb4	56	#include <linux/virtio.h>
ec3d41c4 RR	57
	58	/**
	59	* virtio_config_ops - operations for configuring a virtio device
a586d4f6	60	* @get: read the value of a configuration field
ec3d41c4	61	* vdev: the virtio_device
a586d4f6	62	* offset: the offset of the configuration field
ec3d41c4	63	* buf: the buffer to write the field value into.
a586d4f6	64	* len: the length of the buffer
a586d4f6	65	* @set: write the value of a configuration field
ec3d41c4	66	* vdev: the virtio_device
a586d4f6	67	* offset: the offset of the configuration field
ec3d41c4	68	* buf: the buffer to read the field value from.
a586d4f6	69	* len: the length of the buffer
ec3d41c4 RR	70	* @get_status: read the status byte
	71	* vdev: the virtio_device
	72	* Returns the status byte
	73	* @set_status: write the status byte
	74	* vdev: the virtio_device
	75	* status: the new status byte
d2a7ddda MT	76	* @request_vqs: request the specified number of virtqueues
	77	* vdev: the virtio_device
	78	* max_vqs: the max number of virtqueues we want
	79	* If supplied, must call before any virtqueues are instantiated.
	80	* To modify the max number of virtqueues after request_vqs has been
	81	* called, call free_vqs and then request_vqs with a new value.
	82	* @free_vqs: cleanup resources allocated by request_vqs
	83	* vdev: the virtio_device
	84	* If supplied, must call after all virtqueues have been deleted.
6e5aa7ef RR	85	* @reset: reset the device
	86	* vdev: the virtio device
	87	* After this, status and feature negotiation must be done again
d2a7ddda	88	* @find_vqs: find virtqueues and instantiate them.
ec3d41c4	89	* vdev: the virtio_device
d2a7ddda MT	90	* nvqs: the number of virtqueues to find
	91	* vqs: on success, includes new virtqueues
	92	* callbacks: array of callbacks, for each virtqueue
	93	* names: array of virtqueue names (mainly for debugging)
	94	* Returns 0 on success or error status
	95	* @del_vqs: free virtqueues found by find_vqs().
c45a6816 RR	96	* @get_features: get the array of feature bits for this device.
	97	* vdev: the virtio_device
	98	* Returns the first 32 feature bits (all we currently need).
c624896e	99	* @finalize_features: confirm what device features we'll be using.
c45a6816	100	* vdev: the virtio_device
c624896e RR	101	* This gives the final feature bits for the device: it can change
c624896e RR	102	* the dev->feature bits if it wants.
ec3d41c4	103	*/
d2a7ddda	104	typedef void vq_callback_t(struct virtqueue *);
1842f23c	105	struct virtio_config_ops {
a586d4f6	106	void (get)(struct virtio_device vdev, unsigned offset,
ec3d41c4	107	void *buf, unsigned len);
a586d4f6	108	void (set)(struct virtio_device vdev, unsigned offset,
ec3d41c4 RR	109	const void *buf, unsigned len);
	110	u8 (get_status)(struct virtio_device vdev);
	111	void (set_status)(struct virtio_device vdev, u8 status);
6e5aa7ef	112	void (reset)(struct virtio_device vdev);
d2a7ddda MT	113	int (find_vqs)(struct virtio_device , unsigned nvqs,
	114	struct virtqueue *vqs[],
	115	vq_callback_t *callbacks[],
	116	const char *names[]);
	117	void (del_vqs)(struct virtio_device );
c45a6816	118	u32 (get_features)(struct virtio_device vdev);
c624896e	119	void (finalize_features)(struct virtio_device vdev);
ec3d41c4 RR	120	};
ec3d41c4 RR	121
c45a6816 RR	122	/* If driver didn't advertise the feature, it will never appear. */
	123	void virtio_check_driver_offered_feature(const struct virtio_device *vdev,
	124	unsigned int fbit);
	125
	126	/**
	127	* virtio_has_feature - helper to determine if this device has this feature.
	128	* @vdev: the device
	129	* @fbit: the feature bit
	130	*/
	131	static inline bool virtio_has_feature(const struct virtio_device *vdev,
	132	unsigned int fbit)
	133	{
	134	/* Did you forget to fix assumptions on max features? */
1765e3a4 RR	135	if (__builtin_constant_p(fbit))
	136	BUILD_BUG_ON(fbit >= 32);
	137	else
	138	BUG_ON(fbit >= 32);
c45a6816	139
ee006b35 MM	140	if (fbit < VIRTIO_TRANSPORT_F_START)
	141	virtio_check_driver_offered_feature(vdev, fbit);
	142
c45a6816 RR	143	return test_bit(fbit, vdev->features);
	144	}
	145
ec3d41c4	146	/**
72e61eb4	147	* virtio_config_val - look for a feature and get a virtio config entry.
a586d4f6 RR	148	* @vdev: the virtio device
	149	* @fbit: the feature bit
	150	* @offset: the type to search for.
ec3d41c4 RR	151	* @val: a pointer to the value to fill in.
ec3d41c4 RR	152	*
a586d4f6	153	* The return value is -ENOENT if the feature doesn't exist. Otherwise
72e61eb4 RR	154	* the config value is copied into whatever is pointed to by v. */
72e61eb4 RR	155	#define virtio_config_val(vdev, fbit, offset, v) \
7f31fe05	156	virtio_config_buf((vdev), (fbit), (offset), (v), sizeof(*v))
ec3d41c4	157
3ead6f4d SL	158	#define virtio_config_val_len(vdev, fbit, offset, v, len) \
	159	virtio_config_buf((vdev), (fbit), (offset), (v), (len))
	160
72e61eb4 RR	161	static inline int virtio_config_buf(struct virtio_device *vdev,
	162	unsigned int fbit,
	163	unsigned int offset,
	164	void *buf, unsigned len)
	165	{
c45a6816	166	if (!virtio_has_feature(vdev, fbit))
72e61eb4 RR	167	return -ENOENT;
	168
	169	vdev->config->get(vdev, offset, buf, len);
	170	return 0;
	171	}
d2a7ddda MT	172
	173	static inline
	174	struct virtqueue virtio_find_single_vq(struct virtio_device vdev,
	175	vq_callback_t c, const char n)
	176	{
	177	vq_callback_t *callbacks[] = { c };
	178	const char *names[] = { n };
	179	struct virtqueue *vq;
	180	int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names);
	181	if (err < 0)
	182	return ERR_PTR(err);
	183	return vq;
	184	}
ec3d41c4 RR	185	#endif /* __KERNEL__ */
ec3d41c4 RR	186	#endif /* _LINUX_VIRTIO_CONFIG_H */