1 /*
2  * Randomness driver for virtio
3  *  Copyright (C) 2007, 2008 Rusty Russell IBM Corporation
4  *
5  *  This program is free software; you can redistribute it and/or modify
6  *  it under the terms of the GNU General Public License as published by
7  *  the Free Software Foundation; either version 2 of the License, or
8  *  (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
18  */
19 
20 #include <linux/err.h>
21 #include <linux/hw_random.h>
22 #include <linux/scatterlist.h>
23 #include <linux/spinlock.h>
24 #include <linux/virtio.h>
25 #include <linux/virtio_rng.h>
26 #include <linux/module.h>
27 
28 static DEFINE_IDA(rng_index_ida);
29 
30 struct virtrng_info {
31 	struct hwrng hwrng;
32 	struct virtqueue *vq;
33 	struct completion have_data;
34 	char name[25];
35 	unsigned int data_avail;
36 	int index;
37 	bool busy;
38 	bool hwrng_register_done;
39 	bool hwrng_removed;
40 };
41 
42 
43 static void random_recv_done(struct virtqueue *vq)
44 {
45 	struct virtrng_info *vi = vq->vdev->priv;
46 
47 	/* We can get spurious callbacks, e.g. shared IRQs + virtio_pci. */
48 	if (!virtqueue_get_buf(vi->vq, &vi->data_avail))
49 		return;
50 
51 	complete(&vi->have_data);
52 }
53 
54 /* The host will fill any buffer we give it with sweet, sweet randomness. */
55 static void register_buffer(struct virtrng_info *vi, u8 *buf, size_t size)
56 {
57 	struct scatterlist sg;
58 
59 	sg_init_one(&sg, buf, size);
60 
61 	/* There should always be room for one buffer. */
62 	virtqueue_add_inbuf(vi->vq, &sg, 1, buf, GFP_KERNEL);
63 
64 	virtqueue_kick(vi->vq);
65 }
66 
67 static int virtio_read(struct hwrng *rng, void *buf, size_t size, bool wait)
68 {
69 	int ret;
70 	struct virtrng_info *vi = (struct virtrng_info *)rng->priv;
71 
72 	if (vi->hwrng_removed)
73 		return -ENODEV;
74 
75 	if (!vi->busy) {
76 		vi->busy = true;
77 		init_completion(&vi->have_data);
78 		register_buffer(vi, buf, size);
79 	}
80 
81 	if (!wait)
82 		return 0;
83 
84 	ret = wait_for_completion_killable(&vi->have_data);
85 	if (ret < 0)
86 		return ret;
87 
88 	vi->busy = false;
89 
90 	return vi->data_avail;
91 }
92 
93 static void virtio_cleanup(struct hwrng *rng)
94 {
95 	struct virtrng_info *vi = (struct virtrng_info *)rng->priv;
96 
97 	if (vi->busy)
98 		wait_for_completion(&vi->have_data);
99 }
100 
101 static int probe_common(struct virtio_device *vdev)
102 {
103 	int err, index;
104 	struct virtrng_info *vi = NULL;
105 
106 	vi = kzalloc(sizeof(struct virtrng_info), GFP_KERNEL);
107 	if (!vi)
108 		return -ENOMEM;
109 
110 	vi->index = index = ida_simple_get(&rng_index_ida, 0, 0, GFP_KERNEL);
111 	if (index < 0) {
112 		err = index;
113 		goto err_ida;
114 	}
115 	sprintf(vi->name, "virtio_rng.%d", index);
116 	init_completion(&vi->have_data);
117 
118 	vi->hwrng = (struct hwrng) {
119 		.read = virtio_read,
120 		.cleanup = virtio_cleanup,
121 		.priv = (unsigned long)vi,
122 		.name = vi->name,
123 		.quality = 1000,
124 	};
125 	vdev->priv = vi;
126 
127 	/* We expect a single virtqueue. */
128 	vi->vq = virtio_find_single_vq(vdev, random_recv_done, "input");
129 	if (IS_ERR(vi->vq)) {
130 		err = PTR_ERR(vi->vq);
131 		goto err_find;
132 	}
133 
134 	return 0;
135 
136 err_find:
137 	ida_simple_remove(&rng_index_ida, index);
138 err_ida:
139 	kfree(vi);
140 	return err;
141 }
142 
143 static void remove_common(struct virtio_device *vdev)
144 {
145 	struct virtrng_info *vi = vdev->priv;
146 
147 	vi->hwrng_removed = true;
148 	vi->data_avail = 0;
149 	complete(&vi->have_data);
150 	vdev->config->reset(vdev);
151 	vi->busy = false;
152 	if (vi->hwrng_register_done)
153 		hwrng_unregister(&vi->hwrng);
154 	vdev->config->del_vqs(vdev);
155 	ida_simple_remove(&rng_index_ida, vi->index);
156 	kfree(vi);
157 }
158 
159 static int virtrng_probe(struct virtio_device *vdev)
160 {
161 	return probe_common(vdev);
162 }
163 
164 static void virtrng_remove(struct virtio_device *vdev)
165 {
166 	remove_common(vdev);
167 }
168 
169 static void virtrng_scan(struct virtio_device *vdev)
170 {
171 	struct virtrng_info *vi = vdev->priv;
172 	int err;
173 
174 	err = hwrng_register(&vi->hwrng);
175 	if (!err)
176 		vi->hwrng_register_done = true;
177 }
178 
179 #ifdef CONFIG_PM_SLEEP
180 static int virtrng_freeze(struct virtio_device *vdev)
181 {
182 	remove_common(vdev);
183 	return 0;
184 }
185 
186 static int virtrng_restore(struct virtio_device *vdev)
187 {
188 	return probe_common(vdev);
189 }
190 #endif
191 
192 static struct virtio_device_id id_table[] = {
193 	{ VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID },
194 	{ 0 },
195 };
196 
197 static struct virtio_driver virtio_rng_driver = {
198 	.driver.name =	KBUILD_MODNAME,
199 	.driver.owner =	THIS_MODULE,
200 	.id_table =	id_table,
201 	.probe =	virtrng_probe,
202 	.remove =	virtrng_remove,
203 	.scan =		virtrng_scan,
204 #ifdef CONFIG_PM_SLEEP
205 	.freeze =	virtrng_freeze,
206 	.restore =	virtrng_restore,
207 #endif
208 };
209 
210 module_virtio_driver(virtio_rng_driver);
211 MODULE_DEVICE_TABLE(virtio, id_table);
212 MODULE_DESCRIPTION("Virtio random number driver");
213 MODULE_LICENSE("GPL");
214