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 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 wait_for_completion(&have_data); 69 70 busy = false; 71 72 return data_avail; 73 } 74 75 static void virtio_cleanup(struct hwrng *rng) 76 { 77 if (busy) 78 wait_for_completion(&have_data); 79 } 80 81 82 static struct hwrng virtio_hwrng = { 83 .name = "virtio", 84 .cleanup = virtio_cleanup, 85 .read = virtio_read, 86 }; 87 88 static int virtrng_probe(struct virtio_device *vdev) 89 { 90 int err; 91 92 /* We expect a single virtqueue. */ 93 vq = virtio_find_single_vq(vdev, random_recv_done, "input"); 94 if (IS_ERR(vq)) 95 return PTR_ERR(vq); 96 97 err = hwrng_register(&virtio_hwrng); 98 if (err) { 99 vdev->config->del_vqs(vdev); 100 return err; 101 } 102 103 return 0; 104 } 105 106 static void __devexit virtrng_remove(struct virtio_device *vdev) 107 { 108 vdev->config->reset(vdev); 109 hwrng_unregister(&virtio_hwrng); 110 vdev->config->del_vqs(vdev); 111 } 112 113 static struct virtio_device_id id_table[] = { 114 { VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID }, 115 { 0 }, 116 }; 117 118 static struct virtio_driver virtio_rng_driver = { 119 .driver.name = KBUILD_MODNAME, 120 .driver.owner = THIS_MODULE, 121 .id_table = id_table, 122 .probe = virtrng_probe, 123 .remove = __devexit_p(virtrng_remove), 124 }; 125 126 static int __init init(void) 127 { 128 return register_virtio_driver(&virtio_rng_driver); 129 } 130 131 static void __exit fini(void) 132 { 133 unregister_virtio_driver(&virtio_rng_driver); 134 } 135 module_init(init); 136 module_exit(fini); 137 138 MODULE_DEVICE_TABLE(virtio, id_table); 139 MODULE_DESCRIPTION("Virtio random number driver"); 140 MODULE_LICENSE("GPL"); 141