virtio.h 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. #ifndef _LINUX_VIRTIO_H
  3. #define _LINUX_VIRTIO_H
  4. /* Everything a virtio driver needs to work with any particular virtio
  5. * implementation. */
  6. #include <linux/types.h>
  7. #include <linux/scatterlist.h>
  8. #include <linux/spinlock.h>
  9. #include <linux/device.h>
  10. #include <linux/mod_devicetable.h>
  11. #include <linux/gfp.h>
  12. /**
  13. * virtqueue - a queue to register buffers for sending or receiving.
  14. * @list: the chain of virtqueues for this device
  15. * @callback: the function to call when buffers are consumed (can be NULL).
  16. * @name: the name of this virtqueue (mainly for debugging)
  17. * @vdev: the virtio device this queue was created for.
  18. * @priv: a pointer for the virtqueue implementation to use.
  19. * @index: the zero-based ordinal number for this queue.
  20. * @num_free: number of elements we expect to be able to fit.
  21. *
  22. * A note on @num_free: with indirect buffers, each buffer needs one
  23. * element in the queue, otherwise a buffer will need one element per
  24. * sg element.
  25. */
  26. struct virtqueue {
  27. struct list_head list;
  28. void (*callback)(struct virtqueue *vq);
  29. const char *name;
  30. struct virtio_device *vdev;
  31. unsigned int index;
  32. unsigned int num_free;
  33. void *priv;
  34. };
  35. int virtqueue_add_outbuf(struct virtqueue *vq,
  36. struct scatterlist sg[], unsigned int num,
  37. void *data,
  38. gfp_t gfp);
  39. int virtqueue_add_inbuf(struct virtqueue *vq,
  40. struct scatterlist sg[], unsigned int num,
  41. void *data,
  42. gfp_t gfp);
  43. int virtqueue_add_inbuf_ctx(struct virtqueue *vq,
  44. struct scatterlist sg[], unsigned int num,
  45. void *data,
  46. void *ctx,
  47. gfp_t gfp);
  48. int virtqueue_add_sgs(struct virtqueue *vq,
  49. struct scatterlist *sgs[],
  50. unsigned int out_sgs,
  51. unsigned int in_sgs,
  52. void *data,
  53. gfp_t gfp);
  54. bool virtqueue_kick(struct virtqueue *vq);
  55. bool virtqueue_kick_prepare(struct virtqueue *vq);
  56. bool virtqueue_notify(struct virtqueue *vq);
  57. void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len);
  58. void *virtqueue_get_buf_ctx(struct virtqueue *vq, unsigned int *len,
  59. void **ctx);
  60. void virtqueue_disable_cb(struct virtqueue *vq);
  61. bool virtqueue_enable_cb(struct virtqueue *vq);
  62. unsigned virtqueue_enable_cb_prepare(struct virtqueue *vq);
  63. bool virtqueue_poll(struct virtqueue *vq, unsigned);
  64. bool virtqueue_enable_cb_delayed(struct virtqueue *vq);
  65. void *virtqueue_detach_unused_buf(struct virtqueue *vq);
  66. unsigned int virtqueue_get_vring_size(struct virtqueue *vq);
  67. bool virtqueue_is_broken(struct virtqueue *vq);
  68. const struct vring *virtqueue_get_vring(struct virtqueue *vq);
  69. dma_addr_t virtqueue_get_desc_addr(struct virtqueue *vq);
  70. dma_addr_t virtqueue_get_avail_addr(struct virtqueue *vq);
  71. dma_addr_t virtqueue_get_used_addr(struct virtqueue *vq);
  72. /**
  73. * virtio_device - representation of a device using virtio
  74. * @index: unique position on the virtio bus
  75. * @failed: saved value for VIRTIO_CONFIG_S_FAILED bit (for restore)
  76. * @config_enabled: configuration change reporting enabled
  77. * @config_change_pending: configuration change reported while disabled
  78. * @config_lock: protects configuration change reporting
  79. * @dev: underlying device.
  80. * @id: the device type identification (used to match it with a driver).
  81. * @config: the configuration ops for this device.
  82. * @vringh_config: configuration ops for host vrings.
  83. * @vqs: the list of virtqueues for this device.
  84. * @features: the features supported by both driver and device.
  85. * @priv: private pointer for the driver's use.
  86. */
  87. struct virtio_device {
  88. int index;
  89. bool failed;
  90. bool config_enabled;
  91. bool config_change_pending;
  92. spinlock_t config_lock;
  93. struct device dev;
  94. struct virtio_device_id id;
  95. const struct virtio_config_ops *config;
  96. const struct vringh_config_ops *vringh_config;
  97. struct list_head vqs;
  98. u64 features;
  99. void *priv;
  100. };
  101. static inline struct virtio_device *dev_to_virtio(struct device *_dev)
  102. {
  103. return container_of(_dev, struct virtio_device, dev);
  104. }
  105. void virtio_add_status(struct virtio_device *dev, unsigned int status);
  106. int register_virtio_device(struct virtio_device *dev);
  107. void unregister_virtio_device(struct virtio_device *dev);
  108. bool is_virtio_device(struct device *dev);
  109. void virtio_break_device(struct virtio_device *dev);
  110. void virtio_config_changed(struct virtio_device *dev);
  111. void virtio_config_disable(struct virtio_device *dev);
  112. void virtio_config_enable(struct virtio_device *dev);
  113. #ifdef CONFIG_PM_SLEEP
  114. int virtio_device_freeze(struct virtio_device *dev);
  115. int virtio_device_restore(struct virtio_device *dev);
  116. #endif
  117. size_t virtio_max_dma_size(struct virtio_device *vdev);
  118. #define virtio_device_for_each_vq(vdev, vq) \
  119. list_for_each_entry(vq, &vdev->vqs, list)
  120. /**
  121. * virtio_driver - operations for a virtio I/O driver
  122. * @driver: underlying device driver (populate name and owner).
  123. * @id_table: the ids serviced by this driver.
  124. * @feature_table: an array of feature numbers supported by this driver.
  125. * @feature_table_size: number of entries in the feature table array.
  126. * @feature_table_legacy: same as feature_table but when working in legacy mode.
  127. * @feature_table_size_legacy: number of entries in feature table legacy array.
  128. * @probe: the function to call when a device is found. Returns 0 or -errno.
  129. * @scan: optional function to call after successful probe; intended
  130. * for virtio-scsi to invoke a scan.
  131. * @remove: the function to call when a device is removed.
  132. * @config_changed: optional function to call when the device configuration
  133. * changes; may be called in interrupt context.
  134. * @freeze: optional function to call during suspend/hibernation.
  135. * @restore: optional function to call on resume.
  136. */
  137. struct virtio_driver {
  138. struct device_driver driver;
  139. const struct virtio_device_id *id_table;
  140. const unsigned int *feature_table;
  141. unsigned int feature_table_size;
  142. const unsigned int *feature_table_legacy;
  143. unsigned int feature_table_size_legacy;
  144. int (*validate)(struct virtio_device *dev);
  145. int (*probe)(struct virtio_device *dev);
  146. void (*scan)(struct virtio_device *dev);
  147. void (*remove)(struct virtio_device *dev);
  148. void (*config_changed)(struct virtio_device *dev);
  149. #ifdef CONFIG_PM
  150. int (*freeze)(struct virtio_device *dev);
  151. int (*restore)(struct virtio_device *dev);
  152. #endif
  153. };
  154. static inline struct virtio_driver *drv_to_virtio(struct device_driver *drv)
  155. {
  156. return container_of(drv, struct virtio_driver, driver);
  157. }
  158. int register_virtio_driver(struct virtio_driver *drv);
  159. void unregister_virtio_driver(struct virtio_driver *drv);
  160. /* module_virtio_driver() - Helper macro for drivers that don't do
  161. * anything special in module init/exit. This eliminates a lot of
  162. * boilerplate. Each module may only use this macro once, and
  163. * calling it replaces module_init() and module_exit()
  164. */
  165. #define module_virtio_driver(__virtio_driver) \
  166. module_driver(__virtio_driver, register_virtio_driver, \
  167. unregister_virtio_driver)
  168. #endif /* _LINUX_VIRTIO_H */