1 #ifndef _LINUX_VIRTIO_CONFIG_H 2 #define _LINUX_VIRTIO_CONFIG_H 3 4 #include <linux/err.h> 5 #include <linux/bug.h> 6 #include <linux/virtio.h> 7 #include <uapi/linux/virtio_config.h> 8 9 /** 10 * virtio_config_ops - operations for configuring a virtio device 11 * @get: read the value of a configuration field 12 * vdev: the virtio_device 13 * offset: the offset of the configuration field 14 * buf: the buffer to write the field value into. 15 * len: the length of the buffer 16 * @set: write the value of a configuration field 17 * vdev: the virtio_device 18 * offset: the offset of the configuration field 19 * buf: the buffer to read the field value from. 20 * len: the length of the buffer 21 * @get_status: read the status byte 22 * vdev: the virtio_device 23 * Returns the status byte 24 * @set_status: write the status byte 25 * vdev: the virtio_device 26 * status: the new status byte 27 * @reset: reset the device 28 * vdev: the virtio device 29 * After this, status and feature negotiation must be done again 30 * Device must not be reset from its vq/config callbacks, or in 31 * parallel with being added/removed. 32 * @find_vqs: find virtqueues and instantiate them. 33 * vdev: the virtio_device 34 * nvqs: the number of virtqueues to find 35 * vqs: on success, includes new virtqueues 36 * callbacks: array of callbacks, for each virtqueue 37 * include a NULL entry for vqs that do not need a callback 38 * names: array of virtqueue names (mainly for debugging) 39 * include a NULL entry for vqs unused by driver 40 * Returns 0 on success or error status 41 * @del_vqs: free virtqueues found by find_vqs(). 42 * @get_features: get the array of feature bits for this device. 43 * vdev: the virtio_device 44 * Returns the first 32 feature bits (all we currently need). 45 * @finalize_features: confirm what device features we'll be using. 46 * vdev: the virtio_device 47 * This gives the final feature bits for the device: it can change 48 * the dev->feature bits if it wants. 49 * @bus_name: return the bus name associated with the device 50 * vdev: the virtio_device 51 * This returns a pointer to the bus name a la pci_name from which 52 * the caller can then copy. 53 * @set_vq_affinity: set the affinity for a virtqueue. 54 */ 55 typedef void vq_callback_t(struct virtqueue *); 56 struct virtio_config_ops { 57 void (*get)(struct virtio_device *vdev, unsigned offset, 58 void *buf, unsigned len); 59 void (*set)(struct virtio_device *vdev, unsigned offset, 60 const void *buf, unsigned len); 61 u8 (*get_status)(struct virtio_device *vdev); 62 void (*set_status)(struct virtio_device *vdev, u8 status); 63 void (*reset)(struct virtio_device *vdev); 64 int (*find_vqs)(struct virtio_device *, unsigned nvqs, 65 struct virtqueue *vqs[], 66 vq_callback_t *callbacks[], 67 const char *names[]); 68 void (*del_vqs)(struct virtio_device *); 69 u32 (*get_features)(struct virtio_device *vdev); 70 void (*finalize_features)(struct virtio_device *vdev); 71 const char *(*bus_name)(struct virtio_device *vdev); 72 int (*set_vq_affinity)(struct virtqueue *vq, int cpu); 73 }; 74 75 /* If driver didn't advertise the feature, it will never appear. */ 76 void virtio_check_driver_offered_feature(const struct virtio_device *vdev, 77 unsigned int fbit); 78 79 /** 80 * virtio_has_feature - helper to determine if this device has this feature. 81 * @vdev: the device 82 * @fbit: the feature bit 83 */ 84 static inline bool virtio_has_feature(const struct virtio_device *vdev, 85 unsigned int fbit) 86 { 87 /* Did you forget to fix assumptions on max features? */ 88 if (__builtin_constant_p(fbit)) 89 BUILD_BUG_ON(fbit >= 32); 90 else 91 BUG_ON(fbit >= 32); 92 93 if (fbit < VIRTIO_TRANSPORT_F_START) 94 virtio_check_driver_offered_feature(vdev, fbit); 95 96 return test_bit(fbit, vdev->features); 97 } 98 99 /** 100 * virtio_config_val - look for a feature and get a virtio config entry. 101 * @vdev: the virtio device 102 * @fbit: the feature bit 103 * @offset: the type to search for. 104 * @v: a pointer to the value to fill in. 105 * 106 * The return value is -ENOENT if the feature doesn't exist. Otherwise 107 * the config value is copied into whatever is pointed to by v. */ 108 #define virtio_config_val(vdev, fbit, offset, v) \ 109 virtio_config_buf((vdev), (fbit), (offset), (v), sizeof(*v)) 110 111 #define virtio_config_val_len(vdev, fbit, offset, v, len) \ 112 virtio_config_buf((vdev), (fbit), (offset), (v), (len)) 113 114 static inline int virtio_config_buf(struct virtio_device *vdev, 115 unsigned int fbit, 116 unsigned int offset, 117 void *buf, unsigned len) 118 { 119 if (!virtio_has_feature(vdev, fbit)) 120 return -ENOENT; 121 122 vdev->config->get(vdev, offset, buf, len); 123 return 0; 124 } 125 126 static inline 127 struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev, 128 vq_callback_t *c, const char *n) 129 { 130 vq_callback_t *callbacks[] = { c }; 131 const char *names[] = { n }; 132 struct virtqueue *vq; 133 int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names); 134 if (err < 0) 135 return ERR_PTR(err); 136 return vq; 137 } 138 139 static inline 140 const char *virtio_bus_name(struct virtio_device *vdev) 141 { 142 if (!vdev->config->bus_name) 143 return "virtio"; 144 return vdev->config->bus_name(vdev); 145 } 146 147 /** 148 * virtqueue_set_affinity - setting affinity for a virtqueue 149 * @vq: the virtqueue 150 * @cpu: the cpu no. 151 * 152 * Pay attention the function are best-effort: the affinity hint may not be set 153 * due to config support, irq type and sharing. 154 * 155 */ 156 static inline 157 int virtqueue_set_affinity(struct virtqueue *vq, int cpu) 158 { 159 struct virtio_device *vdev = vq->vdev; 160 if (vdev->config->set_vq_affinity) 161 return vdev->config->set_vq_affinity(vq, cpu); 162 return 0; 163 } 164 165 166 #endif /* _LINUX_VIRTIO_CONFIG_H */ 167