/*
 * 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
 */

/*
 * An evolving, but private, interface to the kernel xPIO (GPIO and DPIO)
 * subsystem.
 */

#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <libdevinfo.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/debug.h>

#include "libxpio_impl.h"

xpio_err_t
xpio_err(xpio_t *xpio)
{
	return (xpio->xp_err);
}

xpio_update_err_t
xpio_update_err(xpio_gpio_update_t *update)
{
	return (update->xgo_err);
}

int32_t
xpio_syserr(xpio_t *xpio)
{
	return (xpio->xp_syserr);
}

int32_t
xpio_update_syserr(xpio_gpio_update_t *update)
{
	return (update->xgo_syserr);
}

const char *
xpio_errmsg(xpio_t *xpio)
{
	return (xpio->xp_errmsg);
}

const char *
xpio_update_errmsg(xpio_gpio_update_t *update)
{
	return (update->xgo_errmsg);
}

const char *
xpio_err2str(xpio_t *xpio, xpio_err_t err)
{
	switch (err) {
	case XPIO_ERR_OK:
		return ("XPIO_ERR_OK");
	case XPIO_ERR_NO_MEM:
		return ("XPIO_ERR_NO_MEM");
	case XPIO_ERR_LIBDEVINFO:
		return ("XPIO_ERR_LIBDEVINFO");
	case XPIO_ERR_INTERNAL:
		return ("XPIO_ERR_INTERNAL");
	case XPIO_ERR_BAD_PTR:
		return ("XPIO_ERR_BAD_PTR");
	case XPIO_ERR_WRONG_MINOR_TYPE:
		return ("XPIO_ERR_WRONG_MINOR_TYPE");
	case XPIO_ERR_OPEN_DEV:
		return ("XPIO_ERR_OPEN_DEV");
	case XPIO_ERR_KGPIO:
		return ("XPIO_ERR_KGPIO");
	case XPIO_ERR_BAD_CTRL_NAME:
		return ("XPIO_ERR_BAD_CTRL_NAME");
	case XPIO_ERR_BAD_GPIO_ID:
		return ("XPIO_ERR_BAD_GPIO_ID");
	case XPIO_ERR_BAD_UPDATE:
		return ("XPIO_ERR_BAD_UPDATE");
	case XPIO_ERR_BAD_DPIO_FEAT:
		return ("XPIO_ERR_BAD_DPIO_FEAT");
	case XPIO_ERR_BAD_DPIO_NAME:
		return ("XPIO_ERR_BAD_DPIO_NAME");
	case XPIO_ERR_BAD_GPIO_NAME:
		return ("XPIO_ERR_BAD_GPIO_NAME");
	case XPIO_ERR_NO_LOOKUP_MATCH:
		return ("XPIO_ERR_NO_LOOKUP_MATCH");
	default:
		return ("unknown error");
	}

}

const char *
xpio_update_err2str(xpio_gpio_update_t *update, xpio_update_err_t err)
{
	switch (err) {
	case XPIO_UPDATE_ERR_OK:
		return ("XPIO_UPDATE_ERR_OK");
	case XPIO_UPDATE_ERR_RO:
		return ("XPIO_UPDATE_ERR_RO");
	case XPIO_UPDATE_ERR_UNKNOWN_ATTR:
		return ("XPIO_UPDATE_ERR_UNKNOWN_ATTR");
	case XPIO_UPDATE_ERR_BAD_TYPE:
		return ("XPIO_UPDATE_ERR_BAD_TYPE");
	case XPIO_UPDATE_ERR_UNKNOWN_VAL:
		return ("XPIO_UPDATE_ERR_UNKNOWN_VAL");
	case XPIO_UPDATE_ERR_CANT_APPLY_VAL:
		return ("XPIO_UPDATE_ERR_CANT_APPLY_VAL");
	case XPIO_UPDATE_ERR_NO_MEM:
		return ("XPIO_UPDATE_ERR_NO_MEM");
	case XPIO_UPDATE_ERR_INTERNAL:
		return ("XPIO_UPDATE_ERR_INTERNAL");
	default:
		return ("unknown error");
	}
}

bool
xpio_error(xpio_t *xpio, xpio_err_t err, int32_t sys, const char *fmt, ...)
{
	va_list ap;

	xpio->xp_err = err;
	xpio->xp_syserr = sys;
	va_start(ap, fmt);
	(void) vsnprintf(xpio->xp_errmsg, sizeof (xpio->xp_errmsg), fmt, ap);
	va_end(ap);
	return (false);
}

bool
xpio_update_error(xpio_gpio_update_t *update, xpio_update_err_t err,
    int32_t sys, const char *fmt, ...)
{
	va_list ap;

	update->xgo_err = err;
	update->xgo_syserr = sys;
	va_start(ap, fmt);
	(void) vsnprintf(update->xgo_errmsg, sizeof (update->xgo_errmsg), fmt,
	    ap);
	va_end(ap);
	return (false);
}
bool
xpio_success(xpio_t *xpio)
{
	xpio->xp_err = XPIO_ERR_OK;
	xpio->xp_syserr = 0;
	xpio->xp_errmsg[0] = '\0';
	return (true);
}

bool
xpio_update_success(xpio_gpio_update_t *update)
{
	update->xgo_err = XPIO_UPDATE_ERR_OK;
	update->xgo_syserr = 0;
	update->xgo_errmsg[0] = '\0';
	return (true);
}

typedef struct {
	xpio_t *xcc_xpio;
	xpio_ctrl_disc_f xcc_func;
	void *xcc_arg;
} xpio_ctrl_cb_t;

static int
xpio_ctrl_discover_cb(di_node_t di, di_minor_t minor, void *arg)
{
	bool ret;
	xpio_ctrl_cb_t *cb = arg;
	xpio_ctrl_disc_t disc;

	disc.xcd_minor = minor;

	ret = cb->xcc_func(cb->xcc_xpio, &disc, cb->xcc_arg);
	if (ret) {
		return (DI_WALK_CONTINUE);
	} else {
		return (DI_WALK_TERMINATE);
	}
}

void
xpio_ctrl_discover(xpio_t *xpio, xpio_ctrl_disc_f func, void *arg)
{
	xpio_ctrl_cb_t cb;

	cb.xcc_xpio = xpio;
	cb.xcc_func = func;
	cb.xcc_arg = arg;
	(void) di_walk_minor(xpio->xp_devinfo, DDI_NT_GPIO_CTRL, 0, &cb,
	    xpio_ctrl_discover_cb);
}

void
xpio_ctrl_fini(xpio_ctrl_t *ctrl)
{
	if (ctrl == NULL) {
		return;
	}

	if (ctrl->xc_fd >= 0) {
		(void) close(ctrl->xc_fd);
		ctrl->xc_fd = -1;
	}

	free(ctrl);
}

void
xpio_ctrl_info_free(xpio_ctrl_info_t *infop)
{
	free(infop);
}

uint32_t
xpio_ctrl_info_ngpios(xpio_ctrl_info_t *infop)
{
	return (infop->xci_ngpios);
}

uint32_t
xpio_ctrl_info_ndpios(xpio_ctrl_info_t *infop)
{
	return (infop->xci_ndpios);
}

const char *
xpio_ctrl_info_devpath(xpio_ctrl_info_t *infop)
{
	return (infop->xci_devpath);
}

bool
xpio_ctrl_info(xpio_ctrl_t *ctrl, xpio_ctrl_info_t **outp)
{
	kgpio_ctrl_info_t info;
	xpio_t *xpio = ctrl->xc_xpio;
	xpio_ctrl_info_t *out;

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

	(void) memset(&info, 0, sizeof (info));
	if (ioctl(ctrl->xc_fd, KGPIO_IOC_CTRL_INFO, &info) != 0) {
		int e = errno;
		return (xpio_error(xpio, XPIO_ERR_KGPIO, e, "failed to issue "
		    "controller information ioctl to %s: %s", ctrl->xc_name,
		    strerror(e)));
	}

	out = calloc(1, sizeof (xpio_ctrl_info_t));
	if (out == NULL) {
		int e = errno;
		return (xpio_error(xpio, XPIO_ERR_NO_MEM, e, "failed to "
		    "allocate memory for a new xpio_ctrl_info_t: %s",
		    strerror(e)));
	}

	out->xci_ngpios = info.kci_ngpios;
	out->xci_ndpios = info.kci_ndpios;
	(void) memcpy(out->xci_devpath, info.kci_devpath,
	    sizeof (info.kci_devpath));

	*outp = out;
	return (xpio_success(xpio));
}

bool
xpio_ctrl_init(xpio_t *xpio, di_minor_t minor, xpio_ctrl_t **outp)
{
	xpio_ctrl_t *ctrl;
	char *path, buf[PATH_MAX];

	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_CTRL) != 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_CTRL));
	}

	path = di_devfs_minor_path(minor);
	if (path == NULL) {
		int e = errno;
		return (xpio_error(xpio, XPIO_ERR_LIBDEVINFO, e, "failed to "
		    "obtain /devices path for the requested minor: %s",
		    strerror(e)));
	}

	if (snprintf(buf, sizeof (buf), "/devices%s", path) >= sizeof (buf)) {
		di_devfs_path_free(path);
		return (xpio_error(xpio, XPIO_ERR_INTERNAL, 0, "failed to "
		    "construct full /devices minor path, would have overflown "
		    "internal buffer"));
	}
	di_devfs_path_free(path);

	ctrl = calloc(1, sizeof (*ctrl));
	if (ctrl == NULL) {
		int e = errno;
		return (xpio_error(xpio, XPIO_ERR_NO_MEM, e, "failed to "
		    "allocate memory for a new xpio_ctrl_t: %s", strerror(e)));
	}

	ctrl->xc_xpio = xpio;
	ctrl->xc_minor = minor;
	ctrl->xc_name = di_minor_name(minor);

	ctrl->xc_fd = open(buf, O_RDWR);
	if (ctrl->xc_fd < 0) {
		int e = errno;
		xpio_ctrl_fini(ctrl);
		return (xpio_error(xpio, XPIO_ERR_OPEN_DEV, e, "failed to open "
		    "device path %s: %s", buf, strerror(e)));
	}

	*outp = ctrl;
	return (xpio_success(xpio));
}

typedef struct {
	bool xcia_found;
	const char *xcia_name;
	xpio_ctrl_t *xcia_ctrl;
} xpio_ctrl_init_arg_t;

static bool
xpio_ctrl_init_by_name_cb(xpio_t *xpio, xpio_ctrl_disc_t *disc, void *arg)
{
	xpio_ctrl_init_arg_t *init = arg;

	if (strcmp(di_minor_name(disc->xcd_minor), init->xcia_name) != 0) {
		return (true);
	}

	/*
	 * As we've found a match. Attempt to open it. Whether we succeed or
	 * fail, we're done at this point.
	 */
	init->xcia_found = true;
	(void) xpio_ctrl_init(xpio, disc->xcd_minor, &init->xcia_ctrl);
	return (false);
}

bool
xpio_ctrl_init_by_name(xpio_t *xpio, const char *name, xpio_ctrl_t **outp)
{
	xpio_ctrl_init_arg_t init;

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

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

	init.xcia_found = false;
	init.xcia_name = name;
	init.xcia_ctrl = NULL;

	xpio_ctrl_discover(xpio, xpio_ctrl_init_by_name_cb, &init);
	if (!init.xcia_found) {
		return (xpio_error(xpio, XPIO_ERR_BAD_CTRL_NAME, 0, "failed to "
		    "find controller %s", init.xcia_name));
	}

	/*
	 * If we have a NULL controller, but it was found, then we know that
	 * this exists and instead had an error.
	 */
	if (init.xcia_ctrl == NULL) {
		return (false);
	}

	*outp = init.xcia_ctrl;
	return (xpio_success(xpio));
}

void
xpio_gpio_info_free(xpio_gpio_info_t *gi)
{
	if (gi == NULL) {
		return;
	}

	nvlist_free(gi->xgi_nvl);
	free(gi);
}

uint32_t
xpio_gpio_id(xpio_gpio_info_t *gi)
{
	return (gi->xgi_id);
}

bool
xpio_gpio_info(xpio_ctrl_t *ctrl, uint32_t gpio_num, xpio_gpio_info_t **outp)
{
	xpio_t *xpio = ctrl->xc_xpio;
	char *nvl_buf = NULL;
	kgpio_gpio_info_t info;
	bool ret;
	int nvl_ret;
	xpio_gpio_info_t *gi;

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

	}

	nvl_buf = malloc(XPIO_NVL_LEN);
	if (nvl_buf == NULL) {
		int e = errno;
		return (xpio_error(xpio, XPIO_ERR_NO_MEM, e, "failed to "
		    "allocate memory for temporary data: %s", strerror(e)));
	}

	(void) memset(&info, 0, sizeof (info));
	info.kgi_id = gpio_num;
	info.kgi_attr = (uintptr_t)nvl_buf;
	info.kgi_attr_len = XPIO_NVL_LEN;

	if (ioctl(ctrl->xc_fd, KGPIO_IOC_GPIO_INFO, &info) != 0) {
		int e = errno;

		switch (e) {
		case ENOENT:
			ret = xpio_error(xpio, XPIO_ERR_BAD_GPIO_ID, 0, "gpio "
			    "%u does is not a valid GPIO for controller %s",
			    gpio_num, ctrl->xc_name);
			break;
		case EOVERFLOW:
			ret = xpio_error(xpio, XPIO_ERR_INTERNAL, 0,
			    "internal error occurred: serialized nvlist "
			    "exceeds library capabilities: wanted %zu bytes",
			    info.kgi_attr_len);
			break;
		case EFAULT:
			abort();
		default:
			ret = xpio_error(xpio, XPIO_ERR_KGPIO, e, "failed to "
			    "issue gpio information ioctl for gpio %u: %s",
			    gpio_num, strerror(e));
			break;
		}
		goto out;
	}

	gi = calloc(1, sizeof (xpio_gpio_info_t));
	if (gi == NULL) {
		int e = errno;
		ret = xpio_error(xpio, XPIO_ERR_NO_MEM, e, "failed to "
		    "allocate memory for a xpio_gpio_info_t: %s", strerror(e));
		goto out;
	}

	gi->xgi_flags = info.kgi_flags;
	gi->xgi_id = gpio_num;
	nvl_ret = nvlist_unpack(nvl_buf, info.kgi_attr_len, &gi->xgi_nvl, 0);
	if (nvl_ret != 0) {
		free(gi);
		ret = xpio_error(xpio, XPIO_ERR_INTERNAL, nvl_ret, "kernel "
		    "gave us an unparseable nvlist_t: %s", strerror(nvl_ret));
	} else {
		*outp = gi;
		ret = xpio_success(xpio);
	}
out:
	free(nvl_buf);
	return (ret);
}

void
xpio_gpio_update_free(xpio_gpio_update_t *update)
{
	if (update == NULL) {
		return;
	}

	if (update->xgo_update != NULL) {
		nvlist_free(update->xgo_update);
		update->xgo_update = NULL;
	}

	if (update->xgo_err_nvl != NULL) {
		nvlist_free(update->xgo_err_nvl);
		update->xgo_err_nvl = NULL;
	}

	free(update);
}

bool
xpio_gpio_update(xpio_ctrl_t *ctrl, xpio_gpio_update_t *update)
{
	xpio_t *xpio = ctrl->xc_xpio;
	int nvl_ret;
	kgpio_update_t kgu;
	size_t pack_size;
	bool ret;
	char *update_buf = NULL, *err_buf = NULL;

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

	if (update->xgo_err_nvl != NULL) {
		return (xpio_error(xpio, XPIO_ERR_UPDATE_USED, 0, "this "
		    "update structure was already used and has error "
		    "information associated with it"));
	}

	nvl_ret = nvlist_size(update->xgo_update, &pack_size, NV_ENCODE_NATIVE);
	if (nvl_ret != 0) {
		return (xpio_error(xpio, XPIO_ERR_INTERNAL, nvl_ret, "failed "
		    "to determine packed update nvlist_t size: %s",
		    strerror(nvl_ret)));
	}

	update_buf = malloc(pack_size);
	if (update_buf == NULL) {
		int e = errno;
		ret = xpio_error(xpio, XPIO_ERR_NO_MEM, e, "failed to allocate "
		    "%zu bytes for the packed nvlist buffer: %s", pack_size,
		    strerror(e));
		goto out;
	}

	err_buf = malloc(XPIO_NVL_LEN);
	if (err_buf == NULL) {
		int e = errno;
		ret = xpio_error(xpio, XPIO_ERR_NO_MEM, e, "failed to allocate "
		    "%u bytes for the packed error buffer: %s", XPIO_NVL_LEN,
		    strerror(e));
		goto out;
	}

	nvl_ret = nvlist_pack(update->xgo_update, &update_buf, &pack_size,
	    NV_ENCODE_NATIVE, 0);
	if (nvl_ret != 0) {
		ret = xpio_error(xpio, XPIO_ERR_INTERNAL, nvl_ret, "failed to "
		    "pack update data: %s", strerror(nvl_ret));
		goto out;
	}

	(void) memset(&kgu, '\0', sizeof (kgpio_update_t));
	kgu.kgu_id = update->xgo_gpio->xgi_id;
	kgu.kgu_attr = (uintptr_t)update_buf;
	kgu.kgu_attr_len = pack_size;
	kgu.kgu_err = (uintptr_t)err_buf;
	kgu.kgu_err_len = XPIO_NVL_LEN;

	if (ioctl(ctrl->xc_fd, KGPIO_IOC_GPIO_UPDATE, &kgu) != 0) {
		int e = errno;
		ret = xpio_error(xpio, XPIO_ERR_KGPIO, e, "failed to isue "
		    "gpio attribute update ioctl to %s, %u: %s", ctrl->xc_name,
		    update->xgo_gpio->xgi_id, strerror(e));
		goto out;
	}

	/*
	 * With no flags and a zero return value, this was successful. That's
	 * good.
	 */
	if (kgu.kgu_flags == 0) {
		ret = xpio_success(xpio);
		goto out;
	}

	/*
	 * We should have packed information. Attempt to serialize it back into
	 * an nvlist for allowing the user to understand what happened.
	 */
	if ((kgu.kgu_flags & KGPIO_UPDATE_ERR_NVL_VALID) != 0) {
		nvl_ret = nvlist_unpack((char *)kgu.kgu_err, kgu.kgu_err_len,
		    &update->xgo_err_nvl, 0);
		if (nvl_ret != 0) {
			ret = xpio_error(xpio, XPIO_ERR_INTERNAL, nvl_ret,
			    "kernel gave us an unparseable error nvlist_t for "
			    "update failure: %s", strerror(nvl_ret));
			goto out;
		}
	}

	ret = xpio_error(xpio, XPIO_ERR_BAD_UPDATE, 0, "failed to apply GPIO "
	    "update, invalid or unsupported attributes");
out:
	free(update_buf);
	free(err_buf);
	return (ret);
}

bool
xpio_gpio_lookup_id(xpio_ctrl_t *ctrl, const char *name, uint32_t *idp)
{
	xpio_t *xpio = ctrl->xc_xpio;
	kgpio_ioc_name2id_t id;

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

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

	(void) memset(&id, 0, sizeof (id));

	if (strlcpy(id.kin_name, name, sizeof (id.kin_name)) >=
	    sizeof (id.kin_name)) {
		return (xpio_error(xpio, XPIO_ERR_BAD_GPIO_NAME, 0, "GPIO name "
		    "'%s' is too long and invalid", name));
	}

	if (ioctl(ctrl->xc_fd, KGPIO_IOC_GPIO_NAME2ID, &id) != 0) {
		int e = errno;
		switch (e) {
		case ENOENT:
			return (xpio_error(xpio, XPIO_ERR_NO_LOOKUP_MATCH, 0,
			    "GPIO name '%s' is unknown on controller %s",
			    name, ctrl->xc_name));
		case EINVAL:
			return (xpio_error(xpio, XPIO_ERR_BAD_GPIO_NAME, 0,
			    "GPIO name '%s' is invalid", name));
		default:
			return (xpio_error(xpio, XPIO_ERR_KGPIO, e,
			    "failed to issue GPIO name to GPIO id ioctl to "
			    "%s: %s", ctrl->xc_name, strerror(e)));
		}
	}

	*idp = id.kin_id;
	return (xpio_success(xpio));
}

bool
xpio_gpio_update_init(xpio_t *xpio, xpio_gpio_info_t *gi,
    xpio_gpio_update_t **outp)
{
	int ret;
	xpio_gpio_update_t *update;

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

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

	update = calloc(1, sizeof (xpio_gpio_update_t));
	if (update == NULL) {
		int e = errno;
		return (xpio_error(xpio, XPIO_ERR_NO_MEM, e, "failed to "
		    "allocate memory for xpio_gpio_update_t: %s", strerror(e)));
	}

	ret = nvlist_alloc(&update->xgo_update, NV_UNIQUE_NAME, 0);
	if (ret != 0) {
		free(update);
		if (ret == ENOMEM) {
			return (xpio_error(xpio, XPIO_ERR_NO_MEM, ret, "failed "
			    "to allocate nvlist_t for xpio_gpio_update_t"));
		}

		return (xpio_error(xpio, XPIO_ERR_INTERNAL, ret, "failed to "
		    "create nvlist_t for xpio_gpio_update_t: %s",
		    strerror(ret)));
	}

	update->xgo_gpio = gi;
	*outp = update;
	return (xpio_success(xpio));
}

void
xpio_fini(xpio_t *xpio)
{
	if (xpio == NULL)
		return;

	if (xpio->xp_devinfo != DI_NODE_NIL) {
		di_fini(xpio->xp_devinfo);
		xpio->xp_devinfo = NULL;
	}

	free(xpio);
}

xpio_t *
xpio_init(void)
{
	xpio_t *xpio;

	xpio = calloc(1, sizeof (xpio_t));
	if (xpio == NULL) {
		return (NULL);
	}
	xpio->xp_err = XPIO_ERR_OK;

	xpio->xp_devinfo = di_init("/", DINFOCPYALL);
	if (xpio->xp_devinfo == DI_NODE_NIL) {
		xpio_fini(xpio);
		return (NULL);
	}

	return (xpio);
}