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 if (virtqueue_add_buf(vq, &sg, 0, 1, buf, GFP_KERNEL) < 0) 51 BUG(); 52 53 virtqueue_kick(vq); 54 } 55 56 static int virtio_read(struct hwrng *rng, void *buf, size_t size, bool wait) 57 { 58 int ret; 59 60 if (!busy) { 61 busy = true; 62 init_completion(&have_data); 63 register_buffer(buf, size); 64 } 65 66 if (!wait) 67 return 0; 68 69 ret = wait_for_completion_killable(&have_data); 70 if (ret < 0) 71 return ret; 72 73 busy = false; 74 75 return data_avail; 76 } 77 78 static void virtio_cleanup(struct hwrng *rng) 79 { 80 if (busy) 81 wait_for_completion(&have_data); 82 } 83 84 85 static struct hwrng virtio_hwrng = { 86 .name = "virtio", 87 .cleanup = virtio_cleanup, 88 .read = virtio_read, 89 }; 90 91 static int probe_common(struct virtio_device *vdev) 92 { 93 int err; 94 95 /* We expect a single virtqueue. */ 96 vq = virtio_find_single_vq(vdev, random_recv_done, "input"); 97 if (IS_ERR(vq)) 98 return PTR_ERR(vq); 99 100 err = hwrng_register(&virtio_hwrng); 101 if (err) { 102 vdev->config->del_vqs(vdev); 103 return err; 104 } 105 106 return 0; 107 } 108 109 static void remove_common(struct virtio_device *vdev) 110 { 111 vdev->config->reset(vdev); 112 busy = false; 113 hwrng_unregister(&virtio_hwrng); 114 vdev->config->del_vqs(vdev); 115 } 116 117 static int virtrng_probe(struct virtio_device *vdev) 118 { 119 return probe_common(vdev); 120 } 121 122 static void virtrng_remove(struct virtio_device *vdev) 123 { 124 remove_common(vdev); 125 } 126 127 #ifdef CONFIG_PM 128 static int virtrng_freeze(struct virtio_device *vdev) 129 { 130 remove_common(vdev); 131 return 0; 132 } 133 134 static int virtrng_restore(struct virtio_device *vdev) 135 { 136 return probe_common(vdev); 137 } 138 #endif 139 140 static struct virtio_device_id id_table[] = { 141 { VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID }, 142 { 0 }, 143 }; 144 145 static struct virtio_driver virtio_rng_driver = { 146 .driver.name = KBUILD_MODNAME, 147 .driver.owner = THIS_MODULE, 148 .id_table = id_table, 149 .probe = virtrng_probe, 150 .remove = virtrng_remove, 151 #ifdef CONFIG_PM 152 .freeze = virtrng_freeze, 153 .restore = virtrng_restore, 154 #endif 155 }; 156 157 static int __init init(void) 158 { 159 return register_virtio_driver(&virtio_rng_driver); 160 } 161 162 static void __exit fini(void) 163 { 164 unregister_virtio_driver(&virtio_rng_driver); 165 } 166 module_init(init); 167 module_exit(fini); 168 169 MODULE_DEVICE_TABLE(virtio, id_table); 170 MODULE_DESCRIPTION("Virtio random number driver"); 171 MODULE_LICENSE("GPL"); 172