xref: /titanic_52/usr/src/uts/sun4v/io/vnex.c (revision 193974072f41a843678abf5f61979c748687e66b)

/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/conf.h>
#include <sys/ddi_impldefs.h>
#include <sys/autoconf.h>
#include <sys/systm.h>
#include <sys/modctl.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ddi_subrdefs.h>
#include <sys/promif.h>
#include <sys/machsystm.h>
#include <sys/ddi_intr_impl.h>
#include <sys/hypervisor_api.h>
#include <sys/intr.h>
#include <sys/hsvc.h>

#define	SUN4V_REG_SPEC2CFG_HDL(x)	((x >> 32) & ~(0xfull << 28))

static kmutex_t vnex_id_lock;
/*
 * Vnex name  to pil map
 */
typedef struct vnex_regspec {
	uint64_t physaddr;
	uint64_t size;
} vnex_regspec_t;

struct vnex_pil_map {
	caddr_t	name;
	uint32_t pil;
};

/* vnex interrupt descriptor */
typedef struct vnex_id {
	dev_info_t *vid_dip;
	uint32_t vid_ino;
	uint64_t vid_ihdl;
	uint_t	(*vid_handler)();
	caddr_t	vid_arg1;
	caddr_t	vid_arg2;
	ddi_intr_handle_impl_t *vid_ddi_hdlp;
	uint64_t vid_cfg_hdl;
	struct vnex_id *vid_next;
} vnex_id_t;

/* vnex interrupt descriptor list */
static vnex_id_t *vnex_id_list;

hrtime_t vnex_pending_timeout = 2ull * NANOSEC; /* 2 seconds in nanoseconds */

/*
 * vnex interrupt descriptor list manipulation functions
 */

static vnex_id_t *vnex_locate_id(dev_info_t *dip, uint32_t ino);
static vnex_id_t *vnex_alloc_id(dev_info_t *dip, uint32_t ino,
	uint64_t dhdl);
static void vnex_add_id(vnex_id_t *vid_p);
static void vnex_rem_id(vnex_id_t *vid_p);
static void vnex_free_id(vnex_id_t *vid_p);

uint_t vnex_intr_wrapper(caddr_t arg);

static struct vnex_pil_map vnex_name_to_pil[] = {
	{"console", 	PIL_12},
	{"fma",		PIL_5},
	{"echo", 	PIL_3},
	{"loop", 	PIL_3},
	{"sunmc", 	PIL_3},
	{"sunvts", 	PIL_3},
	{"explorer", 	PIL_3},
	{"ncp", 	PIL_8},
	{"crypto", 	PIL_8}
};

#define	VNEX_MAX_DEVS	(sizeof (vnex_name_to_pil) /	\
			    sizeof (struct vnex_pil_map))

/*
 * Config information
 */
static int vnex_intr_ops(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_op_t intr_op, ddi_intr_handle_impl_t *hdlp, void *result);

static int
vnex_ctl(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, void *);

static struct bus_ops vnex_bus_ops = {
	BUSO_REV,
	nullbusmap,
	NULL,	/* NO OP */
	NULL,	/* NO OP */
	NULL,	/* NO OP */
	i_ddi_map_fault,
	ddi_no_dma_map,
	ddi_no_dma_allochdl,
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	vnex_ctl,
	ddi_bus_prop_op,
	NULL,	/* (*bus_get_eventcookie)();    */
	NULL,	/* (*bus_add_eventcall)();	*/
	NULL,	/* (*bus_remove_eventcall)();   */
	NULL,	/* (*bus_post_event)();		*/
	NULL,	/* (*bus_intr_ctl)();		*/
	NULL,	/* (*bus_config)();		*/
	NULL,	/* (*bus_unconfig)();		*/
	NULL,	/* (*bus_fm_init)();		*/
	NULL,	/* (*bus_fm_fini)();		*/
	NULL,	/* (*bus_fm_access_enter)();	*/
	NULL,	/* (*bus_fm_access_fini)();	*/
	NULL,	/* (*bus_power)();		*/
	vnex_intr_ops	/* (*bus_intr_op)();	*/
};

static int vnex_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int vnex_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);

static struct dev_ops pseudo_ops = {
	DEVO_REV,		/* devo_rev, */
	0,			/* refcnt  */
	ddi_no_info,		/* info */
	nulldev,		/* identify */
	nulldev,		/* probe */
	vnex_attach,		/* attach */
	vnex_detach,		/* detach */
	nodev,			/* reset */
	(struct cb_ops *)0,	/* driver operations */
	&vnex_bus_ops,		/* bus operations */
	nulldev,		/* power */
	ddi_quiesce_not_needed,		/* quiesce */
};

/*
 * Module linkage information for the kernel.
 */

static struct modldrv modldrv = {
	&mod_driverops, /* Type of module.  This one is a pseudo driver */
	"sun4v virtual-devices nexus driver",
	&pseudo_ops,	/* driver ops */
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modldrv, NULL
};

int
_init(void)
{
	uint64_t mjrnum;
	uint64_t mnrnum;

	/*
	 * Check HV intr group api versioning.
	 * This driver uses the old interrupt routines which are supported
	 * in old firmware in the CORE API group and in newer firmware in
	 * the INTR API group.  Support for these calls will be dropped
	 * once the INTR API group major goes to 2.
	 */

	if ((hsvc_version(HSVC_GROUP_INTR, &mjrnum, &mnrnum) == 0) &&
	    (mjrnum > 1)) {
		cmn_err(CE_WARN, "niumx: unsupported intr api group: "
		    "maj:0x%lx, min:0x%lx", mjrnum, mnrnum);
		return (ENOTSUP);
	}

	return (mod_install(&modlinkage));
}

int
_fini(void)
{
	return (mod_remove(&modlinkage));
}

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

/*ARGSUSED*/
void
vnex_intr_dist(void *arg)
{
	vnex_id_t *vid_p;
	uint32_t cpuid;
	int	intr_state;
	hrtime_t start;

	mutex_enter(&vnex_id_lock);

	for (vid_p = vnex_id_list; vid_p != NULL;
	    vid_p = vid_p->vid_next) {
		/*
		 * Don't do anything for disabled interrupts.
		 * vnex_enable_intr takes care of redistributing interrupts.
		 */
		if ((hvio_intr_getvalid(vid_p->vid_ihdl,
		    &intr_state) == H_EOK) && (intr_state == HV_INTR_NOTVALID))
				continue;

		cpuid = intr_dist_cpuid();

		(void) hvio_intr_setvalid(vid_p->vid_ihdl, HV_INTR_NOTVALID);
		/*
		 * Make a best effort to wait for pending interrupts to finish.
		 * There is not much we can do if we timeout.
		 */
		start = gethrtime();
		while (!panicstr &&
		    (hvio_intr_getstate(vid_p->vid_ihdl, &intr_state) ==
		    H_EOK) && (intr_state == HV_INTR_DELIVERED_STATE)) {
			if (gethrtime() - start > vnex_pending_timeout) {
				cmn_err(CE_WARN, "vnex_intr_dist: %s%d "
				    "ino 0x%x pending: timedout\n",
				    ddi_driver_name(vid_p->vid_dip),
				    ddi_get_instance(vid_p->vid_dip),
				    vid_p->vid_ino);
				break;
			}
		}
		(void) hvio_intr_settarget(vid_p->vid_ihdl, cpuid);
		(void) hvio_intr_setvalid(vid_p->vid_ihdl, HV_INTR_VALID);
	}
	mutex_exit(&vnex_id_lock);
}

static int
vnex_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_ATTACH:
		/*
		 * Intitialize interrupt descriptor list
		 * and mutex.
		 */
		vnex_id_list = NULL;
		mutex_init(&vnex_id_lock, NULL, MUTEX_DRIVER, NULL);
		/*
		 * Add interrupt redistribution callback.
		 */
		intr_dist_add(vnex_intr_dist, dip);
		return (DDI_SUCCESS);

	case DDI_RESUME:
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
}

/*ARGSUSED*/
static int
vnex_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_DETACH:
		return (DDI_FAILURE);

	case DDI_SUSPEND:
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
}

static int
vnex_ctl(dev_info_t *dip, dev_info_t *rdip,
	ddi_ctl_enum_t ctlop, void *arg, void *result)
{
	char	name[12];	/* enough for a decimal integer */
	int		reglen;
	uint32_t	*vnex_regspec;

	switch (ctlop) {
	case DDI_CTLOPS_REPORTDEV:
		if (rdip == NULL)
			return (DDI_FAILURE);
		cmn_err(CE_CONT, "?virtual-device: %s%d\n",
		    ddi_driver_name(rdip), ddi_get_instance(rdip));
		return (DDI_SUCCESS);

	case DDI_CTLOPS_INITCHILD:
	{
		dev_info_t *child = (dev_info_t *)arg;

		if (ddi_getlongprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
		    "reg", (caddr_t)&vnex_regspec, &reglen) != DDI_SUCCESS)
			return (DDI_FAILURE);

		(void) sprintf(name, "%x", *vnex_regspec);
		ddi_set_name_addr(child, name);
		ddi_set_parent_data(child, NULL);
		kmem_free((caddr_t)vnex_regspec, reglen);
		return (DDI_SUCCESS);

	}

	case DDI_CTLOPS_UNINITCHILD:
	{
		dev_info_t *child = (dev_info_t *)arg;

		ddi_set_name_addr(child, NULL);
		ddi_remove_minor_node(arg, NULL);
		return (DDI_SUCCESS);
	}

	/*
	 * These ops correspond to functions that "shouldn't" be called
	 * by a pseudo driver.  So we whinge when we're called.
	 */
	case DDI_CTLOPS_DMAPMAPC:
	case DDI_CTLOPS_REPORTINT:
	case DDI_CTLOPS_REGSIZE:
	{
		*((off_t *)result) = 0;
		return (DDI_SUCCESS);
	}
	case DDI_CTLOPS_NREGS:
	{
		dev_info_t *child = rdip;
		if (ddi_getlongprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
		    "reg", (caddr_t)&vnex_regspec, &reglen) != DDI_SUCCESS)
			return (DDI_FAILURE);
		*((uint_t *)result) = reglen / sizeof (uint32_t);
		kmem_free((caddr_t)vnex_regspec, reglen);
		return (DDI_SUCCESS);
	}
	case DDI_CTLOPS_SIDDEV:
	case DDI_CTLOPS_SLAVEONLY:
	case DDI_CTLOPS_AFFINITY:
	case DDI_CTLOPS_IOMIN:
	case DDI_CTLOPS_POKE:
	case DDI_CTLOPS_PEEK:
		cmn_err(CE_CONT, "%s%d: invalid op (%d) from %s%d\n",
		    ddi_get_name(dip), ddi_get_instance(dip),
		    ctlop, ddi_get_name(rdip), ddi_get_instance(rdip));
		return (DDI_FAILURE);

	/*
	 * Everything else (e.g. PTOB/BTOP/BTOPR requests) we pass up
	 */
	default:
		return (ddi_ctlops(dip, rdip, ctlop, arg, result));
	}
}

static int
vnex_get_pil(dev_info_t *rdip)
{
	int i;
	caddr_t	name;

	name = ddi_node_name(rdip);
	for (i = 0; i < VNEX_MAX_DEVS; i++) {
		if (strcmp(vnex_name_to_pil[i].name,
		    name) == 0) {
			return (vnex_name_to_pil[i].pil);
		}
	}
	/*
	 * if not found pil is 0
	 */
	return (0);
}

static int
vnex_enable_intr(dev_info_t *rdip, ddi_intr_handle_impl_t *hdlp)
{
	vnex_id_t *vid_p;
	uint32_t cpuid;

	vid_p = vnex_locate_id(rdip, hdlp->ih_vector);

	ASSERT(vid_p != NULL);

	cpuid = intr_dist_cpuid();

	if ((hvio_intr_settarget(vid_p->vid_ihdl, cpuid)) != H_EOK) {
		return (DDI_FAILURE);
	}

	if (hvio_intr_setstate(vid_p->vid_ihdl, HV_INTR_IDLE_STATE) != H_EOK) {
		return (DDI_FAILURE);
	}

	if ((hvio_intr_setvalid(vid_p->vid_ihdl, HV_INTR_VALID)) != H_EOK) {
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static int
vnex_disable_intr(dev_info_t *rdip, ddi_intr_handle_impl_t *hdlp)
{
	vnex_id_t *vid_p;

	vid_p = vnex_locate_id(rdip, hdlp->ih_vector);

	ASSERT(vid_p != NULL);

	if (hvio_intr_setvalid(vid_p->vid_ihdl, HV_INTR_NOTVALID) != H_EOK) {
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

int
vnex_ino_to_inum(dev_info_t *dip, uint32_t ino)
{
	vnex_id_t		*vid_p;
	ddi_intr_handle_impl_t	*hdlp;

	if ((vid_p = vnex_locate_id(dip, ino)) == NULL)
		return (-1);
	else if ((hdlp = vid_p->vid_ddi_hdlp) == NULL)
		return (-1);
	else
		return (hdlp->ih_inum);
}

static int
vnex_add_intr(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_handle_impl_t *hdlp)
{
	int reglen, ret = DDI_SUCCESS;
	vnex_id_t	*vid_p;
	uint64_t cfg;
	uint32_t ino;
	uint64_t ihdl;
	vnex_regspec_t *reg_p;

	if (ddi_getlongprop(DDI_DEV_T_ANY, dip,
	    DDI_PROP_DONTPASS, "reg", (caddr_t)&reg_p,
	    &reglen) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	/*
	 * get the sun4v config handle for this device
	 */

	cfg = SUN4V_REG_SPEC2CFG_HDL(reg_p->physaddr);
	kmem_free(reg_p, reglen);
	ino = hdlp->ih_vector;

	/*
	 * call hv to get vihdl
	 */
	if (hvio_intr_devino_to_sysino(cfg, ino, &ihdl) != H_EOK)
		return (DDI_FAILURE);

	hdlp->ih_vector = ihdl;
	/*
	 * Allocate a interrupt descriptor (id) with the
	 * the interrupt handler and append it to
	 * the id list.
	 */

	vid_p = vnex_alloc_id(rdip, ino, cfg);
	vid_p->vid_ihdl = ihdl;
	vid_p->vid_handler =  hdlp->ih_cb_func;
	vid_p->vid_arg1 =  hdlp->ih_cb_arg1;
	vid_p->vid_arg2 =  hdlp->ih_cb_arg2;
	vid_p->vid_ddi_hdlp =  hdlp;

	DDI_INTR_ASSIGN_HDLR_N_ARGS(hdlp,
	    (ddi_intr_handler_t *)vnex_intr_wrapper, (caddr_t)vid_p, NULL);

	if (hdlp->ih_pri == 0) {
		hdlp->ih_pri = vnex_get_pil(rdip);
	}

	ret = i_ddi_add_ivintr(hdlp);
	if (ret != DDI_SUCCESS) {
		return (ret);
	}

	DDI_INTR_ASSIGN_HDLR_N_ARGS(hdlp, vid_p->vid_handler,
	    vid_p->vid_arg1, vid_p->vid_arg2);

	return (ret);
}

static int
vnex_remove_intr(dev_info_t *rdip,
	ddi_intr_handle_impl_t *hdlp)
{
	vnex_id_t *vid_p;
	uint32_t ino;
	int ret = DDI_SUCCESS;

	ino = hdlp->ih_vector;
	vid_p = vnex_locate_id(rdip, ino);

	hdlp->ih_vector = vid_p->vid_ihdl;
	i_ddi_rem_ivintr(hdlp);

	vnex_free_id(vid_p);

	return (ret);
}

static int
vnex_intr_ops(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_op_t intr_op, ddi_intr_handle_impl_t *hdlp, void *result)
{
	int	ret = DDI_SUCCESS;

	switch (intr_op) {
		case DDI_INTROP_GETCAP:
			*(int *)result = DDI_INTR_FLAG_LEVEL;
			break;
		case DDI_INTROP_ALLOC:
			*(int *)result = hdlp->ih_scratch1;
			break;
		case DDI_INTROP_GETPRI:
			*(int *)result = hdlp->ih_pri ?
			    hdlp->ih_pri : vnex_get_pil(rdip);
			break;
		case DDI_INTROP_FREE:
			break;
		case DDI_INTROP_SETPRI:
			break;
		case DDI_INTROP_ADDISR:
			ret = vnex_add_intr(dip, rdip, hdlp);
			break;
		case DDI_INTROP_REMISR:
			ret = vnex_remove_intr(rdip, hdlp);
			break;
		case DDI_INTROP_ENABLE:
			ret = vnex_enable_intr(rdip, hdlp);
			break;
		case DDI_INTROP_DISABLE:
			ret = vnex_disable_intr(rdip, hdlp);
			break;
		case DDI_INTROP_NINTRS:
		case DDI_INTROP_NAVAIL:
			*(int *)result = i_ddi_get_intx_nintrs(rdip);
			break;
		case DDI_INTROP_SUPPORTED_TYPES:
			*(int *)result = i_ddi_get_intx_nintrs(rdip) ?
			    DDI_INTR_TYPE_FIXED : 0;
			break;
		default:
			ret = DDI_ENOTSUP;
			break;
	}

	return (ret);
}

vnex_id_t *
vnex_alloc_id(dev_info_t *dip, uint32_t ino, uint64_t dhdl)
{
	vnex_id_t *vid_p = kmem_alloc(sizeof (vnex_id_t), KM_SLEEP);

	vid_p->vid_dip = dip;
	vid_p->vid_ino = ino;
	vid_p->vid_cfg_hdl = dhdl;

	mutex_enter(&vnex_id_lock);
	vnex_add_id(vid_p);
	mutex_exit(&vnex_id_lock);

	return (vid_p);
}

vnex_id_t *
vnex_locate_id(dev_info_t *dip, uint32_t ino)
{
	vnex_id_t *vid_p;

	mutex_enter(&vnex_id_lock);
	vid_p = vnex_id_list;

	while (vid_p != NULL) {
		if (vid_p->vid_dip == dip && vid_p->vid_ino == ino) {
			mutex_exit(&vnex_id_lock);
			return (vid_p);
		}
		vid_p = vid_p->vid_next;
	}
	mutex_exit(&vnex_id_lock);
	return (NULL);
}

static void
vnex_free_id(vnex_id_t *vid_p)
{
	mutex_enter(&vnex_id_lock);
	vnex_rem_id(vid_p);
	mutex_exit(&vnex_id_lock);

	kmem_free(vid_p, sizeof (*vid_p));
}

static void
vnex_rem_id(vnex_id_t *vid_p)
{
	vnex_id_t *prev_p = vnex_id_list;

	if (vnex_id_list == NULL)
		cmn_err(CE_PANIC, "vnex: interrupt list empty");

	if (vid_p == NULL)
		cmn_err(CE_PANIC, "vnex: no element to remove");

	if (vnex_id_list == vid_p) {
		vnex_id_list = vid_p->vid_next;
	} else {
		while (prev_p != NULL && prev_p->vid_next != vid_p)
			prev_p = prev_p->vid_next;

		if (prev_p == NULL)
			cmn_err(CE_PANIC, "vnex: element %p not in list",
			    (void *) vid_p);

		prev_p->vid_next = vid_p->vid_next;
	}
}

static void
vnex_add_id(vnex_id_t *vid_p)
{
	vid_p->vid_next = vnex_id_list;
	vnex_id_list = vid_p;
}

uint_t
vnex_intr_wrapper(caddr_t arg)
{
	vnex_id_t *vid_p = (vnex_id_t *)arg;
	int res;
	uint_t (*handler)();
	caddr_t handler_arg1;
	caddr_t handler_arg2;

	handler = vid_p->vid_handler;
	handler_arg1 = vid_p->vid_arg1;
	handler_arg2 = vid_p->vid_arg2;

	res = (*handler)(handler_arg1, handler_arg2);

	(void) hvio_intr_setstate(vid_p->vid_ihdl, HV_INTR_IDLE_STATE);

	return (res);
}