usr/src/uts/intel/io/amdzen/usmn.c

/*
 * 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 2022 Oxide Computer Company
 */

/*
 * A device driver that provides user access to the AMD System Management
 * Network for debugging purposes.
 */

#include <sys/types.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/open.h>
#include <sys/cred.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/cmn_err.h>
#include <sys/policy.h>
#include <amdzen_client.h>

#include "usmn.h"

typedef struct usmn {
	dev_info_t *usmn_dip;
	uint_t usmn_ndfs;
} usmn_t;

static usmn_t usmn_data;

static int
usmn_open(dev_t *devp, int flags, int otype, cred_t *credp)
{
	minor_t m;
	usmn_t *usmn = &usmn_data;

	if (crgetzoneid(credp) != GLOBAL_ZONEID ||
	    secpolicy_hwmanip(credp) != 0) {
		return (EPERM);
	}

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

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

	m = getminor(*devp);
	if (m >= usmn->usmn_ndfs) {
		return (ENXIO);
	}

	return (0);
}

static int
usmn_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
	uint_t dfno;
	usmn_t *usmn = &usmn_data;
	usmn_reg_t usr;

	if (cmd != USMN_READ && cmd != USMN_WRITE) {
		return (ENOTTY);
	}

	dfno = getminor(dev);
	if (dfno >= usmn->usmn_ndfs) {
		return (ENXIO);
	}

	if (crgetzoneid(credp) != GLOBAL_ZONEID ||
	    secpolicy_hwmanip(credp) != 0) {
		return (EPERM);
	}

	if (ddi_copyin((void *)arg, &usr, sizeof (usr), mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	/*
	 * We don't need to check size and alignment here; the client access
	 * routines do so for us and return EINVAL if violated.  The same goes
	 * for the value to be written in the USMN_WRITE case below.
	 */
	const smn_reg_t reg = SMN_MAKE_REG_SIZED(usr.usr_addr, usr.usr_size);

	if (cmd == USMN_READ) {
		int ret;

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

		ret = amdzen_c_smn_read(dfno, reg, &usr.usr_data);
		if (ret != 0) {
			return (ret);
		}
	} else if (cmd == USMN_WRITE) {
		int ret;

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

		ret = amdzen_c_smn_write(dfno, reg, usr.usr_data);
		if (ret != 0) {
			return (ret);
		}
	} else {
		return (ENOTSUP);
	}

	if (cmd == USMN_READ &&
	    ddi_copyout(&usr, (void *)arg, sizeof (usr), mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	return (0);
}

static int
usmn_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
	return (0);
}

static void
usmn_cleanup(usmn_t *usmn)
{
	ddi_remove_minor_node(usmn->usmn_dip, NULL);
	usmn->usmn_ndfs = 0;
	usmn->usmn_dip = NULL;
}

static int
usmn_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	usmn_t *usmn = &usmn_data;

	if (cmd == DDI_RESUME) {
		return (DDI_SUCCESS);
	} else if (cmd != DDI_ATTACH) {
		return (DDI_FAILURE);
	}

	if (usmn->usmn_dip != NULL) {
		dev_err(dip, CE_WARN, "!usmn is already attached to a "
		    "dev_info_t: %p", usmn->usmn_dip);
		return (DDI_FAILURE);
	}

	usmn->usmn_dip = dip;
	usmn->usmn_ndfs = amdzen_c_df_count();
	for (uint_t i = 0; i < usmn->usmn_ndfs; i++) {
		char buf[32];

		(void) snprintf(buf, sizeof (buf), "usmn.%u", i);
		if (ddi_create_minor_node(dip, buf, S_IFCHR, i, DDI_PSEUDO,
		    0) != DDI_SUCCESS) {
			dev_err(dip, CE_WARN, "!failed to create minor %s",
			    buf);
			goto err;
		}
	}

	return (DDI_SUCCESS);

err:
	usmn_cleanup(usmn);
	return (DDI_FAILURE);
}

static int
usmn_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
	usmn_t *usmn = &usmn_data;
	minor_t m;

	switch (cmd) {
	case DDI_INFO_DEVT2DEVINFO:
		m = getminor((dev_t)arg);
		if (m >= usmn->usmn_ndfs) {
			return (DDI_FAILURE);
		}
		*resultp = (void *)usmn->usmn_dip;
		break;
	case DDI_INFO_DEVT2INSTANCE:
		m = getminor((dev_t)arg);
		if (m >= usmn->usmn_ndfs) {
			return (DDI_FAILURE);
		}
		*resultp = (void *)(uintptr_t)ddi_get_instance(usmn->usmn_dip);
		break;
	default:
		return (DDI_FAILURE);
	}
	return (DDI_SUCCESS);
}

static int
usmn_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	usmn_t *usmn = &usmn_data;

	if (cmd == DDI_SUSPEND) {
		return (DDI_SUCCESS);
	} else if (cmd != DDI_DETACH) {
		return (DDI_FAILURE);
	}

	if (usmn->usmn_dip != dip) {
		dev_err(dip, CE_WARN, "!asked to detach usmn, but dip doesn't "
		    "match");
		return (DDI_FAILURE);
	}

	usmn_cleanup(usmn);
	return (DDI_SUCCESS);
}

static struct cb_ops usmn_cb_ops = {
	.cb_open = usmn_open,
	.cb_close = usmn_close,
	.cb_strategy = nodev,
	.cb_print = nodev,
	.cb_dump = nodev,
	.cb_read = nodev,
	.cb_write = nodev,
	.cb_ioctl = usmn_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 usmn_dev_ops = {
	.devo_rev = DEVO_REV,
	.devo_refcnt = 0,
	.devo_getinfo = usmn_getinfo,
	.devo_identify = nulldev,
	.devo_probe = nulldev,
	.devo_attach = usmn_attach,
	.devo_detach = usmn_detach,
	.devo_reset = nodev,
	.devo_quiesce = ddi_quiesce_not_needed,
	.devo_cb_ops = &usmn_cb_ops
};

static struct modldrv usmn_modldrv = {
	.drv_modops = &mod_driverops,
	.drv_linkinfo = "AMD User SMN Access",
	.drv_dev_ops = &usmn_dev_ops
};

static struct modlinkage usmn_modlinkage = {
	.ml_rev = MODREV_1,
	.ml_linkage = { &usmn_modldrv, NULL }
};

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

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

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