1 #ifndef _LINUX_VIRTIO_CONFIG_H 2 #define _LINUX_VIRTIO_CONFIG_H 3 /* This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so 4 * anyone can use the definitions to implement compatible drivers/servers. */ 5 6 /* Virtio devices use a standardized configuration space to define their 7 * features and pass configuration information, but each implementation can 8 * store and access that space differently. */ 9 #include <linux/types.h> 10 11 /* Status byte for guest to report progress, and synchronize features. */ 12 /* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */ 13 #define VIRTIO_CONFIG_S_ACKNOWLEDGE 1 14 /* We have found a driver for the device. */ 15 #define VIRTIO_CONFIG_S_DRIVER 2 16 /* Driver has used its parts of the config, and is happy */ 17 #define VIRTIO_CONFIG_S_DRIVER_OK 4 18 /* We've given up on this device. */ 19 #define VIRTIO_CONFIG_S_FAILED 0x80 20 21 /* Some virtio feature bits (currently bits 28 through 31) are reserved for the 22 * transport being used (eg. virtio_ring), the rest are per-device feature 23 * bits. */ 24 #define VIRTIO_TRANSPORT_F_START 28 25 #define VIRTIO_TRANSPORT_F_END 32 26 27 /* Do we get callbacks when the ring is completely used, even if we've 28 * suppressed them? */ 29 #define VIRTIO_F_NOTIFY_ON_EMPTY 24 30 31 #ifdef __KERNEL__ 32 #include <linux/virtio.h> 33 34 /** 35 * virtio_config_ops - operations for configuring a virtio device 36 * @get: read the value of a configuration field 37 * vdev: the virtio_device 38 * offset: the offset of the configuration field 39 * buf: the buffer to write the field value into. 40 * len: the length of the buffer 41 * @set: write the value of a configuration field 42 * vdev: the virtio_device 43 * offset: the offset of the configuration field 44 * buf: the buffer to read the field value from. 45 * len: the length of the buffer 46 * @get_status: read the status byte 47 * vdev: the virtio_device 48 * Returns the status byte 49 * @set_status: write the status byte 50 * vdev: the virtio_device 51 * status: the new status byte 52 * @reset: reset the device 53 * vdev: the virtio device 54 * After this, status and feature negotiation must be done again 55 * @find_vq: find a virtqueue and instantiate it. 56 * vdev: the virtio_device 57 * index: the 0-based virtqueue number in case there's more than one. 58 * callback: the virqtueue callback 59 * Returns the new virtqueue or ERR_PTR() (eg. -ENOENT). 60 * @del_vq: free a virtqueue found by find_vq(). 61 * @get_features: get the array of feature bits for this device. 62 * vdev: the virtio_device 63 * Returns the first 32 feature bits (all we currently need). 64 * @finalize_features: confirm what device features we'll be using. 65 * vdev: the virtio_device 66 * This gives the final feature bits for the device: it can change 67 * the dev->feature bits if it wants. 68 */ 69 struct virtio_config_ops 70 { 71 void (*get)(struct virtio_device *vdev, unsigned offset, 72 void *buf, unsigned len); 73 void (*set)(struct virtio_device *vdev, unsigned offset, 74 const void *buf, unsigned len); 75 u8 (*get_status)(struct virtio_device *vdev); 76 void (*set_status)(struct virtio_device *vdev, u8 status); 77 void (*reset)(struct virtio_device *vdev); 78 struct virtqueue *(*find_vq)(struct virtio_device *vdev, 79 unsigned index, 80 void (*callback)(struct virtqueue *)); 81 void (*del_vq)(struct virtqueue *vq); 82 u32 (*get_features)(struct virtio_device *vdev); 83 void (*finalize_features)(struct virtio_device *vdev); 84 }; 85 86 /* If driver didn't advertise the feature, it will never appear. */ 87 void virtio_check_driver_offered_feature(const struct virtio_device *vdev, 88 unsigned int fbit); 89 90 /** 91 * virtio_has_feature - helper to determine if this device has this feature. 92 * @vdev: the device 93 * @fbit: the feature bit 94 */ 95 static inline bool virtio_has_feature(const struct virtio_device *vdev, 96 unsigned int fbit) 97 { 98 /* Did you forget to fix assumptions on max features? */ 99 if (__builtin_constant_p(fbit)) 100 BUILD_BUG_ON(fbit >= 32); 101 102 virtio_check_driver_offered_feature(vdev, fbit); 103 return test_bit(fbit, vdev->features); 104 } 105 106 /** 107 * virtio_config_val - look for a feature and get a virtio config entry. 108 * @vdev: the virtio device 109 * @fbit: the feature bit 110 * @offset: the type to search for. 111 * @val: a pointer to the value to fill in. 112 * 113 * The return value is -ENOENT if the feature doesn't exist. Otherwise 114 * the config value is copied into whatever is pointed to by v. */ 115 #define virtio_config_val(vdev, fbit, offset, v) \ 116 virtio_config_buf((vdev), (fbit), (offset), (v), sizeof(*v)) 117 118 static inline int virtio_config_buf(struct virtio_device *vdev, 119 unsigned int fbit, 120 unsigned int offset, 121 void *buf, unsigned len) 122 { 123 if (!virtio_has_feature(vdev, fbit)) 124 return -ENOENT; 125 126 vdev->config->get(vdev, offset, buf, len); 127 return 0; 128 } 129 #endif /* __KERNEL__ */ 130 #endif /* _LINUX_VIRTIO_CONFIG_H */ 131