mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-11 21:36:45 +07:00
f0fe6f1150
Handle thaw, restore and freeze notifications from the PM core. Expose these to individual virtio drivers that can quiesce and resume vq operations. For drivers not implementing the thaw() method, use the restore method instead. These functions also save device-specific data so that the device can be put in pre-suspend state after resume, and disable and enable the PCI device in the freeze and resume functions, respectively. Signed-off-by: Amit Shah <amit.shah@redhat.com> Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
107 lines
3.5 KiB
C
107 lines
3.5 KiB
C
#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 (*thaw)(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 */
|