1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Randomness driver for virtio
* Copyright (C) 2007, 2008 Rusty Russell IBM Corporation
*/
#include <common.h>
#include <linux/err.h>
#include <linux/hw_random.h>
#include <linux/spinlock.h>
#include <linux/virtio.h>
#include <linux/virtio_rng.h>
#include <linux/virtio_ring.h>
#include <module.h>
#include <linux/slab.h>
#define BUFFER_SIZE 16UL
struct virtrng_info {
struct hwrng hwrng;
char name[25];
struct virtqueue *rng_vq;
bool hwrng_register_done;
};
static inline struct virtrng_info *to_virtrng_info(struct hwrng *hwrng)
{
return container_of(hwrng, struct virtrng_info, hwrng);
}
static int virtio_rng_read(struct hwrng *hwrng, void *data, size_t len, bool wait)
{
int ret;
unsigned int rsize;
unsigned char buf[BUFFER_SIZE] __aligned(4);
unsigned char *ptr = data;
struct virtio_sg sg;
struct virtio_sg *sgs[1];
struct virtrng_info *vi = to_virtrng_info(hwrng);
size_t remaining = len;
while (remaining) {
sg.addr = buf;
sg.length = min(remaining, sizeof(buf));
sgs[0] = &sg;
ret = virtqueue_add(vi->rng_vq, sgs, 0, 1);
if (ret)
return ret;
virtqueue_kick(vi->rng_vq);
while (!virtqueue_get_buf(vi->rng_vq, &rsize))
;
memcpy(ptr, buf, rsize);
remaining -= rsize;
ptr += rsize;
}
return len;
}
static int probe_common(struct virtio_device *vdev)
{
struct virtrng_info *vi;
vi = xzalloc(sizeof(*vi));
vi->hwrng.name = vdev->dev.name;
vi->hwrng.read = virtio_rng_read;
vdev->priv = vi;
/* We expect a single virtqueue. */
return virtio_find_vqs(vdev, 1, &vi->rng_vq);
}
static void remove_common(struct virtio_device *vdev)
{
vdev->config->reset(vdev);
vdev->config->del_vqs(vdev);
}
static int virtrng_probe(struct virtio_device *vdev)
{
return probe_common(vdev);
}
static void virtrng_remove(struct virtio_device *vdev)
{
remove_common(vdev);
}
static void virtrng_scan(struct virtio_device *vdev)
{
struct virtrng_info *vi = vdev->priv;
int err;
err = hwrng_register(&vdev->dev, &vi->hwrng);
if (!err)
vi->hwrng_register_done = true;
}
static const struct virtio_device_id id_table[] = {
{ VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID },
{ 0 },
};
static struct virtio_driver virtio_rng_driver = {
.driver.name = "virtio-rng",
.id_table = id_table,
.probe = virtrng_probe,
.remove = virtrng_remove,
.scan = virtrng_scan,
};
module_virtio_driver(virtio_rng_driver);
MODULE_DESCRIPTION("Virtio random number driver");
MODULE_LICENSE("GPL");
|
