You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
105 lines
3.4 KiB
105 lines
3.4 KiB
#ifndef _LINUX_VIRTIO_H |
|
#define _LINUX_VIRTIO_H |
|
/* Everything a virtio driver needs to work with any particular virtio |
|
* implementation. */ |
|
#include <linux/types.h> |
|
#include <linux/scatterlist.h> |
|
#include <linux/spinlock.h> |
|
#include <linux/device.h> |
|
#include <linux/mod_devicetable.h> |
|
#include <linux/gfp.h> |
|
|
|
/** |
|
* virtqueue - a queue to register buffers for sending or receiving. |
|
* @list: the chain of virtqueues for this device |
|
* @callback: the function to call when buffers are consumed (can be NULL). |
|
* @name: the name of this virtqueue (mainly for debugging) |
|
* @vdev: the virtio device this queue was created for. |
|
* @priv: a pointer for the virtqueue implementation to use. |
|
*/ |
|
struct virtqueue { |
|
struct list_head list; |
|
void (*callback)(struct virtqueue *vq); |
|
const char *name; |
|
struct virtio_device *vdev; |
|
void *priv; |
|
}; |
|
|
|
int virtqueue_add_buf(struct virtqueue *vq, |
|
struct scatterlist sg[], |
|
unsigned int out_num, |
|
unsigned int in_num, |
|
void *data, |
|
gfp_t gfp); |
|
|
|
void virtqueue_kick(struct virtqueue *vq); |
|
|
|
bool virtqueue_kick_prepare(struct virtqueue *vq); |
|
|
|
void virtqueue_notify(struct virtqueue *vq); |
|
|
|
void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len); |
|
|
|
void virtqueue_disable_cb(struct virtqueue *vq); |
|
|
|
bool virtqueue_enable_cb(struct virtqueue *vq); |
|
|
|
bool virtqueue_enable_cb_delayed(struct virtqueue *vq); |
|
|
|
void *virtqueue_detach_unused_buf(struct virtqueue *vq); |
|
|
|
unsigned int virtqueue_get_vring_size(struct virtqueue *vq); |
|
|
|
/** |
|
* virtio_device - representation of a device using virtio |
|
* @index: unique position on the virtio bus |
|
* @dev: underlying device. |
|
* @id: the device type identification (used to match it with a driver). |
|
* @config: the configuration ops for this device. |
|
* @vqs: the list of virtqueues for this device. |
|
* @features: the features supported by both driver and device. |
|
* @priv: private pointer for the driver's use. |
|
*/ |
|
struct virtio_device { |
|
int index; |
|
struct device dev; |
|
struct virtio_device_id id; |
|
struct virtio_config_ops *config; |
|
struct list_head vqs; |
|
/* Note that this is a Linux set_bit-style bitmap. */ |
|
unsigned long features[1]; |
|
void *priv; |
|
}; |
|
|
|
#define dev_to_virtio(dev) container_of(dev, struct virtio_device, dev) |
|
int register_virtio_device(struct virtio_device *dev); |
|
void unregister_virtio_device(struct virtio_device *dev); |
|
|
|
/** |
|
* virtio_driver - operations for a virtio I/O driver |
|
* @driver: underlying device driver (populate name and owner). |
|
* @id_table: the ids serviced by this driver. |
|
* @feature_table: an array of feature numbers supported by this driver. |
|
* @feature_table_size: number of entries in the feature table array. |
|
* @probe: the function to call when a device is found. Returns 0 or -errno. |
|
* @remove: the function to call when a device is removed. |
|
* @config_changed: optional function to call when the device configuration |
|
* changes; may be called in interrupt context. |
|
*/ |
|
struct virtio_driver { |
|
struct device_driver driver; |
|
const struct virtio_device_id *id_table; |
|
const unsigned int *feature_table; |
|
unsigned int feature_table_size; |
|
int (*probe)(struct virtio_device *dev); |
|
void (*remove)(struct virtio_device *dev); |
|
void (*config_changed)(struct virtio_device *dev); |
|
#ifdef CONFIG_PM |
|
int (*freeze)(struct virtio_device *dev); |
|
int (*restore)(struct virtio_device *dev); |
|
#endif |
|
}; |
|
|
|
int register_virtio_driver(struct virtio_driver *drv); |
|
void unregister_virtio_driver(struct virtio_driver *drv); |
|
#endif /* _LINUX_VIRTIO_H */
|
|
|