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 struct virtqueue *vq; 29 static unsigned int data_avail; 30 static DECLARE_COMPLETION(have_data); 31 static bool busy; 32 33 static void random_recv_done(struct virtqueue *vq) 34 { 35 /* We can get spurious callbacks, e.g. shared IRQs + virtio_pci. */ 36 if (!virtqueue_get_buf(vq, &data_avail)) 37 return; 38 39 complete(&have_data); 40 } 41 42 /* The host will fill any buffer we give it with sweet, sweet randomness. */ 43 static void register_buffer(u8 *buf, size_t size) 44 { 45 struct scatterlist sg; 46 47 sg_init_one(&sg, buf, size); 48 49 /* There should always be room for one buffer. */ 50 virtqueue_add_inbuf(vq, &sg, 1, buf, GFP_KERNEL); 51 52 virtqueue_kick(vq); 53 } 54 55 static int virtio_read(struct hwrng *rng, void *buf, size_t size, bool wait) 56 { 57 int ret; 58 59 if (!busy) { 60 busy = true; 61 init_completion(&have_data); 62 register_buffer(buf, size); 63 } 64 65 if (!wait) 66 return 0; 67 68 ret = wait_for_completion_killable(&have_data); 69 if (ret < 0) 70 return ret; 71 72 busy = false; 73 74 return data_avail; 75 } 76 77 static void virtio_cleanup(struct hwrng *rng) 78 { 79 if (busy) 80 wait_for_completion(&have_data); 81 } 82 83 84 static struct hwrng virtio_hwrng = { 85 .name = "virtio", 86 .cleanup = virtio_cleanup, 87 .read = virtio_read, 88 }; 89 90 static int probe_common(struct virtio_device *vdev) 91 { 92 int err; 93 94 if (vq) { 95 /* We only support one device for now */ 96 return -EBUSY; 97 } 98 /* We expect a single virtqueue. */ 99 vq = virtio_find_single_vq(vdev, random_recv_done, "input"); 100 if (IS_ERR(vq)) { 101 err = PTR_ERR(vq); 102 vq = NULL; 103 return err; 104 } 105 106 err = hwrng_register(&virtio_hwrng); 107 if (err) { 108 vdev->config->del_vqs(vdev); 109 vq = NULL; 110 return err; 111 } 112 113 return 0; 114 } 115 116 static void remove_common(struct virtio_device *vdev) 117 { 118 vdev->config->reset(vdev); 119 busy = false; 120 hwrng_unregister(&virtio_hwrng); 121 vdev->config->del_vqs(vdev); 122 vq = NULL; 123 } 124 125 static int virtrng_probe(struct virtio_device *vdev) 126 { 127 return probe_common(vdev); 128 } 129 130 static void virtrng_remove(struct virtio_device *vdev) 131 { 132 remove_common(vdev); 133 } 134 135 #ifdef CONFIG_PM_SLEEP 136 static int virtrng_freeze(struct virtio_device *vdev) 137 { 138 remove_common(vdev); 139 return 0; 140 } 141 142 static int virtrng_restore(struct virtio_device *vdev) 143 { 144 return probe_common(vdev); 145 } 146 #endif 147 148 static struct virtio_device_id id_table[] = { 149 { VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID }, 150 { 0 }, 151 }; 152 153 static struct virtio_driver virtio_rng_driver = { 154 .driver.name = KBUILD_MODNAME, 155 .driver.owner = THIS_MODULE, 156 .id_table = id_table, 157 .probe = virtrng_probe, 158 .remove = virtrng_remove, 159 #ifdef CONFIG_PM_SLEEP 160 .freeze = virtrng_freeze, 161 .restore = virtrng_restore, 162 #endif 163 }; 164 165 module_virtio_driver(virtio_rng_driver); 166 MODULE_DEVICE_TABLE(virtio, id_table); 167 MODULE_DESCRIPTION("Virtio random number driver"); 168 MODULE_LICENSE("GPL"); 169