Check that bus freq is not zero
[akaros.git] / user / vmm / include / vmm / virtio.h
1 #pragma once
2
3 #include <ros/arch/membar.h>
4 #include <ros/arch/mmu.h>
5 #include <ros/virtio_ring.h>
6 #include <ros/common.h>
7
8 #include <stddef.h>
9 #include <stdbool.h>
10
11 /* this is just an iov but we're going to keep the type for now, in case
12  * we want it at some point.
13  */
14 struct scatterlist {
15         void *v;
16         int length;
17 };
18
19 #define unlikely(x) (x)
20 #define virtio_rmb(x) rmb()
21 #define virtio_wmb(x) wmb()
22 #define virtio_mb(x) mb()
23
24 #define sg_phys(x) ((uintptr_t)x)
25 #define virt_to_phys(x) ((uintptr_t)x)
26
27 struct virtqueue *vring_new_virtqueue(unsigned int index,
28                                       unsigned int num,
29                                       unsigned int vring_align,
30                                       bool weak_barriers,
31                                       void *pages,
32                                       bool (*notify)(struct virtqueue *),
33                                       void (*callback)(struct virtqueue *),
34                                       const char *name);
35
36 int virtqueue_add_outbuf_avail(struct virtqueue *vq,
37                          struct scatterlist sg[], unsigned int num,
38                          void *data,
39                                int opts); // Opts only used in kernel functions.
40 unsigned int virtqueue_get_vring_size(struct virtqueue *_vq);
41 void *virtqueue_get_buf_used(struct virtqueue *_vq, unsigned int *len);
42 int virtqueue_add_inbuf_avail(struct virtqueue *vq,
43                         struct scatterlist sg[], unsigned int num,
44                               void *data, int opts);
45
46 /* linux-isms we may or may not ever care about. */
47 #define __user
48 #define __force
49 #define __cold
50
51 int avail(struct virtqueue *_vq);
52 void showvq(struct virtqueue *_vq);
53 void showdesc(struct virtqueue *_vq, uint16_t head);
54 int virtio_get_buf_avail_start(struct virtqueue *_vq, uint16_t *last_avail_idx, struct scatterlist **sgp, int *sgplen);
55 void virtio_get_buf_avail_done(struct virtqueue *_vq, uint16_t last_avail_idx, int id, int len);
56 void showscatterlist(struct scatterlist *sg, int num);
57
58 unsigned int wait_for_vq_desc(struct virtqueue *vq,
59                                  struct scatterlist iov[],
60                                  unsigned int *out_num, unsigned int *in_num);
61 void add_used(struct virtqueue *vq, unsigned int head, int len);
62
63 /**
64  * virtqueue - a queue to register buffers for sending or receiving.
65  * @list: the chain of virtqueues for this device
66  * @callback: the function to call when buffers are consumed (can be NULL).
67  * @name: the name of this virtqueue (mainly for debugging)
68  * @vdev: the virtio device this queue was created for.
69  * @priv: a pointer for the virtqueue implementation to use.
70  * @index: the zero-based ordinal number for this queue.
71  * @num_free: number of elements we expect to be able to fit.
72  *
73  * A note on @num_free: with indirect buffers, each buffer needs one
74  * element in the queue, otherwise a buffer will need one element per
75  * sg element.
76  */
77 struct virtqueue {
78         void (*callback)(struct virtqueue *vq);
79         const char *name;
80         unsigned int index;
81         unsigned int num_free;
82         void *priv;
83 };
84
85 int virtqueue_add_outbuf(struct virtqueue *vq,
86                          struct scatterlist sg[], unsigned int num,
87                          void *data,
88                          int flags);
89
90 int virtqueue_add_inbuf(struct virtqueue *vq,
91                         struct scatterlist sg[], unsigned int num,
92                         void *data,
93                         int flags);
94
95 int virtqueue_add_sgs(struct virtqueue *vq,
96                       struct scatterlist *sgs[],
97                       unsigned int out_sgs,
98                       unsigned int in_sgs,
99                       void *data,
100                       int flags);
101
102 bool virtqueue_kick(struct virtqueue *vq);
103
104 bool virtqueue_kick_prepare(struct virtqueue *vq);
105
106 bool virtqueue_notify(struct virtqueue *vq);
107
108 void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len);
109
110 void virtqueue_disable_cb(struct virtqueue *vq);
111
112 bool virtqueue_enable_cb(struct virtqueue *vq);
113
114 unsigned virtqueue_enable_cb_prepare(struct virtqueue *vq);
115
116 bool virtqueue_poll(struct virtqueue *vq, unsigned);
117
118 bool virtqueue_enable_cb_delayed(struct virtqueue *vq);
119
120 void *virtqueue_detach_unused_buf(struct virtqueue *vq);
121
122 unsigned int virtqueue_get_vring_size(struct virtqueue *vq);
123
124 bool virtqueue_is_broken(struct virtqueue *vq);
125 void virtqueue_close(struct virtqueue *vq);
126
127 static inline uint32_t read32(const volatile void *addr)
128 {
129         return *(const volatile uint32_t *)addr;
130 }
131
132 static inline void write32(volatile void *addr, uint32_t value)
133 {
134         *(volatile uint32_t *)addr = value;
135 }