sys/dev/virtio/random/virtio_random.c

   1 /*-
   2  * Copyright (c) 2013, Bryan Venteicher <bryanv@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 /* Driver for VirtIO entropy device. */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/kernel.h>
  34 #include <sys/module.h>
  35 #include <sys/sglist.h>
  36 #include <sys/callout.h>
  37 #include <sys/random.h>
  38
  39 #include <machine/bus.h>
  40 #include <machine/resource.h>
  41 #include <sys/bus.h>
  42
  43 #include <dev/virtio/virtio.h>
  44 #include <dev/virtio/virtqueue.h>
  45
  46 struct vtrnd_softc {
  47         device_t                 vtrnd_dev;
  48         uint64_t                 vtrnd_features;
  49         struct callout           vtrnd_callout;
  50         struct virtqueue        *vtrnd_vq;
  51 };
  52
  53 static int      vtrnd_modevent(module_t, int, void *);
  54
  55 static int      vtrnd_probe(device_t);
  56 static int      vtrnd_attach(device_t);
  57 static int      vtrnd_detach(device_t);
  58
  59 static void     vtrnd_negotiate_features(struct vtrnd_softc *);
  60 static int      vtrnd_alloc_virtqueue(struct vtrnd_softc *);
  61 static void     vtrnd_harvest(struct vtrnd_softc *);
  62 static void     vtrnd_timer(void *);
  63
  64 #define VTRND_FEATURES  0
  65
  66 static struct virtio_feature_desc vtrnd_feature_desc[] = {
  67         { 0, NULL }
  68 };
  69
  70 static device_method_t vtrnd_methods[] = {
  71         /* Device methods. */
  72         DEVMETHOD(device_probe,         vtrnd_probe),
  73         DEVMETHOD(device_attach,        vtrnd_attach),
  74         DEVMETHOD(device_detach,        vtrnd_detach),
  75
  76         DEVMETHOD_END
  77 };
  78
  79 static driver_t vtrnd_driver = {
  80         "vtrnd",
  81         vtrnd_methods,
  82         sizeof(struct vtrnd_softc)
  83 };
  84 static devclass_t vtrnd_devclass;
  85
  86 DRIVER_MODULE(virtio_random, virtio_pci, vtrnd_driver, vtrnd_devclass,
  87     vtrnd_modevent, 0);
  88 MODULE_VERSION(virtio_random, 1);
  89 MODULE_DEPEND(virtio_random, virtio, 1, 1, 1);
  90
  91 static int
  92 vtrnd_modevent(module_t mod, int type, void *unused)
  93 {
  94         int error;
  95
  96         switch (type) {
  97         case MOD_LOAD:
  98         case MOD_QUIESCE:
  99         case MOD_UNLOAD:
 100         case MOD_SHUTDOWN:
 101                 error = 0;
 102                 break;
 103         default:
 104                 error = EOPNOTSUPP;
 105                 break;
 106         }
 107
 108         return (error);
 109 }
 110
 111 static int
 112 vtrnd_probe(device_t dev)
 113 {
 114
 115         if (virtio_get_device_type(dev) != VIRTIO_ID_ENTROPY)
 116                 return (ENXIO);
 117
 118         device_set_desc(dev, "VirtIO Entropy Adapter");
 119
 120         return (BUS_PROBE_DEFAULT);
 121 }
 122
 123 static int
 124 vtrnd_attach(device_t dev)
 125 {
 126         struct vtrnd_softc *sc;
 127         int error;
 128
 129         sc = device_get_softc(dev);
 130         sc->vtrnd_dev = dev;
 131
 132         callout_init(&sc->vtrnd_callout, CALLOUT_MPSAFE);
 133
 134         virtio_set_feature_desc(dev, vtrnd_feature_desc);
 135         vtrnd_negotiate_features(sc);
 136
 137         error = vtrnd_alloc_virtqueue(sc);
 138         if (error) {
 139                 device_printf(dev, "cannot allocate virtqueue\n");
 140                 goto fail;
 141         }
 142
 143         callout_reset(&sc->vtrnd_callout, 5 * hz, vtrnd_timer, sc);
 144
 145 fail:
 146         if (error)
 147                 vtrnd_detach(dev);
 148
 149         return (error);
 150 }
 151
 152 static int
 153 vtrnd_detach(device_t dev)
 154 {
 155         struct vtrnd_softc *sc;
 156
 157         sc = device_get_softc(dev);
 158
 159         callout_drain(&sc->vtrnd_callout);
 160
 161         return (0);
 162 }
 163
 164 static void
 165 vtrnd_negotiate_features(struct vtrnd_softc *sc)
 166 {
 167         device_t dev;
 168         uint64_t features;
 169
 170         dev = sc->vtrnd_dev;
 171         features = VTRND_FEATURES;
 172
 173         sc->vtrnd_features = virtio_negotiate_features(dev, features);
 174 }
 175
 176 static int
 177 vtrnd_alloc_virtqueue(struct vtrnd_softc *sc)
 178 {
 179         device_t dev;
 180         struct vq_alloc_info vq_info;
 181
 182         dev = sc->vtrnd_dev;
 183
 184         VQ_ALLOC_INFO_INIT(&vq_info, 0, NULL, sc, &sc->vtrnd_vq,
 185             "%s request", device_get_nameunit(dev));
 186
 187         return (virtio_alloc_virtqueues(dev, 0, 1, &vq_info));
 188 }
 189
 190 static void
 191 vtrnd_harvest(struct vtrnd_softc *sc)
 192 {
 193         struct sglist_seg segs[1];
 194         struct sglist sg;
 195         struct virtqueue *vq;
 196         uint32_t value;
 197         int error;
 198
 199         vq = sc->vtrnd_vq;
 200
 201         sglist_init(&sg, 1, segs);
 202         error = sglist_append(&sg, &value, sizeof(value));
 203         KASSERT(error == 0 && sg.sg_nseg == 1,
 204             ("%s: error %d adding buffer to sglist", __func__, error));
 205
 206         if (!virtqueue_empty(vq))
 207                 return;
 208         if (virtqueue_enqueue(vq, &value, &sg, 0, 1) != 0)
 209                 return;
 210
 211         /*
 212          * Poll for the response, but the command is likely already
 213          * done when we return from the notify.
 214          */
 215         virtqueue_notify(vq);
 216         virtqueue_poll(vq, NULL);
 217
 218         random_harvest(&value, sizeof(value), sizeof(value) * NBBY / 2,
 219             RANDOM_PURE_VIRTIO);
 220 }
 221
 222 static void
 223 vtrnd_timer(void *xsc)
 224 {
 225         struct vtrnd_softc *sc;
 226
 227         sc = xsc;
 228
 229         vtrnd_harvest(sc);
 230         callout_schedule(&sc->vtrnd_callout, 5 * hz);
 231 }