Merge tag 'virtio-next-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / drivers / char / hw_random / virtio-rng.c
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");