xref: /illumos-gate/usr/src/lib/libxpio/common/libxpio_attr.c (revision a3ebb524df668b0fc3a38f33d0049380f5f11ec1)

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

/*
 * This file implements all of the access to and manipulating of attributes. An
 * attribute is a thinly veiled reference to the underlying nvlist_t of data
 * that we were given. Attributes are treated as the underlying nvpair data.
 * This gets us out of some allocation bits, but means that we need to always
 * ask for the gpio information itself depending on what we're trying to do as
 * that has a pointer to our nvlist.
 */

#include <strings.h>
#include <sys/gpio/zen_gpio.h>
#include <sys/gpio/gpio_sim.h>
#include <sys/gpio/pca953x.h>
#include <sys/gpio/ltc4306.h>
#include <sys/sysmacros.h>

#include "libxpio_impl.h"

/*
 * These are data tables that exist for each attribute. They provide a general
 * means of mapping between a string and a known uint32_t value. Currently we
 * assume that these strings do not need translation and localization. There
 * should be one table of values which is then wrapped up inside something else.
 */
typedef struct {
	uint32_t xp_val;
	const char *xp_name;
} xpio_pair_t;

static const xpio_pair_t zen_gpio_pad_pairs[] = {
	{ ZEN_GPIO_PAD_TYPE_GPIO, "gpio" },
	{ ZEN_GPIO_PAD_TYPE_SD, "sd" },
	{ ZEN_GPIO_PAD_TYPE_I2C, "i2c" },
	{ ZEN_GPIO_PAD_TYPE_I3C, "i3c" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_cap_pairs[] = {
	{ ZEN_GPIO_C_AGPIO, "AGPIO" },
	{ ZEN_GPIO_C_REMOTE, "Remote" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_driver_pairs[] = {
	{ ZEN_GPIO_DRIVER_UNKNOWN, "unknown" },
	{ ZEN_GPIO_DRIVER_PUSH_PULL, "push-pull" },
	{ ZEN_GPIO_DRIVER_OPEN_DRAIN, "open-drain" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_output_pairs[] = {
	{ ZEN_GPIO_OUTPUT_DISABLED, "disabled" },
	{ ZEN_GPIO_OUTPUT_LOW, "low" },
	{ ZEN_GPIO_OUTPUT_HIGH, "high" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_input_pairs[] = {
	{ ZEN_GPIO_INPUT_LOW, "low" },
	{ ZEN_GPIO_INPUT_HIGH, "high" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_voltage_pairs[] = {
	{ ZEN_GPIO_V_UNKNOWN, "unknown" },
	{ ZEN_GPIO_V_1P1_S3, "1.1V" },
	{ ZEN_GPIO_V_1P8_S5, "1.8V" },
	{ ZEN_GPIO_V_1P8_S0, "1.8V" },
	{ ZEN_GPIO_V_3P3_S5, "3.3V" },
	{ ZEN_GPIO_V_3P3_S0, "3.3V" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_pull_pairs[] = {
	{ ZEN_GPIO_PULL_DISABLED, "disabled" },
	{ ZEN_GPIO_PULL_DOWN, "down" },
	{ ZEN_GPIO_PULL_UP_4K, "4k-up" },
	{ ZEN_GPIO_PULL_UP_8K, "8k-up" },
	{ ZEN_GPIO_PULL_UP, "up" },
	{ ZEN_GPIO_PULL_DOWN_UP, "up|down" },
	{ ZEN_GPIO_PULL_DOWN_UP_4K, "4k-up|down" },
	{ ZEN_GPIO_PULL_DOWN_UP_8K, "8k-up|down" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_drive_pairs[] = {
	{ ZEN_GPIO_DRIVE_UNKNOWN, "unknown" },
	{ ZEN_GPIO_DRIVE_40R, "40R" },
	{ ZEN_GPIO_DRIVE_60R, "60R" },
	{ ZEN_GPIO_DRIVE_80R, "80R" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_dbt_mode_pairs[] = {
	{ ZEN_GPIO_DEBOUNCE_MODE_NONE, "none" },
	{ ZEN_GPIO_DEBOUNCE_MODE_KEEP_LOW, "keep-low-glitch" },
	{ ZEN_GPIO_DEBOUNCE_MODE_KEEP_HIGH, "keep-high-glitch" },
	{ ZEN_GPIO_DEBOUNCE_MODE_REMOVE, "remove-glitch" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_dbt_unit_pairs[] = {
	{ ZEN_GPIO_DEBOUNCE_UNIT_2RTC, "61us" },
	{ ZEN_GPIO_DEBOUNCE_UNIT_8RTC, "244us" },
	{ ZEN_GPIO_DEBOUNCE_UNIT_512RTC, "15.6ms" },
	{ ZEN_GPIO_DEBOUNCE_UNIT_2048RTC, "62.5ms" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_trigger_mode_pairs[] = {
	{ ZEN_GPIO_TRIGGER_UNKNOWN, "unknown" },
	{ ZEN_GPIO_TRIGGER_EDGE_HIGH, "edge/high" },
	{ ZEN_GPIO_TRIGGER_EDGE_LOW, "edge/low" },
	{ ZEN_GPIO_TRIGGER_EDGE_BOTH, "edge/both" },
	{ ZEN_GPIO_TRIGGER_LEVEL_HIGH, "level/high" },
	{ ZEN_GPIO_TRIGGER_LEVEL_LOW, "level/low" },
	{ 0x00, NULL }
};

static const xpio_pair_t zen_gpio_status_pairs[] = {
	{ ZEN_GPIO_STATUS_WAKE, "wake" },
	{ ZEN_GPIO_STATUS_INTR, "interrupt" },
	{ 0x00, NULL }
};

static const xpio_pair_t gpio_sim_output_pairs[] = {
	{ GPIO_SIM_OUTPUT_DISABLED, "disabled" },
	{ GPIO_SIM_OUTPUT_LOW, "low" },
	{ GPIO_SIM_OUTPUT_HIGH, "high" },
	{ 0x00, NULL }
};

static const xpio_pair_t gpio_sim_input_pairs[] = {
	{ GPIO_SIM_INPUT_LOW, "low" },
	{ GPIO_SIM_INPUT_HIGH, "high" },
	{ 0x00, NULL }
};

static const xpio_pair_t gpio_sim_pull_pairs[] = {
	{ GPIO_SIM_PULL_DISABLED, "disabled" },
	{ GPIO_SIM_PULL_DOWN, "down" },
	{ GPIO_SIM_PULL_DOWN_23K, "23k-down" },
	{ GPIO_SIM_PULL_UP, "up" },
	{ GPIO_SIM_PULL_UP_5K, "5k-up" },
	{ GPIO_SIM_PULL_UP_40K, "40k-up" },
	{ GPIO_SIM_PULL_BOTH, "up|down" },
	{ 0x00, NULL }
};

static const xpio_pair_t gpio_sim_voltage_pairs[] = {
	{ GPIO_SIM_VOLTAGE_1P8, "1.8V" },
	{ GPIO_SIM_VOLTAGE_3P3, "3.3V" },
	{ GPIO_SIM_VOLTAGE_12P0, "12.0V" },
	{ GPIO_SIM_VOLTAGE_54P5, "54.5V" },
	{ 0x00, NULL }
};

static const xpio_pair_t gpio_sim_speed_pairs[] = {
	{ GPIO_SIM_SPEED_LOW, "low" },
	{ GPIO_SIM_SPEED_MEDIUM, "medium" },
	{ GPIO_SIM_SPEED_HIGH, "high" },
	{ GPIO_SIM_SPEED_VERY_HIGH, "very-high" },
	{ 0x00, NULL }
};

static const xpio_pair_t pca953x_input_pairs[] = {
	{ PCA953X_GPIO_INPUT_LOW, "low" },
	{ PCA953X_GPIO_INPUT_HIGH, "high" },
	{ 0x00, NULL }
};

static const xpio_pair_t pca953x_output_pairs[] = {
	{ PCA953X_GPIO_OUTPUT_DISABLED, "disabled" },
	{ PCA953X_GPIO_OUTPUT_LOW, "low" },
	{ PCA953X_GPIO_OUTPUT_HIGH, "high" },
	{ 0x00, NULL }
};

static const xpio_pair_t pca953x_polarity_pairs[] = {
	{ PCA953X_GPIO_POLARITY_NORMAL, "normal" },
	{ PCA953X_GPIO_POLARITY_INVERTED, "inverted" },
	{ 0x00, NULL }
};

static const xpio_pair_t ltc4306_input_pairs[] = {
	{ LTC4306_GPIO_INPUT_LOW, "low" },
	{ LTC4306_GPIO_INPUT_HIGH, "high" },
	{ 0x00, NULL }
};

static const xpio_pair_t ltc4306_output_pairs[] = {
	{ LTC4306_GPIO_OUTPUT_DISABLED, "disabled" },
	{ LTC4306_GPIO_OUTPUT_LOW, "low" },
	{ LTC4306_GPIO_OUTPUT_HIGH, "high" },
	{ 0x00, NULL }
};

static const xpio_pair_t ltc4306_output_mode_pairs[] = {
	{ LTC4306_GPIO_OUTPUT_MODE_PUSH_PULL, "push-pull" },
	{ LTC4306_GPIO_OUTPUT_MODE_OPEN_DRAIN, "open-drain" },
	{ 0x00, NULL }
};

/*
 * These two different functions are intended for different uses. Basically
 * today most attributes that providers expose are semantic enums that describe
 * state. The tostr_f function pointer is intended for when translating from the
 * provider's notion of it to a humans. The tou32_f is intended for translating
 * from a human's notion to a providers. The latter translation still works for
 * properties that are read-only, mainly because it is the provider's job to be
 * the source of truth for what is read-only or not.
 */
typedef bool (*xpio_xlate_tostr_f)(const uint32_t, const xpio_pair_t *, char *,
    size_t);
typedef bool (*xpio_xlate_tou32_f)(const char *, const xpio_pair_t *,
    uint32_t *);

typedef struct {
	const char *xt_name;
	const xpio_pair_t *xt_pairs;
	xpio_xlate_tostr_f xt_xlate_tostr;
	xpio_xlate_tou32_f xt_xlate_tou32;
} xpio_translate_t;

static bool
xpio_attr_xlate_tostr_direct(const uint32_t val, const xpio_pair_t *pairs,
    char *buf, size_t buflen)
{
	for (uint_t i = 0; pairs[i].xp_name != NULL; i++) {
		if (val == pairs[i].xp_val) {
			return (strlcpy(buf, pairs[i].xp_name, buflen) <
			    buflen);
		}
	}
	return (false);
}

static bool
xpio_attr_xlate_tou32_direct(const char *str, const xpio_pair_t *pairs,
    uint32_t *outp)
{
	for (uint_t i = 0; pairs[i].xp_name != NULL; i++) {
		if (strcmp(str, pairs[i].xp_name) == 0) {
			*outp = pairs[i].xp_val;
			return (true);
		}
	}
	return (false);
}

static bool
xpio_attr_xlate_tostr_bitfield(const uint32_t val, const xpio_pair_t *pairs,
    char *buf, size_t buflen)
{
	size_t off = 0;
	bool first = true;

	buf[0] = '\0';
	for (uint_t i = 0; pairs[i].xp_name != NULL; i++) {
		int ret;

		if ((pairs[i].xp_val & val) != pairs[i].xp_val) {
			continue;
		}

		ret = snprintf(buf + off, buflen - off, "%s%s",
		    first ? "" : "|", pairs[i].xp_name);
		if (ret >= (buflen - off)) {
			return (false);
		}
		off += ret;
		first = false;
	}

	return (true);
}

/*
 * We expect a bit field to have a series of strings that are | delineated. This
 * means that we need to search and only look at the portion of the string that
 * matches the '|'. This leads to use needing to check two things for a match:
 *
 *   o That a strncmp() with the found string length matches.
 *   o That the total length indicates the end of the pair's string. This must
 *     be done after the first check as the first check returning zero
 *     effectively gives us a guarantee on the pair's length and that the next
 *     byte is valid.
 */
static bool
xpio_attr_xlate_tou32_bitfield(const char *str, const xpio_pair_t *pairs,
    uint32_t *outp)
{
	*outp = 0;
	bool found = false;

	while (*str != '\0') {
		size_t len;
		const char *pipe = strchr(str, '|');
		bool match = false;

		if (pipe != NULL) {
			len = (uintptr_t)pipe - (uintptr_t)str;
		} else {
			len = strlen(str);
		}

		for (uint_t i = 0; pairs[i].xp_name != NULL; i++) {
			if (strncmp(pairs[i].xp_name, str, len) == 0 &&
			    pairs[i].xp_name[len] == '\0') {
				found = true;
				match = true;
				*outp |= pairs[i].xp_val;
				match = true;
				break;
			}
		}

		if (!match) {
			return (false);
		}

		if (pipe != NULL) {
			str = pipe + 1;
		} else {
			break;
		}
	}

	return (found);
}

static bool
xpio_attr_xlate_tostr_hex(const uint32_t val, const xpio_pair_t *pairs,
    char *buf, size_t buflen)
{
	return (snprintf(buf, buflen, "0x%x", val) < buflen);
}

static bool
xpio_attr_xlate_tou32_hex(const char *str, const xpio_pair_t *pairs,
    uint32_t *outp)
{
	char *eptr;
	unsigned long long l;

	errno = 0;
	l = strtoull(str, &eptr, 0);
	if (errno != 0 || *eptr != '\0' || l > UINT32_MAX) {
		return (false);
	}

	*outp = (uint32_t)l;
	return (true);
}

static const xpio_translate_t xpio_attr_xlates[] = {
	/* zen_gpio(4D) attrs */
	{ ZEN_GPIO_ATTR_PAD_TYPE, zen_gpio_pad_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_CAPS, zen_gpio_cap_pairs,
	    xpio_attr_xlate_tostr_bitfield, xpio_attr_xlate_tou32_bitfield },
	{ ZEN_GPIO_ATTR_OUTPUT_DRIVER, zen_gpio_driver_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_OUTPUT, zen_gpio_output_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_INPUT, zen_gpio_input_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_VOLTAGE, zen_gpio_voltage_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_PULL, zen_gpio_pull_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_DRIVE_STRENGTH, zen_gpio_drive_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_DEBOUNCE_MODE, zen_gpio_dbt_mode_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_DEBOUNCE_UNIT, zen_gpio_dbt_unit_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_DEBOUNCE_COUNT, NULL, xpio_attr_xlate_tostr_hex,
	    xpio_attr_xlate_tou32_hex },
	{ ZEN_GPIO_ATTR_TRIGGER_MODE, zen_gpio_trigger_mode_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ ZEN_GPIO_ATTR_STATUS, zen_gpio_status_pairs,
	    xpio_attr_xlate_tostr_bitfield, xpio_attr_xlate_tou32_bitfield },
	{ ZEN_GPIO_ATTR_RAW_REG, NULL, xpio_attr_xlate_tostr_hex,
	    xpio_attr_xlate_tou32_hex },
	/* gpio_sim(4D) attrs */
	{ GPIO_SIM_ATTR_OUTPUT, gpio_sim_output_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ GPIO_SIM_ATTR_INPUT, gpio_sim_input_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ GPIO_SIM_ATTR_PULL, gpio_sim_pull_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ GPIO_SIM_ATTR_VOLTAGE, gpio_sim_voltage_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ GPIO_SIM_ATTR_SPEED, gpio_sim_speed_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	/* pca953x(4D) attrs */
	{ PCA953X_GPIO_ATTR_INPUT, pca953x_input_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ PCA953X_GPIO_ATTR_OUTPUT, pca953x_output_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ PCA953X_GPIO_ATTR_POLARITY, pca953x_polarity_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	/* ltc4306(4D) attrs */
	{ LTC4306_GPIO_ATTR_INPUT, ltc4306_input_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ LTC4306_GPIO_ATTR_OUTPUT, ltc4306_output_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct },
	{ LTC4306_GPIO_ATTR_OUTPUT_MODE, ltc4306_output_mode_pairs,
	    xpio_attr_xlate_tostr_direct, xpio_attr_xlate_tou32_direct }
};

bool
xpio_gpio_attr_xlate_uint32_to_str(xpio_gpio_info_t *gi, xpio_gpio_attr_t *attr,
    uint32_t val, char *buf, size_t buflen)
{
	const char *name = xpio_gpio_attr_name(gi, attr);

	for (size_t i = 0; i < ARRAY_SIZE(xpio_attr_xlates); i++) {
		if (strcmp(name, xpio_attr_xlates[i].xt_name) != 0)
			continue;

		return (xpio_attr_xlates[i].xt_xlate_tostr(val,
		    xpio_attr_xlates[i].xt_pairs, buf, buflen));
	}

	return (false);
}

bool
xpio_gpio_attr_xlate_to_str(xpio_gpio_info_t *gi, xpio_gpio_attr_t *attr,
    char *buf, size_t buflen)
{
	uint32_t val;

	if (!xpio_gpio_attr_value_uint32(attr, &val)) {
		return (false);
	}

	return (xpio_gpio_attr_xlate_uint32_to_str(gi, attr, val, buf, buflen));
}

xpio_gpio_attr_t *
xpio_gpio_attr_find(xpio_gpio_info_t *gi, const char *name)
{
	nvpair_t *pair;

	if (strcmp(name, KGPIO_ATTR_META) == 0) {
		return (NULL);
	}

	if (nvlist_lookup_nvpair(gi->xgi_nvl, name, &pair) != 0) {
		return (NULL);
	}

	switch (nvpair_type(pair)) {
	case DATA_TYPE_UINT32:
	case DATA_TYPE_STRING:
		break;
	default:
		return (NULL);
	}

	return ((xpio_gpio_attr_t *)pair);
}

xpio_gpio_attr_t *
xpio_gpio_attr_next(xpio_gpio_info_t *gi, xpio_gpio_attr_t *attr)
{
	nvpair_t *pair_in = (nvpair_t *)attr;

	for (;;) {
		nvpair_t *next = nvlist_next_nvpair(gi->xgi_nvl, pair_in);
		if (next == NULL) {
			return (NULL);
		}

		switch (nvpair_type(next)) {
		case DATA_TYPE_UINT32:
		case DATA_TYPE_STRING:
			break;
		default:
			pair_in = next;
			continue;
		}

		if (strcmp(KGPIO_ATTR_META, nvpair_name(next)) == 0) {
			pair_in = next;
			continue;
		}

		return ((xpio_gpio_attr_t *)next);
	}
}

const char *
xpio_gpio_attr_name(xpio_gpio_info_t *gi, xpio_gpio_attr_t *attr)
{
	nvpair_t *pair = (nvpair_t *)attr;
	return (nvpair_name(pair));
}

xpio_attr_type_t
xpio_gpio_attr_type(xpio_gpio_info_t *gi, xpio_gpio_attr_t *attr)
{
	nvpair_t *pair = (nvpair_t *)attr;

	/*
	 * We should only have handed out an nvpair that matches these two types
	 * at this point.
	 */
	switch (nvpair_type(pair)) {
	case DATA_TYPE_UINT32:
		return (XPIO_ATTR_TYPE_UINT32);
	case DATA_TYPE_STRING:
		return (XPIO_ATTR_TYPE_STRING);
	default:
		abort();
	}
}

static const char *
xpio_gpio_attr_type_name(xpio_attr_type_t type)
{
	switch (type) {
	case XPIO_ATTR_TYPE_UINT32:
		return ("XPIO_ATTR_TYPE_UINT32");
	case XPIO_ATTR_TYPE_STRING:
		return ("XPIO_ATTR_TYPE_STRING");
	default:
		abort();
	}
}

bool
xpio_gpio_attr_value_string(xpio_gpio_attr_t *attr, const char **outp)
{
	char *lookup;

	if (nvpair_value_string((nvpair_t *)attr, &lookup) != 0) {
		return (false);
	}

	*outp = lookup;
	return (true);
}

bool
xpio_gpio_attr_value_uint32(xpio_gpio_attr_t *attr, uint32_t *outp)
{
	return (nvpair_value_uint32((nvpair_t *)attr, outp) == 0);
}

void
xpio_gpio_attr_possible_string(xpio_gpio_info_t *gi, xpio_gpio_attr_t *attr,
    const char ***outp, uint_t *countp)
{
	nvlist_t *meta_nvl, *attr_nvl;
	const char *key = nvpair_name((nvpair_t *)attr);
	char **strp;

	*outp = NULL;
	*countp = 0;

	if (nvlist_lookup_nvlist(gi->xgi_nvl, KGPIO_ATTR_META, &meta_nvl) !=
	    0) {
		return;
	}

	if (nvlist_lookup_nvlist(meta_nvl, key, &attr_nvl) != 0) {
		return;
	}

	if (nvlist_lookup_string_array(attr_nvl, KGPIO_ATTR_POS, &strp,
	    countp) != 0) {
		*outp = (const char **)strp;
	}
}

void
xpio_gpio_attr_possible_uint32(xpio_gpio_info_t *gi, xpio_gpio_attr_t *attr,
    uint32_t **outp, uint_t *countp)
{
	nvlist_t *meta_nvl, *attr_nvl;
	const char *key = nvpair_name((nvpair_t *)attr);

	*outp = NULL;
	*countp = 0;

	if (nvlist_lookup_nvlist(gi->xgi_nvl, KGPIO_ATTR_META, &meta_nvl) !=
	    0) {
		return;
	}

	if (nvlist_lookup_nvlist(meta_nvl, key, &attr_nvl) != 0) {
		return;
	}

	(void) nvlist_lookup_uint32_array(attr_nvl, KGPIO_ATTR_POS, outp,
	    countp);
}

xpio_attr_prot_t
xpio_gpio_attr_prot(xpio_gpio_info_t *gi, xpio_gpio_attr_t *attr)
{
	uint32_t prot;
	nvlist_t *meta_nvl, *attr_nvl;
	const char *key = nvpair_name((nvpair_t *)attr);

	if (nvlist_lookup_nvlist(gi->xgi_nvl, KGPIO_ATTR_META, &meta_nvl) !=
	    0) {
		return (XPIO_ATTR_PROT_RO);
	}

	if (nvlist_lookup_nvlist(meta_nvl, key, &attr_nvl) != 0) {
		return (XPIO_ATTR_PROT_RO);
	}

	if (nvlist_lookup_uint32(attr_nvl, KGPIO_ATTR_PROT, &prot) != 0) {
		return (XPIO_ATTR_PROT_RO);
	}

	switch (prot) {
	case KGPIO_PROT_RW:
		return (XPIO_ATTR_PROT_RW);
	case KGPIO_PROT_RO:
	default:
		return (XPIO_ATTR_PROT_RO);
	}
}

bool
xpio_gpio_attr_set_uint32(xpio_gpio_update_t *update, xpio_gpio_attr_t *attr,
    uint32_t val)
{
	int ret;
	xpio_attr_type_t type = xpio_gpio_attr_type(update->xgo_gpio, attr);
	const char *key = xpio_gpio_attr_name(update->xgo_gpio, attr);

	if (type != XPIO_ATTR_TYPE_UINT32) {
		return (xpio_update_error(update, XPIO_UPDATE_ERR_BAD_TYPE, 0,
		    "attribute type for %s is %s, not a uint32", key,
		    xpio_gpio_attr_type_name(type)));
	}

	ret = nvlist_add_uint32(update->xgo_update, key, val);
	switch (ret) {
	case 0:
		return (xpio_update_success(update));
	case ENOMEM:
		return (xpio_update_error(update, XPIO_UPDATE_ERR_NO_MEM, ret,
		    "failed to allocate memory to insert attribute %s into "
		    "update structure", key));
	default:
		return (xpio_update_error(update, XPIO_UPDATE_ERR_INTERNAL, ret,
		    "unexpected internal error while trying to insert "
		    "attribute %s into update structure: %s", key,
		    strerror(ret)));
	}
}

bool
xpio_gpio_attr_set_str(xpio_gpio_update_t *update, xpio_gpio_attr_t *attr,
    const char *val)
{
	int ret;
	xpio_attr_type_t type = xpio_gpio_attr_type(update->xgo_gpio, attr);
	const char *key = xpio_gpio_attr_name(update->xgo_gpio, attr);

	if (type != XPIO_ATTR_TYPE_STRING) {
		return (xpio_update_error(update, XPIO_UPDATE_ERR_BAD_TYPE, 0,
		    "attribute type for %s is %s, not a string", key,
		    xpio_gpio_attr_type_name(type)));
	}

	ret = nvlist_add_string(update->xgo_update, key, val);
	switch (ret) {
	case 0:
		return (xpio_update_success(update));
	case ENOMEM:
		return (xpio_update_error(update, XPIO_UPDATE_ERR_NO_MEM, ret,
		    "failed to allocate memory to insert attribute %s into "
		    "update structure", key));
	default:
		return (xpio_update_error(update, XPIO_UPDATE_ERR_INTERNAL, ret,
		    "unexpected internal error while trying to insert "
		    "attribute %s into update structure: %s", key,
		    strerror(ret)));
	}
}

/*
 * This update path attempts to translate the passed in string into the
 * appropriate attribute type. This is designed for tools that want to work in
 * the more human values that we have for various GPIO attributes.
 */
bool
xpio_gpio_attr_from_str(xpio_gpio_update_t *update, xpio_gpio_attr_t *attr,
    const char *raw_val)
{
	xpio_attr_type_t type = xpio_gpio_attr_type(update->xgo_gpio, attr);
	const char *key = xpio_gpio_attr_name(update->xgo_gpio, attr);

	/*
	 * If the data type for this is a string, then we can just insert the
	 * value as is and there is no need for translation. Otherwise, we must
	 * look at the data type and perform the appropriate translation.
	 */
	if (type == XPIO_ATTR_TYPE_STRING) {
		return (xpio_gpio_attr_set_str(update, attr, raw_val));
	}

	for (size_t i = 0; i < ARRAY_SIZE(xpio_attr_xlates); i++) {
		uint32_t u32;

		if (strcmp(key, xpio_attr_xlates[i].xt_name) != 0)
			continue;
		if (!xpio_attr_xlates[i].xt_xlate_tou32(raw_val,
		    xpio_attr_xlates[i].xt_pairs, &u32)) {
			return (xpio_update_error(update,
			    XPIO_UPDATE_ERR_CANT_XLATE, 0, "failed to  "
			    "translate attribute %s value %s to a uint32",
			    key, raw_val));
		}

		return (xpio_gpio_attr_set_uint32(update, attr, u32));
	}

	return (xpio_update_error(update, XPIO_UPDATE_ERR_INTERNAL, ENOENT,
	    "missing internal translator for attr %s to type %s", key,
	    xpio_gpio_attr_type_name(type)));

}

xpio_gpio_attr_err_t *
xpio_gpio_attr_err_next(xpio_gpio_update_t *update, xpio_gpio_attr_err_t *cur)
{
	nvpair_t *pair_in = (nvpair_t *)cur;

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

	for (;;) {
		nvpair_t *next = nvlist_next_nvpair(update->xgo_err_nvl,
		    pair_in);
		if (next == NULL) {
			return (NULL);
		}

		if (nvpair_type(next) != DATA_TYPE_UINT32) {
			pair_in = next;
			continue;
		}

		return ((xpio_gpio_attr_err_t *)next);
	}
}

const char *
xpio_gpio_attr_err_name(xpio_gpio_attr_err_t *err)
{
	nvpair_t *pair = (nvpair_t *)err;
	return (nvpair_name(pair));
}

xpio_update_err_t
xpio_gpio_attr_err_err(xpio_gpio_attr_err_t *err)
{
	uint32_t val;
	nvpair_t *pair = (nvpair_t *)err;

	if (nvpair_value_uint32(pair, &val) != 0) {
		return (XPIO_UPDATE_ERR_INTERNAL);
	}

	switch (val) {
	case KGPIO_ATTR_ERR_OK:
		return (XPIO_UPDATE_ERR_OK);
	case KGPIO_ATTR_ERR_ATTR_RO:
		return (XPIO_UPDATE_ERR_RO);
	case KGPIO_ATTR_ERR_UNKNOWN_ATTR:
		return (XPIO_UPDATE_ERR_UNKNOWN_ATTR);
	case KGPIO_ATTR_ERR_BAD_TYPE:
		return (XPIO_UPDATE_ERR_BAD_TYPE);
	case KGPIO_ATTR_ERR_UNKNOWN_VAL:
		return (XPIO_UPDATE_ERR_CANT_XLATE);
	case KGPIO_ATTR_ERR_CANT_APPLY_VAL:
		return (XPIO_UPDATE_ERR_CANT_APPLY_VAL);
	default:
		return (XPIO_UPDATE_ERR_INTERNAL);
	}
}