xref: /illumos-gate/usr/src/uts/sun4v/io/n2rng/n2rng.c (revision 03b8b03e)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */


/*
 * Niagara 2 Random Number Generator (RNG) driver
 */

#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/cmn_err.h>
#include <sys/ksynch.h>
#include <sys/kmem.h>
#include <sys/stat.h>
#include <sys/open.h>
#include <sys/file.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/param.h>
#include <sys/cpuvar.h>
#include <sys/disp.h>
#include <sys/hsvc.h>
#include <sys/machsystm.h>
#include <sys/hypervisor_api.h>
#include <sys/n2rng.h>

static int	n2rng_attach(dev_info_t *, ddi_attach_cmd_t);
static int	n2rng_detach(dev_info_t *, ddi_detach_cmd_t);
static int	n2rng_suspend(n2rng_t *);
static int	n2rng_resume(n2rng_t *);
static uint64_t sticks_per_usec(void);
u_longlong_t	gettick(void);
static int	n2rng_init_ctl(n2rng_t *);
static void	n2rng_uninit_ctl(n2rng_t *);
static int	n2rng_config(n2rng_t *);
static void	n2rng_config_task(void * targ);

/*
 * Device operations.
 */

static struct dev_ops devops = {
	DEVO_REV,		/* devo_rev */
	0,			/* devo_refcnt */
	nodev,			/* devo_getinfo */
	nulldev,		/* devo_identify */
	nulldev,		/* devo_probe */
	n2rng_attach,		/* devo_attach */
	n2rng_detach,		/* devo_detach */
	nodev,			/* devo_reset */
	NULL,			/* devo_cb_ops */
	NULL,			/* devo_bus_ops */
	ddi_power,		/* devo_power */
	ddi_quiesce_not_supported,	/* devo_quiesce */
};

/*
 * Module linkage.
 */
static struct modldrv modldrv = {
	&mod_driverops,			/* drv_modops */
	"N2 RNG Driver",		/* drv_linkinfo */
	&devops,			/* drv_dev_ops */
};

static struct modlinkage modlinkage = {
	MODREV_1,			/* ml_rev */
	&modldrv,			/* ml_linkage */
	NULL
};

/*
 * Driver globals Soft state.
 */
static void	*n2rng_softstate = NULL;

/*
 * Hypervisor NCS services information.
 */
static boolean_t ncs_hsvc_available = B_FALSE;

#define	NVERSIONS	2

/*
 * HV API versions supported by this driver.
 */
static hsvc_info_t ncs_hsvc[NVERSIONS] = {
	{ HSVC_REV_1, NULL, HSVC_GROUP_RNG, 2, 0, DRIVER },	/* v2.0 */
	{ HSVC_REV_1, NULL, HSVC_GROUP_RNG, 1, 0, DRIVER },	/* v1.0 */
};
int	ncs_version_index;	/* index into ncs_hsvc[] */

/*
 * DDI entry points.
 */
int
_init(void)
{
	int	rv;

	rv = ddi_soft_state_init(&n2rng_softstate, sizeof (n2rng_t), 1);
	if (rv != 0) {
		/* this should *never* happen! */
		return (rv);
	}

	if ((rv = mod_install(&modlinkage)) != 0) {
		/* cleanup here */
		ddi_soft_state_fini(&n2rng_softstate);
		return (rv);
	}

	return (0);
}

int
_fini(void)
{
	int	rv;

	rv = mod_remove(&modlinkage);
	if (rv == 0) {
		/* cleanup here */
		ddi_soft_state_fini(&n2rng_softstate);
	}

	return (rv);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

static int
n2rng_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	n2rng_t		*n2rng = NULL;
	int		instance;
	int		rv;
	int		version;
	uint64_t	ncs_minor_ver;

	instance = ddi_get_instance(dip);
	DBG1(NULL, DENTRY, "n2rng_attach called, instance %d", instance);
	/*
	 * Only instance 0 of n2rng driver is allowed.
	 */
	if (instance != 0) {
		n2rng_diperror(dip, "only one instance (0) allowed");
		return (DDI_FAILURE);
	}

	switch (cmd) {
	case DDI_RESUME:
		n2rng = (n2rng_t *)ddi_get_soft_state(n2rng_softstate,
		    instance);
		if (n2rng == NULL) {
			n2rng_diperror(dip, "no soft state in attach");
			return (DDI_FAILURE);
		}
		return (n2rng_resume(n2rng));

	case DDI_ATTACH:
		break;
	default:
		return (DDI_FAILURE);
	}

	rv = ddi_soft_state_zalloc(n2rng_softstate, instance);
	if (rv != DDI_SUCCESS) {
		n2rng_diperror(dip, "unable to allocate soft state");
		return (DDI_FAILURE);
	}
	n2rng = (n2rng_t *)ddi_get_soft_state(n2rng_softstate, instance);
	ASSERT(n2rng != NULL);
	n2rng->n_dip = dip;

	mutex_init(&n2rng->n_lock, NULL, MUTEX_DRIVER, NULL);
	n2rng->n_flags = 0;
	n2rng->n_timeout_id = 0;
	n2rng->n_sticks_per_usec = sticks_per_usec();

	/* Determine binding type */
	n2rng->n_binding_name = ddi_binding_name(dip);
	if (strncmp(n2rng->n_binding_name, N2RNG_BINDNAME_N2,
	    strlen(N2RNG_BINDNAME_N2)) == 0) {
		/*
		 * Niagara 2
		 */
		n2rng->n_binding = N2RNG_CPU_N2;
	} else if (strncmp(n2rng->n_binding_name, N2RNG_BINDNAME_VF,
	    strlen(N2RNG_BINDNAME_VF)) == 0) {
		/*
		 * Victoria Falls
		 */
		n2rng->n_binding = N2RNG_CPU_VF;
	} else if (strncmp(n2rng->n_binding_name, N2RNG_BINDNAME_KT,
	    strlen(N2RNG_BINDNAME_KT)) == 0) {
		/*
		 * Rainbow Falls
		 */
		n2rng->n_binding = N2RNG_CPU_KT;
	} else {
		n2rng_diperror(dip,
		    "unable to determine n2rng (cpu) binding (%s)",
		    n2rng->n_binding_name);
		goto errorexit;
	}
	DBG1(n2rng, DCHATTY, "n2rng_attach: n2rng->n_binding_name = %s",
	    n2rng->n_binding_name);

	/* Negotiate HV api version number */
	for (version = 0; version < NVERSIONS; version++) {
		rv = hsvc_register(&ncs_hsvc[version], &ncs_minor_ver);
		if (rv == 0)
			break;

		DBG4(n2rng, DCHATTY, "n2rng_attach: grp: 0x%lx, maj: %ld, "
		    "min: %ld, errno: %d", ncs_hsvc[version].hsvc_group,
		    ncs_hsvc[version].hsvc_major,
		    ncs_hsvc[version].hsvc_minor, rv);
	}
	if (version == NVERSIONS) {
		for (version = 0; version < NVERSIONS; version++) {
			cmn_err(CE_WARN,
			    "%s: cannot negotiate hypervisor services "
			    "group: 0x%lx major: %ld minor: %ld errno: %d",
			    ncs_hsvc[version].hsvc_modname,
			    ncs_hsvc[version].hsvc_group,
			    ncs_hsvc[version].hsvc_major,
			    ncs_hsvc[version].hsvc_minor, rv);
		}
		goto errorexit;
	}
	ncs_version_index = version;
	ncs_hsvc_available = B_TRUE;
	DBG2(n2rng, DATTACH, "n2rng_attach: ncs api version (%ld.%ld)",
	    ncs_hsvc[ncs_version_index].hsvc_major, ncs_minor_ver);
	n2rng->n_hvapi_major_version = ncs_hsvc[ncs_version_index].hsvc_major;
	n2rng->n_hvapi_minor_version = (uint_t)ncs_minor_ver;

	/*
	 * Verify that we are running version 2.0 or later api on multiple
	 * rng systems.
	 */
	if ((n2rng->n_binding != N2RNG_CPU_N2) &&
	    (n2rng->n_hvapi_major_version < 2)) {
		cmn_err(CE_NOTE, "n2rng: Incompatible hyperviser api "
		    "version %d.%d detected", n2rng->n_hvapi_major_version,
		    n2rng->n_hvapi_minor_version);
	}

	/* Initialize ctl structure if runnning in the control domain */
	if (n2rng_init_ctl(n2rng) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "n2rng: unable to initialize rng "
		    "control structures");
		goto errorexit;
	}

	/* Allocate single thread task queue for rng diags and registration */
	n2rng->n_taskq = ddi_taskq_create(dip, "n2rng_taskq", 1,
	    TASKQ_DEFAULTPRI, 0);

	if (n2rng->n_taskq == NULL) {
		n2rng_diperror(dip, "ddi_taskq_create() failed");
		goto errorexit;
	}

	/* Dispatch task to configure the RNG and register with KCF */
	if (ddi_taskq_dispatch(n2rng->n_taskq, n2rng_config_task,
	    (void *)n2rng, DDI_SLEEP) != DDI_SUCCESS) {
		n2rng_diperror(dip, "ddi_taskq_dispatch() failed");
		goto errorexit;
	}

	return (DDI_SUCCESS);

errorexit:
	/* Wait for pending config tasks to complete and delete the taskq */
	if (n2rng->n_taskq != NULL) {
		ddi_taskq_destroy(n2rng->n_taskq);
		n2rng->n_taskq = NULL;
	}

	n2rng_uninit_ctl(n2rng);

	(void) n2rng_uninit(n2rng);

	if (ncs_hsvc_available == B_TRUE) {
		(void) hsvc_unregister(&ncs_hsvc[ncs_version_index]);
		ncs_hsvc_available = B_FALSE;
	}

	mutex_destroy(&n2rng->n_lock);
	ddi_soft_state_free(n2rng_softstate, instance);

	return (DDI_FAILURE);
}

static int
n2rng_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	int		instance;
	int		rv;
	n2rng_t		*n2rng;
	timeout_id_t	tid;

	instance = ddi_get_instance(dip);
	n2rng = (n2rng_t *)ddi_get_soft_state(n2rng_softstate, instance);
	if (n2rng == NULL) {
		n2rng_diperror(dip, "no soft state in detach");
		return (DDI_FAILURE);
	}

	switch (cmd) {
	case DDI_SUSPEND:
		return (n2rng_suspend(n2rng));
	case DDI_DETACH:
		break;
	default:
		return (DDI_FAILURE);
	}

	/* Destroy task queue first to insure configuration has completed */
	if (n2rng->n_taskq != NULL) {
		ddi_taskq_destroy(n2rng->n_taskq);
		n2rng->n_taskq = NULL;
	}

	/* Untimeout pending config retry operations */
	mutex_enter(&n2rng->n_lock);
	tid = n2rng->n_timeout_id;
	n2rng->n_timeout_id = 0;
	mutex_exit(&n2rng->n_lock);
	if (tid) {
		DBG1(n2rng, DCHATTY, "n2rng_detach: untimeout pending retry "
		    "id = %x", tid);
		(void) untimeout(tid);
	}

	n2rng_uninit_ctl(n2rng);

	/* unregister with KCF---also tears down FIPS state */
	rv = n2rng_uninit(n2rng) ? DDI_FAILURE : DDI_SUCCESS;

	if (ncs_hsvc_available == B_TRUE) {
		(void) hsvc_unregister(&ncs_hsvc[ncs_version_index]);
		ncs_hsvc_available = B_FALSE;
	}

	mutex_destroy(&n2rng->n_lock);
	ddi_soft_state_free(n2rng_softstate, instance);

	return (rv);
}

/*ARGSUSED*/
static int
n2rng_suspend(n2rng_t *n2rng)
{
	/* unregister with KCF---also tears down FIPS state */
	if (n2rng_uninit(n2rng) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "n2rng: unable to unregister from KCF");
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
n2rng_resume(n2rng_t *n2rng)
{
	/* Assume clock is same speed and all data structures are intact */

	/* Re-configure the RNG hardware and register with KCF */
	return (n2rng_config(n2rng));
}

/*
 * Map hypervisor error code to solaris. Only
 * H_ENORADDR, H_EBADALIGN, H_EWOULDBLOCK, and EIO
 * are meaningful to this device. Any other error
 * codes are mapped EINVAL.
 */
int
n2rng_herr2kerr(uint64_t hv_errcode)
{
	int	s_errcode;

	switch (hv_errcode) {
	case H_EWOULDBLOCK:
		s_errcode = EWOULDBLOCK;
		break;
	case H_EIO:
		s_errcode = EIO;
		break;
	case H_EBUSY:
		s_errcode = EBUSY;
		break;
	case H_EOK:
		s_errcode = 0;
		break;
	case H_ENOACCESS:
		s_errcode = EPERM;
		break;
	case H_ENORADDR:
	case H_EBADALIGN:
	default:
		s_errcode = EINVAL;
		break;
	}
	return (s_errcode);
}

/*
 * Waits approximately delay_sticks counts of the stick register.
 * Times shorter than one sys clock tick (10ms on most systems) are
 * done by busy waiting.
 */
void
cyclesleep(n2rng_t *n2rng, uint64_t delay_sticks)
{
	uint64_t	end_stick = gettick() + delay_sticks;
	int64_t		sticks_to_wait;
	clock_t		sys_ticks_to_wait;
	clock_t		usecs_to_wait;

	/*CONSTCOND*/
	while (1) {
		sticks_to_wait = end_stick - gettick();
		if (sticks_to_wait <= 0) {
			return;
		}

		usecs_to_wait = sticks_to_wait / n2rng->n_sticks_per_usec;
		sys_ticks_to_wait = drv_usectohz(usecs_to_wait);

		if (sys_ticks_to_wait > 0) {
			/* sleep */
			delay(sys_ticks_to_wait);
		} else if (usecs_to_wait > 0) {
			/* busy wait */
			drv_usecwait(usecs_to_wait);
		}
	}
}

static void
log_internal_errors(uint64_t hverr, char *fname)
{
	switch (hverr) {
	case H_EBADALIGN:
		cmn_err(CE_WARN,
		    "n2rng: internal alignment "
		    "problem");
		break;
	case H_ENORADDR:
		cmn_err(CE_WARN, "n2rng: internal "
		    "invalid address");
		break;
	case H_ENOACCESS:
		cmn_err(CE_WARN, "n2rng: access failure");
		break;
	case H_EWOULDBLOCK:
		cmn_err(CE_WARN, "n2rng: hardware busy");
		break;
	default:
		cmn_err(CE_NOTE,
		    "n2rng: %s "
		    "unexpectedly "
		    "returned hverr %ld", fname, hverr);
		break;
	}
}

/*
 * Collects a buffer full of bits, using the specified setup. numbytes
 * must be a multiple of 8. If a sub-operation fails with EIO (handle
 * mismatch), returns EIO.  If collect_setupp is NULL, the current
 * setup is used.  If exit_setupp is NULL, the control configuratin
 * and state are not set at exit.  WARNING: the buffer must be 8-byte
 * aligned and in contiguous physical addresses.  Contiguousness is
 * not checked!
 */
int
n2rng_collect_diag_bits(n2rng_t *n2rng, int rngid,
    n2rng_setup_t *collect_setupp, void *buffer, int numbytes,
    n2rng_setup_t *exit_setupp, uint64_t exitstate)
{
	int		rv;
	int		override_rv = 0;
	uint64_t	hverr;
	int		i;
	uint64_t	tdelta;
	n2rng_setup_t	setupbuffer[2];
	n2rng_setup_t	*setupcontigp;
	uint64_t	setupphys;
	int		numchunks;
	boolean_t	rnglooping;
	int		busycount = 0;
	int		blockcount = 0;

	if (numbytes % sizeof (uint64_t)) {
		return (EINVAL);
	}

	if ((uint64_t)buffer % sizeof (uint64_t) != 0) {
		return (EINVAL);
	}

	numchunks = ((numbytes / sizeof (uint64_t)) + RNG_DIAG_CHUNK_SIZE - 1)
	    / RNG_DIAG_CHUNK_SIZE;
	/*
	 * Use setupbuffer[0] if it is contiguous, otherwise
	 * setupbuffer[1].
	 */
	setupcontigp = &setupbuffer[
	    CONTIGUOUS(&setupbuffer[0], n2rng_setup_t) ? 0 : 1];
	setupphys = va_to_pa(setupcontigp);

	/*
	 * If a non-null collect_setupp pointer has been provided,
	 * push the specified setup into the hardware.
	 */
	if (collect_setupp != NULL) {
		/* copy the specified state to the aligned buffer */
		*setupcontigp = *collect_setupp;
		rnglooping = B_TRUE;
		while (rnglooping) {
			hverr = n2rng_ctl_write(n2rng, rngid, setupphys,
			    CTL_STATE_HEALTHCHECK,
			    n2rng->n_ctl_data->n_watchdog_cycles, &tdelta);
			rv = n2rng_herr2kerr(hverr);
			switch (hverr) {
			case H_EOK:
				rnglooping = B_FALSE;
				break;
			case H_EIO: /* control yanked from us */
			case H_ENOACCESS: /* We are not control domain */
				return (rv);
			case H_EWOULDBLOCK:
				/* Data currently not available, try again */
				if (++blockcount > RNG_MAX_BLOCK_ATTEMPTS) {
					DBG1(n2rng, DHEALTH,
					    "n2rng_collect_diag_bits(1) : "
					    "exceeded block count of %d",
					    RNG_MAX_BLOCK_ATTEMPTS);
					return (rv);
				} else {
					cyclesleep(n2rng, tdelta);
				}
				break;
			case H_EBUSY:
				/*
				 * A control write is already in progress.
				 * Note: This shouldn't happen since
				 * n2rng_ctl_write() waits for the
				 * write to complete.
				 */
				if (++busycount > RNG_MAX_BUSY_ATTEMPTS) {
					DBG1(n2rng, DHEALTH,
					    "n2rng_collect_diag_bits(1): "
					    "exceeded busy count of %d",
					    RNG_MAX_BUSY_ATTEMPTS);
					return (rv);
				} else {
					delay(RNG_RETRY_BUSY_DELAY);
				}
				break;
			default:
				log_internal_errors(hverr, "hv_rng_ctl_write");
				override_rv = rv;
				goto restore_state;
			}
		} /* while (rnglooping) */
	} /* if (collect_setupp != NULL) */

	/* If the caller asks for some bytes, collect the data */
	if (numbytes > 0) {
		for (i = 0; i < numchunks; i++) {
			size_t thisnumbytes = (i == numchunks - 1) ?
			    numbytes - i * (RNG_DIAG_CHUNK_SIZE *
			    sizeof (uint64_t)) :
			    RNG_DIAG_CHUNK_SIZE * sizeof (uint64_t);

			/* try until we successfully read a word of data */
			rnglooping = B_TRUE;
			busycount = 0;
			blockcount = 0;
			while (rnglooping) {
				hverr = n2rng_data_read_diag(n2rng, rngid,
				    va_to_pa((uint64_t *)buffer +
				    RNG_DIAG_CHUNK_SIZE * i),
				    thisnumbytes, &tdelta);
				rv = n2rng_herr2kerr(hverr);
				switch (hverr) {
				case H_EOK:
					rnglooping = B_FALSE;
					break;
				case H_EIO:
				case H_ENOACCESS:
					return (rv);
				case H_EWOULDBLOCK:
					/* Data not available, try again */
					if (++blockcount >
					    RNG_MAX_BLOCK_ATTEMPTS) {
						DBG1(n2rng, DHEALTH,
						    "n2rng_collect_diag_bits"
						    "(2): exceeded block count"
						    " of %d",
						    RNG_MAX_BLOCK_ATTEMPTS);
						return (rv);
					} else {
						cyclesleep(n2rng, tdelta);
					}
					break;
				default:
					log_internal_errors(hverr,
					    "hv_rng_data_read_diag");
					override_rv = rv;
					goto restore_state;
				}
			} /* while (!rnglooping) */
		} /* for */
	}

restore_state:

	/* restore the preferred configuration and set exit state */
	if (exit_setupp != NULL) {

		*setupcontigp = *exit_setupp;
		rnglooping = B_TRUE;
		busycount = 0;
		blockcount = 0;
		while (rnglooping) {
			hverr = n2rng_ctl_write(n2rng, rngid, setupphys,
			    exitstate, n2rng->n_ctl_data->n_watchdog_cycles,
			    &tdelta);
			rv = n2rng_herr2kerr(hverr);
			switch (hverr) {
			case H_EOK:
			case H_EIO: /* control yanked from us */
			case H_EINVAL: /* some external error, probably */
			case H_ENOACCESS: /* We are not control domain */
				rnglooping = B_FALSE;
				break;
			case H_EWOULDBLOCK:
				/* Data currently not available, try again */
				if (++blockcount > RNG_MAX_BLOCK_ATTEMPTS) {
					DBG1(n2rng, DHEALTH,
					    "n2rng_collect_diag_bits(3): "
					    "exceeded block count of %d",
					    RNG_MAX_BLOCK_ATTEMPTS);
					return (rv);
				} else {
					cyclesleep(n2rng, tdelta);
				}
				break;
			case H_EBUSY:
				/*
				 * A control write is already in progress.
				 * Note: This shouldn't happen since
				 * n2rng_ctl_write() waits for the
				 * write to complete.
				 */
				if (++busycount > RNG_MAX_BUSY_ATTEMPTS) {
					DBG1(n2rng, DHEALTH,
					    "n2rng_collect_diag_bits(3): "
					    "exceeded busy count of %d",
					    RNG_MAX_BUSY_ATTEMPTS);
					return (rv);
				} else {
					delay(RNG_RETRY_BUSY_DELAY);
				}
				break;
			default:
				rnglooping = B_FALSE;
				log_internal_errors(hverr, "hv_rng_ctl_write");
				break;
			}
		} /* while */
	} /* if */

	/*
	 * override_rv takes care of the case where we abort becuase
	 * of some error, but still want to restore the peferred state
	 * and return the first error, even if other error occur.
	 */
	return (override_rv ? override_rv : rv);
}

int
n2rng_getentropy(n2rng_t *n2rng, void *buffer, size_t size)
{
	int		i, rv = 0;  /* so it works if size is zero */
	uint64_t	hverr;
	uint64_t	*buffer_w = (uint64_t *)buffer;
	int		num_w = size / sizeof (uint64_t);
	uint64_t	randval;
	uint64_t	randvalphys = va_to_pa(&randval);
	uint64_t	tdelta;
	int		failcount = 0;
	int		blockcount = 0;
	boolean_t	rnglooping;

	for (i = 0; i < num_w; i++) {
		rnglooping = B_TRUE;
		while (rnglooping) {
			hverr = hv_rng_data_read(randvalphys, &tdelta);
			rv = n2rng_herr2kerr(hverr);
			switch (hverr) {
			case H_EOK:
				buffer_w[i] = randval;
				failcount = 0;
				rnglooping = B_FALSE;
				break;
			case H_EIO:
				/*
				 * Either a health check is in progress, or
				 * the watchdog timer has expired while running
				 * hv api version 2.0 or higher with health
				 * checks enabled.
				 */
				if (n2rng->n_hvapi_major_version < 2) {
					/*
					 * A health check is in progress.
					 * Wait RNG_RETRY_HLCHK_USECS and fail
					 * after RNG_MAX_DATA_READ_ATTEMPTS
					 * failures.
					 */
					if (++failcount >
					    RNG_MAX_DATA_READ_ATTEMPTS) {
						DBG2(n2rng, DHEALTH,
						    "n2rng_getentropy: exceeded"
						    "EIO count of %d on cpu %d",
						    RNG_MAX_DATA_READ_ATTEMPTS,
						    CPU->cpu_id);
						goto exitpoint;
					} else {
						delay(drv_usectohz
						    (RNG_RETRY_HLCHK_USECS));
					}
				} else {
					/*
					 * Just return the error. If a flurry of
					 * random data requests happen to occur
					 * during a health check, there are
					 * multiple levels of defense:
					 * - 2.0 HV provides random data pool
					 * - FIPS algorithm tolerates failures
					 * - Software failover
					 * - Automatic configuration retries
					 * - Hardware failover on some systems
					 */
					goto exitpoint;
				}
				break;
			case H_EWOULDBLOCK:
				/* Data currently not available, try again */
				if (++blockcount > RNG_MAX_BLOCK_ATTEMPTS) {
					DBG1(n2rng, DHEALTH,
					    "n2rng_getentropy: "
					    "exceeded block count of %d",
					    RNG_MAX_BLOCK_ATTEMPTS);
					goto exitpoint;
				} else {
					cyclesleep(n2rng, tdelta);
				}
				break;
			default:
				log_internal_errors(hverr, "hv_rng_data_read");
				goto exitpoint;
			}
		} /* while */
	} /* for */

exitpoint:
	return (rv);
}

uint64_t
n2rng_ctl_read(n2rng_t *n2rng, int rngid, uint64_t ctlregs_pa, uint64_t *state,
    uint64_t *tdelta, uint64_t *wdelta)
{
	uint64_t	rv;
	uint64_t	wstatus;

	/* Call correct hv function based on api version */
	if (n2rng->n_hvapi_major_version == 2) {
		rv = hv_rng_ctl_read_v2(ctlregs_pa, (uint64_t)rngid, state,
		    tdelta, wdelta, &wstatus);
		if (rv == 0) {
			rv = wstatus;
		}
	} else {
		rv = hv_rng_ctl_read(ctlregs_pa, state, tdelta);
		*wdelta = 0;
	}

	return (rv);
}

uint64_t
n2rng_ctl_wait(n2rng_t *n2rng, int rngid)
{
	uint64_t	state;
	uint64_t	tdelta;
	uint64_t	wdelta;
	uint64_t	wstatus;
	boolean_t	rnglooping = B_TRUE;
	uint64_t	rv;
	n2rng_setup_t	setupbuffer[2];
	n2rng_setup_t	*setupcontigp;
	uint64_t	setupphys;
	int		busycount = 0;
	int		blockcount = 0;

	/*
	 * Use setupbuffer[0] if it is contiguous, otherwise
	 * setupbuffer[1].
	 */
	setupcontigp = &setupbuffer[
	    CONTIGUOUS(&setupbuffer[0], n2rng_setup_t) ? 0 : 1];
	setupphys = va_to_pa(setupcontigp);

	while (rnglooping) {
		rv = hv_rng_ctl_read_v2(setupphys, (uint64_t)rngid, &state,
		    &tdelta, &wdelta, &wstatus);
		switch (rv) {
		case H_EOK:
			rv = wstatus;
			rnglooping = B_FALSE;
			break;
		case H_EWOULDBLOCK:
			/* Data currently not available, try again */
			if (++blockcount > RNG_MAX_BLOCK_ATTEMPTS) {
				DBG1(n2rng, DHEALTH, "n2rng_ctl_wait: "
				    "exceeded block count of %d",
				    RNG_MAX_BLOCK_ATTEMPTS);
				return (rv);
			} else {
				cyclesleep(n2rng, tdelta);
			}
			break;
		case H_EBUSY:
			/* Control write still pending, try again */
			if (++busycount > RNG_MAX_BUSY_ATTEMPTS) {
				DBG1(n2rng, DHEALTH, "n2rng_ctl_wait: "
				    "exceeded busy count of %d",
				    RNG_MAX_BUSY_ATTEMPTS);
				return (rv);
			} else {
				delay(RNG_RETRY_BUSY_DELAY);
			}
			break;
		default:
			log_internal_errors(rv, "n2rng_ctl_wait");
			rnglooping = B_FALSE;
		}
	} /* while (rnglooping) */

	return (rv);
}

uint64_t
n2rng_ctl_write(n2rng_t *n2rng, int rngid, uint64_t ctlregs_pa,
    uint64_t newstate, uint64_t wtimeout, uint64_t *tdelta)
{
	uint64_t	rv;

	/* Call correct hv function based on api version */
	if (n2rng->n_hvapi_major_version == 2) {
		rv = hv_rng_ctl_write_v2(ctlregs_pa, newstate, wtimeout,
		    (uint64_t)rngid);
		if (rv == H_EOK) {
			/* Wait for control registers to be written */
			rv = n2rng_ctl_wait(n2rng, rngid);
		}
		*tdelta = RNG_DEFAULT_ACCUMULATE_CYCLES;
	} else {
		rv = hv_rng_ctl_write(ctlregs_pa, newstate, wtimeout, tdelta);
	}

	return (rv);
}

uint64_t
n2rng_data_read_diag(n2rng_t *n2rng, int rngid, uint64_t data_pa,
    size_t  datalen, uint64_t *tdelta)
{
	uint64_t	rv;

	/* Call correct hv function based on api version */
	if (n2rng->n_hvapi_major_version == 2) {
		rv = hv_rng_data_read_diag_v2(data_pa, datalen,
		    (uint64_t)rngid, tdelta);
		if (*tdelta == 0) {
			*tdelta = RNG_DEFAULT_ACCUMULATE_CYCLES;
		}
	} else {
		rv = hv_rng_data_read_diag(data_pa, datalen, tdelta);
	}

	return (rv);
}

uint64_t
n2rng_check_ctl_access(n2rng_t *n2rng)
{
	uint64_t	rv;
	uint64_t	unused_64;

	/* Call correct hv function based on api version */
	if (n2rng->n_hvapi_major_version == 2) {
		/*
		 * Attempt to read control registers with invalid ID and data
		 * just to see if we get an access error
		 */
		rv = hv_rng_ctl_read_v2(0, N2RNG_INVALID_ID,
		    &unused_64, &unused_64, &unused_64, &unused_64);
	} else {
		rv = hv_rng_get_diag_control();
	}

	return (rv);
}

/*
 * n2rng_config_retry()
 *
 * Schedule a timed call to n2rng_config() if one is not already pending
 */
void
n2rng_config_retry(n2rng_t *n2rng, clock_t seconds)
{
	mutex_enter(&n2rng->n_lock);
	/* Check if a config retry is already pending */
	if (n2rng->n_timeout_id) {
		DBG1(n2rng, DCFG, "n2rng_config_retry: retry pending "
		    "id = %x", n2rng->n_timeout_id);
	} else {
		n2rng->n_timeout_id = timeout(n2rng_config_task,
		    (void *)n2rng, drv_usectohz(seconds * SECOND));
		DBG2(n2rng, DCFG, "n2rng_config_retry: retry scheduled in "
		    "%d seconds, id = %x", seconds, n2rng->n_timeout_id);
	}
	mutex_exit(&n2rng->n_lock);
}

static uint64_t
sticks_per_usec(void)
{
	uint64_t starttick = gettick();
	hrtime_t starttime = gethrtime();
	uint64_t endtick;
	hrtime_t endtime;

	delay(2);

	endtick = gettick();
	endtime = gethrtime();

	return ((1000 * (endtick - starttick)) / (endtime - starttime));
}

static int
n2rng_init_ctl(n2rng_t *n2rng)
{
	int		rv;
	int		hverr;
	rng_entry_t	*rng;
	int		rngid;
	int		blockcount = 0;

	n2rng->n_ctl_data = NULL;

	/* Attempt to gain diagnostic control */
	do {
		hverr = n2rng_check_ctl_access(n2rng);
		rv = n2rng_herr2kerr(hverr);
		if ((hverr == H_EWOULDBLOCK) &&
		    (++blockcount > RNG_MAX_BUSY_ATTEMPTS)) {
			DBG1(n2rng, DHEALTH, "n2rng_int_ctl: exceeded busy "
			    "count of %d", RNG_MAX_BUSY_ATTEMPTS);
			return (rv);
		} else {
			delay(RNG_RETRY_BUSY_DELAY);
		}
	} while (hverr == H_EWOULDBLOCK);

	/*
	 * If attempt fails with EPERM, the driver is not running in the
	 * control domain
	 */
	if (rv == EPERM) {
		DBG0(n2rng, DATTACH,
		    "n2rng_init_ctl: Running in guest domain");
		return (DDI_SUCCESS);
	}

	/* Allocate control stucture only used in control domain */
	n2rng->n_ctl_data = kmem_alloc(sizeof (rng_ctl_data_t), KM_SLEEP);
	n2rng->n_ctl_data->n_num_rngs_online = 0;

	/*
	 * If running with an API version less than 2.0 default to one rng.
	 * Otherwise get number of rngs from device properties.
	 */
	if (n2rng->n_hvapi_major_version < 2) {
		n2rng->n_ctl_data->n_num_rngs = 1;
	} else {
		n2rng->n_ctl_data->n_num_rngs =
		    ddi_getprop(DDI_DEV_T_ANY, n2rng->n_dip,
		    DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS,
		    N2RNG_PROP_NUM_UNITS, 0);
		if (n2rng->n_ctl_data->n_num_rngs == 0) {
			cmn_err(CE_WARN, "n2rng: %s property not found",
			    N2RNG_PROP_NUM_UNITS);
			return (DDI_FAILURE);
		}
	}

	/* Allocate space for all rng entries */
	n2rng->n_ctl_data->n_rngs =
	    kmem_zalloc(n2rng->n_ctl_data->n_num_rngs *
	    sizeof (rng_entry_t), KM_SLEEP);

	/* Get accumulate cycles from .conf file. */
	n2rng->n_ctl_data->n_accumulate_cycles =
	    ddi_getprop(DDI_DEV_T_ANY, n2rng->n_dip,
	    DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS, "acc_cycles",
	    RNG_DEFAULT_ACCUMULATE_CYCLES);

	/* Get health check frequency from .conf file */
	n2rng->n_ctl_data->n_hc_secs = ddi_getprop(DDI_DEV_T_ANY, n2rng->n_dip,
	    DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS, "hc_seconds",
	    RNG_DEFAULT_HC_SECS);

	/* API versions prior to 2.0 do not support health checks */
	if ((n2rng->n_hvapi_major_version < 2) &&
	    (n2rng->n_ctl_data->n_hc_secs > 0)) {
		cmn_err(CE_WARN, "n2rng: Hyperviser api "
		    "version %d.%d does not support health checks",
		    n2rng->n_hvapi_major_version,
		    n2rng->n_hvapi_minor_version);
		n2rng->n_ctl_data->n_hc_secs = 0;
	}


	/* Calculate watchdog timeout value */
	if (n2rng->n_ctl_data->n_hc_secs <= 0) {
		n2rng->n_ctl_data->n_watchdog_cycles = 0;
	} else {
		n2rng->n_ctl_data->n_watchdog_cycles =
		    ((uint64_t)(RNG_EXTRA_WATCHDOG_SECS) +
		    n2rng->n_ctl_data->n_hc_secs) *
		    n2rng->n_sticks_per_usec * 1000000;
	}

	/*
	 * Set some plausible state into the preferred configuration.
	 * The intent is that the health check will immediately overwrite it.
	 */
	for (rngid = 0; rngid < n2rng->n_ctl_data->n_num_rngs; rngid++) {

		rng = &n2rng->n_ctl_data->n_rngs[rngid];

		rng->n_preferred_config.ctlwds[0].word = 0;
		rng->n_preferred_config.ctlwds[0].fields.rnc_anlg_sel =
		    N2RNG_NOANALOGOUT;
		rng->n_preferred_config.ctlwds[0].fields.rnc_cnt =
		    RNG_DEFAULT_ACCUMULATE_CYCLES;
		rng->n_preferred_config.ctlwds[0].fields.rnc_mode =
		    RNG_MODE_NORMAL;
		rng->n_preferred_config.ctlwds[1].word =
		    rng->n_preferred_config.ctlwds[0].word;
		rng->n_preferred_config.ctlwds[2].word =
		    rng->n_preferred_config.ctlwds[0].word;
		rng->n_preferred_config.ctlwds[3].word =
		    rng->n_preferred_config.ctlwds[0].word;
		rng->n_preferred_config.ctlwds[0].fields.rnc_vcoctl = 1;
		rng->n_preferred_config.ctlwds[0].fields.rnc_selbits = 1;
		rng->n_preferred_config.ctlwds[1].fields.rnc_vcoctl = 2;
		rng->n_preferred_config.ctlwds[1].fields.rnc_selbits = 2;
		rng->n_preferred_config.ctlwds[2].fields.rnc_vcoctl = 3;
		rng->n_preferred_config.ctlwds[2].fields.rnc_selbits = 4;
		rng->n_preferred_config.ctlwds[3].fields.rnc_vcoctl = 0;
		rng->n_preferred_config.ctlwds[3].fields.rnc_selbits = 7;
	}

	n2rng_setcontrol(n2rng);
	DBG2(n2rng, DATTACH,
	    "n2rng_init_ctl: Running in control domain with %d rng device%s",
	    n2rng->n_ctl_data->n_num_rngs,
	    (n2rng->n_ctl_data->n_num_rngs == 1) ? "" : "s");
	DBG2(n2rng, DCFG,
	    "n2rng_init_ctl: n_sticks_per_usec = %ld, n_hc_secs = %d",
	    n2rng->n_sticks_per_usec,
	    n2rng->n_ctl_data->n_hc_secs);
	DBG2(n2rng, DCFG,
	    "n2rng_init_ctl: n_watchdog_cycles = %ld, "
	    "n_accumulate_cycles = %ld", n2rng->n_ctl_data->n_watchdog_cycles,
	    n2rng->n_ctl_data->n_accumulate_cycles);

	return (DDI_SUCCESS);
}

static void
n2rng_uninit_ctl(n2rng_t *n2rng)
{
	if (n2rng->n_ctl_data) {
		if (n2rng->n_ctl_data->n_num_rngs) {
			kmem_free(n2rng->n_ctl_data->n_rngs,
			    n2rng->n_ctl_data->n_num_rngs *
			    sizeof (rng_entry_t));
			n2rng->n_ctl_data->n_rngs = NULL;
			n2rng->n_ctl_data->n_num_rngs = 0;
		}
		kmem_free(n2rng->n_ctl_data, sizeof (rng_ctl_data_t));
		n2rng->n_ctl_data = NULL;
	}
}


/*
 * n2rng_config_test()
 *
 * Attempt read random data to see if the rng is configured.
 */
int
n2rng_config_test(n2rng_t *n2rng)
{
	int		rv = 0;
	uint64_t	hverr;
	uint64_t	randval = 0;
	uint64_t	randvalphys = va_to_pa(&randval);
	uint64_t	tdelta;
	int		failcount = 0;
	int		blockcount = 0;
	boolean_t	rnglooping = B_TRUE;

	while (rnglooping) {
		hverr = hv_rng_data_read(randvalphys, &tdelta);
		rv = n2rng_herr2kerr(hverr);
		switch (hverr) {
		case H_EOK:
			failcount = 0;
			rnglooping = B_FALSE;
			break;
		case H_EIO:
			/*
			 * A health check is in progress.
			 * Wait RNG_RETRY_HLCHK_USECS and fail
			 * after RNG_MAX_DATA_READ_ATTEMPTS
			 * failures.
			 */
			if (++failcount > RNG_MAX_DATA_READ_ATTEMPTS) {
				goto exitpoint;
			} else {
				delay(drv_usectohz(RNG_RETRY_HLCHK_USECS));
			}
			break;
		case H_EWOULDBLOCK:
			/* Data currently not available, try again */
			if (++blockcount > RNG_MAX_BLOCK_ATTEMPTS) {
				DBG1(n2rng, DHEALTH, "n2rng_config_test: "
				    "exceeded block count of %d",
				    RNG_MAX_BLOCK_ATTEMPTS);
				goto exitpoint;
			} else {
				cyclesleep(n2rng, tdelta);
			}
			break;
		case H_ENOACCESS:
			/* An rng error has occured during health check */
			goto exitpoint;
		default:
			log_internal_errors(hverr, "hv_rng_data_read");
			goto exitpoint;
		}
	} /* while */

exitpoint:
	return (rv);
}

/*
 * n2rng_config()
 *
 * Run health check on the RNG hardware
 * Configure the RNG hardware
 * Register with crypto framework
 */
static int
n2rng_config(n2rng_t *n2rng)
{
	int		rv;
	rng_entry_t	*rng;
	int		rngid;

	/*
	 * Run health checks and configure rngs if running in control domain,
	 * otherwise just check if at least one rng is available.
	 */
	if (n2rng_iscontrol(n2rng)) {

		for (rngid = 0; rngid < n2rng->n_ctl_data->n_num_rngs;
		    rngid++) {

			rng = &n2rng->n_ctl_data->n_rngs[rngid];

			/* Only test rngs that have not already failed */
			if (rng->n_rng_state == CTL_STATE_ERROR) {
				continue;
			}

			if ((n2rng->n_binding == N2RNG_CPU_VF) &&
			    (n2rng->n_hvapi_major_version < 2)) {
				/*
				 * Since api versions prior to 2.0 do not
				 * support multiple rngs, bind to the current
				 * processor for the entire health check
				 * process.
				 */
				thread_affinity_set(curthread, CPU_CURRENT);
				DBG1(n2rng, DCFG, "n2rng_config: "
				    "Configuring single rng from cpu %d",
				    CPU->cpu_id);
				rv = n2rng_do_health_check(n2rng, rngid);
				thread_affinity_clear(curthread);
			} else {
				rv = n2rng_do_health_check(n2rng, rngid);
			}

			switch (rv) {
			case 0:
				/*
				 * Successful, increment online count if
				 * necessary
				 */
				DBG1(n2rng, DCFG, "n2rng_config: rng(%d) "
				    "passed health checks", rngid);
				if (rng->n_rng_state != CTL_STATE_CONFIGURED) {
					rng->n_rng_state =
					    CTL_STATE_CONFIGURED;
					n2rng->n_ctl_data->n_num_rngs_online++;
				}
				break;
			default:
				/*
				 * Health checks failed, decrement online
				 * count if necessary
				 */
				cmn_err(CE_WARN, "n2rng: rng(%d) "
				    "failed health checks", rngid);
				if (rng->n_rng_state == CTL_STATE_CONFIGURED) {
					n2rng->n_ctl_data->n_num_rngs_online--;
				}
				rng->n_rng_state = CTL_STATE_ERROR;
				break;
			}
		}
		DBG2(n2rng, DCFG, "n2rng_config: %d rng%s online",
		    n2rng->n_ctl_data->n_num_rngs_online,
		    (n2rng->n_ctl_data->n_num_rngs_online == 1) ? "" : "s");

		/* Check if all rngs have failed */
		if (n2rng->n_ctl_data->n_num_rngs_online == 0) {
			cmn_err(CE_WARN, "n2rng: %d RNG device%s failed",
			    n2rng->n_ctl_data->n_num_rngs,
			    (n2rng->n_ctl_data->n_num_rngs == 1) ? "" : "s");
			goto errorexit;
		} else {
			n2rng_setconfigured(n2rng);
		}
	} else {
		/* Running in guest domain, just check if rng is configured */
		rv = n2rng_config_test(n2rng);
		switch (rv) {
		case 0:
			n2rng_setconfigured(n2rng);
			break;
		case EIO:
			/* Don't set configured to force a retry */
			break;
		default:
			goto errorexit;
		}
	}

	/*
	 * Initialize FIPS state and register with KCF if we have at least one
	 * RNG configured.  Otherwise schedule a retry if all rngs have not
	 * failed.
	 */
	if (n2rng_isconfigured(n2rng)) {

		if (n2rng_init(n2rng) != DDI_SUCCESS) {
			cmn_err(CE_WARN, "n2rng: unable to register with KCF");
			goto errorexit;
		}

		/*
		 * Schedule a retry if running in the control domain and a
		 * health check time has been specified.
		 */
		if (n2rng_iscontrol(n2rng) &&
		    (n2rng->n_ctl_data->n_hc_secs > 0)) {
			n2rng_config_retry(n2rng,
			    n2rng->n_ctl_data->n_hc_secs);
		}
	} else if (!n2rng_isfailed(n2rng)) {
		/* Schedule a retry if one is not already pending */
		n2rng_config_retry(n2rng, RNG_CFG_RETRY_SECS);
	}
	return (DDI_SUCCESS);

errorexit:
	/* Unregister from kCF if we are registered */
	(void) n2rng_unregister_provider(n2rng);
	n2rng_setfailed(n2rng);
	cmn_err(CE_WARN, "n2rng: hardware failure detected");
	return (DDI_FAILURE);
}

/*
 * n2rng_config_task()
 *
 * Call n2rng_config() from the task queue or after a timeout, ignore result.
 */
static void
n2rng_config_task(void *targ)
{
	n2rng_t *n2rng = (n2rng_t *)targ;

	mutex_enter(&n2rng->n_lock);
	n2rng->n_timeout_id = 0;
	mutex_exit(&n2rng->n_lock);
	(void) n2rng_config(n2rng);
}