libxpio/common/libxpio_dpio.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
 */

/*
 * Dedicated Purpose I/O related routines
 */

#include <unistd.h>
#include <strings.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/debug.h>

#include "libxpio_impl.h"

/*
 * To avoid translation of flags we assume the kernel flags and our library
 * flags are the same. The casts are required as that gets us the underlying
 * enum's value in a way that a static assertion can handle.
 */
CTASSERT((uint32_t)XPIO_DPIO_F_READ == (uint32_t)KGPIO_DPIO_F_READ);
CTASSERT((uint32_t)XPIO_DPIO_F_WRITE == (uint32_t)KGPIO_DPIO_F_WRITE);
CTASSERT((uint32_t)XPIO_DPIO_F_KERNEL == (uint32_t)KGPIO_DPIO_F_KERNEL);

/*
 * We do not have a /dev entry point for the dpinfo minor that we need to use to
 * get information about DPIOs as this is private to the implementation. We
 * therefore record it here.
 */
static const char *xpio_dpinfo_path = "/devices/pseudo/kgpio@0:dpinfo";

typedef struct {
	xpio_t *xdc_xpio;
	xpio_dpio_disc_f xdc_func;
	void *xdc_arg;
} xpio_dpio_cb_t;

static int
xpio_dpio_discover_cb(di_node_t di, di_minor_t minor, void *arg)
{
	bool ret;
	xpio_dpio_cb_t *cb = arg;
	xpio_dpio_disc_t disc;

	disc.xdd_minor = minor;

	ret = cb->xdc_func(cb->xdc_xpio, &disc, cb->xdc_arg);
	if (ret) {
		return (DI_WALK_CONTINUE);
	} else {
		return (DI_WALK_TERMINATE);
	}
}

void
xpio_dpio_discover(xpio_t *xpio, xpio_dpio_disc_f func, void *arg)
{
	xpio_dpio_cb_t cb;

	cb.xdc_xpio = xpio;
	cb.xdc_func = func;
	cb.xdc_arg = arg;
	(void) di_walk_minor(xpio->xp_devinfo, DDI_NT_GPIO_DPIO, 0, &cb,
	    xpio_dpio_discover_cb);
}

void
xpio_dpio_info_free(xpio_dpio_info_t *info)
{
	free(info);
}

const char *
xpio_dpio_info_ctrl(xpio_dpio_info_t *info)
{
	return (info->xdi_ctrl);
}

const char *
xpio_dpio_info_name(xpio_dpio_info_t *info)
{
	/*
	 * The raw minor name which is what we use to go to the kernel with
	 * includes a 'dpio:' prefix. However, that is not what users actually
	 * create and use, so strip that out of the returned name.
	 */
	return (info->xdi_dpio + 5);
}

uint32_t
xpio_dpio_info_gpionum(xpio_dpio_info_t *info)
{
	return (info->xdi_gpio);
}

dpio_caps_t
xpio_dpio_info_caps(xpio_dpio_info_t *info)
{
	return (info->xdi_caps);
}

dpio_flags_t
xpio_dpio_info_flags(xpio_dpio_info_t *info)
{
	return (info->xdi_flags);
}

bool
xpio_dpio_info(xpio_t *xpio, di_minor_t minor, xpio_dpio_info_t **outp)
{
	int fd = -1;
	xpio_dpio_info_t *info = NULL;
	dpio_info_t dpi;

	if (minor == DI_NODE_NIL) {
		return (xpio_error(xpio, XPIO_ERR_BAD_PTR, 0, "encountered "
		    "invalid di_minor_t: %p", minor));
	}

	if (outp == NULL) {
		return (xpio_error(xpio, XPIO_ERR_BAD_PTR, 0, "encountered "
		    "invalid xpio_ctrl_t output pointer: %p", outp));
	}
	*outp = NULL;

	if (strcmp(di_minor_nodetype(minor), DDI_NT_GPIO_DPIO) != 0) {
		return (xpio_error(xpio, XPIO_ERR_WRONG_MINOR_TYPE, 0,
		    "minor %s has incorrect node type: %s, expected %s",
		    di_minor_name(minor), di_minor_nodetype(minor),
		    DDI_NT_GPIO_DPIO));
	}

	if ((fd = open(xpio_dpinfo_path, O_RDONLY)) < 0) {
		int e = errno;
		return (xpio_error(xpio, XPIO_ERR_OPEN_DEV, e, "failed to open "
		    "DPIO information minor: %s", strerror(e)));
	}

	info = calloc(1, sizeof (xpio_dpio_info_t));
	if (info == NULL) {
		int e = errno;
		(void) xpio_error(xpio, XPIO_ERR_NO_MEM, e, "failed to "
		    "allocate memory for a xpio_dpio_info_t: %s", strerror(e));
		goto err;
	}

	(void) memset(&dpi, 0, sizeof (dpi));
	if (strlcpy(dpi.dpi_dpio, di_minor_name(minor),
	    sizeof (dpi.dpi_dpio)) >= sizeof (dpi.dpi_dpio)) {
		(void) xpio_error(xpio, XPIO_ERR_INTERNAL, 0, "DPIO name "
		    "somehow exceeded expected system length");
		goto err;
	}

	if (ioctl(fd, DPIO_IOC_INFO, &dpi) != 0) {
		int e = errno;
		switch (e) {
		case ENOENT:
			(void) xpio_error(xpio, XPIO_ERR_BAD_DPIO_NAME, 0,
			    "DPIO %s does not exist", di_minor_name(minor));
			goto err;
		case EFAULT:
			abort();
		default:
			(void) xpio_error(xpio, XPIO_ERR_KGPIO, e, "failed to "
			    "issue dpio information ioctl for dpio %s: %s",
			    di_minor_name(minor), strerror(e));

			goto err;
		}
	}

	(void) memcpy(info->xdi_dpio, dpi.dpi_dpio, sizeof (dpi.dpi_dpio));
	(void) memcpy(info->xdi_ctrl, dpi.dpi_ctrl, sizeof (dpi.dpi_ctrl));
	info->xdi_gpio = dpi.dpi_gpio;
	info->xdi_caps = dpi.dpi_caps;
	info->xdi_flags = dpi.dpi_flags;

	(void) close(fd);
	*outp = info;
	return (xpio_success(xpio));

err:
	if (fd >= 0) {
		(void) close(fd);
	}
	free(info);
	return (false);
}

bool
xpio_dpio_create(xpio_ctrl_t *ctrl, xpio_gpio_info_t *gi, const char *name,
    xpio_dpio_features_t feat)
{
	kgpio_dpio_create_t create;
	xpio_t *xpio = ctrl->xc_xpio;
	const uint32_t all_feats = XPIO_DPIO_F_READ | XPIO_DPIO_F_WRITE |
	    XPIO_DPIO_F_KERNEL;

	if (gi == NULL) {
		return (xpio_error(xpio, XPIO_ERR_BAD_PTR, 0, "encountered "
		    "invalid xpio_gpio_info_t pointer: %p", gi));
	}

	if (name == NULL) {
		return (xpio_error(xpio, XPIO_ERR_BAD_PTR, 0, "encountered "
		    "invalid pointer for DPIO name: %p", name));
	}

	if ((feat & ~all_feats) != 0) {
		return (xpio_error(xpio, XPIO_ERR_BAD_DPIO_FEAT, 0, "found "
		    "unknown dpio features specified: 0x%x",
		    feat & ~all_feats));
	}

	(void) memset(&create, 0, sizeof (create));
	if (strlcpy(create.kdc_name, name, sizeof (create.kdc_name)) >=
	    sizeof (create.kdc_name)) {
		return (xpio_error(xpio, XPIO_ERR_BAD_DPIO_NAME, 0,
		    "requested DPIO name is longer than the maximum supported "
		    "(%zu characters including '\\0')",
		    sizeof (create.kdc_name)));
	}

	/*
	 * Right now there is a 1:1 mapping between library and kgpio features.
	 */
	create.kdc_flags = (kgpio_dpio_flags_t)feat;
	create.kdc_id = gi->xgi_id;

	/*
	 * At some point it'd be good for us to take this apart and create much
	 * more useful semantic errors rather than this generic error as it
	 * basically requires someone to go into the code to figure out what
	 * happened. Basically, we want something like with update.
	 */
	if (ioctl(ctrl->xc_fd, KGPIO_IOC_DPIO_CREATE, &create) != 0) {
		int e = errno;
		return (xpio_error(xpio, XPIO_ERR_KGPIO, e, "failed to create "
		    "dpio %s: %s", name, strerror(e)));
	}

	return (xpio_success(xpio));
}

bool
xpio_dpio_destroy(xpio_ctrl_t *ctrl, xpio_gpio_info_t *gi)
{
	kgpio_dpio_destroy_t destroy;
	xpio_t *xpio = ctrl->xc_xpio;

	if (gi == NULL) {
		return (xpio_error(xpio, XPIO_ERR_BAD_PTR, 0, "encountered "
		    "invalid xpio_gpio_info_t pointer: %p", gi));
	}

	destroy.kdd_id = gi->xgi_id;


	/*
	 * At some point it'd be good for us to take this apart and create much
	 * more useful semantic errors rather than this generic error as it
	 * basically requires someone to go into the code to figure out what
	 * happened. Basically, we want something like with update.
	 */
	if (ioctl(ctrl->xc_fd, KGPIO_IOC_DPIO_DESTROY, &destroy) != 0) {
		int e = errno;
		return (xpio_error(xpio, XPIO_ERR_KGPIO, e, "failed to destroy "
		    "dpio %s/%u: %s", ctrl->xc_name, gi->xgi_id, strerror(e)));
	}
	return (xpio_success(xpio));
}