linux/include/linux/virtio_config.h
<<
>>
Prefs
   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 */
  55typedef void vq_callback_t(struct virtqueue *);
  56struct 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. */
  76void 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 */
  84static 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
 114static 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
 126static inline
 127struct 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
 139static inline
 140const 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 */
 156static inline
 157int 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
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.