/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2020 Oxide Computer Company
 */

/*
 * This pseudo-device driver implements access to kernel sensors. See
 * uts/common/os/ksensor.c for more information on the framework and how this
 * driver fits in.
 */

#include <sys/types.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/open.h>
#include <sys/cred.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/zone.h>
#include <sys/ksensor_impl.h>

static dev_info_t *ksensor_dip;

static int
ksensor_create_cb(id_t id, const char *class, const char *name)
{
	if (ddi_create_minor_node(ksensor_dip, name, S_IFCHR, (minor_t)id,
	    class, 0) != 0) {
		dev_err(ksensor_dip, CE_WARN, "!failed to create ksensor node "
		    "for %s:%s (minor %d)", class, name, id);
		return (EIO);
	}

	return (0);
}

static void
ksensor_remove_cb(id_t id, const char *name)
{
	ddi_remove_minor_node(ksensor_dip, (char *)name);
}

static int
ksensor_open(dev_t *devp, int flags, int otype, cred_t *credp)
{
	if (crgetzoneid(credp) != GLOBAL_ZONEID || drv_priv(credp) != 0) {
		return (EPERM);
	}

	if ((flags & (FEXCL | FNDELAY | FNONBLOCK | FWRITE)) != 0) {
		return (EINVAL);
	}

	if (otype != OTYP_CHR) {
		return (EINVAL);
	}

	return (0);
}

static int
ksensor_ioctl_kind(minor_t min, intptr_t arg, int mode)
{
	int ret;
	sensor_ioctl_kind_t kind;

	bzero(&kind, sizeof (kind));
	ret = ksensor_op_kind((id_t)min, &kind);
	if (ret == 0) {
		if (ddi_copyout(&kind, (void *)arg, sizeof (kind),
		    mode & FKIOCTL) != 0) {
			ret = EFAULT;
		}
	}
	return (ret);
}

static int
ksensor_ioctl_scalar(minor_t min, intptr_t arg, int mode)
{
	int ret;
	sensor_ioctl_scalar_t scalar;

	bzero(&scalar, sizeof (scalar));
	ret = ksensor_op_scalar((id_t)min, &scalar);
	if (ret == 0) {
		if (ddi_copyout(&scalar, (void *)arg, sizeof (scalar),
		    mode & FKIOCTL) != 0) {
			ret = EFAULT;
		}
	}
	return (ret);
}

static int
ksensor_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
	minor_t m;

	if ((mode & FREAD) == 0) {
		return (EINVAL);
	}

	m = getminor(dev);
	switch (cmd) {
	case SENSOR_IOCTL_KIND:
		return (ksensor_ioctl_kind(m, arg, mode));
	case SENSOR_IOCTL_SCALAR:
		return (ksensor_ioctl_scalar(m, arg, mode));
	default:
		return (ENOTTY);
	}
}

static int
ksensor_close(dev_t dev, int flags, int otype, cred_t *credp)
{
	return (0);
}

static int
ksensor_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_RESUME:
		return (DDI_SUCCESS);
	case DDI_ATTACH:
		break;
	default:
		return (DDI_FAILURE);
	}

	if (ksensor_dip != NULL) {
		dev_err(dip, CE_WARN, "ksensor driver already attatched");
		return (DDI_FAILURE);
	}

	ksensor_dip = dip;
	if (ksensor_register(dip, ksensor_create_cb, ksensor_remove_cb) != 0) {
		ksensor_dip = NULL;
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

/*
 * All minors always maps to a single instance. Don't worry about minor validity
 * here.
 */
static int
ksensor_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
    void **resultp)
{
	if (cmd != DDI_INFO_DEVT2DEVINFO && cmd != DDI_INFO_DEVT2INSTANCE) {
		return (DDI_FAILURE);
	}

	if (cmd == DDI_INFO_DEVT2DEVINFO) {
		*resultp = ksensor_dip;
	} else {
		int inst = ddi_get_instance(ksensor_dip);
		*resultp = (void *)(uintptr_t)inst;
	}

	return (DDI_SUCCESS);
}

static int
ksensor_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_DETACH:
		break;
	case DDI_SUSPEND:
		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}

	if (ksensor_dip == NULL) {
		dev_err(dip, CE_WARN, "asked to detach ksensor driver when no "
		    "dip is attached");
		return (DDI_FAILURE);
	}

	if (ksensor_dip != dip) {
		dev_err(dip, CE_WARN, "asked to detach ksensor driver, but dip "
		    "doesn't match");
		return (DDI_FAILURE);
	}

	ksensor_unregister(dip);
	ddi_remove_minor_node(dip, NULL);
	ksensor_dip = NULL;
	return (DDI_SUCCESS);
}

static struct cb_ops ksensor_cb_ops = {
	.cb_open = ksensor_open,
	.cb_close = ksensor_close,
	.cb_strategy = nodev,
	.cb_print = nodev,
	.cb_dump = nodev,
	.cb_read = nodev,
	.cb_write = nodev,
	.cb_ioctl = ksensor_ioctl,
	.cb_devmap = nodev,
	.cb_mmap = nodev,
	.cb_segmap = nodev,
	.cb_chpoll = nochpoll,
	.cb_prop_op = ddi_prop_op,
	.cb_flag = D_MP,
	.cb_rev = CB_REV,
	.cb_aread = nodev,
	.cb_awrite = nodev
};

static struct dev_ops ksensor_dev_ops = {
	.devo_rev = DEVO_REV,
	.devo_refcnt = 0,
	.devo_getinfo = ksensor_getinfo,
	.devo_identify = nulldev,
	.devo_probe = nulldev,
	.devo_attach = ksensor_attach,
	.devo_detach = ksensor_detach,
	.devo_reset = nodev,
	.devo_power = ddi_power,
	.devo_quiesce = ddi_quiesce_not_needed,
	.devo_cb_ops = &ksensor_cb_ops
};

static struct modldrv ksensor_modldrv = {
	.drv_modops = &mod_driverops,
	.drv_linkinfo = "Kernel Sensor driver",
	.drv_dev_ops = &ksensor_dev_ops
};

static struct modlinkage ksensor_modlinkage = {
	.ml_rev = MODREV_1,
	.ml_linkage = { &ksensor_modldrv, NULL }
};

int
_init(void)
{
	return (mod_install(&ksensor_modlinkage));
}

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

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