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

/*
 * I2C port discovery and initialization.
 */

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "libi2c_impl.h"

void
i2c_port_discover_fini(i2c_port_iter_t *iter)
{
        if (iter == NULL) {
                return;
        }

        free(iter->pi_ports);
        di_fini(iter->pi_root);
        free(iter);
}

i2c_iter_t
i2c_port_discover_step(i2c_port_iter_t *iter, const i2c_port_disc_t **discp)
{
        for (;;) {
                if (iter->pi_curport == iter->pi_nports) {
                        return (I2C_ITER_DONE);
                }

                iter->pi_disc.pd_devi = iter->pi_ports[iter->pi_curport];
                iter->pi_curport++;

                if (!i2c_node_to_path(iter->pi_hdl, iter->pi_disc.pd_devi,
                    iter->pi_disc.pd_path, sizeof (iter->pi_disc.pd_path))) {
                        continue;
                }

                *discp = &iter->pi_disc;
                return (I2C_ITER_VALID);
        }
}

/*
 * We have two nodes that are not the same. They are at the same point in the
 * tree though. We expect all devices at a given layer in the tree to have the
 * same type. We start with the node name and if they're the same fall back to
 * the bus address which must be unique at this point.
 */
static int
i2c_port_sort_node(di_node_t l, di_node_t r)
{
        const char *nl = di_node_name(l);
        const char *nr = di_node_name(r);
        int ret;

        if ((ret = strcmp(nl, nr)) == 0) {
                nl = di_bus_addr(l);
                nr = di_bus_addr(r);
                ret = strcmp(nl, nr);
        }

        return (ret);
}

typedef struct {
        di_node_t ni_ctrl;
        di_node_t ni_parent;
        uint32_t ni_height;
} node_info_t;

static void
i2c_port_sort_info(di_node_t dn, node_info_t *info)
{
        (void) memset(info, 0, sizeof (node_info_t));

        info->ni_parent = di_parent_node(dn);
        for (;;) {
                i2c_node_type_t type = i2c_node_type(dn);

                if (type == I2C_NODE_T_CTRL) {
                        info->ni_ctrl = dn;
                        return;
                }

                info->ni_height++;
                dn = di_parent_node(dn);
                if (dn == DI_NODE_NIL) {
                        return;
                }
        }
}

static int
i2c_port_sort(const void *left, const void *right)
{
        di_node_t l = *(di_node_t *)left;
        di_node_t r = *(di_node_t *)right;
        node_info_t li, ri;

        if (l == r) {
                return (0);
        }

        /*
         * We have two nodes that are different points in the tree. We basically
         * want to ask:
         *
         *  - What controller do they point to?
         *  - What are the relative heights in the tree?
         *
         * If they belong to different controllers, we sort based on the
         * controller's name. If they belong to the same controller, then we use
         * the height in the tree. If they have the same height, we then see if
         * they have the same parent. If they don't, we sort on the parent (like
         * the controller). If they do, we use their name directly.
         */
        i2c_port_sort_info(l, &li);
        i2c_port_sort_info(r, &ri);

        if (li.ni_ctrl != ri.ni_ctrl) {
                return (i2c_port_sort_node(li.ni_ctrl, ri.ni_ctrl));
        }

        if (li.ni_height != ri.ni_height) {
                return (li.ni_height < ri.ni_height ? -1 : 1);
        }

        if (li.ni_parent != ri.ni_parent) {
                return (i2c_port_sort_node(li.ni_parent, ri.ni_parent));
        }

        return (i2c_port_sort_node(l, r));
}
bool
i2c_port_discover_init(i2c_hdl_t *hdl, i2c_port_iter_t **iterp)
{
        i2c_port_iter_t *iter;

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

        iter = calloc(1, sizeof (i2c_port_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_port_iter_t"));
        }

        iter->pi_root = di_init("/", DINFOCPYALL);
        if (iter->pi_root == NULL) {
                int e = errno;
                i2c_port_discover_fini(iter);
                return (i2c_error(hdl, I2C_ERR_LIBDEVINFO, e, "failed to "
                    "initialize devinfo snapshot: %s", strerrordesc_np(e)));
        }
        iter->pi_done = false;

        /*
         * We want port discovery to have a reasonably stable and meaningful
         * order. This is going to be built on top of for devices. We want to
         * treat this in a bit of a depth-search sense. We don't want to do the
         * children of one controller's port, then switch to a different
         * controller, and then come back to say a mux. To facilitate this, note
         * all the ports first, sort them, and then come back to it.
         */
        for (di_node_t dn = di_drv_first_node(I2C_NEX_DRV, iter->pi_root);
            dn != NULL; dn = di_drv_next_node(dn)) {
                if (!i2c_node_is_type(dn, I2C_NODE_T_PORT)) {
                        continue;
                }

                if (iter->pi_nalloc == iter->pi_nports) {
                        di_node_t *new;
                        uint32_t toalloc = iter->pi_nalloc + 16;

                        new = recallocarray(iter->pi_ports, iter->pi_nports,
                            toalloc, sizeof (di_node_t));
                        if (new == NULL) {
                                int e = errno;
                                i2c_port_discover_fini(iter);
                                return (i2c_error(hdl, I2C_ERR_NO_MEM, e,
                                    "failed to allocate memory for a %u "
                                    "element di_node_t array",
                                    toalloc));
                        }
                        iter->pi_ports = new;
                        iter->pi_nalloc = toalloc;
                }

                iter->pi_ports[iter->pi_nports] = dn;
                iter->pi_nports++;
        }

        qsort(iter->pi_ports, iter->pi_nports, sizeof (di_node_t),
            i2c_port_sort);

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

bool
i2c_port_discover(i2c_hdl_t *hdl, i2c_port_disc_f func, void *arg)
{
        i2c_port_iter_t *iter;
        const i2c_port_disc_t *disc;
        i2c_iter_t ret;

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

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

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

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

        return (i2c_success(hdl));
}

di_node_t
i2c_port_disc_devi(const i2c_port_disc_t *disc)
{
        return (disc->pd_devi);
}

const char *
i2c_port_disc_path(const i2c_port_disc_t *disc)
{
        return (disc->pd_path);
}

void
i2c_port_fini(i2c_port_t *port)
{
        if (port == NULL) {
                return;
        }

        if (port->port_fd >= 0) {
                (void) close(port->port_fd);
        }

        di_devfs_path_free(port->port_minor);
        free(port->port_name);
        free(port);
}

bool
i2c_port_init(i2c_hdl_t *hdl, di_node_t di, i2c_port_t **portp)
{
        di_minor_t minor;
        di_node_t parent;
        i2c_node_type_t ptype;

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

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

        /*
         * We've verified that we were given an i2cnex instance, make sure this
         * corresponds to a port.
         */
        if (!i2c_node_is_type(di, I2C_NODE_T_PORT)) {
                return (i2c_error(hdl, I2C_ERR_BAD_DEVI, 0, "devi %s@%s is "
                    "not an i2c port", di_node_name(di), di_bus_addr(di)));
        }

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

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

        port->port_fd = -1;
        port->port_hdl = hdl;
        port->port_inst = di_instance(di);
        port->port_name = strdup(di_bus_addr(di));
        if (port->port_name == NULL) {
                int e = errno;
                i2c_port_fini(port);
                return (i2c_error(hdl, I2C_ERR_NO_MEM, e, "failed to duplicate "
                    "port bus address"));
        }

        parent = di_parent_node(di);
        ptype = i2c_node_type(parent);
        if (ptype == I2C_NODE_T_CTRL) {
                port->port_type = I2C_PORT_TYPE_CTRL;
        } else if (ptype == I2C_NODE_T_MUX) {
                port->port_type = I2C_PORT_TYPE_MUX;
        } else {
                i2c_port_fini(port);
                return (i2c_error(hdl, I2C_ERR_BAD_DEVI, 0, "devi %s@%s is not "
                    "an i2c port: found wrong parent", di_node_name(di),
                    di_bus_addr(di)));
        }

        if (!i2c_node_to_path(hdl, di, port->port_path,
            sizeof (port->port_path))) {
                i2c_port_fini(port);
                return (false);
        }

        port->port_minor = di_devfs_minor_path(minor);
        if (port->port_minor == NULL) {
                int e = errno;
                i2c_port_fini(port);
                return (i2c_error(hdl, I2C_ERR_LIBDEVINFO, e, "failed to "
                    "obtain ports's devfs path: %s", strerrordesc_np(e)));
        }

        port->port_fd = openat(hdl->ih_devfd, port->port_minor + 1, O_RDWR);
        if (port->port_fd < 0) {
                int e = errno;
                (void) i2c_error(hdl, I2C_ERR_OPEN_DEV, e, "failed to open "
                    "device path /devices%s: %s", port->port_minor,
                    strerrordesc_np(e));
                i2c_port_fini(port);
                return (false);
        }

        if (ioctl(port->port_fd, UI2C_IOCTL_PORT_INFO, &port->port_info) != 0) {
                int e = errno;
                i2c_port_fini(port);
                return (i2c_ioctl_syserror(hdl, e, "port information request"));
        }

        if (port->port_info.upo_error.i2c_error != I2C_CORE_E_OK) {
                return (i2c_ioctl_error(hdl, &port->port_info.upo_error,
                    "port information request"));
        }

        *portp = port;
        return (i2c_success(hdl));
}

/*
 * Initialize a port based on the passed in name. This name may be a top-level
 * port for the controller or it may be a port on a mux. We end up walking the
 * path, tokenizing and parsing it to try to find something here.
 */
bool
i2c_port_init_by_path(i2c_hdl_t *hdl, const char *path, i2c_port_t **portp)
{
        i2c_node_type_t type;
        di_node_t dn, root;

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

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

        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_PORT)) {
                di_fini(root);
                return (false);
        }

        if (type != I2C_NODE_T_PORT) {
                di_fini(root);
                return (i2c_error(hdl, I2C_ERR_BAD_PORT, 0, "parsed I2C path "
                    "%s did not end at a port", path));
        }

        bool ret = i2c_port_init(hdl, dn, portp);
        di_fini(root);
        return (ret);
}

const char *
i2c_port_name(i2c_port_t *port)
{
        return (port->port_name);
}

const char *
i2c_port_path(i2c_port_t *port)
{
        return (port->port_path);
}

uint32_t
i2c_port_portno(i2c_port_t *port)
{
        return (port->port_info.upo_portno);
}

i2c_port_type_t
i2c_port_type(i2c_port_t *port)
{
        return (port->port_type);
}

void
i2c_port_map_free(i2c_port_map_t *map)
{
        free(map);
}

bool
i2c_port_map_snap(i2c_port_t *port, i2c_port_map_t **mapp)
{
        i2c_port_map_t *map;
        i2c_hdl_t *hdl = port->port_hdl;

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

        map = calloc(1, sizeof (i2c_port_map_t));
        if (map == NULL) {
                int e = errno;
                return (i2c_error(hdl, I2C_ERR_NO_MEM, e, "failed to allocate "
                    "memory for a new i2c_port_map_t"));
        }
        map->pm_hdl = hdl;

        if (ioctl(port->port_fd, UI2C_IOCTL_PORT_INFO, &map->pm_info) != 0) {
                int e = errno;
                i2c_port_fini(port);
                return (i2c_ioctl_syserror(hdl, e, "port maprmation request"));
        }

        if (map->pm_info.upo_error.i2c_error != I2C_CORE_E_OK) {
                return (i2c_ioctl_error(hdl, &map->pm_info.upo_error,
                    "port information request"));
        }

        *mapp = map;
        return (i2c_success(hdl));
}

void
i2c_port_map_ndevs(const i2c_port_map_t *map, uint32_t *local, uint32_t *ds)
{
        if (local != NULL) {
                *local = map->pm_info.upo_ndevs;
        }

        if (ds != NULL) {
                *ds = map->pm_info.upo_ndevs_ds;
        }
}

bool
i2c_port_map_addr_info(const i2c_port_map_t *map, const i2c_addr_t *addr,
    uint32_t *devsp, bool *dsp, major_t *majorp)
{
        if (!i2c_addr_validate(map->pm_hdl, addr)) {
                return (false);
        }

        if (addr->ia_type != I2C_ADDR_7BIT) {
                (void) i2c_error(map->pm_hdl, I2C_ERR_UNSUP_ADDR_TYPE, 0,
                    "port map information is not available for this address "
                    "type");
                return (false);
        }

        const ui2c_port_addr_info_t *info = &map->pm_info.upo_7b[addr->ia_addr];

        if (devsp != NULL) {
                *devsp = info->pai_ndevs;
        }

        if (dsp != NULL) {
                *dsp = info->pai_downstream;
        }

        if (majorp != NULL) {
                *majorp = info->pai_major;
        }


        return (i2c_success(map->pm_hdl));
}