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 static inline 100 struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev, 101 vq_callback_t *c, const char *n) 102 { 103 vq_callback_t *callbacks[] = { c }; 104 const char *names[] = { n }; 105 struct virtqueue *vq; 106 int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names); 107 if (err < 0) 108 return ERR_PTR(err); 109 return vq; 110 } 111 112 /** 113 * virtio_device_ready - enable vq use in probe function 114 * @vdev: the device 115 * 116 * Driver must call this to use vqs in the probe function. 117 * 118 * Note: vqs are enabled automatically after probe returns. 119 */ 120 static inline 121 void virtio_device_ready(struct virtio_device *dev) 122 { 123 unsigned status = dev->config->get_status(dev); 124 125 BUG_ON(status & VIRTIO_CONFIG_S_DRIVER_OK); 126 dev->config->set_status(dev, status | VIRTIO_CONFIG_S_DRIVER_OK); 127 } 128 129 static inline 130 const char *virtio_bus_name(struct virtio_device *vdev) 131 { 132 if (!vdev->config->bus_name) 133 return "virtio"; 134 return vdev->config->bus_name(vdev); 135 } 136 137 /** 138 * virtqueue_set_affinity - setting affinity for a virtqueue 139 * @vq: the virtqueue 140 * @cpu: the cpu no. 141 * 142 * Pay attention the function are best-effort: the affinity hint may not be set 143 * due to config support, irq type and sharing. 144 * 145 */ 146 static inline 147 int virtqueue_set_affinity(struct virtqueue *vq, int cpu) 148 { 149 struct virtio_device *vdev = vq->vdev; 150 if (vdev->config->set_vq_affinity) 151 return vdev->config->set_vq_affinity(vq, cpu); 152 return 0; 153 } 154 155 /* Config space accessors. */ 156 #define virtio_cread(vdev, structname, member, ptr) \ 157 do { \ 158 /* Must match the member's type, and be integer */ \ 159 if (!typecheck(typeof((((structname*)0)->member)), *(ptr))) \ 160 (*ptr) = 1; \ 161 \ 162 switch (sizeof(*ptr)) { \ 163 case 1: \ 164 *(ptr) = virtio_cread8(vdev, \ 165 offsetof(structname, member)); \ 166 break; \ 167 case 2: \ 168 *(ptr) = virtio_cread16(vdev, \ 169 offsetof(structname, member)); \ 170 break; \ 171 case 4: \ 172 *(ptr) = virtio_cread32(vdev, \ 173 offsetof(structname, member)); \ 174 break; \ 175 case 8: \ 176 *(ptr) = virtio_cread64(vdev, \ 177 offsetof(structname, member)); \ 178 break; \ 179 default: \ 180 BUG(); \ 181 } \ 182 } while(0) 183 184 /* Config space accessors. */ 185 #define virtio_cwrite(vdev, structname, member, ptr) \ 186 do { \ 187 /* Must match the member's type, and be integer */ \ 188 if (!typecheck(typeof((((structname*)0)->member)), *(ptr))) \ 189 BUG_ON((*ptr) == 1); \ 190 \ 191 switch (sizeof(*ptr)) { \ 192 case 1: \ 193 virtio_cwrite8(vdev, \ 194 offsetof(structname, member), \ 195 *(ptr)); \ 196 break; \ 197 case 2: \ 198 virtio_cwrite16(vdev, \ 199 offsetof(structname, member), \ 200 *(ptr)); \ 201 break; \ 202 case 4: \ 203 virtio_cwrite32(vdev, \ 204 offsetof(structname, member), \ 205 *(ptr)); \ 206 break; \ 207 case 8: \ 208 virtio_cwrite64(vdev, \ 209 offsetof(structname, member), \ 210 *(ptr)); \ 211 break; \ 212 default: \ 213 BUG(); \ 214 } \ 215 } while(0) 216 217 static inline u8 virtio_cread8(struct virtio_device *vdev, unsigned int offset) 218 { 219 u8 ret; 220 vdev->config->get(vdev, offset, &ret, sizeof(ret)); 221 return ret; 222 } 223 224 static inline void virtio_cread_bytes(struct virtio_device *vdev, 225 unsigned int offset, 226 void *buf, size_t len) 227 { 228 vdev->config->get(vdev, offset, buf, len); 229 } 230 231 static inline void virtio_cwrite8(struct virtio_device *vdev, 232 unsigned int offset, u8 val) 233 { 234 vdev->config->set(vdev, offset, &val, sizeof(val)); 235 } 236 237 static inline u16 virtio_cread16(struct virtio_device *vdev, 238 unsigned int offset) 239 { 240 u16 ret; 241 vdev->config->get(vdev, offset, &ret, sizeof(ret)); 242 return ret; 243 } 244 245 static inline void virtio_cwrite16(struct virtio_device *vdev, 246 unsigned int offset, u16 val) 247 { 248 vdev->config->set(vdev, offset, &val, sizeof(val)); 249 } 250 251 static inline u32 virtio_cread32(struct virtio_device *vdev, 252 unsigned int offset) 253 { 254 u32 ret; 255 vdev->config->get(vdev, offset, &ret, sizeof(ret)); 256 return ret; 257 } 258 259 static inline void virtio_cwrite32(struct virtio_device *vdev, 260 unsigned int offset, u32 val) 261 { 262 vdev->config->set(vdev, offset, &val, sizeof(val)); 263 } 264 265 static inline u64 virtio_cread64(struct virtio_device *vdev, 266 unsigned int offset) 267 { 268 u64 ret; 269 vdev->config->get(vdev, offset, &ret, sizeof(ret)); 270 return ret; 271 } 272 273 static inline void virtio_cwrite64(struct virtio_device *vdev, 274 unsigned int offset, u64 val) 275 { 276 vdev->config->set(vdev, offset, &val, sizeof(val)); 277 } 278 279 /* Conditional config space accessors. */ 280 #define virtio_cread_feature(vdev, fbit, structname, member, ptr) \ 281 ({ \ 282 int _r = 0; \ 283 if (!virtio_has_feature(vdev, fbit)) \ 284 _r = -ENOENT; \ 285 else \ 286 virtio_cread((vdev), structname, member, ptr); \ 287 _r; \ 288 }) 289 290 #endif /* _LINUX_VIRTIO_CONFIG_H */ 291