libi2c/common/libi2c.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 2025 Oxide Computer Company
 */

/*
 * libi2c, a magical place that deals with everyone's favorite device class to
 * hate.
 */

#include <stdlib.h>
#include <ctype.h>
#include <strings.h>
#include <sys/debug.h>
#include <sys/ilstr.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/obpdefs.h>

#include "libi2c_impl.h"

void
i2c_fini(i2c_hdl_t *hdl)
{
	freelocale(hdl->ih_c_loc);
	(void) close(hdl->ih_devfd);
	free(hdl);
}

i2c_hdl_t *
i2c_init(void)
{
	i2c_hdl_t *hdl;

	hdl = calloc(1, sizeof (i2c_hdl_t));
	if (hdl == NULL) {
		return (NULL);
	}

	hdl->ih_devfd = open("/devices", O_RDONLY | O_DIRECTORY);
	if (hdl->ih_devfd < 0) {
		free(hdl);
		return (NULL);
	}

	hdl->ih_c_loc = newlocale(LC_ALL_MASK, "C", NULL);
	return (hdl);
}

/*
 * Provide a simple answer as to whether or not an address is a reserved
 * address. This function is a bit awkward as invalid addresses are technically
 * not reserved.
 */
bool
i2c_addr_reserved(const i2c_addr_t *addr)
{
	switch (addr->ia_type) {
	case I2C_ADDR_7BIT:
		if (addr->ia_addr >= (1 << 7)) {
			return (false);
		}
		break;
	case I2C_ADDR_10BIT:
		if (addr->ia_addr >= (1 << 10)) {
			return (false);
		}
		break;
	default:
		return (false);
	}

	/*
	 * Because we've already done a size check up above we know illegal
	 * 7-bit addresses that are reserved 10-bit addresses will have already
	 * been checked.
	 */
	switch (addr->ia_addr) {
	case I2C_RSVD_ADDR_GEN_CALL:
	case I2C_RSVD_ADDR_C_BUS:
	case I2C_RSVD_ADDR_DIFF_BUS:
	case I2C_RSVD_ADDR_FUTURE:
	case I2C_RSVD_ADDR_HS_0:
	case I2C_RSVD_ADDR_HS_1:
	case I2C_RSVD_ADDR_HS_2:
	case I2C_RSVD_ADDR_HS_3:
	case I2C_RSVD_ADDR_10B_0:
	case I2C_RSVD_ADDR_10B_1:
	case I2C_RSVD_ADDR_10B_2:
	case I2C_RSVD_ADDR_10B_3:
	case I2C_RSVD_ADDR_DID_0:
	case I2C_RSVD_ADDR_DID_1:
	case I2C_RSVD_ADDR_DID_2:
	case I2C_RSVD_ADDR_DID_3:
		return (true);
	default:
		return (false);
	}
}

bool
i2c_addr_validate(i2c_hdl_t *hdl, const i2c_addr_t *addr)
{
	uint16_t max;

	if (addr == NULL) {
		return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
		    "invalid i2c_addr_t pointer: %p", addr));
	}

	switch (addr->ia_type) {
	case I2C_ADDR_7BIT:
		max = 1 << 7;
		break;
	case I2C_ADDR_10BIT:
		max = 1 << 10;
		break;
	default:
		return (i2c_error(hdl, I2C_ERR_BAD_ADDR_TYPE, 0, "invalid "
		    "address type family 0x%x", addr->ia_type));
	}

	if (addr->ia_addr >= max) {
		return (i2c_error(hdl, I2C_ERR_BAD_ADDR, 0, "address 0x%x is "
		    "outside the valid range for the address type: [0x00, "
		    "0x%02x]", addr->ia_addr, max - 1));
	}

	return (true);
}

/*
 * The set of valid characters for the 'name' and 'compatible' properties comes
 * from IEEE 1275 (which was carried forward into device tree). A name must be
 * at most 31 characters. It is allowed to contain lower case, upper case,
 * numbers, and ",.+-_". We require the first character to be a letter. We check
 * all of this against our copy of the C locale to ensure that a program in a
 * different locale doesn't get a different answer.
 */
CTASSERT(I2C_NAME_MAX == OBP_MAXDRVNAME);
bool
i2c_name_validate(i2c_hdl_t *hdl, const char *name, const char *desc)
{
	size_t len;

	if (name == NULL) {
		return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
		    "invalid %s pointer: %p", desc, name));
	}

	len = strnlen(name, I2C_NAME_MAX);
	if (len >= I2C_NAME_MAX) {
		return (i2c_error(hdl, I2C_ERR_BAD_DEV_NAME, 0, "%s exceeds "
		    "%u character length limit, including NUL", desc,
		    I2C_NAME_MAX));
	} else if (len == 0) {
		return (i2c_error(hdl, I2C_ERR_BAD_DEV_NAME, 0, "%s cannot "
		    "have zero length", desc));
	}

	if (isalpha_l(name[0], hdl->ih_c_loc) == 0) {
		return (i2c_error(hdl, I2C_ERR_BAD_DEV_NAME, 0, "%s must "
		    "have an ASCII upper or lowercase first letter: found 0x%x",
		    desc, name[0]));
	}

	for (size_t i = 1; i < len; i++) {
		if (isalpha_l(name[i], hdl->ih_c_loc) ||
		    isdigit_l(name[i], hdl->ih_c_loc)) {
			continue;
		}

		if (name[i] == ',' || name[i] == '.' || name[i] == '+' ||
		    name[i] == '-' || name[i] == '_') {
			continue;
		}

		return (i2c_error(hdl, I2C_ERR_BAD_DEV_NAME, 0, "%s character "
		    "%zu is not from the valid set: found 0x%x", desc, i,
		    name[i]));
	}

	return (true);
}

i2c_node_type_t
i2c_node_type(di_node_t dn)
{
	const char *drv = di_driver_name(dn);
	char *strs;
	int nstrs;

	nstrs = di_prop_lookup_strings(DDI_DEV_T_ANY, dn, "device_type",
	    &strs);
	if (nstrs == 1 && strcmp(strs, "i2c") == 0) {
		return (I2C_NODE_T_DEV);
	}

	if (drv == NULL || strcmp(drv, I2C_NEX_DRV) != 0) {
		return (I2C_NODE_T_OTHER);
	}

	nstrs = di_prop_lookup_strings(DDI_DEV_T_ANY, dn, I2C_NEXUS_TYPE_PROP,
	    &strs);
	if (nstrs != 1) {
		return (I2C_NODE_T_OTHER);
	}

	if (strcmp(strs, I2C_NEXUS_TYPE_PORT) == 0) {
		return (I2C_NODE_T_PORT);
	} else if (strcmp(strs, I2C_NEXUS_TYPE_CTRL) == 0) {
		return (I2C_NODE_T_CTRL);
	} else if (strcmp(strs, I2C_NEXUS_TYPE_MUX) == 0) {
		return (I2C_NODE_T_MUX);
	}

	return (I2C_NODE_T_OTHER);
}

/*
 * Given a device node, find the corresponding minor node in its parent port.
 * This node will be named after the kernel form of the device, which is going
 * to be the type,addr aka reg[0],reg[1].
 */
static di_minor_t
i2c_node_minor_device(di_node_t dn)
{
	int nreg, *reg;
	char name[32];

	nreg = di_prop_lookup_ints(DDI_DEV_T_ANY, dn, "reg", &reg);
	if (nreg == 0 || (nreg % 2) != 0) {
		return (DI_MINOR_NIL);
	}

	(void) snprintf(name, sizeof (name), "%x,%x", reg[0], reg[1]);
	dn = di_parent_node(dn);
	if (i2c_node_type(dn) != I2C_NODE_T_PORT) {
		return (DI_MINOR_NIL);
	}

	for (di_minor_t m = di_minor_next(dn, DI_MINOR_NIL); m != DI_MINOR_NIL;
	    m = di_minor_next(dn, m)) {
		if (strcmp(di_minor_nodetype(m), DDI_NT_I2C_DEV) == 0 &&
		    strcmp(di_minor_name(m), name) == 0) {
			return (m);
		}
	}

	return (DI_MINOR_NIL);
}

di_minor_t
i2c_node_minor(di_node_t dn)
{
	const char *nt;
	i2c_node_type_t type = i2c_node_type(dn);

	switch (type) {
	case I2C_NODE_T_CTRL:
		nt = DDI_NT_I2C_CTRL;
		break;
	case I2C_NODE_T_PORT:
		nt = DDI_NT_I2C_PORT;
		break;
	case I2C_NODE_T_MUX:
		nt = DDI_NT_I2C_MUX;
		break;
	/*
	 * Device's don't have their control minor under them. The parent port
	 * has it, so when we need that, change this around to go search the
	 * parent for it.
	 */
	case I2C_NODE_T_DEV:
		return (i2c_node_minor_device(dn));
	default:
		return (DI_MINOR_NIL);
	}

	for (di_minor_t m = di_minor_next(dn, DI_MINOR_NIL); m != DI_MINOR_NIL;
	    m = di_minor_next(dn, m)) {
		if (strcmp(di_minor_nodetype(m), nt) == 0) {
			return (m);
		}
	}

	return (DI_MINOR_NIL);
}

bool
i2c_node_is_type(di_node_t dn, i2c_node_type_t type)
{
	return (i2c_node_type(dn) == type);
}


/*
 * This constructs the named i2c path that can be used to get to the node dn
 * through a series of '/' delineated pieces. The canonical name to use varies
 * based on the node type and stop once we hit a controller:
 *
 *  - controllers: controller name in the di_node_t address
 *  - ports: port name in the di_node_t address
 *  - devices: primary i2c address
 */
bool
i2c_node_to_path(i2c_hdl_t *hdl, di_node_t dn, char *buf, size_t buflen)
{
	ilstr_t ils;
	bool first = true;
	i2c_addr_t addr;
	char addrstr[32];

	ilstr_init_prealloc(&ils, buf, buflen);

	for (;;) {
		i2c_node_type_t type = i2c_node_type(dn);

		switch (type) {
		case I2C_NODE_T_CTRL:
		case I2C_NODE_T_PORT:
			if (!first) {
				ilstr_prepend_str(&ils, "/");
			}
			ilstr_prepend_str(&ils, di_bus_addr(dn));
			first = false;
			break;
		case I2C_NODE_T_MUX:
			/*
			 * The i2cnex that represents a mux today is not used in
			 * the logical path that we use with humans.
			 */
			break;
		case I2C_NODE_T_DEV:
			if (!first) {
				ilstr_prepend_str(&ils, "/");
			}

			/*
			 * While it is tempting to use the bus address here, we
			 * cannot actually assume that a device address is
			 * valid. A device will only be addressed on the bus if
			 * a driver is attached to it.
			 *
			 * Therefore a device is identified with the primary
			 * address that it has, e.g. regs[0]. We use the
			 * somewhat more user firendly form of the address where
			 * 10-bit addresses have the leading '1,' to indicate
			 * the class, but 7-bit do not. As in practice that's
			 * what we'll be dealing with 99% of the time.
			 */
			if (!i2c_reg_to_addr(hdl, dn, &addr, 0)) {
				return (false);
			}

			VERIFY(i2c_addr_to_string(hdl, &addr, addrstr,
			    sizeof (addrstr)));
			ilstr_prepend_str(&ils, addrstr);
			first = false;
			break;
		default:
			return (i2c_error(hdl, I2C_ERR_INTERNAL, 0,
			    "encountered unknown node type constructing path: "
			    "0x%x", type));
		}

		/*
		 * If we've hit a controller we're done. However, look out in
		 * case we haven't and make sure we have a parent before
		 * continuing.
		 */
		if (type == I2C_NODE_T_CTRL)
			break;

		dn = di_parent_node(dn);
		if (dn == DI_NODE_NIL)
			break;
	}

	if (ilstr_errno(&ils) != ILSTR_ERROR_OK) {
		return (i2c_error(hdl, I2C_ERR_INTERNAL, 0, "failed to "
		    "construct string for node %s: %s", di_node_name(dn),
		    ilstr_errstr(&ils)));
	}

	return (true);
}

/*
 * Parse the kernel's I2C device address style, <type>,<address>. The only
 * thing assumed about str is that it is null terminated. The kernel integers
 * for type and address are always in hex regardless of whether or not they
 * have a leading 0x.
 */
bool
i2c_kernel_address_parse(i2c_hdl_t *hdl, const char *str, i2c_addr_t *addr)
{
	char *eptr;
	unsigned long ul;

	errno = 0;
	ul = strtoul(str, &eptr, 16);
	if (errno != 0 || *eptr != ',') {
		return (i2c_error(hdl, I2C_ERR_INTERNAL, 0, "kernel string %s "
		    "did not have a valid leading type", str));
	}

	if (ul == I2C_ADDR_7BIT) {
		addr->ia_type = I2C_ADDR_7BIT;
	} else if (ul == I2C_ADDR_10BIT) {
		addr->ia_type = I2C_ADDR_10BIT;
	} else {
		return (i2c_error(hdl, I2C_ERR_INTERNAL, 0, "kernel string %s "
		    "did not have a valid type, found 0x%lx", str, ul));
	}

	errno = 0;
	ul = strtoul(eptr + 1, &eptr, 16);
	if (errno != 0 || *eptr != '\0') {
		return (i2c_error(hdl, I2C_ERR_INTERNAL, 0, "kernel string %s "
		    "did not have a valid address", str));
	}

	if ((addr->ia_type == I2C_ADDR_7BIT && ul >= 1 << 7) ||
	    (addr->ia_type == I2C_ADDR_10BIT && ul >= 1 << 10)) {
		return (i2c_error(hdl, I2C_ERR_INTERNAL, 0, "kernel string %s "
		    "address 0x%lx is too large for type", str, ul));
	}

	addr->ia_addr = (uint16_t)ul;
	return (true);
}

/*
 * Parse a user address as compared to a kernel address. The main difference
 * here is that the user address does not use a prefix for the 7-bit addresses
 * and the 10-bit addresses use the "10b," prefix.
 */
bool
i2c_addr_parse(i2c_hdl_t *hdl, const char *buf, i2c_addr_t *addr)
{
	char *eptr;
	unsigned long ul;
	const char *comma;
	uint16_t max;

	if (buf == NULL) {
		return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
		    "invalid address string pointer: %p", buf));
	}

	if (addr == NULL) {
		return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
		    "invalid i2c_addr_t pointer: %p", addr));
	}

	comma = strchr(buf, ',');
	if (comma != NULL) {
		size_t len = (uintptr_t)comma - (uintptr_t)buf;
		if (len != 3 || strncmp("10b", buf, len) != 0) {
			return (i2c_error(hdl, I2C_ERR_BAD_ADDR_TYPE, 0,
			    "found invalid address type on %s", buf));
		}
		addr->ia_type = I2C_ADDR_10BIT;
		buf = comma + 1;
		max = 1 << 10;
	} else {
		addr->ia_type = I2C_ADDR_7BIT;
		max = 1 << 7;
	}

	errno = 0;
	ul = strtoul(buf, &eptr, 0);
	if (errno != 0 || *eptr != '\0') {
		return (i2c_error(hdl, I2C_ERR_BAD_ADDR, 0, "address %s could "
		    "not be parsed", buf));
	}

	if (ul >= max) {
		return (i2c_error(hdl, I2C_ERR_BAD_ADDR, 0, "address 0x%lx is "
		    "outside the valid range for the address type: [0x00, "
		    "0x%02x]", ul, max - 1));
	}

	addr->ia_addr = (uint16_t)ul;
	return (true);
}

bool
i2c_addr_to_string(i2c_hdl_t *hdl, const i2c_addr_t *addr, char *buf,
    size_t len)
{
	size_t ret;

	if (buf == NULL) {
		return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
		    "invalid address string pointer: %p", buf));
	}

	if (addr == NULL) {
		return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
		    "invalid i2c_addr_t pointer: %p", addr));
	}

	if (!i2c_addr_validate(hdl, addr)) {
		return (false);
	}

	if (addr->ia_type == I2C_ADDR_10BIT) {
		ret = snprintf(buf, len, "10b,0x%03x", addr->ia_addr);
	} else {
		ret = snprintf(buf, len, "0x%02x", addr->ia_addr);
	}
	if (ret >= len) {
		return (i2c_error(hdl, I2C_ERR_BUF_TOO_SMALL, 0, "output "
		    "buffer is too small: need %zu bytes, have %zu", ret,
		    len));
	}

	return (true);
}

/*
 * Convert the specified index for a device into an address.
 */
bool
i2c_reg_to_addr(i2c_hdl_t *hdl, di_node_t dn, i2c_addr_t *addr, uint32_t n)
{
	int nreg, *reg;
	uint32_t type_idx = n * 2;
	uint32_t addr_idx = n * 2 + 1;

	nreg = di_prop_lookup_ints(DDI_DEV_T_ANY, dn, "reg", &reg);
	if (nreg == 0 || (nreg % 2) != 0) {
		return (i2c_error(hdl, I2C_ERR_INTERNAL, 0, "device %s@%s "
		    "does not have a valid i2c reg[] property",
		    di_node_name(dn), di_bus_addr(dn)));
	}

	if (addr_idx >= nreg) {
		return (i2c_error(hdl, I2C_ERR_INTERNAL, 0, "device %s@%s "
		    "does not have a valid i2c reg[] property",
		    di_node_name(dn), di_bus_addr(dn)));
	}

	if (reg[type_idx] == I2C_ADDR_7BIT) {
		addr->ia_type = I2C_ADDR_7BIT;
	} else if (reg[type_idx] == I2C_ADDR_10BIT) {
		addr->ia_type = I2C_ADDR_10BIT;
	} else {
		return (i2c_error(hdl, I2C_ERR_INTERNAL, 0, "device %s@%s "
		    "does not have a valid i2c address type, found 0x%x",
		    di_node_name(dn), di_bus_addr(dn), reg[type_idx]));
	}

	if ((addr->ia_type == I2C_ADDR_7BIT && reg[addr_idx] >= 1 << 7) ||
	    (addr->ia_type == I2C_ADDR_10BIT && reg[addr_idx] >= 1 << 10)) {
		return (i2c_error(hdl, I2C_ERR_INTERNAL, 0, "device %s@%s "
		    "address 0x%x is too large for type", di_node_name(dn),
		    di_bus_addr(dn), reg[addr_idx]));
	}

	addr->ia_addr = (uint16_t)reg[1];

	return (true);
}

bool
i2c_addr_equal(const i2c_addr_t *a, const i2c_addr_t *b)
{
	return (a->ia_type == b->ia_type && a->ia_addr == b->ia_addr);
}

di_node_t
i2c_path_find_ctrl(di_node_t root, const char *name)
{
	for (di_node_t di = di_drv_first_node(I2C_NEX_DRV, root); di != NULL;
	    di = di_drv_next_node(di)) {
		if (!i2c_node_is_type(di, I2C_NODE_T_CTRL)) {
			continue;
		}

		if (strcmp(name, di_bus_addr(di)) == 0) {
			return (di);
		}
	}

	return (DI_NODE_NIL);
}

di_node_t
i2c_path_find_mux(di_node_t dev)
{
	for (di_node_t dn = di_child_node(dev); dn != NULL;
	    dn = di_sibling_node(dn)) {
		if (i2c_node_type(dn) == I2C_NODE_T_MUX) {
			return (dn);
		}
	}

	return (DI_NODE_NIL);
}

di_node_t
i2c_path_find_port(di_node_t parent, const char *name)
{
	for (di_node_t dn = di_child_node(parent); dn != NULL;
	    dn = di_sibling_node(dn)) {
		if (!i2c_node_is_type(dn, I2C_NODE_T_PORT)) {
			continue;
		}

		if (strcmp(di_bus_addr(dn), name) == 0) {
			return (dn);
		}
	}

	return (DI_NODE_NIL);
}

/*
 * When parsing a device, there are three different options that we accept:
 *
 *  - The device's name@address
 *  - The device's address
 *  - The device's driver and instance (e.g. spd511x2)
 *
 * The address is always reg[0] because the aactual node address may not exist
 * at this time. Similarly, we cannot assume that a driver is bound and attached
 * to the node.
 */
di_node_t
i2c_path_find_device(i2c_hdl_t *hdl, di_node_t port, const char *name)
{
	for (di_node_t dn = di_child_node(port); dn != NULL;
	    dn = di_sibling_node(dn)) {
		i2c_addr_t daddr;
		char daddrstr[32];

		if (i2c_node_type(dn) != I2C_NODE_T_DEV) {
			continue;
		}

		if (!i2c_reg_to_addr(hdl, dn, &daddr, 0)) {
			continue;
		}

		if (!i2c_addr_to_string(hdl, &daddr, daddrstr,
		    sizeof (daddrstr))) {
			continue;
		}

		/*
		 * Always check if we match on the converted address.
		 */
		if (strcmp(name, daddrstr) == 0) {
			return (dn);
		}

		/*
		 * We didn't match on that, is there a driver?
		 */
		if (di_driver_name(dn) != NULL && di_instance(dn) != -1) {
			char buf[128];

			(void) snprintf(buf, sizeof (buf), "%s%d",
			    di_driver_name(dn), di_instance(dn));
			if (strcmp(name, buf) == 0) {
				return (dn);
			}
		}

		/*
		 * Finally check if we match name@addr. Only do this if we have
		 * an actual @ in the user bit.
		 */
		const char *at = strchr(name, '@');
		if (at != NULL) {
			char buf[128];

			(void) snprintf(buf, sizeof (buf), "%s@%s",
			    di_node_name(dn), daddrstr);
			if (strcmp(name, buf) == 0) {
				return (dn);
			}
		}
	}

	return (DI_NODE_NIL);
}

bool
i2c_path_parse(i2c_hdl_t *hdl, const char *path, di_node_t root, di_node_t *dnp,
    i2c_node_type_t *typep, i2c_err_t err)
{
	di_node_t cur_devi;
	char *dup, *state;
	i2c_node_type_t cur;
	bool ret = false;

	if (path == NULL) {
		return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
		    "invalid I2C path pointer: %p", path));
	}

	dup = strdup(path);
	if (dup == NULL) {
		int e = errno;
		return (i2c_error(hdl, I2C_ERR_NO_MEM, e, "failed to duplicate "
		    "I2C path"));
	}

	cur = I2C_NODE_T_OTHER;
	cur_devi = NULL;
	for (const char *ent = strtok_r(dup, "/", &state); ent != NULL;
	    ent = strtok_r(NULL, "/", &state)) {
		switch (cur) {
		case I2C_NODE_T_OTHER:
			/*
			 * This is our top-level state. We need to find a
			 * controller that matches this name.
			 */
			cur_devi = i2c_path_find_ctrl(root, ent);
			if (cur_devi == DI_NODE_NIL) {
				(void) i2c_error(hdl, err, 0,
				    "failed to find controller %s as part of "
				    "parsing I2C path %s", ent, path);
				goto err;
			}
			cur = I2C_NODE_T_CTRL;
			break;
		case I2C_NODE_T_DEV:
			/*
			 * Today we expect a device to only ever have a single
			 * node under it which is a mux. We walk all the
			 * children and look for this. This is because muxes
			 * aren't named. It's possible someone has created more
			 * than one node, so that's why we don't just go
			 * directly. After we do this, we explicitly fall
			 * through to the controller handling logic, as it has
			 * to do the same class.
			 */
			cur_devi = i2c_path_find_mux(cur_devi);
			if (cur_devi == DI_NODE_NIL) {
				(void) i2c_error(hdl, err, 0,
				    "failed to find mux %s as part of "
				    "parsing I2C path %s", ent, path);
				goto err;
			}
			/* FALLTHROUGH */
		case I2C_NODE_T_CTRL:
			cur_devi = i2c_path_find_port(cur_devi, ent);
			if (cur_devi == DI_NODE_NIL) {
				(void) i2c_error(hdl, err, 0,
				    "failed to find port %s as part of "
				    "parsing I2C path %s", ent, path);
				goto err;
			}
			cur = I2C_NODE_T_PORT;
			break;
		case I2C_NODE_T_PORT:
			cur_devi = i2c_path_find_device(hdl, cur_devi, ent);
			if (cur_devi == DI_NODE_NIL) {
				(void) i2c_error(hdl, err, 0,
				    "failed to find device %s as part of "
				    "parsing I2C path %s", ent, path);
				goto err;
			}
			cur = I2C_NODE_T_DEV;
			break;
		default:
			abort();
		}
	}

	*dnp = cur_devi;
	*typep = cur;
	ret = true;

err:
	free(dup);
	return (ret);
}