OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [include/] [linux/] [virtio_config.h] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
#ifndef _LINUX_VIRTIO_CONFIG_H
2
#define _LINUX_VIRTIO_CONFIG_H
3
/* Virtio devices use a standardized configuration space to define their
4
 * features and pass configuration information, but each implementation can
5
 * store and access that space differently. */
6
#include <linux/types.h>
7
 
8
/* Status byte for guest to report progress, and synchronize config. */
9
/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
10
#define VIRTIO_CONFIG_S_ACKNOWLEDGE     1
11
/* We have found a driver for the device. */
12
#define VIRTIO_CONFIG_S_DRIVER          2
13
/* Driver has used its parts of the config, and is happy */
14
#define VIRTIO_CONFIG_S_DRIVER_OK       4
15
/* We've given up on this device. */
16
#define VIRTIO_CONFIG_S_FAILED          0x80
17
 
18
/* Feature byte (actually 7 bits availabe): */
19
/* Requirements/features of the virtio implementation. */
20
#define VIRTIO_CONFIG_F_VIRTIO 1
21
/* Requirements/features of the virtqueue (may have more than one). */
22
#define VIRTIO_CONFIG_F_VIRTQUEUE 2
23
 
24
#ifdef __KERNEL__
25
struct virtio_device;
26
 
27
/**
28
 * virtio_config_ops - operations for configuring a virtio device
29
 * @find: search for the next configuration field of the given type.
30
 *      vdev: the virtio_device
31
 *      type: the feature type
32
 *      len: the (returned) length of the field if found.
33
 *      Returns a token if found, or NULL.  Never returnes the same field twice
34
 *      (ie. it's used up).
35
 * @get: read the value of a configuration field after find().
36
 *      vdev: the virtio_device
37
 *      token: the token returned from find().
38
 *      buf: the buffer to write the field value into.
39
 *      len: the length of the buffer (given by find()).
40
 *      Note that contents are conventionally little-endian.
41
 * @set: write the value of a configuration field after find().
42
 *      vdev: the virtio_device
43
 *      token: the token returned from find().
44
 *      buf: the buffer to read the field value from.
45
 *      len: the length of the buffer (given by find()).
46
 *      Note that contents are conventionally little-endian.
47
 * @get_status: read the status byte
48
 *      vdev: the virtio_device
49
 *      Returns the status byte
50
 * @set_status: write the status byte
51
 *      vdev: the virtio_device
52
 *      status: the new status byte
53
 * @find_vq: find the first VIRTIO_CONFIG_F_VIRTQUEUE and create a virtqueue.
54
 *      vdev: the virtio_device
55
 *      callback: the virqtueue callback
56
 *      Returns the new virtqueue or ERR_PTR().
57
 * @del_vq: free a virtqueue found by find_vq().
58
 */
59
struct virtio_config_ops
60
{
61
        void *(*find)(struct virtio_device *vdev, u8 type, unsigned *len);
62
        void (*get)(struct virtio_device *vdev, void *token,
63
                    void *buf, unsigned len);
64
        void (*set)(struct virtio_device *vdev, void *token,
65
                    const void *buf, unsigned len);
66
        u8 (*get_status)(struct virtio_device *vdev);
67
        void (*set_status)(struct virtio_device *vdev, u8 status);
68
        struct virtqueue *(*find_vq)(struct virtio_device *vdev,
69
                                     bool (*callback)(struct virtqueue *));
70
        void (*del_vq)(struct virtqueue *vq);
71
};
72
 
73
/**
74
 * virtio_config_val - get a single virtio config and mark it used.
75
 * @config: the virtio config space
76
 * @type: the type to search for.
77
 * @val: a pointer to the value to fill in.
78
 *
79
 * Once used, the config type is marked with VIRTIO_CONFIG_F_USED so it can't
80
 * be found again.  This version does endian conversion. */
81
#define virtio_config_val(vdev, type, v) ({                             \
82
        int _err = __virtio_config_val((vdev),(type),(v),sizeof(*(v))); \
83
                                                                        \
84
        BUILD_BUG_ON(sizeof(*(v)) != 1 && sizeof(*(v)) != 2             \
85
                     && sizeof(*(v)) != 4 && sizeof(*(v)) != 8);        \
86
        if (!_err) {                                                    \
87
                switch (sizeof(*(v))) {                                 \
88
                case 2: le16_to_cpus((__u16 *) v); break;               \
89
                case 4: le32_to_cpus((__u32 *) v); break;               \
90
                case 8: le64_to_cpus((__u64 *) v); break;               \
91
                }                                                       \
92
        }                                                               \
93
        _err;                                                           \
94
})
95
 
96
int __virtio_config_val(struct virtio_device *dev,
97
                        u8 type, void *val, size_t size);
98
 
99
/**
100
 * virtio_use_bit - helper to use a feature bit in a bitfield value.
101
 * @dev: the virtio device
102
 * @token: the token as returned from vdev->config->find().
103
 * @len: the length of the field.
104
 * @bitnum: the bit to test.
105
 *
106
 * If handed a NULL token, it returns false, otherwise returns bit status.
107
 * If it's one, it sets the mirroring acknowledgement bit. */
108
int virtio_use_bit(struct virtio_device *vdev,
109
                   void *token, unsigned int len, unsigned int bitnum);
110
#endif /* __KERNEL__ */
111
#endif /* _LINUX_VIRTIO_CONFIG_H */

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.