 @@ -1,14 +1,14 @@
-/*	$NetBSD: bcm2835_rng.c,v 1.3 2013/02/01 16:10:16 skrll Exp $ */
+/*	$NetBSD: bcm2835_rng.c,v 1.4 2013/06/13 00:55:01 tls Exp $ */
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jared D. McNeill
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -20,65 +20,66 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: bcm2835_rng.c,v 1.3 2013/02/01 16:10:16 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: bcm2835_rng.c,v 1.4 2013/06/13 00:55:01 tls Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/bus.h>
 #include <sys/rnd.h>
 #include <sys/atomic.h>
 #include <arm/broadcom/bcm_amba.h>
 #include <arm/broadcom/bcm2835reg.h>
 #include <arm/broadcom/bcm2835_intr.h>
 #define RNG_CTRL		0x00
 #define  RNG_CTRL_EN		__BIT(0)
 #define RNG_STATUS		0x04
 #define  RNG_STATUS_CNT_MASK	__BITS(31,24)
 #define  RNG_STATUS_CNT_SHIFT	24
 #define RNG_DATA		0x08
 #define RNG_DATA_MAX		256
 struct bcm2835rng_softc {
 	device_t sc_dev;
 	bus_space_tag_t sc_iot;
 	bus_space_handle_t sc_ioh;
 	krndsource_t sc_rnd;
 	callout_t sc_tick;
 	kmutex_t sc_mutex;
 	uint32_t sc_data[RNG_DATA_MAX];
 };
 static void bcmrng_get(size_t, void *);
 static int bcmrng_match(device_t, cfdata_t, void *);
 static void bcmrng_attach(device_t, device_t, void *);
 static void bcmrng_tick(void *);
 CFATTACH_DECL_NEW(bcmrng_amba, sizeof(struct bcm2835rng_softc),
     bcmrng_match, bcmrng_attach, NULL, NULL);
 /* ARGSUSED */
 static int
 bcmrng_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct amba_attach_args *aaa = aux;
 	if (strcmp(aaa->aaa_name, "bcmrng") != 0)
 		return 0;
 	return 1;
 @@ -93,49 +94,57 @@ bcmrng_attach(device_t parent, device_t
 	aprint_naive("\n");
 	aprint_normal(": RNG\n");
 	sc->sc_dev = self;
 	sc->sc_iot = aaa->aaa_iot;
 	if (bus_space_map(aaa->aaa_iot, aaa->aaa_addr, BCM2835_RNG_SIZE, 0,
 	    &sc->sc_ioh)) {
 		aprint_error_dev(sc->sc_dev, "unable to map device\n");
 		return;
+	}
-	rnd_attach_source(&sc->sc_rnd, device_xname(self), RND_TYPE_RNG,
+	mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_VM);
 	    RND_FLAG_NO_ESTIMATE);
-	callout_init(&sc->sc_tick, CALLOUT_MPSAFE);
+	rndsource_setcb(&sc->sc_rnd, bcmrng_get, sc);
-	callout_setfunc(&sc->sc_tick, bcmrng_tick, sc);
+	rnd_attach_source(&sc->sc_rnd, device_xname(self), RND_TYPE_RNG,
 	    RND_FLAG_NO_ESTIMATE|RND_FLAG_HASCB);
 	/* discard initial numbers, broadcom says they are "less random" */
 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, RNG_STATUS, 0x40000);
 	/* enable rng */
 	ctrl = bus_space_read_4(sc->sc_iot, sc->sc_ioh, RNG_CTRL);
 	ctrl |= RNG_CTRL_EN;
 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, RNG_CTRL, ctrl);
 	/* start timer */
 	bcmrng_tick(sc);
+}
 static void
-bcmrng_tick(void *priv)
+bcmrng_get(size_t bytes, void *priv)
+{
-	struct bcm2835rng_softc *sc = priv;
+        struct bcm2835rng_softc *sc = priv;
 	uint32_t status;
-	int cnt;
+	int need = bytes, cnt;
-	status = bus_space_read_4(sc->sc_iot, sc->sc_ioh, RNG_STATUS);
+        mutex_spin_enter(&sc->sc_mutex);
 	cnt = (status & RNG_STATUS_CNT_MASK) >> RNG_STATUS_CNT_SHIFT;
-	if (cnt > 0) {
+        printf("bcmrng: asked for %d bytes", (int)bytes);
 		bus_space_read_multi_4(sc->sc_iot, sc->sc_ioh, RNG_DATA,
-		    sc->sc_data, cnt);
+	if (__predict_false(need < 1)) {
-		rnd_add_data(&sc->sc_rnd, sc->sc_data,
+		return;
 		    cnt * 4, cnt * 4 * NBBY);
+	}
-	callout_schedule(&sc->sc_tick, 1);
+	while (need > 0) {
 		status = bus_space_read_4(sc->sc_iot, sc->sc_ioh, RNG_STATUS);
 		cnt = (status & RNG_STATUS_CNT_MASK) >> RNG_STATUS_CNT_SHIFT;
 		if (cnt > 0) {
 			bus_space_read_multi_4(sc->sc_iot, sc->sc_ioh,
 					       RNG_DATA, sc->sc_data, cnt);
 			rnd_add_data(&sc->sc_rnd, sc->sc_data,
 		    		     cnt * 4, cnt * 4 * NBBY);
+		}
 		need -= cnt * 4;
+	}
 	mutex_spin_exit(&sc->sc_mutex);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rndpseudo.c,v 1.11 2012/11/25 15:29:24 christos Exp $	*/
+/*	$NetBSD: rndpseudo.c,v 1.12 2013/06/13 00:55:01 tls Exp $	*/
 /*-
  * Copyright (c) 1997-2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Michael Graff <explorer@flame.org> and Thor Lancelot Simon.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -20,27 +20,27 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rndpseudo.c,v 1.11 2012/11/25 15:29:24 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rndpseudo.c,v 1.12 2013/06/13 00:55:01 tls Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_compat_netbsd.h"
 #endif
 #include <sys/param.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/file.h>
 #include <sys/filedesc.h>
 #include <sys/select.h>
 #include <sys/poll.h>
 #include <sys/kmem.h>
 @@ -209,26 +209,27 @@ rndopen(dev_t dev, int flag, int ifmt,
 	    case RND_DEV_RANDOM:
 		hard = 1;
 		break;
 	    default:
 		return ENXIO;
+	}
 	ctx = pool_cache_get(rp_cpc, PR_WAITOK);
 	if ((error = fd_allocfile(&fp, &fd)) != 0) {
 	    pool_cache_put(rp_cpc, ctx);
 	    return error;
+	}
 	ctx->cprng = NULL;
 	ctx->hard = hard;
 	ctx->bytesonkey = 0;
 	mutex_init(&ctx->interlock, MUTEX_DEFAULT, IPL_NONE);
 	return fd_clone(fp, fd, flag, &rnd_fileops, ctx);
+}
 static void
 rnd_alloc_cprng(rp_ctx_t *ctx)
+{
 	char personalization_buf[64];
 	struct lwp *l = curlwp;
 	int cflags = ctx->hard ? CPRNG_USE_CV :
 				 CPRNG_INIT_ANY|CPRNG_REKEY_ANY;
 @@ -288,42 +289,57 @@ rnd_read(struct file * fp, off_t *offp,
 		return EIO;
+        }
 	strength = cprng_strong_strength(cprng);
 	ret = 0;
 	bf = pool_cache_get(rp_pc, PR_WAITOK);
 	while (uio->uio_resid > 0) {
 		int n, nread, want;
 		want = MIN(RND_TEMP_BUFFER_SIZE, uio->uio_resid);
 		/* XXX is this _really_ what's wanted? */
 		if (ctx->hard) {
 #ifdef RND_VERBOSE
 			printf("rnd: hard, want = %d, strength = %d, "
 			       "bytesonkey = %d\n", (int)want, (int)strength,
 			       (int)ctx->bytesonkey);
 #endif
 			n = MIN(want, strength - ctx->bytesonkey);
 			if (n < 1) {
-			    cprng_strong_deplete(cprng);
+#ifdef RND_VERBOSE
-			    n = MIN(want, strength);
+			    printf("rnd: BAD BAD BAD: n = %d, want = %d, "
-			    ctx->bytesonkey = 0;
+				   "strength = %d, bytesonkey = %d\n", n,
-			    membar_producer();
+				   (int)want, (int)strength,
 				   (int)ctx->bytesonkey);
 #endif
+			}
 		} else {
 			n = want;
+		}
 		nread = cprng_strong(cprng, bf, n,
 				     (fp->f_flag & FNONBLOCK) ? FNONBLOCK : 0);
 		if (ctx->hard && nread > 0) {
-			atomic_add_int(&ctx->bytesonkey, nread);
+			if (atomic_add_int_nv(&ctx->bytesonkey, nread) >=
 			    strength) {
 				cprng_strong_deplete(cprng);
 				ctx->bytesonkey = 0;
 				membar_producer();
+			}
 #ifdef RND_VERBOSE
 			printf("rnd: new bytesonkey %d\n", ctx->bytesonkey);
 #endif
+		}
 		if (nread < 1) {
 			if (fp->f_flag & FNONBLOCK) {
 				ret = EWOULDBLOCK;
 			} else {
 				ret = EINTR;
+			}
 			goto out;
+		}
 		ret = uiomove((void *)bf, nread, uio);
 		if (ret != 0 || n < want) {
 			goto out;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: amdpm.c,v 1.36 2012/10/27 17:18:28 chs Exp $	*/
+/*	$NetBSD: amdpm.c,v 1.37 2013/06/13 00:55:01 tls Exp $	*/
 /*-
  * Copyright (c) 2002 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Enami Tsugutomo.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -20,51 +20,53 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: amdpm.c,v 1.36 2012/10/27 17:18:28 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: amdpm.c,v 1.37 2013/06/13 00:55:01 tls Exp $");
 #include "opt_amdpm.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/callout.h>
 #include <sys/rnd.h>
 #include <sys/mutex.h>
 #include <sys/bus.h>
 #include <dev/ic/acpipmtimer.h>
 #include <dev/i2c/i2cvar.h>
 #include <dev/pci/pcivar.h>
 #include <dev/pci/pcireg.h>
 #include <dev/pci/pcidevs.h>
 #include <dev/pci/amdpmreg.h>
 #include <dev/pci/amdpmvar.h>
 #include <dev/pci/amdpm_smbusreg.h>
 static void	amdpm_rnd_callout(void *);
 static void	amdpm_rnd_callout_locked(void *);
 #ifdef AMDPM_RND_COUNTERS
 #define	AMDPM_RNDCNT_INCR(ev)	(ev)->ev_count++
 #endif
 static int
 amdpm_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct pci_attach_args *pa = aux;
 	if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_AMD) {
 		switch (PCI_PRODUCT(pa->pa_id)) {
 		case PCI_PRODUCT_AMD_PBC768_PMC:
 @@ -73,26 +75,37 @@ amdpm_match(device_t parent, cfdata_t ma
+		}
+	}
 	if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_NVIDIA) {
 		switch (PCI_PRODUCT(pa->pa_id)) {
 		case PCI_PRODUCT_NVIDIA_XBOX_SMBUS:
 			return (1);
+		}
+	}
 	return (0);
+}
 static void
 amdpm_rnd_get(size_t bytes, void *priv)
+{
 	struct amdpm_softc *sc = priv;
 	mutex_enter(&sc->sc_mutex);
 	sc->sc_rnd_need = bytes;
 	amdpm_rnd_callout_locked(sc);
 	mutex_exit(&sc->sc_mutex);
+}
 static void
 amdpm_attach(device_t parent, device_t self, void *aux)
+{
 	struct amdpm_softc *sc = device_private(self);
 	struct pci_attach_args *pa = aux;
 	pcireg_t confreg, pmptrreg;
 	u_int32_t pmreg;
 	int i;
 	pci_aprint_devinfo(pa, NULL);
 	sc->sc_dev = self;
 	if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_NVIDIA_XBOX_SMBUS)
 @@ -141,96 +154,120 @@ amdpm_attach(device_t parent, device_t s
 		    AMDPM_PMSIZE, 0, &sc->sc_ioh)) {
 			aprint_error_dev(self, "failed to map PMxx space\n");
 			return;
+		}
+	}
 	/* don't attach a timecounter on nforce boards */
 	if ((confreg & AMDPM_TMRRST) == 0 && (confreg & AMDPM_STOPTMR) == 0 &&
 	    !sc->sc_nforce) {
 		acpipmtimer_attach(self, sc->sc_iot, sc->sc_ioh,
 		  AMDPM_TMR, ((confreg & AMDPM_TMR32) ? ACPIPMT_32BIT : 0));
+	}
 	/* XXX this mutex is IPL_VM because it can be taken by rnd_getmore() */
 	mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_VM);
 	/* try to attach devices on the smbus */
 	if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_AMD_PBC8111_ACPI ||
 	    PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_AMD_PBC768_PMC ||
 	    sc->sc_nforce) {
 		amdpm_smbus_attach(sc);
+	}
 	if (confreg & AMDPM_RNGEN) {
 		/* Check to see if we can read data from the RNG. */
 		(void) bus_space_read_4(sc->sc_iot, sc->sc_ioh,
 		    AMDPM_RNGDATA);
 		for (i = 0; i < 1000; i++) {
 			pmreg = bus_space_read_4(sc->sc_iot,
 			    sc->sc_ioh, AMDPM_RNGSTAT);
 			if (pmreg & AMDPM_RNGDONE)
 				break;
 			delay(1);
+		}
 		if ((pmreg & AMDPM_RNGDONE) != 0) {
 			aprint_normal_dev(self, ""
 			    "random number generator enabled (apprx. %dms)\n",
 			    i);
-			callout_init(&sc->sc_rnd_ch, 0);
+			callout_init(&sc->sc_rnd_ch, CALLOUT_MPSAFE);
 			rndsource_setcb(&sc->sc_rnd_source,
 					amdpm_rnd_get, sc);
 			rnd_attach_source(&sc->sc_rnd_source,
 			    device_xname(self), RND_TYPE_RNG,
 			    /*
 			     * XXX Careful!  The use of RND_FLAG_NO_ESTIMATE
 			     * XXX here is unobvious: we later feed raw bits
 			     * XXX into the "entropy pool" with rnd_add_data,
 			     * XXX explicitly supplying an entropy estimate.
 			     * XXX In this context, NO_ESTIMATE serves only
 			     * XXX to prevent rnd_add_data from trying to
 			     * XXX use the *time at which we added the data*
 			     * XXX as entropy, which is not a good idea since
 			     * XXX we add data periodically from a callout.
 			     */
-			    RND_FLAG_NO_ESTIMATE);
+			    RND_FLAG_NO_ESTIMATE|RND_FLAG_HASCB);
 #ifdef AMDPM_RND_COUNTERS
 			evcnt_attach_dynamic(&sc->sc_rnd_hits, EVCNT_TYPE_MISC,
 			    NULL, device_xname(self), "rnd hits");
 			evcnt_attach_dynamic(&sc->sc_rnd_miss, EVCNT_TYPE_MISC,
 			    NULL, device_xname(self), "rnd miss");
 			for (i = 0; i < 256; i++) {
 				evcnt_attach_dynamic(&sc->sc_rnd_data[i],
 				    EVCNT_TYPE_MISC, NULL, device_xname(self),
 				    "rnd data");
+			}
 #endif
 			sc->sc_rnd_need = RND_POOLBITS / NBBY;
 			amdpm_rnd_callout(sc);
+		}
+	}
+}
 CFATTACH_DECL_NEW(amdpm, sizeof(struct amdpm_softc),
     amdpm_match, amdpm_attach, NULL, NULL);
 static void
-amdpm_rnd_callout(void *v)
+amdpm_rnd_callout_locked(void *v)
+{
 	struct amdpm_softc *sc = v;
 	u_int32_t rngreg;
 #ifdef AMDPM_RND_COUNTERS
 	int i;
 #endif
 	if (sc->sc_rnd_need < 1) {
 		callout_stop(&sc->sc_rnd_ch);
 		return;
+	}
 	if ((bus_space_read_4(sc->sc_iot, sc->sc_ioh, AMDPM_RNGSTAT) &
 	    AMDPM_RNGDONE) != 0) {
 		rngreg = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
 		    AMDPM_RNGDATA);
 		rnd_add_data(&sc->sc_rnd_source, &rngreg,
 		    sizeof(rngreg), sizeof(rngreg) * NBBY);
 		sc->sc_rnd_need -= sizeof(rngreg);
 #ifdef AMDPM_RND_COUNTERS
 		AMDPM_RNDCNT_INCR(&sc->sc_rnd_hits);
 		for (i = 0; i < sizeof(rngreg); i++, rngreg >>= NBBY)
 			AMDPM_RNDCNT_INCR(&sc->sc_rnd_data[rngreg & 0xff]);
 #endif
+	}
 #ifdef AMDPM_RND_COUNTERS
 	else
 		AMDPM_RNDCNT_INCR(&sc->sc_rnd_miss);
 #endif
-	callout_reset(&sc->sc_rnd_ch, 1, amdpm_rnd_callout, sc);
+	if (sc->sc_rnd_need > 0) {
 		callout_reset(&sc->sc_rnd_ch, 1, amdpm_rnd_callout, sc);
+	}
+}
 static void
 amdpm_rnd_callout(void *v)
+{
 	struct amdpm_softc *sc = v;
 	mutex_enter(&sc->sc_mutex);
 	amdpm_rnd_callout_locked(v);
 	mutex_exit(&sc->sc_mutex);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: amdpm_smbus.c,v 1.19 2012/10/27 17:18:28 chs Exp $ */
+/*	$NetBSD: amdpm_smbus.c,v 1.20 2013/06/13 00:55:01 tls Exp $ */
 /*
  * Copyright (c) 2005 Anil Gopinath (anil_public@yahoo.com)
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -22,27 +22,27 @@
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /* driver for SMBUS 1.0 host controller found in the
  * AMD-8111 HyperTransport I/O Hub
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: amdpm_smbus.c,v 1.19 2012/10/27 17:18:28 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: amdpm_smbus.c,v 1.20 2013/06/13 00:55:01 tls Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/rnd.h>
 #include <sys/mutex.h>
 #include <dev/pci/pcireg.h>
 #include <dev/pci/pcivar.h>
 #include <dev/pci/pcidevs.h>
 #include <dev/i2c/i2cvar.h>
 @@ -73,28 +73,26 @@ amdpm_smbus_attach(struct amdpm_softc *s
         struct i2cbus_attach_args iba;
 	/* register with iic */
 	sc->sc_i2c.ic_cookie = sc;
 	sc->sc_i2c.ic_acquire_bus = amdpm_smbus_acquire_bus;
 	sc->sc_i2c.ic_release_bus = amdpm_smbus_release_bus;
 	sc->sc_i2c.ic_send_start = NULL;
 	sc->sc_i2c.ic_send_stop = NULL;
 	sc->sc_i2c.ic_initiate_xfer = NULL;
 	sc->sc_i2c.ic_read_byte = NULL;
 	sc->sc_i2c.ic_write_byte = NULL;
 	sc->sc_i2c.ic_exec = amdpm_smbus_exec;
 	mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);
 	iba.iba_tag = &sc->sc_i2c;
 	(void)config_found_ia(sc->sc_dev, "i2cbus", &iba, iicbus_print);
+}
 static int
 amdpm_smbus_acquire_bus(void *cookie, int flags)
+{
 	struct amdpm_softc *sc = cookie;
 	mutex_enter(&sc->sc_mutex);
 	return 0;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: amdpmvar.h,v 1.9 2012/10/27 17:18:28 chs Exp $	*/
+/*	$NetBSD: amdpmvar.h,v 1.10 2013/06/13 00:55:01 tls Exp $	*/
 /*-
  * Copyright (c) 2002 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Enami Tsugutomo.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -43,23 +43,24 @@ struct amdpm_softc {
 	bus_space_tag_t sc_iot;
 	bus_space_handle_t sc_ioh;		/* PMxx space */
 	bus_space_handle_t sc_sm_ioh;		/* SM space */
 	i2c_addr_t sc_smbus_slaveaddr;		/* address of smbus slave */
 	struct i2c_controller sc_i2c;		/* i2c controller info */
 	kmutex_t sc_mutex;
 	void *sc_ih;
 	struct callout sc_rnd_ch;
 	krndsource_t sc_rnd_source;
 	int sc_rnd_need;
 #ifdef AMDPM_RND_COUNTERS
 	struct evcnt sc_rnd_hits;
 	struct evcnt sc_rnd_miss;
 	struct evcnt sc_rnd_data[256];
 #endif
 	char sc_nforce;
 };
 #endif /* _DEV_PCI_AMDPMVAR_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: hifn7751var.h,v 1.9 2012/10/27 17:18:32 chs Exp $	*/
+/*	$NetBSD: hifn7751var.h,v 1.10 2013/06/13 00:55:01 tls Exp $	*/
 /*	$OpenBSD: hifn7751var.h,v 1.18 2000/06/02 22:36:45 deraadt Exp $	*/
 /*
  * Invertex AEON / Hifn 7751 driver
  * Copyright (c) 1999 Invertex Inc. All rights reserved.
  * Copyright (c) 1999 Theo de Raadt
  * Copyright (c) 2000-2001 Network Security Technologies, Inc.
  *			http://www.netsec.net
+ *
  * Please send any comments, feedback, bug-fixes, or feature requests to
  * software@invertex.com.
+ *
  * Redistribution and use in source and binary forms, with or without
 @@ -159,41 +159,42 @@ struct hifn_softc {
 #define	HIFN_HAS_AES		0x04	/* includes AES support */
 #define	HIFN_IS_7811		0x08	/* Hifn 7811 part */
 #define	HIFN_IS_7956		0x10	/* Hifn 7956/7955 don't have SDRAM */
 #define	HIFN_NO_BURSTWRITE	0x20
 #define	HIFN_HAS_LEDS		0x40
 #define HIFN_RNG_BITSPER	17	/* From Hifn 6500 paper: 0.06 bits
 					   of entropy per RNG register bit
 					   worst-case */
 	struct callout		sc_rngto;	/* rng timeout */
 	struct callout		sc_tickto;	/* led-clear timeout */
 	krndsource_t	sc_rnd_source;
 	int			sc_rngfirst;
 	int			sc_rnghz;
 	int			sc_rng_need;	/* how many bytes wanted */
 	int			sc_c_busy;	/* command ring busy */
 	int			sc_s_busy;	/* source data ring busy */
 	int			sc_d_busy;	/* destination data ring busy */
 	int			sc_r_busy;	/* result ring busy */
 	int			sc_active;	/* for initial countdown */
 	int			sc_needwakeup;	/* ops q'd wating on resources */
 	int			sc_curbatch;	/* # ops submitted w/o int */
 	int			sc_suspended;
 	struct hifn_session sc_sessions[2048];
 	pci_chipset_tag_t sc_pci_pc;
 	pcitag_t sc_pci_tag;
 	bus_size_t sc_waw_lastreg;
 	int sc_waw_lastgroup;
 	kmutex_t		sc_mtx;
 };
 #define WRITE_REG_0(sc,reg,val)		hifn_write_4((sc), 0, (reg), (val))
 #define WRITE_REG_1(sc,reg,val)		hifn_write_4((sc), 1, (reg), (val))
 #define	READ_REG_0(sc,reg)		hifn_read_4((sc), 0, (reg))
 #define	READ_REG_1(sc,reg)		hifn_read_4((sc), 1, (reg))
 #define	SET_LED(sc,v)							\
 	if (sc->sc_flags & HIFN_HAS_LEDS)				\
 		WRITE_REG_1(sc, HIFN_1_7811_MIPSRST,			\
 		    READ_REG_1(sc, HIFN_1_7811_MIPSRST) | (v))
 #define	CLR_LED(sc,v)							\
 	if (sc->sc_flags & HIFN_HAS_LEDS)				\

 @@ -1,14 +1,14 @@
-/*	$NetBSD: hifn7751.c,v 1.51 2012/10/27 17:18:32 chs Exp $	*/
+/*	$NetBSD: hifn7751.c,v 1.52 2013/06/13 00:55:01 tls Exp $	*/
 /*	$FreeBSD: hifn7751.c,v 1.5.2.7 2003/10/08 23:52:00 sam Exp $ */
 /*	$OpenBSD: hifn7751.c,v 1.140 2003/08/01 17:55:54 deraadt Exp $	*/
 /*
  * Invertex AEON / Hifn 7751 driver
  * Copyright (c) 1999 Invertex Inc. All rights reserved.
  * Copyright (c) 1999 Theo de Raadt
  * Copyright (c) 2000-2001 Network Security Technologies, Inc.
  *			http://www.netsec.net
  * Copyright (c) 2003 Hifn Inc.
+ *
  * This driver is based on a previous driver by Invertex, for which they
  * requested:  Please send any comments, feedback, bug-fixes, or feature
 @@ -38,30 +38,31 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  * Effort sponsored in part by the Defense Advanced Research Projects
  * Agency (DARPA) and Air Force Research Laboratory, Air Force
  * Materiel Command, USAF, under agreement number F30602-01-2-0537.
+ *
  */
 /*
  * Driver for various  Hifn pre-HIPP encryption processors.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: hifn7751.c,v 1.51 2012/10/27 17:18:32 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: hifn7751.c,v 1.52 2013/06/13 00:55:01 tls Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/errno.h>
 #include <sys/malloc.h>
 #include <sys/kernel.h>
 #include <sys/mbuf.h>
 #include <sys/device.h>
 #ifdef __OpenBSD__
 #include <crypto/crypto.h>
 #include <dev/rndvar.h>
 #else
 #include <opencrypto/cryptodev.h>
 #include <sys/cprng.h>
 @@ -130,42 +131,42 @@ static int	hifn_process(void*, struct cr
 static void	hifn_callback(struct hifn_softc *, struct hifn_command *,
 			      u_int8_t *);
 static int	hifn_crypto(struct hifn_softc *, struct hifn_command *,
 			    struct cryptop*, int);
 static int	hifn_readramaddr(struct hifn_softc *, int, u_int8_t *);
 static int	hifn_writeramaddr(struct hifn_softc *, int, u_int8_t *);
 static int	hifn_dmamap_aligned(bus_dmamap_t);
 static int	hifn_dmamap_load_src(struct hifn_softc *,
 				     struct hifn_command *);
 static int	hifn_dmamap_load_dst(struct hifn_softc *,
 				     struct hifn_command *);
 static int	hifn_init_pubrng(struct hifn_softc *);
 static void	hifn_rng(void *);
 static void	hifn_rng_locked(void *);
 static void	hifn_tick(void *);
 static void	hifn_abort(struct hifn_softc *);
 static void	hifn_alloc_slot(struct hifn_softc *, int *, int *, int *,
 				int *);
 static void	hifn_write_4(struct hifn_softc *, int, bus_size_t, u_int32_t);
 static u_int32_t hifn_read_4(struct hifn_softc *, int, bus_size_t);
 #ifdef	HAVE_CRYPTO_LZS
 static int	hifn_compression(struct hifn_softc *, struct cryptop *,
 				 struct hifn_command *);
 static struct mbuf *hifn_mkmbuf_chain(int, struct mbuf *);
 static int	hifn_compress_enter(struct hifn_softc *, struct hifn_command *);
 static void	hifn_callback_comp(struct hifn_softc *, struct hifn_command *,
 				   u_int8_t *);
 #endif	/* HAVE_CRYPTO_LZS */
 struct hifn_stats hifnstats;
 static const struct hifn_product {
 	pci_vendor_id_t		hifn_vendor;
 	pci_product_id_t	hifn_product;
 	int			hifn_flags;
 	const char		*hifn_name;
 } hifn_products[] = {
 	{ PCI_VENDOR_INVERTEX,	PCI_PRODUCT_INVERTEX_AEON,
 ,
 	  "Invertex AEON",
 	},
 @@ -408,56 +409,72 @@ hifn_attach(device_t parent, device_t se
 		crypto_register(sc->sc_cid, CRYPTO_MD5_HMAC_96, 0, 0,
 		    hifn_newsession, hifn_freesession, hifn_process, sc);
 		crypto_register(sc->sc_cid, CRYPTO_SHA1_HMAC_96, 0, 0,
 		    hifn_newsession, hifn_freesession, hifn_process, sc);
 		crypto_register(sc->sc_cid, CRYPTO_DES_CBC, 0, 0,
 		    hifn_newsession, hifn_freesession, hifn_process, sc);
 		break;
+	}
 	bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap, 0,
 	    sc->sc_dmamap->dm_mapsize,
 	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
-	if (sc->sc_flags & (HIFN_HAS_PUBLIC | HIFN_HAS_RNG))
+	if (sc->sc_flags & (HIFN_HAS_PUBLIC | HIFN_HAS_RNG)) {
 		hifn_init_pubrng(sc);
 		sc->sc_rng_need = RND_POOLBITS / NBBY;
+	}
 	mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_VM);
 #ifdef	__OpenBSD__
 	timeout_set(&sc->sc_tickto, hifn_tick, sc);
 	timeout_add(&sc->sc_tickto, hz);
 #else
-	callout_init(&sc->sc_tickto, 0);
+	callout_init(&sc->sc_tickto, CALLOUT_MPSAFE);
 	callout_reset(&sc->sc_tickto, hz, hifn_tick, sc);
 #endif
 	return;
 fail_intr:
 	pci_intr_disestablish(pc, sc->sc_ih);
 fail_mem:
 	bus_dmamap_unload(sc->sc_dmat, dmamap);
 	bus_dmamap_destroy(sc->sc_dmat, dmamap);
 	bus_dmamem_unmap(sc->sc_dmat, kva, sizeof(*sc->sc_dma));
 	bus_dmamem_free(sc->sc_dmat, &seg, rseg);
 	/* Turn off DMA polling */
 	WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET |
 	    HIFN_DMACNFG_DMARESET | HIFN_DMACNFG_MODE);
 fail_io1:
 	bus_space_unmap(sc->sc_st1, sc->sc_sh1, iosize1);
 fail_io0:
 	bus_space_unmap(sc->sc_st0, sc->sc_sh0, iosize0);
+}
 static void
 hifn_rng_get(size_t bytes, void *priv)
+{
 	struct hifn_softc *sc = priv;
 	mutex_enter(&sc->sc_mtx);
 	sc->sc_rng_need = bytes;
 	hifn_rng_locked(sc);
 	mutex_exit(&sc->sc_mtx);
+}
 static int
 hifn_init_pubrng(struct hifn_softc *sc)
+{
 	u_int32_t r;
 	int i;
 	if ((sc->sc_flags & HIFN_IS_7811) == 0) {
 		/* Reset 7951 public key/rng engine */
 		WRITE_REG_1(sc, HIFN_1_PUB_RESET,
 		    READ_REG_1(sc, HIFN_1_PUB_RESET) | HIFN_PUBRST_RESET);
 		for (i = 0; i < 100; i++) {
 			DELAY(1000);
 @@ -490,182 +507,196 @@ hifn_init_pubrng(struct hifn_softc *sc)
 			    READ_REG_1(sc, HIFN_1_RNG_CONFIG) |
 			    HIFN_RNGCFG_ENA);
 		/*
 		 * The Hifn RNG documentation states that at their
 		 * recommended "conservative" RNG config values,
 		 * the RNG must warm up for 0.4s before providing
 		 * data that meet their worst-case estimate of 0.06
 		 * bits of random data per output register bit.
 		 */
 		DELAY(4000);
 #ifdef __NetBSD__
 		rndsource_setcb(&sc->sc_rnd_source, hifn_rng_get, sc);
 		/*
 		 * XXX Careful!  The use of RND_FLAG_NO_ESTIMATE
 		 * XXX here is unobvious: we later feed raw bits
 		 * XXX into the "entropy pool" with rnd_add_data,
 		 * XXX explicitly supplying an entropy estimate.
 		 * XXX In this context, NO_ESTIMATE serves only
 		 * XXX to prevent rnd_add_data from trying to
 		 * XXX use the *time at which we added the data*
 		 * XXX as entropy, which is not a good idea since
 		 * XXX we add data periodically from a callout.
 		 */
 		rnd_attach_source(&sc->sc_rnd_source, device_xname(sc->sc_dv),
-				  RND_TYPE_RNG, RND_FLAG_NO_ESTIMATE);
+				  RND_TYPE_RNG,
 				  RND_FLAG_NO_ESTIMATE|RND_FLAG_HASCB);
 #endif
 		sc->sc_rngfirst = 1;
 		if (hz >= 100)
 			sc->sc_rnghz = hz / 100;
 		else
 			sc->sc_rnghz = 1;
 #ifdef	__OpenBSD__
 		timeout_set(&sc->sc_rngto, hifn_rng, sc);
 #else	/* !__OpenBSD__ */
-		callout_init(&sc->sc_rngto, 0);
+		callout_init(&sc->sc_rngto, CALLOUT_MPSAFE);
 #endif	/* !__OpenBSD__ */
+	}
 	/* Enable public key engine, if available */
 	if (sc->sc_flags & HIFN_HAS_PUBLIC) {
 		WRITE_REG_1(sc, HIFN_1_PUB_IEN, HIFN_PUBIEN_DONE);
 		sc->sc_dmaier |= HIFN_DMAIER_PUBDONE;
 		WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
+	}
 	/* Call directly into the RNG once to prime the pool. */
 	hifn_rng(sc);   /* Sets callout/timeout at end */
 	return (0);
+}
 static void
-hifn_rng(void *vsc)
+hifn_rng_locked(void *vsc)
+{
 	struct hifn_softc *sc = vsc;
 #ifdef __NetBSD__
 	uint32_t num[64];
 #else
 	uint32_t num[2];
 #endif
 	uint32_t sts;
 	int i;
 	size_t got, gotent;
 	if (sc->sc_rng_need < 1) {
 		callout_stop(&sc->sc_rngto);
 		return;
+	}
 	if (sc->sc_flags & HIFN_IS_7811) {
 		for (i = 0; i < 5; i++) {	/* XXX why 5? */
 			sts = READ_REG_1(sc, HIFN_1_7811_RNGSTS);
 			if (sts & HIFN_7811_RNGSTS_UFL) {
 				printf("%s: RNG underflow: disabling\n",
 				    device_xname(sc->sc_dv));
 				return;
+			}
 			if ((sts & HIFN_7811_RNGSTS_RDY) == 0)
 				break;
 			/*
 			 * There are at least two words in the RNG FIFO
 			 * at this point.
 			 */
 			num[0] = READ_REG_1(sc, HIFN_1_7811_RNGDAT);
 			num[1] = READ_REG_1(sc, HIFN_1_7811_RNGDAT);
 			got = 2 * sizeof(num[0]);
 			gotent = (got * NBBY) / HIFN_RNG_BITSPER;
 			if (sc->sc_rngfirst)
 				sc->sc_rngfirst = 0;
 #ifdef __NetBSD__
-			rnd_add_data(&sc->sc_rnd_source, num,
+			rnd_add_data(&sc->sc_rnd_source, num, got, gotent);
-* sizeof(num[0]),
+			sc->sc_rng_need -= gotent;
 			    (2 * sizeof(num[0]) * NBBY) /
 			    HIFN_RNG_BITSPER);
 #else
 			/*
 			 * XXX This is a really bad idea.
 			 * XXX Hifn estimate as little as 0.06
 			 * XXX actual bits of entropy per output
 			 * XXX register bit.  How can we tell the
 			 * XXX kernel RNG subsystem we're handing
 			 * XXX it 64 "true" random bits, for any
 			 * XXX sane value of "true"?
 			 * XXX
 			 * XXX The right thing to do here, if we
 			 * XXX cannot supply an estimate ourselves,
 			 * XXX would be to hash the bits locally.
 			 */
 			add_true_randomness(num[0]);
 			add_true_randomness(num[1]);
 #endif
+		}
 	} else {
-#ifdef __NetBSD__
+		int nwords = 0;
 		/* First time through, try to help fill the pool. */
-		int nwords = sc->sc_rngfirst ?
+		if (sc->sc_rng_need) {
-		    sizeof(num) / sizeof(num[0]) : 4;
+			nwords = (sc->sc_rng_need * NBBY) / HIFN_RNG_BITSPER;
 #else
 		int nwords = 2;
-#endif
+		if (nwords < 2) {
 			nwords = 2;
+		}
 		/*
 		 * We must be *extremely* careful here.  The Hifn
 		 * 795x differ from the published 6500 RNG design
 		 * in more ways than the obvious lack of the output
 		 * FIFO and LFSR control registers.  In fact, there
 		 * is only one LFSR, instead of the 6500's two, and
 		 * it's 32 bits, not 31.
+		 *
 		 * Further, a block diagram obtained from Hifn shows
 		 * a very curious latching of this register: the LFSR
 		 * rotates at a frequency of RNG_Clk / 8, but the
 		 * RNG_Data register is latched at a frequency of
 		 * RNG_Clk, which means that it is possible for
 		 * consecutive reads of the RNG_Data register to read
 		 * identical state from the LFSR.  The simplest
 		 * workaround seems to be to read eight samples from
 		 * the register for each one that we use.  Since each
 		 * read must require at least one PCI cycle, and
 		 * RNG_Clk is at least PCI_Clk, this is safe.
 		 */
 		if (sc->sc_rngfirst) {
 			sc->sc_rngfirst = 0;
 		for(i = 0 ; i < nwords * 8; i++)
+		{
 			volatile u_int32_t regtmp;
 			regtmp = READ_REG_1(sc, HIFN_1_RNG_DATA);
 			num[i / 8] = regtmp;
+		}
 		got = nwords * sizeof(num[0]);
 		gotent = (got * NBBY) / HIFN_RNG_BITSPER;
 #ifdef __NetBSD__
-		rnd_add_data(&sc->sc_rnd_source, num,
+		rnd_add_data(&sc->sc_rnd_source, num, got, gotent);
-		    nwords * sizeof(num[0]),
+		sc->sc_rng_need -= gotent;
 		    (nwords * sizeof(num[0]) * NBBY) /
 		    HIFN_RNG_BITSPER);
 #else
 		/* XXX a bad idea; see 7811 block above */
 		add_true_randomness(num[0]);
 #endif
+	}
 #ifdef	__OpenBSD__
 	timeout_add(&sc->sc_rngto, sc->sc_rnghz);
 #else
-	callout_reset(&sc->sc_rngto, sc->sc_rnghz, hifn_rng, sc);
+	if (sc->sc_rng_need > 0) {
 		callout_reset(&sc->sc_rngto, sc->sc_rnghz, hifn_rng, sc);
+	}
 #endif
+}
 static void
 hifn_rng(void *vsc)
+{
 	struct hifn_softc *sc = vsc;
 	mutex_spin_enter(&sc->sc_mtx);
 	hifn_rng_locked(vsc);
 	mutex_spin_exit(&sc->sc_mtx);
+}
 static void
 hifn_puc_wait(struct hifn_softc *sc)
+{
 	int i;
 	for (i = 5000; i > 0; i--) {
 		DELAY(1);
 		if (!(READ_REG_0(sc, HIFN_0_PUCTRL) & HIFN_PUCTRL_RESET))
 			break;
+	}
 	if (!i)
 		printf("%s: proc unit did not reset\n", device_xname(sc->sc_dv));
+}
 @@ -1580,27 +1611,27 @@ hifn_dmamap_load_src(struct hifn_softc *
+		}
+	}
 	dma->srci = idx;
 	dma->srcu += map->dm_nsegs;
 	return (idx);
+}
 static int
 hifn_crypto(struct hifn_softc *sc, struct hifn_command *cmd,
     struct cryptop *crp, int hint)
+{
 	struct	hifn_dma *dma = sc->sc_dma;
 	u_int32_t cmdlen;
-	int	cmdi, resi, s, err = 0;
+	int	cmdi, resi, err = 0;
 	if (bus_dmamap_create(sc->sc_dmat, HIFN_MAX_DMALEN, MAX_SCATTER,
 	    HIFN_MAX_SEGLEN, 0, BUS_DMA_NOWAIT, &cmd->src_map))
 		return (ENOMEM);
 	if (crp->crp_flags & CRYPTO_F_IMBUF) {
 		if (bus_dmamap_load_mbuf(sc->sc_dmat, cmd->src_map,
 		    cmd->srcu.src_m, BUS_DMA_NOWAIT)) {
 			err = ENOMEM;
 			goto err_srcmap1;
+		}
 	} else if (crp->crp_flags & CRYPTO_F_IOV) {
 		if (bus_dmamap_load_uio(sc->sc_dmat, cmd->src_map,
 @@ -1710,41 +1741,37 @@ hifn_crypto(struct hifn_softc *sc, struc
 #endif
 	if (cmd->src_map == cmd->dst_map)
 		bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
 , cmd->src_map->dm_mapsize,
 		    BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
 	else {
 		bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
 , cmd->src_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
 		bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
 , cmd->dst_map->dm_mapsize, BUS_DMASYNC_PREREAD);
+	}
 	s = splnet();
 	/*
 	 * need 1 cmd, and 1 res
 	 * need N src, and N dst
 	 */
 	if ((dma->cmdu + 1) > HIFN_D_CMD_RSIZE ||
 	    (dma->resu + 1) > HIFN_D_RES_RSIZE) {
 		splx(s);
 		err = ENOMEM;
 		goto err_dstmap;
+	}
 	if ((dma->srcu + cmd->src_map->dm_nsegs) > HIFN_D_SRC_RSIZE ||
 	    (dma->dstu + cmd->dst_map->dm_nsegs + 1) > HIFN_D_DST_RSIZE) {
 		splx(s);
 		err = ENOMEM;
 		goto err_dstmap;
+	}
 	if (dma->cmdi == HIFN_D_CMD_RSIZE) {
 		dma->cmdi = 0;
 		dma->cmdr[HIFN_D_CMD_RSIZE].l = htole32(HIFN_D_VALID |
 		    HIFN_D_JUMP | HIFN_D_MASKDONEIRQ);
 		HIFN_CMDR_SYNC(sc, HIFN_D_CMD_RSIZE,
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
+	}
 	cmdi = dma->cmdi++;
 	cmdlen = hifn_write_command(cmd, dma->command_bufs[cmdi]);
 @@ -1827,52 +1854,50 @@ hifn_crypto(struct hifn_softc *sc, struc
 	if (sc->sc_d_busy == 0) {
 		WRITE_REG_1(sc, HIFN_1_DMA_CSR, HIFN_DMACSR_D_CTRL_ENA);
 		sc->sc_d_busy = 1;
+	}
 #ifdef HIFN_DEBUG
 	if (hifn_debug)
 		printf("%s: command: stat %8x ier %8x\n",
 		    device_xname(sc->sc_dv),
 		    READ_REG_1(sc, HIFN_1_DMA_CSR), READ_REG_1(sc, HIFN_1_DMA_IER));
 #endif
 	sc->sc_active = 5;
 	splx(s);
 	return (err);		/* success */
 err_dstmap:
 	if (cmd->src_map != cmd->dst_map)
 		bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
 err_dstmap1:
 	if (cmd->src_map != cmd->dst_map)
 		bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
 err_srcmap:
 	if (crp->crp_flags & CRYPTO_F_IMBUF &&
 	    cmd->srcu.src_m != cmd->dstu.dst_m)
 		m_freem(cmd->dstu.dst_m);
 	bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
 err_srcmap1:
 	bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
 	return (err);
+}
 static void
 hifn_tick(void *vsc)
+{
 	struct hifn_softc *sc = vsc;
 	int s;
-	s = splnet();
+	mutex_spin_enter(&sc->sc_mtx);
 	if (sc->sc_active == 0) {
 		struct hifn_dma *dma = sc->sc_dma;
 		u_int32_t r = 0;
 		if (dma->cmdu == 0 && sc->sc_c_busy) {
 			sc->sc_c_busy = 0;
 			r |= HIFN_DMACSR_C_CTRL_DIS;
 			CLR_LED(sc, HIFN_MIPSRST_LED0);
+		}
 		if (dma->srcu == 0 && sc->sc_s_busy) {
 			sc->sc_s_busy = 0;
 			r |= HIFN_DMACSR_S_CTRL_DIS;
 			CLR_LED(sc, HIFN_MIPSRST_LED1);
 @@ -1881,55 +1906,59 @@ hifn_tick(void *vsc)
 			sc->sc_d_busy = 0;
 			r |= HIFN_DMACSR_D_CTRL_DIS;
+		}
 		if (dma->resu == 0 && sc->sc_r_busy) {
 			sc->sc_r_busy = 0;
 			r |= HIFN_DMACSR_R_CTRL_DIS;
 			CLR_LED(sc, HIFN_MIPSRST_LED2);
+		}
 		if (r)
 			WRITE_REG_1(sc, HIFN_1_DMA_CSR, r);
+	}
 	else
 		sc->sc_active--;
 	splx(s);
 #ifdef	__OpenBSD__
 	timeout_add(&sc->sc_tickto, hz);
 #else
 	callout_reset(&sc->sc_tickto, hz, hifn_tick, sc);
 #endif
 	mutex_spin_exit(&sc->sc_mtx);
+}
 static int
 hifn_intr(void *arg)
+{
 	struct hifn_softc *sc = arg;
 	struct hifn_dma *dma = sc->sc_dma;
 	u_int32_t dmacsr, restart;
 	int i, u;
 	dmacsr = READ_REG_1(sc, HIFN_1_DMA_CSR);
 #ifdef HIFN_DEBUG
 	if (hifn_debug)
 		printf("%s: irq: stat %08x ien %08x u %d/%d/%d/%d\n",
 		       device_xname(sc->sc_dv),
 		       dmacsr, READ_REG_1(sc, HIFN_1_DMA_IER),
 		       dma->cmdu, dma->srcu, dma->dstu, dma->resu);
 #endif
 	mutex_spin_enter(&sc->sc_mtx);
 	/* Nothing in the DMA unit interrupted */
-	if ((dmacsr & sc->sc_dmaier) == 0)
+	if ((dmacsr & sc->sc_dmaier) == 0) {
 		mutex_spin_exit(&sc->sc_mtx);
 		return (0);
+	}
 	WRITE_REG_1(sc, HIFN_1_DMA_CSR, dmacsr & sc->sc_dmaier);
 	if (dmacsr & HIFN_DMACSR_ENGINE)
 		WRITE_REG_0(sc, HIFN_0_PUISR, READ_REG_0(sc, HIFN_0_PUISR));
 	if ((sc->sc_flags & HIFN_HAS_PUBLIC) &&
 	    (dmacsr & HIFN_DMACSR_PUBDONE))
 		WRITE_REG_1(sc, HIFN_1_PUB_STATUS,
 		    READ_REG_1(sc, HIFN_1_PUB_STATUS) | HIFN_PUBSTS_DONE);
 	restart = dmacsr & (HIFN_DMACSR_R_OVER | HIFN_DMACSR_D_OVER);
 	if (restart)
 @@ -1938,27 +1967,27 @@ hifn_intr(void *arg)
 	if (sc->sc_flags & HIFN_IS_7811) {
 		if (dmacsr & HIFN_DMACSR_ILLR)
 			printf("%s: illegal read\n", device_xname(sc->sc_dv));
 		if (dmacsr & HIFN_DMACSR_ILLW)
 			printf("%s: illegal write\n", device_xname(sc->sc_dv));
+	}
 	restart = dmacsr & (HIFN_DMACSR_C_ABORT | HIFN_DMACSR_S_ABORT |
 	    HIFN_DMACSR_D_ABORT | HIFN_DMACSR_R_ABORT);
 	if (restart) {
 		printf("%s: abort, resetting.\n", device_xname(sc->sc_dv));
 		hifnstats.hst_abort++;
 		hifn_abort(sc);
-		return (1);
+		goto out;
+	}
 	if ((dmacsr & HIFN_DMACSR_C_WAIT) && (dma->resu == 0)) {
 		/*
 		 * If no slots to process and we receive a "waiting on
 		 * command" interrupt, we disable the "waiting on command"
 		 * (by clearing it).
 		 */
 		sc->sc_dmaier &= ~HIFN_DMAIER_C_WAIT;
 		WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier);
+	}
 	/* clear the rings */
 @@ -2016,149 +2045,169 @@ hifn_intr(void *arg)
 			HIFN_CMDR_SYNC(sc, i,
 			    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 			break;
+		}
 		if (i != HIFN_D_CMD_RSIZE) {
 			u--;
 			HIFN_CMD_SYNC(sc, i, BUS_DMASYNC_POSTWRITE);
+		}
 		if (++i == (HIFN_D_CMD_RSIZE + 1))
 			i = 0;
+	}
 	dma->cmdk = i; dma->cmdu = u;
 out:
 	mutex_spin_exit(&sc->sc_mtx);
 	return (1);
+}
 /*
  * Allocate a new 'session' and return an encoded session id.  'sidp'
  * contains our registration id, and should contain an encoded session
  * id on successful allocation.
  */
 static int
 hifn_newsession(void *arg, u_int32_t *sidp, struct cryptoini *cri)
+{
 	struct cryptoini *c;
 	struct hifn_softc *sc = arg;
-	int i, mac = 0, cry = 0, comp = 0;
+	int i, mac = 0, cry = 0, comp = 0, retval = EINVAL;
 	KASSERT(sc != NULL /*, ("hifn_newsession: null softc")*/);
 	if (sidp == NULL || cri == NULL || sc == NULL)
-		return (EINVAL);
+		return retval;
 	mutex_spin_enter(&sc->sc_mtx);
 	for (i = 0; i < sc->sc_maxses; i++)
 		if (sc->sc_sessions[i].hs_state == HS_STATE_FREE)
 			break;
-	if (i == sc->sc_maxses)
+	if (i == sc->sc_maxses) {
-		return (ENOMEM);
+		retval = ENOMEM;
 		goto out;
+	}
 	for (c = cri; c != NULL; c = c->cri_next) {
 		switch (c->cri_alg) {
 		case CRYPTO_MD5:
 		case CRYPTO_SHA1:
 		case CRYPTO_MD5_HMAC_96:
 		case CRYPTO_SHA1_HMAC_96:
-			if (mac)
+			if (mac) {
-				return (EINVAL);
+				goto out;
+			}
 			mac = 1;
 			break;
 		case CRYPTO_DES_CBC:
 		case CRYPTO_3DES_CBC:
 		case CRYPTO_AES_CBC:
 			/* Note that this is an initialization
 			   vector, not a cipher key; any function
 			   giving sufficient Hamming distance
 			   between outputs is fine.  Use of RC4
 			   to generate IVs has been FIPS140-2
 			   certified by several labs. */
 #ifdef __NetBSD__
 			cprng_fast(sc->sc_sessions[i].hs_iv,
 			    c->cri_alg == CRYPTO_AES_CBC ?
 				HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
 #else	/* FreeBSD and OpenBSD have get_random_bytes */
 			/* XXX this may read fewer, does it matter? */
  			get_random_bytes(sc->sc_sessions[i].hs_iv,
 				c->cri_alg == CRYPTO_AES_CBC ?
 					HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH);
 #endif
 			/*FALLTHROUGH*/
 		case CRYPTO_ARC4:
-			if (cry)
+			if (cry) {
-				return (EINVAL);
+				goto out;
+			}
 			cry = 1;
 			break;
 #ifdef HAVE_CRYPTO_LZS
 		case CRYPTO_LZS_COMP:
-			if (comp)
+			if (comp) {
-				return (EINVAL);
+				goto out;
+			}
 			comp = 1;
 			break;
 #endif
 		default:
-			return (EINVAL);
+			goto out;
+		}
+	}
-	if (mac == 0 && cry == 0 && comp == 0)
+	if (mac == 0 && cry == 0 && comp == 0) {
-		return (EINVAL);
+		goto out;
+	}
 	/*
 	 * XXX only want to support compression without chaining to
 	 * MAC/crypt engine right now
 	 */
-	if ((comp && mac) || (comp && cry))
+	if ((comp && mac) || (comp && cry)) {
-		return (EINVAL);
+		goto out;
+	}
 	*sidp = HIFN_SID(device_unit(sc->sc_dv), i);
 	sc->sc_sessions[i].hs_state = HS_STATE_USED;
-	return (0);
+	retval = 0;
 out:
 	mutex_spin_exit(&sc->sc_mtx);
 	return retval;
+}
 /*
  * Deallocate a session.
  * XXX this routine should run a zero'd mac/encrypt key into context ram.
  * XXX to blow away any keys already stored there.
  */
 static int
 hifn_freesession(void *arg, u_int64_t tid)
+{
 	struct hifn_softc *sc = arg;
 	int session;
 	u_int32_t sid = ((u_int32_t) tid) & 0xffffffff;
 	KASSERT(sc != NULL /*, ("hifn_freesession: null softc")*/);
 	if (sc == NULL)
 		return (EINVAL);
 	mutex_spin_enter(&sc->sc_mtx);
 	session = HIFN_SESSION(sid);
-	if (session >= sc->sc_maxses)
+	if (session >= sc->sc_maxses) {
 		mutex_spin_exit(&sc->sc_mtx);
 		return (EINVAL);
+	}
 	memset(&sc->sc_sessions[session], 0, sizeof(sc->sc_sessions[session]));
 	mutex_spin_exit(&sc->sc_mtx);
 	return (0);
+}
 static int
 hifn_process(void *arg, struct cryptop *crp, int hint)
+{
 	struct hifn_softc *sc = arg;
 	struct hifn_command *cmd = NULL;
 	int session, err, ivlen;
 	struct cryptodesc *crd1, *crd2, *maccrd, *enccrd;
 	if (crp == NULL || crp->crp_callback == NULL) {
 		hifnstats.hst_invalid++;
 		return (EINVAL);
+	}
 	mutex_spin_enter(&sc->sc_mtx);
 	session = HIFN_SESSION(crp->crp_sid);
 	if (sc == NULL || session >= sc->sc_maxses) {
 		err = EINVAL;
 		goto errout;
+	}
 	cmd = (struct hifn_command *)malloc(sizeof(struct hifn_command),
 	    M_DEVBUF, M_NOWAIT|M_ZERO);
 	if (cmd == NULL) {
 		hifnstats.hst_nomem++;
 		err = ENOMEM;
 		goto errout;
 @@ -2367,50 +2416,53 @@ hifn_process(void *arg, struct cryptop *
+	}
 	cmd->crp = crp;
 	cmd->session_num = session;
 	cmd->softc = sc;
 	err = hifn_crypto(sc, cmd, crp, hint);
 	if (err == 0) {
 		if (enccrd)
 			sc->sc_sessions[session].hs_prev_op =
 				enccrd->crd_flags & CRD_F_ENCRYPT;
 		if (sc->sc_sessions[session].hs_state == HS_STATE_USED)
 			sc->sc_sessions[session].hs_state = HS_STATE_KEY;
 		mutex_spin_exit(&sc->sc_mtx);
 		return 0;
 	} else if (err == ERESTART) {
 		/*
 		 * There weren't enough resources to dispatch the request
 		 * to the part.  Notify the caller so they'll requeue this
 		 * request and resubmit it again soon.
 		 */
 #ifdef HIFN_DEBUG
 		if (hifn_debug)
 			printf("%s: requeue request\n", device_xname(sc->sc_dv));
 #endif
 		free(cmd, M_DEVBUF);
 		sc->sc_needwakeup |= CRYPTO_SYMQ;
 		mutex_spin_exit(&sc->sc_mtx);
 		return (err);
+	}
 errout:
 	if (cmd != NULL)
 		free(cmd, M_DEVBUF);
 	if (err == EINVAL)
 		hifnstats.hst_invalid++;
 	else
 		hifnstats.hst_nomem++;
 	crp->crp_etype = err;
 	mutex_spin_exit(&sc->sc_mtx);
 	crypto_done(crp);
 	return (0);
+}
 static void
 hifn_abort(struct hifn_softc *sc)
+{
 	struct hifn_dma *dma = sc->sc_dma;
 	struct hifn_command *cmd;
 	struct cryptop *crp;
 	int i, u;
 	i = dma->resk; u = dma->resu;
 @@ -2706,58 +2758,53 @@ hifn_compression(struct hifn_softc *sc,
 		bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
 , cmd->dst_map->dm_mapsize, BUS_DMASYNC_PREREAD);
+	}
 	cmd->crp = crp;
 	/*
 	 * Always use session 0.  The modes of compression we use are
 	 * stateless and there is always at least one compression
 	 * context, zero.
 	 */
 	cmd->session_num = 0;
 	cmd->softc = sc;
 	s = splnet();
 	err = hifn_compress_enter(sc, cmd);
 	splx(s);
 	if (err != 0)
 		goto fail;
 	return (0);
 fail:
 	if (cmd->dst_map != NULL) {
 		if (cmd->dst_map->dm_nsegs > 0)
 			bus_dmamap_unload(sc->sc_dmat, cmd->dst_map);
 		bus_dmamap_destroy(sc->sc_dmat, cmd->dst_map);
+	}
 	if (cmd->src_map != NULL) {
 		if (cmd->src_map->dm_nsegs > 0)
 			bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
 		bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
+	}
 	free(cmd, M_DEVBUF);
 	if (err == EINVAL)
 		hifnstats.hst_invalid++;
 	else
 		hifnstats.hst_nomem++;
 	crp->crp_etype = err;
 	crypto_done(crp);
 	return (0);
+}
 /*
  * must be called at splnet()
  */
 static int
 hifn_compress_enter(struct hifn_softc *sc, struct hifn_command *cmd)
+{
 	struct hifn_dma *dma = sc->sc_dma;
 	int cmdi, resi;
 	u_int32_t cmdlen;
 	if ((dma->cmdu + 1) > HIFN_D_CMD_RSIZE ||
 	    (dma->resu + 1) > HIFN_D_CMD_RSIZE)
 		return (ENOMEM);
 	if ((dma->srcu + cmd->src_map->dm_nsegs) > HIFN_D_SRC_RSIZE ||
 	    (dma->dstu + cmd->dst_map->dm_nsegs) > HIFN_D_DST_RSIZE)
 @@ -2911,27 +2958,26 @@ hifn_callback_comp(struct hifn_softc *sc
 			goto out;
+		}
 		if (bus_dmamap_load_mbuf(sc->sc_dmat, cmd->dst_map,
 		    cmd->dstu.dst_m, BUS_DMA_NOWAIT)) {
 			err = ENOMEM;
 			goto out;
+		}
 		bus_dmamap_sync(sc->sc_dmat, cmd->src_map,
 , cmd->src_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
 		bus_dmamap_sync(sc->sc_dmat, cmd->dst_map,
 , cmd->dst_map->dm_mapsize, BUS_DMASYNC_PREREAD);
 		/* already at splnet... */
 		err = hifn_compress_enter(sc, cmd);
 		if (err != 0)
 			goto out;
 		return;
+	}
 	olen = dstsize - (letoh16(baseres.dst_cnt) |
 	    (((letoh16(baseres.session) & HIFN_BASE_RES_DSTLEN_M) >>
 	    HIFN_BASE_RES_DSTLEN_S) << 16));
 	crp->crp_olen = olen - cmd->compcrd->crd_skip;
 	bus_dmamap_unload(sc->sc_dmat, cmd->src_map);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ubsec.c,v 1.28 2012/10/27 17:18:35 chs Exp $	*/
+/*	$NetBSD: ubsec.c,v 1.29 2013/06/13 00:55:01 tls Exp $	*/
 /* $FreeBSD: src/sys/dev/ubsec/ubsec.c,v 1.6.2.6 2003/01/23 21:06:43 sam Exp $ */
 /*	$OpenBSD: ubsec.c,v 1.127 2003/06/04 14:04:58 jason Exp $	*/
 /*
  * Copyright (c) 2000 Jason L. Wright (jason@thought.net)
  * Copyright (c) 2000 Theo de Raadt (deraadt@openbsd.org)
  * Copyright (c) 2001 Patrik Lindergren (patrik@ipunplugged.com)
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -25,42 +25,42 @@
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
+ *
  * Effort sponsored in part by the Defense Advanced Research Projects
  * Agency (DARPA) and Air Force Research Laboratory, Air Force
  * Materiel Command, USAF, under agreement number F30602-01-2-0537.
+ *
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ubsec.c,v 1.28 2012/10/27 17:18:35 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ubsec.c,v 1.29 2013/06/13 00:55:01 tls Exp $");
 #undef UBSEC_DEBUG
 /*
  * uBsec 5[56]01, bcm580xx, bcm582x hardware crypto accelerator
  */
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/endian.h>
 #ifdef __NetBSD__
   #define UBSEC_NO_RNG	/* hangs on attach */
   #define letoh16 htole16
   #define letoh32 htole32
 #define UBSEC_NO_RNG		/* until statistically tested */
 #endif
 #include <sys/errno.h>
 #include <sys/malloc.h>
 #include <sys/kernel.h>
 #include <sys/mbuf.h>
 #include <sys/device.h>
 #include <sys/queue.h>
 #include <opencrypto/cryptodev.h>
 #include <opencrypto/xform.h>
 #ifdef __OpenBSD__
  #include <dev/rndvar.h>
  #include <sys/md5k.h>
 @@ -109,27 +109,29 @@ extern int ubsec_debug;
 int ubsec_debug=1;
 #endif
 static	int	ubsec_intr(void *);
 static	int	ubsec_newsession(void*, u_int32_t *, struct cryptoini *);
 static	int	ubsec_freesession(void*, u_int64_t);
 static	int	ubsec_process(void*, struct cryptop *, int hint);
 static	void	ubsec_callback(struct ubsec_softc *, struct ubsec_q *);
 static	void	ubsec_feed(struct ubsec_softc *);
 static	void	ubsec_mcopy(struct mbuf *, struct mbuf *, int, int);
 static	void	ubsec_callback2(struct ubsec_softc *, struct ubsec_q2 *);
 static	void	ubsec_feed2(struct ubsec_softc *);
 #ifndef UBSEC_NO_RNG
-static	void	ubsec_rng(void *);
+static  void	ubsec_rng(void *);
 static  void	ubsec_rng_locked(void *);
 static  void	ubsec_rng_get(size_t, void *);
 #endif /* UBSEC_NO_RNG */
 static	int 	ubsec_dma_malloc(struct ubsec_softc *, bus_size_t,
 				 struct ubsec_dma_alloc *, int);
 static	void	ubsec_dma_free(struct ubsec_softc *, struct ubsec_dma_alloc *);
 static	int	ubsec_dmamap_aligned(bus_dmamap_t);
 static	int	ubsec_kprocess(void*, struct cryptkop *, int);
 static	int	ubsec_kprocess_modexp_sw(struct ubsec_softc *,
 					 struct cryptkop *, int);
 static	int	ubsec_kprocess_modexp_hw(struct ubsec_softc *,
 					 struct cryptkop *, int);
 static	int	ubsec_kprocess_rsapriv(struct ubsec_softc *,
 				       struct cryptkop *, int);
 @@ -349,26 +351,29 @@ ubsec_attach(device_t parent, device_t s
 			aprint_error(" at %s", intrstr);
 		aprint_error("\n");
 		return;
+	}
 	aprint_normal_dev(self, "interrupting at %s\n", intrstr);
 	sc->sc_cid = crypto_get_driverid(0);
 	if (sc->sc_cid < 0) {
 		aprint_error_dev(self, "couldn't get crypto driver id\n");
 		pci_intr_disestablish(pc, sc->sc_ih);
 		return;
+	}
 	sc->sc_rng_need = RND_POOLBITS / NBBY;
 	mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_VM);
 	SIMPLEQ_INIT(&sc->sc_freequeue);
 	dmap = sc->sc_dmaa;
 	for (i = 0; i < UBS_MAX_NQUEUE; i++, dmap++) {
 		struct ubsec_q *q;
 		q = (struct ubsec_q *)malloc(sizeof(struct ubsec_q),
 		    M_DEVBUF, M_NOWAIT);
 		if (q == NULL) {
 			aprint_error_dev(self, "can't allocate queue buffers\n");
 			break;
+		}
 		if (ubsec_dma_malloc(sc, sizeof(struct ubsec_dmachunk),
 @@ -420,26 +425,30 @@ ubsec_attach(device_t parent, device_t s
 		if (ubsec_dma_malloc(sc, sizeof(struct ubsec_ctx_rngbypass),
 		    &sc->sc_rng.rng_q.q_ctx, 0)) {
 			ubsec_dma_free(sc, &sc->sc_rng.rng_q.q_mcr);
 			goto skip_rng;
+		}
 		if (ubsec_dma_malloc(sc, sizeof(u_int32_t) *
 		    UBSEC_RNG_BUFSIZ, &sc->sc_rng.rng_buf, 0)) {
 			ubsec_dma_free(sc, &sc->sc_rng.rng_q.q_ctx);
 			ubsec_dma_free(sc, &sc->sc_rng.rng_q.q_mcr);
 			goto skip_rng;
+		}
 		rndsource_setcb(&sc->sc_rnd_source, ubsec_rng_get, sc);
 		rnd_attach_source(&sc->sc_rnd_source, device_xname(sc->sc_dev),
 				  RND_TYPE_RNG,
 				  RND_FLAG_NO_ESTIMATE|RND_FLAG_HASCB);
 		if (hz >= 100)
 			sc->sc_rnghz = hz / 100;
 		else
 			sc->sc_rnghz = 1;
 #ifdef __OpenBSD__
 		timeout_set(&sc->sc_rngto, ubsec_rng, sc);
 		timeout_add(&sc->sc_rngto, sc->sc_rnghz);
 #else
 		callout_init(&sc->sc_rngto, 0);
 		callout_reset(&sc->sc_rngto, sc->sc_rnghz, ubsec_rng, sc);
 #endif
  skip_rng:
 		if (sc->sc_rnghz)
 @@ -464,29 +473,31 @@ ubsec_attach(device_t parent, device_t s
 /*
  * UBSEC Interrupt routine
  */
 static int
 ubsec_intr(void *arg)
+{
 	struct ubsec_softc *sc = arg;
 	volatile u_int32_t stat;
 	struct ubsec_q *q;
 	struct ubsec_dma *dmap;
 	int npkts = 0, i;
 	mutex_spin_enter(&sc->sc_mtx);
 	stat = READ_REG(sc, BS_STAT);
 	stat &= sc->sc_statmask;
 	if (stat == 0) {
 		mutex_spin_exit(&sc->sc_mtx);
 		return (0);
+	}
 	WRITE_REG(sc, BS_STAT, stat);		/* IACK */
 	/*
 	 * Check to see if we have any packets waiting for us
 	 */
 	if ((stat & BS_STAT_MCR1_DONE)) {
 		while (!SIMPLEQ_EMPTY(&sc->sc_qchip)) {
 			q = SIMPLEQ_FIRST(&sc->sc_qchip);
 			dmap = q->q_dma;
 @@ -573,26 +584,27 @@ ubsec_intr(void *arg)
 		ubsec_feed(sc);
+	}
 	if (sc->sc_needwakeup) {		/* XXX check high watermark */
 		int wkeup = sc->sc_needwakeup & (CRYPTO_SYMQ|CRYPTO_ASYMQ);
 #ifdef UBSEC_DEBUG
 		if (ubsec_debug)
 			printf("%s: wakeup crypto (%x)\n", device_xname(sc->sc_dev),
 				sc->sc_needwakeup);
 #endif /* UBSEC_DEBUG */
 		sc->sc_needwakeup &= ~wkeup;
 		crypto_unblock(sc->sc_cid, wkeup);
+	}
 	mutex_spin_exit(&sc->sc_mtx);
 	return (1);
+}
 /*
  * ubsec_feed() - aggregate and post requests to chip
  * OpenBSD comments:
  *		  It is assumed that the caller set splnet()
  */
 static void
 ubsec_feed(struct ubsec_softc *sc)
+{
 	struct ubsec_q *q, *q2;
 	int npkts, i;
 @@ -916,60 +928,60 @@ ubsec_op_cb(void *arg, bus_dma_segment_t
 	op->mapsize = mapsize;
 	op->nsegs = nsegs;
 	memcpy(op->segs, seg, nsegs * sizeof (seg[0]));
+}
 #endif
 static int
 ubsec_process(void *arg, struct cryptop *crp, int hint)
+{
 	struct ubsec_q *q = NULL;
 #ifdef	__OpenBSD__
 	int card;
 #endif
-	int err = 0, i, j, s, nicealign;
+	int err = 0, i, j, nicealign;
 	struct ubsec_softc *sc;
 	struct cryptodesc *crd1, *crd2, *maccrd, *enccrd;
 	int encoffset = 0, macoffset = 0, cpskip, cpoffset;
 	int sskip, dskip, stheend, dtheend;
 	int16_t coffset;
 	struct ubsec_session *ses;
 	struct ubsec_pktctx ctx;
 	struct ubsec_dma *dmap = NULL;
 	sc = arg;
 	KASSERT(sc != NULL /*, ("ubsec_process: null softc")*/);
 	if (crp == NULL || crp->crp_callback == NULL || sc == NULL) {
 		ubsecstats.hst_invalid++;
 		return (EINVAL);
+	}
 	if (UBSEC_SESSION(crp->crp_sid) >= sc->sc_nsessions) {
 		ubsecstats.hst_badsession++;
 		return (EINVAL);
+	}
-	s = splnet();
+	mutex_spin_enter(&sc->sc_mtx);
 	if (SIMPLEQ_EMPTY(&sc->sc_freequeue)) {
 		ubsecstats.hst_queuefull++;
 		sc->sc_needwakeup |= CRYPTO_SYMQ;
-		splx(s);
+		mutex_spin_exit(&sc->sc_mtx);
 		return(ERESTART);
+	}
 	q = SIMPLEQ_FIRST(&sc->sc_freequeue);
 	SIMPLEQ_REMOVE_HEAD(&sc->sc_freequeue, /*q,*/ q_next);
-	splx(s);
+	mutex_spin_exit(&sc->sc_mtx);
 	dmap = q->q_dma; /* Save dma pointer */
 	memset(q, 0, sizeof(struct ubsec_q));
 	memset(&ctx, 0, sizeof(ctx));
 	q->q_sesn = UBSEC_SESSION(crp->crp_sid);
 	q->q_dma = dmap;
 	ses = &sc->sc_sessions[q->q_sesn];
 	if (crp->crp_flags & CRYPTO_F_IMBUF) {
 		q->q_src_m = (struct mbuf *)crp->crp_buf;
 		q->q_dst_m = (struct mbuf *)crp->crp_buf;
 	} else if (crp->crp_flags & CRYPTO_F_IOV) {
 @@ -1426,53 +1438,53 @@ ubsec_process(void *arg, struct cryptop
 		for (i = 0; i < 6; i++)
 			ctxl->pc_deskey[i] = ctx.pc_deskey[i];
 		for (i = 0; i < 5; i++)
 			ctxl->pc_hminner[i] = ctx.pc_hminner[i];
 		for (i = 0; i < 5; i++)
 			ctxl->pc_hmouter[i] = ctx.pc_hmouter[i];
 		ctxl->pc_iv[0] = ctx.pc_iv[0];
 		ctxl->pc_iv[1] = ctx.pc_iv[1];
 	} else
 		memcpy((char *)dmap->d_alloc.dma_vaddr +
 		    offsetof(struct ubsec_dmachunk, d_ctx), &ctx,
 		    sizeof(struct ubsec_pktctx));
-	s = splnet();
+	mutex_spin_enter(&sc->sc_mtx);
 	SIMPLEQ_INSERT_TAIL(&sc->sc_queue, q, q_next);
 	sc->sc_nqueue++;
 	ubsecstats.hst_ipackets++;
 	ubsecstats.hst_ibytes += dmap->d_alloc.dma_map->dm_mapsize;
 	if ((hint & CRYPTO_HINT_MORE) == 0 || sc->sc_nqueue >= ubsec_maxbatch)
 		ubsec_feed(sc);
-	splx(s);
+	mutex_spin_exit(&sc->sc_mtx);
 	return (0);
 errout:
 	if (q != NULL) {
 		if ((q->q_dst_m != NULL) && (q->q_src_m != q->q_dst_m))
 			m_freem(q->q_dst_m);
 		if (q->q_dst_map != NULL && q->q_dst_map != q->q_src_map) {
 			bus_dmamap_unload(sc->sc_dmat, q->q_dst_map);
 			bus_dmamap_destroy(sc->sc_dmat, q->q_dst_map);
+		}
 		if (q->q_src_map != NULL) {
 			bus_dmamap_unload(sc->sc_dmat, q->q_src_map);
 			bus_dmamap_destroy(sc->sc_dmat, q->q_src_map);
+		}
-		s = splnet();
+		mutex_spin_enter(&sc->sc_mtx);
 		SIMPLEQ_INSERT_TAIL(&sc->sc_freequeue, q, q_next);
-		splx(s);
+		mutex_spin_exit(&sc->sc_mtx);
+	}
 #if 0 /* jonathan says: this openbsd code seems to be subsumed elsewhere */
 	if (err == EINVAL)
 		ubsecstats.hst_invalid++;
 	else
 		ubsecstats.hst_nomem++;
 #endif
 	if (err != ERESTART) {
 		crp->crp_etype = err;
 		crypto_done(crp);
 	} else {
 		sc->sc_needwakeup |= CRYPTO_SYMQ;
+	}
 @@ -1628,33 +1640,38 @@ ubsec_callback2(struct ubsec_softc *sc,
 	case UBS_CTXOP_RNGBYPASS: {
 		struct ubsec_q2_rng *rng = (struct ubsec_q2_rng *)q;
 		u_int32_t *p;
 		int i;
 		bus_dmamap_sync(sc->sc_dmat, rng->rng_buf.dma_map, 0,
 		    rng->rng_buf.dma_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
 		p = (u_int32_t *)rng->rng_buf.dma_vaddr;
 #ifndef __NetBSD__
 		for (i = 0; i < UBSEC_RNG_BUFSIZ; p++, i++)
 			add_true_randomness(letoh32(*p));
 		rng->rng_used = 0;
 #else
-		/* XXX NetBSD rnd subsystem too weak */
+		i = UBSEC_RNG_BUFSIZ * sizeof(u_int32_t);
-		i = 0; (void)i;	/* shut off gcc warnings */
+		rnd_add_data(&sc->sc_rnd_source, (char *)p, i, i * NBBY);
 		sc->sc_rng_need -= i;
 		rng->rng_used = 0;
 #endif
 #ifdef __OpenBSD__
 		timeout_add(&sc->sc_rngto, sc->sc_rnghz);
 #else
-		callout_reset(&sc->sc_rngto, sc->sc_rnghz, ubsec_rng, sc);
+		if (sc->sc_rng_need > 0) {
 			callout_reset(&sc->sc_rngto, sc->sc_rnghz,
 				      ubsec_rng, sc);
+		}
 #endif
 		break;
+	}
 #endif
 	case UBS_CTXOP_MODEXP: {
 		struct ubsec_q2_modexp *me = (struct ubsec_q2_modexp *)q;
 		u_int rlen, clen;
 		krp = me->me_krp;
 		rlen = (me->me_modbits + 7) / 8;
 		clen = (krp->krp_param[krp->krp_iparams].crp_nbits + 7) / 8;
 		bus_dmamap_sync(sc->sc_dmat, me->me_M.dma_map,
 @@ -1717,40 +1734,68 @@ ubsec_callback2(struct ubsec_softc *sc,
 		/* Can't free here, so put us on the free list. */
 		SIMPLEQ_INSERT_TAIL(&sc->sc_q2free, &rp->rpr_q, q_next);
 		break;
+	}
 	default:
 		printf("%s: unknown ctx op: %x\n", device_xname(sc->sc_dev),
 		    letoh16(ctx->ctx_op));
 		break;
+	}
+}
 #ifndef UBSEC_NO_RNG
 static void
 ubsec_rng_get(size_t bytes, void *vsc)
+{
 	struct ubsec_softc *sc = vsc;
 	mutex_spin_enter(&sc->sc_mtx);
 	sc->sc_rng_need = bytes;
 	ubsec_rng_locked(sc);
 	mutex_spin_exit(&sc->sc_mtx);
+}
 static void
 ubsec_rng(void *vsc)
+{
 	struct ubsec_softc *sc = vsc;
 	mutex_spin_enter(&sc->sc_mtx);
 	ubsec_rng_locked(sc);
 	mutex_spin_exit(&sc->sc_mtx);
+}
 static void
 ubsec_rng_locked(void *vsc)
+{
 	struct ubsec_softc *sc = vsc;
 	struct ubsec_q2_rng *rng = &sc->sc_rng;
 	struct ubsec_mcr *mcr;
 	struct ubsec_ctx_rngbypass *ctx;
 	int s;
-	s = splnet();
+	mutex_spin_enter(&sc->sc_mtx);
 	if (rng->rng_used) {
-		splx(s);
+		mutex_spin_exit(&sc->sc_mtx);
 		return;
+	}
 	if (sc->sc_rng_need < 1) {
 		callout_stop(&sc->sc_rngto);
 		mutex_spin_exit(&sc->sc_mtx);
 		return;
+	}
 	sc->sc_nqueue2++;
 	if (sc->sc_nqueue2 >= UBS_MAX_NQUEUE)
 		goto out;
 	mcr = (struct ubsec_mcr *)rng->rng_q.q_mcr.dma_vaddr;
 	ctx = (struct ubsec_ctx_rngbypass *)rng->rng_q.q_ctx.dma_vaddr;
 	mcr->mcr_pkts = htole16(1);
 	mcr->mcr_flags = 0;
 	mcr->mcr_cmdctxp = htole32(rng->rng_q.q_ctx.dma_paddr);
 	mcr->mcr_ipktbuf.pb_addr = mcr->mcr_ipktbuf.pb_next = 0;
 	mcr->mcr_ipktbuf.pb_len = 0;
 	mcr->mcr_reserved = mcr->mcr_pktlen = 0;
 @@ -1760,36 +1805,36 @@ ubsec_rng(void *vsc)
 	mcr->mcr_opktbuf.pb_next = 0;
 	ctx->rbp_len = htole16(sizeof(struct ubsec_ctx_rngbypass));
 	ctx->rbp_op = htole16(UBS_CTXOP_RNGSHA1);
 	rng->rng_q.q_type = UBS_CTXOP_RNGSHA1;
 	bus_dmamap_sync(sc->sc_dmat, rng->rng_buf.dma_map, 0,
 	    rng->rng_buf.dma_map->dm_mapsize, BUS_DMASYNC_PREREAD);
 	SIMPLEQ_INSERT_TAIL(&sc->sc_queue2, &rng->rng_q, q_next);
 	rng->rng_used = 1;
 	ubsec_feed2(sc);
 	ubsecstats.hst_rng++;
-	splx(s);
+	mutex_spin_exit(&sc->sc_mtx);
 	return;
 out:
 	/*
 	 * Something weird happened, generate our own call back.
 	 */
 	sc->sc_nqueue2--;
-	splx(s);
+	mutex_spin_exit(&sc->sc_mtx);
 #ifdef __OpenBSD__
 	timeout_add(&sc->sc_rngto, sc->sc_rnghz);
 #else
 	callout_reset(&sc->sc_rngto, sc->sc_rnghz, ubsec_rng, sc);
 #endif
+}
 #endif /* UBSEC_NO_RNG */
 static int
 ubsec_dma_malloc(struct ubsec_softc *sc, bus_size_t size,
 		 struct ubsec_dma_alloc *dma,int mapflags)
+{
 	int r;
 @@ -2087,27 +2132,27 @@ ubsec_kprocess(void *arg, struct cryptko
+}
 /*
  * Start computation of cr[C] = (cr[M] ^ cr[E]) mod cr[N] (sw normalization)
  */
 static int
 ubsec_kprocess_modexp_sw(struct ubsec_softc *sc, struct cryptkop *krp,
 			 int hint)
+{
 	struct ubsec_q2_modexp *me;
 	struct ubsec_mcr *mcr;
 	struct ubsec_ctx_modexp *ctx;
 	struct ubsec_pktbuf *epb;
-	int s, err = 0;
+	int err = 0;
 	u_int nbits, normbits, mbits, shiftbits, ebits;
 	me = (struct ubsec_q2_modexp *)malloc(sizeof *me, M_DEVBUF, M_NOWAIT);
 	if (me == NULL) {
 		err = ENOMEM;
 		goto errout;
+	}
 	memset(me, 0, sizeof *me);
 	me->me_krp = krp;
 	me->me_q.q_type = UBS_CTXOP_MODEXP;
 	nbits = ubsec_ksigbits(&krp->krp_param[UBS_MODEXP_PAR_N]);
 	if (nbits <= 512)
 @@ -2244,31 +2289,31 @@ ubsec_kprocess_modexp_sw(struct ubsec_so
 	 * ubsec_feed2 will sync mcr and ctx, we just need to sync
 	 * everything else.
 	 */
 	bus_dmamap_sync(sc->sc_dmat, me->me_M.dma_map,
 , me->me_M.dma_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
 	bus_dmamap_sync(sc->sc_dmat, me->me_E.dma_map,
 , me->me_E.dma_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
 	bus_dmamap_sync(sc->sc_dmat, me->me_C.dma_map,
 , me->me_C.dma_map->dm_mapsize, BUS_DMASYNC_PREREAD);
 	bus_dmamap_sync(sc->sc_dmat, me->me_epb.dma_map,
 , me->me_epb.dma_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
 	/* Enqueue and we're done... */
-	s = splnet();
+	mutex_spin_enter(&sc->sc_mtx);
 	SIMPLEQ_INSERT_TAIL(&sc->sc_queue2, &me->me_q, q_next);
 	ubsec_feed2(sc);
 	ubsecstats.hst_modexp++;
-	splx(s);
+	mutex_spin_exit(&sc->sc_mtx);
 	return (0);
 errout:
 	if (me != NULL) {
 		if (me->me_q.q_mcr.dma_map != NULL)
 			ubsec_dma_free(sc, &me->me_q.q_mcr);
 		if (me->me_q.q_ctx.dma_map != NULL) {
 			memset(me->me_q.q_ctx.dma_vaddr, 0, me->me_q.q_ctx.dma_size);
 			ubsec_dma_free(sc, &me->me_q.q_ctx);
+		}
 		if (me->me_M.dma_map != NULL) {
 			memset(me->me_M.dma_vaddr, 0, me->me_M.dma_size);
 @@ -2292,27 +2337,27 @@ errout:
+}
 /*
  * Start computation of cr[C] = (cr[M] ^ cr[E]) mod cr[N] (hw normalization)
  */
 static int
 ubsec_kprocess_modexp_hw(struct ubsec_softc *sc, struct cryptkop *krp,
 			 int hint)
+{
 	struct ubsec_q2_modexp *me;
 	struct ubsec_mcr *mcr;
 	struct ubsec_ctx_modexp *ctx;
 	struct ubsec_pktbuf *epb;
-	int s, err = 0;
+	int err = 0;
 	u_int nbits, normbits, mbits, shiftbits, ebits;
 	me = (struct ubsec_q2_modexp *)malloc(sizeof *me, M_DEVBUF, M_NOWAIT);
 	if (me == NULL) {
 		err = ENOMEM;
 		goto errout;
+	}
 	memset(me, 0, sizeof *me);
 	me->me_krp = krp;
 	me->me_q.q_type = UBS_CTXOP_MODEXP;
 	nbits = ubsec_ksigbits(&krp->krp_param[UBS_MODEXP_PAR_N]);
 	if (nbits <= 512)
 @@ -2449,30 +2494,30 @@ ubsec_kprocess_modexp_hw(struct ubsec_so
 	 * ubsec_feed2 will sync mcr and ctx, we just need to sync
 	 * everything else.
 	 */
 	bus_dmamap_sync(sc->sc_dmat, me->me_M.dma_map,
 , me->me_M.dma_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
 	bus_dmamap_sync(sc->sc_dmat, me->me_E.dma_map,
 , me->me_E.dma_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
 	bus_dmamap_sync(sc->sc_dmat, me->me_C.dma_map,
 , me->me_C.dma_map->dm_mapsize, BUS_DMASYNC_PREREAD);
 	bus_dmamap_sync(sc->sc_dmat, me->me_epb.dma_map,
 , me->me_epb.dma_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
 	/* Enqueue and we're done... */
-	s = splnet();
+	mutex_spin_enter(&sc->sc_mtx);
 	SIMPLEQ_INSERT_TAIL(&sc->sc_queue2, &me->me_q, q_next);
 	ubsec_feed2(sc);
-	splx(s);
+	mutex_spin_exit(&sc->sc_mtx);
 	return (0);
 errout:
 	if (me != NULL) {
 		if (me->me_q.q_mcr.dma_map != NULL)
 			ubsec_dma_free(sc, &me->me_q.q_mcr);
 		if (me->me_q.q_ctx.dma_map != NULL) {
 			memset(me->me_q.q_ctx.dma_vaddr, 0, me->me_q.q_ctx.dma_size);
 			ubsec_dma_free(sc, &me->me_q.q_ctx);
+		}
 		if (me->me_M.dma_map != NULL) {
 			memset(me->me_M.dma_vaddr, 0, me->me_M.dma_size);
 @@ -2492,27 +2537,27 @@ errout:
+	}
 	krp->krp_status = err;
 	crypto_kdone(krp);
 	return (0);
+}
 static int
 ubsec_kprocess_rsapriv(struct ubsec_softc *sc, struct cryptkop *krp,
 		       int hint)
+{
 	struct ubsec_q2_rsapriv *rp = NULL;
 	struct ubsec_mcr *mcr;
 	struct ubsec_ctx_rsapriv *ctx;
-	int s, err = 0;
+	int err = 0;
 	u_int padlen, msglen;
 	msglen = ubsec_ksigbits(&krp->krp_param[UBS_RSAPRIV_PAR_P]);
 	padlen = ubsec_ksigbits(&krp->krp_param[UBS_RSAPRIV_PAR_Q]);
 	if (msglen > padlen)
 		padlen = msglen;
 	if (padlen <= 256)
 		padlen = 256;
 	else if (padlen <= 384)
 		padlen = 384;
 	else if (padlen <= 512)
 		padlen = 512;
 @@ -2645,31 +2690,31 @@ ubsec_kprocess_rsapriv(struct ubsec_soft
 	ctx->rpr_q_len = htole16(padlen);
 	ctx->rpr_p_len = htole16(padlen);
 	/*
 	 * ubsec_feed2 will sync mcr and ctx, we just need to sync
 	 * everything else.
 	 */
 	bus_dmamap_sync(sc->sc_dmat, rp->rpr_msgin.dma_map,
 , rp->rpr_msgin.dma_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
 	bus_dmamap_sync(sc->sc_dmat, rp->rpr_msgout.dma_map,
 , rp->rpr_msgout.dma_map->dm_mapsize, BUS_DMASYNC_PREREAD);
 	/* Enqueue and we're done... */
-	s = splnet();
+	mutex_spin_enter(&sc->sc_mtx);
 	SIMPLEQ_INSERT_TAIL(&sc->sc_queue2, &rp->rpr_q, q_next);
 	ubsec_feed2(sc);
 	ubsecstats.hst_modexpcrt++;
-	splx(s);
+	mutex_spin_exit(&sc->sc_mtx);
 	return (0);
 errout:
 	if (rp != NULL) {
 		if (rp->rpr_q.q_mcr.dma_map != NULL)
 			ubsec_dma_free(sc, &rp->rpr_q.q_mcr);
 		if (rp->rpr_msgin.dma_map != NULL) {
 			memset(rp->rpr_msgin.dma_vaddr, 0, rp->rpr_msgin.dma_size);
 			ubsec_dma_free(sc, &rp->rpr_msgin);
+		}
 		if (rp->rpr_msgout.dma_map != NULL) {
 			memset(rp->rpr_msgout.dma_vaddr, 0, rp->rpr_msgout.dma_size);
 			ubsec_dma_free(sc, &rp->rpr_msgout);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ubsecvar.h,v 1.4 2012/10/27 17:18:35 chs Exp $	*/
+/*	$NetBSD: ubsecvar.h,v 1.5 2013/06/13 00:55:01 tls Exp $	*/
 /*	$OpenBSD: ubsecvar.h,v 1.36 2003/06/04 16:02:41 jason Exp $	*/
 /*
  * Copyright (c) 2000 Theo de Raadt
  * Copyright (c) 2001 Patrik Lindergren (patrik@ipunplugged.com)
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -139,47 +139,50 @@ struct ubsec_q {
 	struct mbuf			*q_src_m, *q_dst_m;
 	struct uio			*q_src_io, *q_dst_io;
 	bus_dmamap_t			q_src_map;
 	bus_dmamap_t			q_dst_map;
 	int				q_sesn;
 	int				q_flags;
 };
 struct ubsec_softc {
 	device_t		sc_dev;		/* generic device */
 	void			*sc_ih;		/* interrupt handler cookie */
 	kmutex_t		sc_mtx;
 	bus_space_handle_t	sc_sh;		/* memory handle */
 	bus_space_tag_t		sc_st;		/* memory tag */
 	bus_dma_tag_t		sc_dmat;	/* dma tag */
 	int			sc_flags;	/* device specific flags */
 	int			sc_suspended;
 	int			sc_needwakeup;	/* notify crypto layer */
 	u_int32_t		sc_statmask;	/* interrupt status mask */
 	int32_t			sc_cid;		/* crypto tag */
 	SIMPLEQ_HEAD(,ubsec_q)	sc_queue;	/* packet queue, mcr1 */
 	int			sc_nqueue;	/* count enqueued, mcr1 */
 	SIMPLEQ_HEAD(,ubsec_q)	sc_qchip;	/* on chip, mcr1 */
 	int			sc_nqchip;	/* count on chip, mcr1 */
 	SIMPLEQ_HEAD(,ubsec_q)	sc_freequeue;	/* list of free queue elements */
 	SIMPLEQ_HEAD(,ubsec_q2)	sc_queue2;	/* packet queue, mcr2 */
 	int			sc_nqueue2;	/* count enqueued, mcr2 */
 	SIMPLEQ_HEAD(,ubsec_q2)	sc_qchip2;	/* on chip, mcr2 */
 	int			sc_nsessions;	/* # of sessions */
 	struct ubsec_session	*sc_sessions;	/* sessions */
 	struct callout		sc_rngto;	/* rng timeout */
 	int			sc_rnghz;	/* rng poll time */
 	struct ubsec_q2_rng	sc_rng;
 	krndsource_t		sc_rnd_source;
 	int			sc_rng_need;	/* how many bytes wanted */
 	struct ubsec_dma	sc_dmaa[UBS_MAX_NQUEUE];
 	struct ubsec_q		*sc_queuea[UBS_MAX_NQUEUE];
 	SIMPLEQ_HEAD(,ubsec_q2)	sc_q2free;	/* free list */
 };
 #define	UBSEC_QFLAGS_COPYOUTIV		0x1
 struct ubsec_session {
 	u_int32_t	ses_used;
 	u_int32_t	ses_deskey[6];		/* 3DES key */
 	u_int32_t	ses_hminner[5];		/* hmac inner state */
 	u_int32_t	ses_hmouter[5];		/* hmac outer state */
 	u_int32_t	ses_iv[2];		/* [3]DES iv */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sd.c,v 1.300 2013/05/29 00:47:49 christos Exp $	*/
+/*	$NetBSD: sd.c,v 1.301 2013/06/13 00:55:01 tls Exp $	*/
 /*-
  * Copyright (c) 1998, 2003, 2004 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -37,27 +37,27 @@
  * Mellon University, makes this software available to CMU to distribute
  * or use in any manner that they see fit as long as this message is kept with
  * the software. For this reason TFS also grants any other persons or
  * organisations permission to use or modify this software.
+ *
  * TFS supplies this software to be publicly redistributed
  * on the understanding that TFS is not responsible for the correct
  * functioning of this software in any circumstances.
+ *
  * Ported to run under 386BSD by Julian Elischer (julian@dialix.oz.au) Sept 1992
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sd.c,v 1.300 2013/05/29 00:47:49 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sd.c,v 1.301 2013/06/13 00:55:01 tls Exp $");
 #include "opt_scsi.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/scsiio.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/uio.h>
 @@ -205,27 +205,27 @@ sdmatch(device_t parent, cfdata_t match,
 	return (priority);
+}
 /*
  * Attach routine common to atapi & scsi.
  */
 static void
 sdattach(device_t parent, device_t self, void *aux)
+{
 	struct sd_softc *sd = device_private(self);
 	struct scsipibus_attach_args *sa = aux;
 	struct scsipi_periph *periph = sa->sa_periph;
-	int error, result, rndval = cprng_strong32();
+	int error, result;
 	struct disk_parms *dp = &sd->params;
 	char pbuf[9];
 	SC_DEBUG(periph, SCSIPI_DB2, ("sdattach: "));
 	sd->sc_dev = self;
 	sd->type = (sa->sa_inqbuf.type & SID_TYPE);
 	strncpy(sd->name, sa->sa_inqbuf.product, sizeof(sd->name));
 	if (sd->type == T_SIMPLE_DIRECT)
 		periph->periph_quirks |= PQUIRK_ONLYBIG | PQUIRK_NOBIGMODESENSE;
 	if (SCSIPI_BUSTYPE_TYPE(scsipi_periph_bustype(sa->sa_periph)) ==
 	    SCSIPI_BUSTYPE_SCSI && periph->periph_version == 0)
 @@ -318,36 +318,36 @@ sdattach(device_t parent, device_t self,
 	 */
 	rnd_attach_source(&sd->rnd_source, device_xname(sd->sc_dev),
 			  RND_TYPE_DISK, 0);
 	/* Discover wedges on this disk. */
 	dkwedge_discover(&sd->sc_dk);
 	/*
 	 * Disk insertion and removal times can be a useful source
 	 * of entropy, though the estimator should never _count_
 	 * these bits, on insertion, because the deltas to the
 	 * nonexistent) previous event should never allow it.
 	 */
-	rnd_add_uint32(&sd->rnd_source, rndval);
+	rnd_add_uint32(&sd->rnd_source, 0);
+}
 static int
 sddetach(device_t self, int flags)
+{
 	struct sd_softc *sd = device_private(self);
-	int s, bmaj, cmaj, i, mn, rc, rndval = cprng_strong32();
+	int s, bmaj, cmaj, i, mn, rc;
-	rnd_add_uint32(&sd->rnd_source, rndval);
+	rnd_add_uint32(&sd->rnd_source, 0);
 	if ((rc = disk_begindetach(&sd->sc_dk, sdlastclose, self, flags)) != 0)
 		return rc;
 	/* locate the major number */
 	bmaj = bdevsw_lookup_major(&sd_bdevsw);
 	cmaj = cdevsw_lookup_major(&sd_cdevsw);
 	/* Nuke the vnodes for any open instances */
 	for (i = 0; i < MAXPARTITIONS; i++) {
 		mn = SDMINOR(device_unit(self), i);
 		vdevgone(bmaj, mn, mn, VBLK);
 		vdevgone(cmaj, mn, mn, VCHR);

 @@ -1,14 +1,14 @@
-/*      $NetBSD: kern_rndpool.c,v 1.2 2012/04/17 02:50:38 tls Exp $        */
+/*      $NetBSD: kern_rndpool.c,v 1.3 2013/06/13 00:55:01 tls Exp $        */
 /*-
  * Copyright (c) 1997 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Michael Graff <explorer@flame.org>.  This code uses ideas and
  * algorithms from the Linux driver written by Ted Ts'o.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -21,49 +21,52 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_rndpool.c,v 1.2 2012/04/17 02:50:38 tls Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_rndpool.c,v 1.3 2013/06/13 00:55:01 tls Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/sha1.h>
 #include <sys/rnd.h>
 #include <dev/rnd_private.h>
 /*
  * The random pool "taps"
  */
 #define	TAP1	99
 #define	TAP2	59
 #define	TAP3	31
 #define	TAP4	 9
 #define	TAP5	 7
 /*
  * Let others know: the pool is full.
+ *
  * XXX these should be per-pool if we really mean to allow multiple pools.
  */
 int rnd_full = 0;			/* Flag: is the pool full? */
 int rnd_filled = 0;			/* Count: how many times filled? */
 int rnd_empty = 1;			/* Flag: is the pool empty? */
 static inline void rndpool_add_one_word(rndpool_t *, u_int32_t);
 void
 rndpool_init(rndpool_t *rp)
+{
 	rp->cursor = 0;
 	rp->rotate = 1;
 	memset(&rp->stats, 0, sizeof(rp->stats));
 	rp->stats.curentropy = 0;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_rndq.c,v 1.10 2013/01/26 22:22:07 tls Exp $	*/
+/*	$NetBSD: kern_rndq.c,v 1.11 2013/06/13 00:55:01 tls Exp $	*/
 /*-
  * Copyright (c) 1997-2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Michael Graff <explorer@flame.org> and Thor Lancelot Simon.
  * This code uses ideas and algorithms from the Linux driver written by
  * Ted Ts'o.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -22,40 +22,41 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_rndq.c,v 1.10 2013/01/26 22:22:07 tls Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_rndq.c,v 1.11 2013/06/13 00:55:01 tls Exp $");
 #include <sys/param.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/select.h>
 #include <sys/poll.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/conf.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/intr.h>
 #include <sys/rnd.h>
 #include <sys/vnode.h>
 #include <sys/pool.h>
 #include <sys/kauth.h>
 #include <sys/once.h>
 #include <sys/rngtest.h>
 #include <sys/cpu.h>	/* XXX temporary, see rnd_detach_source */
 #include <dev/rnd_private.h>
 #if defined(__HAVE_CPU_COUNTER) && !defined(_RUMPKERNEL) /* XXX: bad pooka */
 #include <machine/cpu_counter.h>
 #endif
 @@ -89,30 +90,33 @@ int	rnd_debug = 0;
 typedef struct _rnd_sample_t {
 	SIMPLEQ_ENTRY(_rnd_sample_t) next;
 	krndsource_t	*source;
 	int		cursor;
 	int		entropy;
 	u_int32_t	ts[RND_SAMPLE_COUNT];
 	u_int32_t	values[RND_SAMPLE_COUNT];
 } rnd_sample_t;
 /*
  * The event queue.  Fields are altered at an interrupt level.
  * All accesses must be protected with the mutex.
  */
 volatile int			rnd_timeout_pending;
 SIMPLEQ_HEAD(, _rnd_sample_t)	rnd_samples;
 kmutex_t			rnd_mtx;
 /*
  * This lock protects dispatch of our soft interrupts.
  */
 kmutex_t			rndsoft_mtx;
 /*
  * Entropy sinks: usually other generators waiting to be rekeyed.
+ *
  * A sink's callback MUST NOT re-add the sink to the list, or
  * list corruption will occur.  The list is protected by the
  * rndsink_mtx, which must be released before calling any sink's
  * callback.
  */
 TAILQ_HEAD(, rndsink)		rnd_sinks;
 kmutex_t			rndsink_mtx;
 /*
 @@ -139,34 +143,35 @@ kcondvar_t rndpool_cv;
 static krndsource_t rnd_source_no_collect = {
 	/* LIST_ENTRY list */
 	.name = { 'N', 'o', 'C', 'o', 'l', 'l', 'e', 'c', 't',
 , 0, 0, 0, 0, 0, 0 },
 	.last_time = 0, .last_delta = 0, .last_delta2 = 0, .total = 0,
 	.type = RND_TYPE_UNKNOWN,
 	.flags = (RND_FLAG_NO_COLLECT |
 		  RND_FLAG_NO_ESTIMATE |
 		  RND_TYPE_UNKNOWN),
 	.state = NULL,
 	.test_cnt = 0,
 	.test = NULL
 };
 void *rnd_process, *rnd_wakeup;
-struct callout rnd_callout, skew_callout;
+struct callout skew_callout;
 void	      rnd_wakeup_readers(void);
 static inline u_int32_t rnd_estimate_entropy(krndsource_t *, u_int32_t);
 static inline u_int32_t rnd_counter(void);
-static        void	rnd_timeout(void *);
+static        void	rnd_intr(void *);
-static	      void	rnd_process_events(void *);
+static	      void	rnd_wake(void *);
 static	      void	rnd_process_events(void);
 u_int32_t     rnd_extract_data_locked(void *, u_int32_t, u_int32_t); /* XXX */
 static	      void	rnd_add_data_ts(krndsource_t *, const void *const,
 					uint32_t, uint32_t, uint32_t);
 int			rnd_ready = 0;
 int			rnd_initial_entropy = 0;
 #ifdef DIAGNOSTIC
 static int		rnd_tested = 0;
 static rngtest_t	rnd_rt;
 static uint8_t		rnd_testbits[sizeof(rnd_rt.rt_b)];
 #endif
 @@ -186,91 +191,161 @@ rnd_counter(void)
 #if defined(__HAVE_CPU_COUNTER) && !defined(_RUMPKERNEL) /* XXX: bad pooka */
 	if (cpu_hascounter())
 		return (cpu_counter32());
 #endif
 	if (rnd_ready) {
 		microtime(&tv);
 		return (tv.tv_sec * 1000000 + tv.tv_usec);
+	}
 	/* when called from rnd_init, its too early to call microtime safely */
 	return (0);
+}
 /*
  * We may be called from low IPL -- protect our softint.
  */
 static inline void
 rnd_schedule_softint(void *softint)
+{
 	mutex_spin_enter(&rndsoft_mtx);
 	softint_schedule(softint);
 	mutex_spin_exit(&rndsoft_mtx);
+}
 /*
  * XXX repulsive: we can't initialize our softints in rnd_init
  * XXX (too early) so we wrap the points where we'd schedule them, thus.
  */
 static inline void
 rnd_schedule_process(void)
+{
 	if (__predict_true(rnd_process)) {
 		rnd_schedule_softint(rnd_process);
 		return;
+	}
 	if (!cold) {
 		rnd_process = softint_establish(SOFTINT_SERIAL|SOFTINT_MPSAFE,
 						rnd_intr, NULL);
+	}
 	rnd_process_events();
+}
 static inline void
 rnd_schedule_wakeup(void)
+{
 	if (__predict_true(rnd_wakeup)) {
 		rnd_schedule_softint(rnd_wakeup);
 		return;
+	}
 	if (!cold) {
 		rnd_wakeup = softint_establish(SOFTINT_CLOCK|SOFTINT_MPSAFE,
 					       rnd_wake, NULL);
+	}
 	rnd_wakeup_readers();
+}
 /*
  * Tell any sources with "feed me" callbacks that we are hungry.
  */
 static void
 rnd_getmore(size_t byteswanted)
+{
 	krndsource_t *rs;
 	KASSERT(mutex_owned(&rndpool_mtx));
 	LIST_FOREACH(rs, &rnd_sources, list) {
 		if (rs->flags & RND_FLAG_HASCB) {
 			KASSERT(rs->get != NULL);
 			KASSERT(rs->getarg != NULL);
 			rs->get((size_t)byteswanted, rs->getarg);
 #ifdef RND_VERBOSE
 			printf("rnd: asking source %s for %d bytes\n",
 			       rs->name, (int)byteswanted);
 #endif
+		}
+	}
+}
 /*
  * Check to see if there are readers waiting on us.  If so, kick them.
  */
 void
 rnd_wakeup_readers(void)
+{
 	rndsink_t *sink, *tsink;
 	size_t	entropy_count;
 	TAILQ_HEAD(, rndsink) sunk = TAILQ_HEAD_INITIALIZER(sunk);
 	mutex_spin_enter(&rndpool_mtx);
-	if (rndpool_get_entropy_count(&rnd_pool) < RND_ENTROPY_THRESHOLD * 8) {
+	entropy_count = rndpool_get_entropy_count(&rnd_pool);
 	if (entropy_count < RND_ENTROPY_THRESHOLD * 8) {
 		rnd_empty = 1;
 		mutex_spin_exit(&rndpool_mtx);
 		return;
 	} else {
 #ifdef RND_VERBOSE
 		if (__predict_false(!rnd_initial_entropy)) {
 			printf("rnd: have initial entropy (%u)\n",
 			       (unsigned int)entropy_count);
+		}
 #endif
 		rnd_empty = 0;
 		rnd_initial_entropy = 1;
+	}
 	/*
-	 * First, take care of in-kernel consumers needing rekeying.
+	 * First, take care of consumers needing rekeying.
 	 */
 	mutex_spin_enter(&rndsink_mtx);
 	TAILQ_FOREACH_SAFE(sink, &rnd_sinks, tailq, tsink) {
 		if (!mutex_tryenter(&sink->mtx)) {
 #ifdef RND_VERBOSE
 			printf("rnd_wakeup_readers: "
 			       "skipping busy rndsink\n");
 #endif
 			continue;
+		}
 		KASSERT(RSTATE_PENDING == sink->state);
-		if ((sink->len + RND_ENTROPY_THRESHOLD) * 8 <
+		if (sink->len * 8 < rndpool_get_entropy_count(&rnd_pool)) {
 			rndpool_get_entropy_count(&rnd_pool)) {
 			/* We have enough entropy to sink some here. */
 			if (rndpool_extract_data(&rnd_pool, sink->data,
 						 sink->len, RND_EXTRACT_GOOD)
 			    != sink->len) {
 				panic("could not extract estimated "
 				      "entropy from pool");
+			}
 			sink->state = RSTATE_HASBITS;
 			/* Move this sink to the list of pending callbacks */
 			TAILQ_REMOVE(&rnd_sinks, sink, tailq);
 			TAILQ_INSERT_HEAD(&sunk, sink, tailq);
 		} else {
 			mutex_exit(&sink->mtx);
 	mutex_spin_exit(&rndsink_mtx);
 	/*
 	 * If we still have enough new bits to do something, feed userspace.
 	 */
 	if (rndpool_get_entropy_count(&rnd_pool) > RND_ENTROPY_THRESHOLD * 8) {
 #ifdef RND_VERBOSE
-		if (!rnd_initial_entropy)
+			printf("sink wants %d, we have %d, asking for more\n",
-			printf("rnd: have initial entropy (%u)\n",
+			       (int)sink->len * 8,
-			       rndpool_get_entropy_count(&rnd_pool));
+			       (int)rndpool_get_entropy_count(&rnd_pool));
 #endif
-		rnd_initial_entropy = 1;
+			mutex_spin_exit(&sink->mtx);
-		mutex_spin_exit(&rndpool_mtx);
+			rnd_getmore(sink->len * 8);
 	} else {
 		mutex_spin_exit(&rndpool_mtx);
+	}
 	mutex_spin_exit(&rndsink_mtx);
 	mutex_spin_exit(&rndpool_mtx);
 	/*
-	 * Now that we have dropped the mutex, we can run sinks' callbacks.
+	 * Now that we have dropped the mutexes, we can run sinks' callbacks.
 	 * Since we have reused the "tailq" member of the sink structure for
 	 * this temporary on-stack queue, the callback must NEVER re-add
 	 * the sink to the main queue, or our on-stack queue will become
 	 * corrupt.
 	 */
 	while ((sink = TAILQ_FIRST(&sunk))) {
 #ifdef RND_VERBOSE
 		printf("supplying %d bytes to entropy sink \"%s\""
 		       " (cb %p, arg %p).\n",
 		       (int)sink->len, sink->name, sink->cb, sink->arg);
 #endif
 		sink->state = RSTATE_HASBITS;
 		sink->cb(sink->arg);
 @@ -368,29 +443,27 @@ rnd_skew(void *arg)
  * rnd_init() must be called very early on in the boot process, so
  * the pool is ready for other devices to attach as sources.
  */
 void
 rnd_init(void)
+{
 	u_int32_t c;
 	if (rnd_ready)
 		return;
 	mutex_init(&rnd_mtx, MUTEX_DEFAULT, IPL_VM);
 	mutex_init(&rndsink_mtx, MUTEX_DEFAULT, IPL_VM);
 	mutex_init(&rndsoft_mtx, MUTEX_DEFAULT, IPL_VM);
 	callout_init(&rnd_callout, CALLOUT_MPSAFE);
 	callout_setfunc(&rnd_callout, rnd_timeout, NULL);
 	/*
 	 * take a counter early, hoping that there's some variance in
 	 * the following operations
 	 */
 	c = rnd_counter();
 	LIST_INIT(&rnd_sources);
 	SIMPLEQ_INIT(&rnd_samples);
 	TAILQ_INIT(&rnd_sinks);
 	rndpool_init(&rnd_pool);
 	mutex_init(&rndpool_mtx, MUTEX_DEFAULT, IPL_VM);
 @@ -747,46 +820,30 @@ rnd_add_data_ts(krndsource_t *rs, const
 	/*
 	 * If we didn't finish any sample buffers, we're done.
 	 */
 	if (!filled) {
 		return;
+	}
 	mutex_spin_enter(&rnd_mtx);
 	while ((state = SIMPLEQ_FIRST(&tmp_samples))) {
 		SIMPLEQ_REMOVE_HEAD(&tmp_samples, next);
 		SIMPLEQ_INSERT_HEAD(&rnd_samples, state, next);
+	}
 	/*
 	 * If we are still starting up, cause immediate processing of
 	 * the queued samples.  Otherwise, if the timeout isn't
 	 * pending, have it run in the near future.
 	 */
 	if (__predict_false(cold)) {
 #ifdef RND_VERBOSE
 		printf("rnd: directly processing boot-time events.\n");
 #endif
 		rnd_process_events(NULL);	/* Drops lock! */
 		return;
 	if (rnd_timeout_pending == 0) {
 		rnd_timeout_pending = 1;
 		mutex_spin_exit(&rnd_mtx);
 		callout_schedule(&rnd_callout, 1);
 		return;
 	mutex_spin_exit(&rnd_mtx);
 	/* Cause processing of queued samples */
 	rnd_schedule_process();
+}
 static int
 rnd_hwrng_test(rnd_sample_t *sample)
+{
 	krndsource_t *source = sample->source;
 	size_t cmplen;
 	uint8_t *v1, *v2;
 	size_t resid, totest;
 	KASSERT(source->type == RND_TYPE_RNG);
 	/*
 @@ -827,69 +884,97 @@ rnd_hwrng_test(rnd_sample_t *sample)
 			return 1;
+		}
 		source->test_cnt = -1;
 		memset(source->test, 0, sizeof(*source->test));
+	}
 	return 0;
+}
 /*
  * Process the events in the ring buffer.  Called by rnd_timeout or
  * by the add routines directly if the callout has never fired (that
  * is, if we are "cold" -- just booted).
+ *
  * Call with rnd_mtx held -- WILL RELEASE IT.
  */
 static void
-rnd_process_events(void *arg)
+rnd_process_events(void)
+{
-	rnd_sample_t *sample;
+	rnd_sample_t *sample = NULL;
 	krndsource_t *source, *badsource = NULL;
 	static krndsource_t *last_source;
 	u_int32_t entropy;
 	size_t pool_entropy;
 	int found = 0, wake = 0;
 	SIMPLEQ_HEAD(, _rnd_sample_t) dq_samples =
 			SIMPLEQ_HEAD_INITIALIZER(dq_samples);
 	SIMPLEQ_HEAD(, _rnd_sample_t) df_samples =
 			SIMPLEQ_HEAD_INITIALIZER(df_samples);
         TAILQ_HEAD(, rndsink) sunk = TAILQ_HEAD_INITIALIZER(sunk);
 	/*
 	 * Sample queue is protected by rnd_mtx, drain to onstack queue
 	 * and drop lock.
 	 */
 	mutex_spin_enter(&rnd_mtx);
 	while ((sample = SIMPLEQ_FIRST(&rnd_samples))) {
 		found++;
 		SIMPLEQ_REMOVE_HEAD(&rnd_samples, next);
 		/*
 		 * We repeat this check here, since it is possible
 		 * the source was disabled before we were called, but
 		 * after the entry was queued.
 		 */
 		if (__predict_false(sample->source->flags
 				    & RND_FLAG_NO_COLLECT)) {
 			SIMPLEQ_INSERT_TAIL(&df_samples, sample, next);
 		} else {
 			SIMPLEQ_INSERT_TAIL(&dq_samples, sample, next);
+		}
+	}
 	mutex_spin_exit(&rnd_mtx);
 	/* Don't thrash the rndpool mtx either.  Hold, add all samples. */
 	mutex_spin_enter(&rndpool_mtx);
 	pool_entropy = rndpool_get_entropy_count(&rnd_pool);
 	if (pool_entropy > RND_ENTROPY_THRESHOLD * 8) {
 		wake++;
 	} else {
 		rnd_empty = 1;
 		rnd_getmore((RND_POOLBITS - pool_entropy) / 8);
 #ifdef RND_VERBOSE
 		printf("rnd: empty, asking for %d bits\n",
 		       (int)((RND_POOLBITS - pool_entropy) / 8));
 #endif
+	}
 	while ((sample = SIMPLEQ_FIRST(&dq_samples))) {
 		SIMPLEQ_REMOVE_HEAD(&dq_samples, next);
 		source = sample->source;
 		entropy = sample->entropy;
 		/*
 		 * Don't provide a side channel for timing attacks on
 		 * low-rate sources: require mixing with some other
 		 * source before we schedule a wakeup.
 		 */
 		if (!wake &&
 		    (source != last_source || source->flags & RND_FLAG_FAST)) {
 			wake++;
+		}
 		last_source = source;
 		/*
 		 * Hardware generators are great but sometimes they
 		 * have...hardware issues.  Don't use any data from
 		 * them unless it passes some tests.
 		 */
 		if (source->type == RND_TYPE_RNG) {
 			if (__predict_false(rnd_hwrng_test(sample))) {
 				/*
 				 * Detach the bad source.  See below.
 				 */
 				badsource = source;
 				printf("rnd: detaching source \"%s\".",
 				       badsource->name);
 				break;
 @@ -915,72 +1000,75 @@ rnd_process_events(void *arg)
 		 * point at which we detected a problem onwards.
 		 */
 		rnd_detach_source(badsource);
 		while ((sample = SIMPLEQ_FIRST(&dq_samples))) {
 			SIMPLEQ_REMOVE_HEAD(&dq_samples, next);
 			rnd_sample_free(sample);
+		}
+	}
 	while ((sample = SIMPLEQ_FIRST(&df_samples))) {
 		SIMPLEQ_REMOVE_HEAD(&df_samples, next);
 		rnd_sample_free(sample);
+	}
 	/*
 	 * Wake up any potential readers waiting.
 	 */
-	rnd_wakeup_readers();
+	if (wake) {
 		rnd_schedule_wakeup();
+	}
+}
 /*
  * Timeout, run to process the events in the ring buffer.
  */
 static void
-rnd_timeout(void *arg)
+rnd_intr(void *arg)
+{
-        mutex_spin_enter(&rnd_mtx);
+	rnd_process_events();
         rnd_timeout_pending = 0;
         rnd_process_events(arg);
 static void
 rnd_wake(void *arg)
+{
 	rnd_wakeup_readers();
+}
 u_int32_t
 rnd_extract_data_locked(void *p, u_int32_t len, u_int32_t flags)
+{
 	static int timed_in;
 	int entropy_count;
 	KASSERT(mutex_owned(&rndpool_mtx));
 	if (__predict_false(!timed_in)) {
 		if (boottime.tv_sec) {
 			rndpool_add_data(&rnd_pool, &boottime,
 					 sizeof(boottime), 0);
+		}
 		timed_in++;
+	}
 	if (__predict_false(!rnd_initial_entropy)) {
 		u_int32_t c;
 #ifdef RND_VERBOSE
 		printf("rnd: WARNING! initial entropy low (%u).\n",
 		       rndpool_get_entropy_count(&rnd_pool));
 #endif
 		/* Try once again to put something in the pool */
 		c = rnd_counter();
 		rndpool_add_data(&rnd_pool, &c, sizeof(u_int32_t), 1);
+	}
 #ifdef DIAGNOSTIC
 	while (!rnd_tested) {
 		int entropy_count;
 		entropy_count = rndpool_get_entropy_count(&rnd_pool);
 #ifdef RND_VERBOSE
 		printf("rnd: starting statistical RNG test, entropy = %d.\n",
 			entropy_count);
 #endif
 		if (rndpool_extract_data(&rnd_pool, rnd_rt.rt_b,
 		    sizeof(rnd_rt.rt_b), RND_EXTRACT_ANY)
 		    != sizeof(rnd_rt.rt_b)) {
 			panic("rnd: could not get bits for statistical test");
+		}
 		/*
 		 * Stash the tested bits so we can put them back in the
 		 * pool, restoring the entropy count.  DO NOT rely on
 @@ -1002,26 +1090,30 @@ rnd_extract_data_locked(void *p, u_int32
 			continue;
+		}
 		memset(&rnd_rt, 0, sizeof(rnd_rt));
 		rndpool_add_data(&rnd_pool, rnd_testbits, sizeof(rnd_testbits),
 				 entropy_count);
 		memset(rnd_testbits, 0, sizeof(rnd_testbits));
 #ifdef RND_VERBOSE
 		printf("rnd: statistical RNG test done, entropy = %d.\n",
 		       rndpool_get_entropy_count(&rnd_pool));
 #endif
 		rnd_tested++;
+	}
 #endif
 	entropy_count = rndpool_get_entropy_count(&rnd_pool);
 	if (entropy_count < (RND_ENTROPY_THRESHOLD * 2 + len) * 8) {
 		rnd_getmore(RND_POOLBITS - entropy_count * 8);
+	}
 	return rndpool_extract_data(&rnd_pool, p, len, flags);
+}
 u_int32_t
 rnd_extract_data(void *p, u_int32_t len, u_int32_t flags)
+{
 	uint32_t retval;
 	mutex_spin_enter(&rndpool_mtx);
 	retval = rnd_extract_data_locked(p, len, flags);
 	mutex_spin_exit(&rndpool_mtx);
 	return retval;
+}
 @@ -1031,33 +1123,27 @@ rndsink_attach(rndsink_t *rs)
+{
 #ifdef RND_VERBOSE
 	printf("rnd: entropy sink \"%s\" wants %d bytes of data.\n",
 	       rs->name, (int)rs->len);
 #endif
 	KASSERT(mutex_owned(&rs->mtx));
 	KASSERT(rs->state = RSTATE_PENDING);
 	mutex_spin_enter(&rndsink_mtx);
 	TAILQ_INSERT_TAIL(&rnd_sinks, rs, tailq);
 	mutex_spin_exit(&rndsink_mtx);
-	mutex_spin_enter(&rnd_mtx);
+	rnd_schedule_process();
 	if (rnd_timeout_pending == 0) {
 		rnd_timeout_pending = 1;
 		callout_schedule(&rnd_callout, 1);
 	mutex_spin_exit(&rnd_mtx);
+}
 void
 rndsink_detach(rndsink_t *rs)
+{
 	rndsink_t *sink, *tsink;
 #ifdef RND_VERBOSE
 	printf("rnd: entropy sink \"%s\" no longer wants data.\n", rs->name);
 #endif
 	KASSERT(mutex_owned(&rs->mtx));
 	mutex_spin_enter(&rndsink_mtx);
 	TAILQ_FOREACH_SAFE(sink, &rnd_sinks, tailq, tsink) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_cprng.c,v 1.16 2013/03/28 18:06:48 tls Exp $ */
+/*	$NetBSD: subr_cprng.c,v 1.17 2013/06/13 00:55:01 tls Exp $ */
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Thor Lancelot Simon.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -36,27 +36,27 @@
 #include <sys/systm.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 #include <sys/rngtest.h>
 #include <sys/rnd.h>
 #include <dev/rnd_private.h>
 #if defined(__HAVE_CPU_COUNTER)
 #include <machine/cpu_counter.h>
 #endif
 #include <sys/cprng.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_cprng.c,v 1.16 2013/03/28 18:06:48 tls Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_cprng.c,v 1.17 2013/06/13 00:55:01 tls Exp $");
 void
 cprng_init(void)
+{
 	nist_ctr_initialize();
+}
 static inline uint32_t
 cprng_counter(void)
+{
 	struct timeval tv;
 #if defined(__HAVE_CPU_COUNTER)
 @@ -190,28 +190,37 @@ cprng_strong_create(const char *const na
 	mutex_init(&c->mtx, MUTEX_DEFAULT, ipl);
 	if (c->flags & CPRNG_USE_CV) {
 		cv_init(&c->cv, (const char *)c->name);
+	}
 	selinit(&c->selq);
 	r = cprng_entropy_try(key, sizeof(key));
 	if (r != sizeof(key)) {
 		if (c->flags & CPRNG_INIT_ANY) {
 #ifdef DEBUG
-			printf("cprng %s: WARNING insufficient "
+			/*
-			       "entropy at creation.\n", name);
+			 * If we have ever crossed the pool's
 			 * minimum-entropy threshold, then we are
 			 * providing cryptographically strong
 			 * random output -- if not information-
 			 * theoretically strong.  Warn elsewise.
 			 */
 			if (!rnd_initial_entropy) {
 				printf("cprng %s: WARNING insufficient "
 			 		"entropy at creation.\n", name);
+			}
 #endif
 		} else {
 			hard++;
+		}
 		getmore++;
+	}
 	if (nist_ctr_drbg_instantiate(&c->drbg, key, sizeof(key),
 				      &cc, sizeof(cc), name, strlen(name))) {
 		panic("cprng %s: instantiation failed.", name);
+	}
 	if (getmore) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rnd.h,v 1.35 2013/01/26 19:05:11 tls Exp $	*/
+/*	$NetBSD: rnd.h,v 1.36 2013/06/13 00:55:01 tls Exp $	*/
 /*-
  * Copyright (c) 1997 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Michael Graff <explorer@flame.org>.  This code uses ideas and
  * algorithms from the Linux driver written by Ted Ts'o.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -82,26 +82,27 @@ typedef struct
 typedef struct {
 	char		name[16];	/* device name */
 	uint32_t	total;		/* entropy from this source */
 	uint32_t	type;		/* type */
 	uint32_t	flags;		/* flags */
 } rndsource_t;
 /*
  * Flags to control the source.  Low byte is type, upper bits are flags.
  */
 #define	RND_FLAG_NO_ESTIMATE	0x00000100	/* don't estimate entropy */
 #define	RND_FLAG_NO_COLLECT	0x00000200	/* don't collect entropy */
 #define RND_FLAG_FAST		0x00000400	/* process samples in bulk */
 #define RND_FLAG_HASCB		0x00000800	/* has get callback */
 #define	RND_TYPE_UNKNOWN	0	/* unknown source */
 #define	RND_TYPE_DISK		1	/* source is physical disk */
 #define	RND_TYPE_NET		2	/* source is a network device */
 #define	RND_TYPE_TAPE		3	/* source is a tape drive */
 #define	RND_TYPE_TTY		4	/* source is a tty device */
 #define	RND_TYPE_RNG		5	/* source is a hardware RNG */
 #define RND_TYPE_SKEW		6	/* source is skew between clocks */
 #define RND_TYPE_ENV		7	/* source is temp or fan sensor */
 #define RND_TYPE_VM		8	/* source is VM system events */
 #define RND_TYPE_POWER		9	/* source is power events */
 #define	RND_TYPE_MAX		9	/* last type id used */
 @@ -117,28 +118,37 @@ typedef struct {
 typedef struct krndsource {
 	LIST_ENTRY(krndsource) list;	/* the linked list */
         char            name[16];       /* device name */
         uint32_t        last_time;      /* last time recorded */
         uint32_t        last_delta;     /* last delta value */
         uint32_t        last_delta2;    /* last delta2 value */
         uint32_t        total;          /* entropy from this source */
         uint32_t        type;           /* type */
         uint32_t        flags;          /* flags */
         void            *state;         /* state information */
         size_t          test_cnt;       /* how much test data accumulated? */
         rngtest_t	*test;          /* test data for RNG type sources */
 	void		(*get)(size_t, void *);	/* pool wants N bytes (badly) */
 	void		*getarg;	/* argument to get-function */
 } krndsource_t;
 static inline void
 rndsource_setcb(struct krndsource *const rs, void *const cb, void *const arg)
+{
 	rs->get = cb;
 	rs->getarg = arg;
+}
 enum rsink_st {
 	RSTATE_IDLE = 0,
 	RSTATE_PENDING,
 	RSTATE_HASBITS
 };
 typedef struct rndsink {
         TAILQ_ENTRY(rndsink) tailq;     /* the queue */
 	kmutex_t	mtx;		/* lock to seed or unregister */
 	enum rsink_st	state;		/* in-use?  filled? */
         void            (*cb)(void *);  /* callback function when ready */
         void            *arg;           /* callback function argument */
         char            name[16];       /* sink name */
 @@ -176,26 +186,27 @@ void		rnd_detach_source(krndsource_t *);
 void		rndsink_attach(rndsink_t *);
 void		rndsink_detach(rndsink_t *);
 void		rnd_seed(void *, size_t);
 static inline void
 rnd_add_uint32(krndsource_t *kr, uint32_t val)
+{
 	if (RND_ENABLED(kr)) {
 		_rnd_add_uint32(kr, val);
+	}
+}
 extern int	rnd_empty;
 extern int	rnd_full;
 extern int	rnd_filled;
 extern int	rnd_initial_entropy;
 #endif /* _KERNEL */
 #define	RND_MAXSTATCOUNT	10	/* 10 sources at once max */
 /*
  * return "count" random entries, starting at "start"
  */
 typedef struct {
 	uint32_t	start;