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

/*
 * Device addition, removal, and discovery
 */

#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <sys/sysmacros.h>
#include <sys/debug.h>
#include <fcntl.h>

#include "libi2c_impl.h"

void
i2c_device_add_req_fini(i2c_dev_add_req_t *req)
{
        nvlist_free(req->add_nvl);
        free(req);
}

bool
i2c_device_add_req_init(i2c_port_t *port, i2c_dev_add_req_t **reqp)
{
        i2c_hdl_t *hdl = port->port_hdl;
        i2c_dev_add_req_t *req;

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

        req = calloc(1, sizeof (i2c_dev_add_req_t));
        if (req == NULL) {
                int e = errno;
                return (i2c_error(hdl, I2C_ERR_NO_MEM, e, "failed to allocate "
                    "memory for a new i2c_dev_add_req_t"));
        }
        req->add_port = port;
        req->add_need = I2C_DEV_ADD_REQ_FIELD_NAME | I2C_DEV_ADD_REQ_FIELD_ADDR;

        int ret = nvlist_alloc(&req->add_nvl, NV_UNIQUE_NAME, 0);
        if (!i2c_nvlist_error(hdl, ret, "create a nvlist")) {
                free(req);
                return (false);
        }

        *reqp = req;
        return (i2c_success(hdl));
}

bool
i2c_device_add_req_set_addr(i2c_dev_add_req_t *req, const i2c_addr_t *addr)
{
        int ret;
        i2c_hdl_t *hdl = req->add_port->port_hdl;

        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);
        }

        ret = nvlist_add_uint16(req->add_nvl, UI2C_IOCTL_NVL_TYPE,
            addr->ia_type);
        if (!i2c_nvlist_error(hdl, ret, "insert address type")) {
                return (false);
        }

        ret = nvlist_add_uint16(req->add_nvl, UI2C_IOCTL_NVL_ADDR,
            addr->ia_addr);
        if (!i2c_nvlist_error(hdl, ret, "insert address type")) {
                return (false);
        }

        req->add_need &= ~I2C_DEV_ADD_REQ_FIELD_ADDR;
        return (i2c_success(hdl));
}

bool
i2c_device_add_req_set_name(i2c_dev_add_req_t *req, const char *name)
{
        i2c_hdl_t *hdl = req->add_port->port_hdl;

        if (!i2c_name_validate(hdl, name, "name")) {
                return (false);
        }

        int ret = nvlist_add_string(req->add_nvl, UI2C_IOCTL_NVL_NAME, name);
        if (!i2c_nvlist_error(hdl, ret, "insert name string")) {
                return (false);
        }

        req->add_need &= ~I2C_DEV_ADD_REQ_FIELD_NAME;
        return (i2c_success(hdl));
}

bool
i2c_device_add_req_set_compatible(i2c_dev_add_req_t *req, char *const *compat,
    size_t ncompat)
{
        i2c_hdl_t *hdl = req->add_port->port_hdl;

        /*
         * Treat this as a request to clear the optional compatible information.
         */
        if (compat == NULL && ncompat == 0) {
                int ret = nvlist_remove(req->add_nvl, UI2C_IOCTL_NVL_COMPAT,
                    DATA_TYPE_STRING_ARRAY);
                if (ret == 0 || ret == ENOENT) {
                        return (i2c_success(hdl));
                }
                return (i2c_error(hdl, I2C_ERR_INTERNAL, ret, "unexpected "
                    "internal error while trying to clear compatible[]"));
        }

        if (compat == NULL) {
                return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
                    "invalid compatible pointer: %p", compat));
        } else if (ncompat == 0) {
                return (i2c_error(hdl, I2C_ERR_COMPAT_LEN_RANGE, 0, "number "
                    "of compatible entries cannot be zero when given a "
                    "non-NULL pointer (%p)", compat));
        } else if (ncompat > UI2C_IOCTL_NVL_NCOMPAT_MAX) {
                return (i2c_error(hdl, I2C_ERR_COMPAT_LEN_RANGE, 0, "device "
                    "compatible array is too long (%zu), valid range is [1, "
                    "%u]", ncompat, UI2C_IOCTL_NVL_NCOMPAT_MAX));
        }

        for (size_t i = 0; i < ncompat; i++) {
                char desc[64];

                (void) snprintf(desc, sizeof (desc), "compatible[%u]", i);
                if (!i2c_name_validate(hdl, compat[i], desc)) {
                        return (false);
                }
        }

        int ret = nvlist_add_string_array(req->add_nvl, UI2C_IOCTL_NVL_COMPAT,
            compat, ncompat);
        if (!i2c_nvlist_error(hdl, ret, "insert compatible string[]")) {
                return (false);
        }
        return (i2c_success(hdl));
}

bool
i2c_device_add_req_exec(i2c_dev_add_req_t *req)
{
        i2c_hdl_t *hdl = req->add_port->port_hdl;
        size_t pack_size;
        char *pack_buf = NULL;
        int nvl_ret;
        bool ret = false;
        ui2c_dev_add_t dev;

        if (req->add_need != 0) {
                char buf[128];
                bool comma = false;

                buf[0] = '\0';
                if ((req->add_need & I2C_DEV_ADD_REQ_FIELD_ADDR) != 0) {
                        (void) strlcat(buf, "device address", sizeof (buf));
                        comma = true;
                }

                if ((req->add_need & I2C_DEV_ADD_REQ_FIELD_NAME) != 0) {
                        if (comma) {
                                (void) strlcat(buf, ",", sizeof (buf));
                        }
                        (void) strlcat(buf, "name", sizeof (buf));
                        comma = true;
                }

                return (i2c_error(hdl, I2C_ERR_ADD_DEV_REQ_MISSING_FIELDS, 0,
                    "cannot execute add device request due to missing fields: "
                    "%s", buf));
        }

        nvl_ret = nvlist_size(req->add_nvl, &pack_size, NV_ENCODE_NATIVE);
        if (!i2c_nvlist_error(hdl, nvl_ret, "determine packed nvlist size")) {
                goto out;
        }

        pack_buf = malloc(pack_size);
        if (pack_buf == NULL) {
                ret = i2c_error(hdl, I2C_ERR_NO_MEM, errno, "failed to "
                    "allocate %zu bytes for packed request nvlist", pack_size);
                goto out;
        }

        nvl_ret = nvlist_pack(req->add_nvl, &pack_buf, &pack_size,
            NV_ENCODE_NATIVE, 0);
        if (!i2c_nvlist_error(hdl, nvl_ret, "pack request nvlist")) {
                goto out;
        }

        (void) memset(&dev, 0, sizeof (ui2c_dev_add_t));
        dev.uda_nvl = (uintptr_t)pack_buf;
        dev.uda_nvl_len = pack_size;

        if (ioctl(req->add_port->port_fd, UI2C_IOCTL_DEVICE_ADD, &dev) != 0) {
                int e = errno;
                ret = i2c_ioctl_syserror(hdl, e, "add device request");
                goto out;
        }

        if (dev.uda_error.i2c_error != I2C_CORE_E_OK) {
                ret = i2c_ioctl_error(hdl, &dev.uda_error,
                    "add device request");
                goto out;
        }

        ret = i2c_success(hdl);
out:
        free(pack_buf);
        return (ret);
}

bool
i2c_device_rem(i2c_port_t *port, const i2c_addr_t *addr)
{
        ui2c_dev_rem_t rem;
        i2c_hdl_t *hdl = port->port_hdl;

        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);
        }

        (void) memset(&rem, 0, sizeof (ui2c_dev_rem_t));
        rem.udr_addr = *addr;

        if (ioctl(port->port_fd, UI2C_IOCTL_DEVICE_REMOVE, &rem) != 0) {
                int e = errno;
                return (i2c_ioctl_syserror(hdl, e, "remove device request"));
        }

        if (rem.udr_error.i2c_error != I2C_CORE_E_OK) {
                return (i2c_ioctl_error(hdl, &rem.udr_error,
                    "remove device request"));
        }

        return (i2c_success(hdl));
}

void
i2c_device_discover_fini(i2c_dev_iter_t *iter)
{
        if (iter == NULL)
                return;

        i2c_port_discover_fini(iter->di_iter);
        free(iter);
}

/*
 * Fill information about the device's under this single port per the notes in
 * i2c_device_discover_step().
 */
static bool
i2c_device_discover_port(i2c_hdl_t *hdl, dev_port_info_t *dpi)
{
        for (di_minor_t m = di_minor_next(dpi->dpi_port, DI_MINOR_NIL);
            m != DI_MINOR_NIL; m = di_minor_next(dpi->dpi_port, m)) {
                i2c_addr_t addr;

                if (strcmp(di_minor_nodetype(m), DDI_NT_I2C_DEV) != 0)
                        continue;

                if (!i2c_kernel_address_parse(hdl, di_minor_name(m), &addr)) {
                        return (false);
                }

                if (addr.ia_type == I2C_ADDR_7BIT) {
                        dpi->dpi_7b[addr.ia_addr].dmi_minor = m;
                } else {
                        dpi->dpi_10b[addr.ia_addr].dmi_minor = m;
                }
        }

        /*
         * Now go through all of our children and try to map them to something
         * we know.
         */
        for (di_node_t di = di_child_node(dpi->dpi_port); di != DI_NODE_NIL;
            di = di_sibling_node(di)) {
                i2c_addr_t addr;

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

                /*
                 * For the purposes of iteration we order devices by the first
                 * address that they have in their regs[] array. We assume that
                 * this will be the primary one. We will skip cases where we
                 * have a minor but not a devinfo in this list.
                 */
                if (!i2c_reg_to_addr(hdl, di, &addr, 0)) {
                        return (false);
                }

                if (addr.ia_type == I2C_ADDR_7BIT) {
                        dpi->dpi_7b[addr.ia_addr].dmi_node = di;
                } else {
                        dpi->dpi_10b[addr.ia_addr].dmi_node = di;
                }
        }

        return (true);
}

static bool
i2c_device_discover_one(i2c_dev_iter_t *iter, dev_map_info_t *map)
{
        iter->di_disc.idd_map = map;
        iter->di_disc.idd_port = &iter->di_info;
        if (!i2c_node_to_path(iter->di_hdl, map->dmi_node,
            iter->di_disc.idd_path, sizeof (iter->di_disc.idd_path))) {
                return (false);
        }

        return (true);
}

/*
 * Device discovery starts by walking the last of I2C ports. After that we
 * proceed to try to walk all of the immediate children. The port has a list of
 * all of the minors that are I2C devices. So we first gather that up and marry
 * it up to the actual dev_info nodes in the snapshot. The minor node will be
 * created while we're creating the child node and we should only see one if we
 * see the other. By walking the minor node list, this gives us a way to ignore
 * dev info nodes that end up under the port that aren't actually in-band
 * devices (e.g. a non-in-band mux).
 */
i2c_iter_t
i2c_device_discover_step(i2c_dev_iter_t *iter, const i2c_dev_disc_t **discp)
{
        for (;;) {
                /*
                 * First check if we're already done or if we're taking a lap
                 * because we've processed all ports.
                 */
                if (iter->di_done) {
                        return (I2C_ITER_DONE);
                }

                if (iter->di_curport == NULL) {
                        i2c_iter_t iret = i2c_port_discover_step(iter->di_iter,
                            &iter->di_curport);
                        if (iret == I2C_ITER_DONE) {
                                iter->di_done = true;
                                return (I2C_ITER_DONE);
                        } else if (iret != I2C_ITER_VALID) {
                                return (iret);
                        }

                        memset(&iter->di_info, 0, sizeof (dev_port_info_t));
                        iter->di_info.dpi_port =
                            i2c_port_disc_devi(iter->di_curport);
                }

                /*
                 * See if we have minor info for this port yet. If not, we go
                 * and build it.
                 */
                dev_port_info_t *pi = &iter->di_info;
                if (!pi->dpi_scanned) {
                        pi->dpi_scanned = true;
                        if (!i2c_device_discover_port(iter->di_hdl, pi)) {
                                return (I2C_ITER_ERROR);
                        }
                }

                /*
                 * Is this port done, if so move onto the next.
                 */
                if (pi->dpi_7bit_done && pi->dpi_10bit_done) {
                        iter->di_curport = NULL;
                        continue;
                }

                if (!pi->dpi_7bit_done) {
                        while (pi->dpi_curidx < ARRAY_SIZE(pi->dpi_7b)) {
                                dev_map_info_t *map =
                                    &pi->dpi_7b[pi->dpi_curidx];
                                pi->dpi_curidx++;
                                if (map->dmi_minor == DI_MINOR_NIL ||
                                    map->dmi_node == DI_NODE_NIL) {
                                        continue;
                                }

                                if (i2c_device_discover_one(iter, map)) {
                                        *discp = &iter->di_disc;
                                        return (I2C_ITER_VALID);
                                } else {
                                        return (I2C_ITER_ERROR);
                                }
                        }
                        pi->dpi_7bit_done = true;
                        pi->dpi_curidx = 0;
                }


                if (!pi->dpi_10bit_done) {
                        while (pi->dpi_curidx < ARRAY_SIZE(pi->dpi_10b)) {
                                dev_map_info_t *map =
                                    &pi->dpi_10b[pi->dpi_curidx];
                                pi->dpi_curidx++;
                                if (map->dmi_minor == DI_MINOR_NIL ||
                                    map->dmi_node == DI_NODE_NIL) {
                                        continue;
                                }

                                if (i2c_device_discover_one(iter, map)) {
                                        *discp = &iter->di_disc;
                                        return (I2C_ITER_VALID);
                                } else {
                                        return (I2C_ITER_ERROR);
                                }
                        }
                        pi->dpi_10bit_done = true;
                        pi->dpi_curidx = 0;
                }
        }

        return (I2C_ITER_ERROR);
}

bool
i2c_device_discover_init(i2c_hdl_t *hdl, i2c_dev_iter_t **iterp)
{
        i2c_dev_iter_t *iter;

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

        iter = calloc(1, sizeof (i2c_dev_iter_t));
        if (iter == NULL) {
                int e = errno;
                return (i2c_error(hdl, I2C_ERR_NO_MEM, e, "failed to allocate "
                    "memory for a new i2c_dev_iter_t"));
        }

        iter->di_hdl = hdl;
        iter->di_done = false;
        if (!i2c_port_discover_init(hdl, &iter->di_iter)) {
                free(iter);
                return (false);
        }

        *iterp = iter;
        return (i2c_success(hdl));
}

bool
i2c_device_discover(i2c_hdl_t *hdl, i2c_dev_disc_f func, void *arg)
{
        i2c_dev_iter_t *iter;
        const i2c_dev_disc_t *disc;
        i2c_iter_t ret;

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

        if (!i2c_device_discover_init(hdl, &iter)) {
                return (false);
        }

        while ((ret = i2c_device_discover_step(iter, &disc)) ==
            I2C_ITER_VALID) {
                if (!func(hdl, disc, arg))
                        break;
        }

        i2c_device_discover_fini(iter);
        if (ret == I2C_ITER_ERROR) {
                return (false);
        }

        return (i2c_success(hdl));
}

const char *
i2c_device_disc_name(const i2c_dev_disc_t *disc)
{
        return (di_node_name(disc->idd_map->dmi_node));
}

di_node_t
i2c_device_disc_devi(const i2c_dev_disc_t *disc)
{
        return (disc->idd_map->dmi_node);
}

di_minor_t
i2c_device_disc_devctl(const i2c_dev_disc_t *disc)
{
        return (disc->idd_map->dmi_minor);
}

const char *
i2c_device_disc_path(const i2c_dev_disc_t *disc)
{
        return (disc->idd_path);
}

void
i2c_device_info_free(i2c_dev_info_t *info)
{
        free(info->dinfo_name);
        free(info->dinfo_driver);
        free(info->dinfo_addrs);
        di_devfs_path_free(info->dinfo_minor);
        free(info);
}

const char *
i2c_device_info_path(const i2c_dev_info_t *info)
{
        return (info->dinfo_path);
}

const char *
i2c_device_info_name(const i2c_dev_info_t *info)
{
        return (info->dinfo_name);
}

const char *
i2c_device_info_driver(const i2c_dev_info_t *info)
{
        return (info->dinfo_driver);
}

int
i2c_device_info_instance(const i2c_dev_info_t *info)
{
        return (info->dinfo_inst);
}

uint32_t
i2c_device_info_naddrs(const i2c_dev_info_t *info)
{
        return (info->dinfo_naddrs);
}

const i2c_addr_t *
i2c_device_info_addr_primary(const i2c_dev_info_t *info)
{
        return (&info->dinfo_info.udi_primary);
}

const i2c_addr_t *
i2c_device_info_addr(const i2c_dev_info_t *info, uint32_t n)
{
        if (n >= info->dinfo_naddrs) {
                return (NULL);
        }

        return (&info->dinfo_addrs[n]);
}

i2c_addr_source_t
i2c_device_info_addr_source(const i2c_dev_info_t *info, uint32_t n)
{
        if (n >= info->dinfo_naddrs) {
                return (0);
        }

        return (info->dinfo_info.udi_7b[info->dinfo_addrs[n].ia_addr]);
}

bool
i2c_device_info_snap(i2c_hdl_t *hdl, di_node_t dn, i2c_dev_info_t **infop)
{
        di_minor_t minor;
        i2c_dev_info_t *info;

        if (dn == DI_NODE_NIL) {
                return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
                    "invalid di_node_t: %p", dn));
        }

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

        if (!i2c_node_is_type(dn, I2C_NODE_T_DEV)) {
                return (i2c_error(hdl, I2C_ERR_BAD_DEVI, 0, "devi %s@%s is "
                    "not an i2c device", di_node_name(dn), di_bus_addr(dn)));
        }

        minor = i2c_node_minor(dn);
        if (minor == DI_MINOR_NIL) {
                return (i2c_error(hdl, I2C_ERR_BAD_DEVI, 0, "devi %s@%s is "
                    "not an i2c device: failed to find device minor",
                    di_node_name(dn), di_bus_addr(dn)));
        }

        info = calloc(1, sizeof (i2c_dev_info_t));
        info->dinfo_name = strdup(di_node_name(dn));
        if (info->dinfo_name == NULL) {
                int e = errno;
                i2c_device_info_free(info);
                return (i2c_error(hdl, I2C_ERR_NO_MEM, e, "failed to duplicate "
                    "device node name"));
        }

        if (!i2c_node_to_path(hdl, dn, info->dinfo_path,
            sizeof (info->dinfo_path))) {
                i2c_device_info_free(info);
                return (false);
        }

        if (di_driver_name(dn) != NULL) {
                info->dinfo_driver = strdup(di_driver_name(dn));
                if (info->dinfo_driver == NULL) {
                        int e = errno;
                        i2c_device_info_free(info);
                        return (i2c_error(hdl, I2C_ERR_NO_MEM, e, "failed to "
                            "duplicate device driver name"));
                }
        } else {
                info->dinfo_driver = NULL;
        }
        info->dinfo_inst = di_instance(dn);
        info->dinfo_minor = di_devfs_minor_path(minor);
        if (info->dinfo_minor == NULL) {
                int e = errno;
                i2c_device_info_free(info);
                return (i2c_error(hdl, I2C_ERR_LIBDEVINFO, e, "failed to "
                    "obtain devices's devfs path: %s", strerrordesc_np(e)));
        }

        int fd = openat(hdl->ih_devfd, info->dinfo_minor + 1, O_RDONLY);
        if (fd < 0) {
                int e = errno;
                (void) i2c_error(hdl, I2C_ERR_OPEN_DEV, e, "failed to open "
                    "device path /devices%s: %s", info->dinfo_minor,
                    strerrordesc_np(e));
                i2c_device_info_free(info);
                return (false);
        }

        if (ioctl(fd, UI2C_IOCTL_DEV_INFO, &info->dinfo_info) != 0) {
                int e = errno;
                i2c_device_info_free(info);
                return (i2c_ioctl_syserror(hdl, e, "device information "
                    "request"));
        }

        (void) close(fd);
        if (info->dinfo_info.udi_error.i2c_error != I2C_CORE_E_OK) {
                i2c_device_info_free(info);
                return (i2c_ioctl_error(hdl, &info->dinfo_info.udi_error,
                    "device information request"));
        }

        for (uint32_t i = 0; i < ARRAY_SIZE(info->dinfo_info.udi_7b); i++) {
                if (info->dinfo_info.udi_7b[i] != 0) {
                        info->dinfo_naddrs++;
                }
        }

        VERIFY3U(info->dinfo_naddrs, >, 0);
        info->dinfo_addrs = calloc(info->dinfo_naddrs, sizeof (i2c_addr_t));
        if (info->dinfo_addrs == NULL) {
                int e = errno;
                (void) i2c_error(hdl, I2C_ERR_NO_MEM, e, "failed to allocate "
                    "memory for %u I2C addresses", info->dinfo_naddrs);
                i2c_device_info_free(info);
                return (false);
        }

        for (uint32_t i = 0, idx = 0; i < ARRAY_SIZE(info->dinfo_info.udi_7b);
            i++) {
                if (info->dinfo_info.udi_7b[i] != 0) {
                        info->dinfo_addrs[idx].ia_type = I2C_ADDR_7BIT;
                        info->dinfo_addrs[idx].ia_addr = i;
                        idx++;
                }
        }

        *infop = info;
        return (i2c_success(hdl));
}

/*
 * Get information about a device specified by path. In addition, return its
 * port. If nodev_ok is set to true, then our caller is fine with returning
 * success, but without the device information. This would happen if the path
 * ended at a port.
 */
bool
i2c_port_dev_init_by_path(i2c_hdl_t *hdl, const char *path, bool nodev_ok,
    i2c_port_t **portp, i2c_dev_info_t **infop)
{
        i2c_node_type_t type;
        di_node_t dn, root, port_dn, dev_dn;
        if (path == NULL) {
                return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
                    "invalid i2c path: %p", path));
        }

        if (portp == NULL) {
                return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
                    "invalid i2c_port_t output pointer: %p", infop));
        }
        *portp = NULL;

        if (infop == NULL) {
                return (i2c_error(hdl, I2C_ERR_BAD_PTR, 0, "encountered "
                    "invalid i2c_dev_info_t output pointer: %p", infop));
        }
        *infop = NULL;

        root = di_init("/", DINFOCPYALL);
        if (root == DI_NODE_NIL) {
                int e = errno;
                return (i2c_error(hdl, I2C_ERR_LIBDEVINFO, e, "failed to "
                    "initialize devinfo snapshot: %s", strerrordesc_np(e)));
        }

        if (!i2c_path_parse(hdl, path, root, &dn, &type, I2C_ERR_BAD_DEVICE)) {
                di_fini(root);
                return (false);
        }

        switch (type) {
        case I2C_NODE_T_DEV:
                dev_dn = dn;
                port_dn = di_parent_node(dev_dn);
                break;
        case I2C_NODE_T_PORT:
                if (!nodev_ok) {
                        return (i2c_error(hdl, I2C_ERR_BAD_DEVICE, 0, "parsed "
                            "I2C path %s did not end at a device", path));
                }
                dev_dn = DI_NODE_NIL;
                port_dn = dn;
                break;
        default:
                di_fini(root);
                return (i2c_error(hdl, I2C_ERR_BAD_DEVICE, 0, "parsed I2C "
                    "path %s did not end at a device (or port)", path));
        }

        if (!i2c_port_init(hdl, port_dn, portp)) {
                di_fini(root);
                return (false);
        }

        if (dev_dn != DI_NODE_NIL) {
                if (!i2c_device_info_snap(hdl, dev_dn, infop)) {
                        di_fini(root);
                        i2c_port_fini(*portp);
                        return (false);
                }
        }

        return (true);
}