/*
 * 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 Controller related functions.
 */

#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_ctrl_discover_fini(i2c_ctrl_iter_t *iter)
{
        if (iter == NULL)
                return;

        di_fini(iter->ci_root);
        free(iter);
}

i2c_iter_t
i2c_ctrl_discover_step(i2c_ctrl_iter_t *iter, const i2c_ctrl_disc_t **discp)
{
        *discp = NULL;

        if (iter->ci_done) {
                return (I2C_ITER_DONE);
        }

        for (;;) {
                if (iter->ci_cur == DI_NODE_NIL) {
                        iter->ci_cur = di_drv_first_node(I2C_NEX_DRV,
                            iter->ci_root);
                } else {
                        iter->ci_cur = di_drv_next_node(iter->ci_cur);
                }

                if (iter->ci_cur == DI_NODE_NIL) {
                        iter->ci_done = true;
                        return (I2C_ITER_DONE);
                }

                if (!i2c_node_is_type(iter->ci_cur, I2C_NODE_T_CTRL)) {
                        continue;
                }

                iter->ci_disc.icd_devi = iter->ci_cur;
                iter->ci_disc.icd_minor = i2c_node_minor(iter->ci_cur);
                if (iter->ci_disc.icd_minor == DI_MINOR_NIL) {
                        continue;
                }

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

        return (I2C_ITER_DONE);
}

bool
i2c_ctrl_discover_init(i2c_hdl_t *hdl, i2c_ctrl_iter_t **iterp)
{
        i2c_ctrl_iter_t *iter;

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

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

        iter->ci_hdl = hdl;
        iter->ci_root = di_init("/", DINFOCPYALL);
        if (iter->ci_root == NULL) {
                int e = errno;
                i2c_ctrl_discover_fini(iter);
                return (i2c_error(hdl, I2C_ERR_LIBDEVINFO, e, "failed to "
                    "initialize devinfo snapshot: %s", strerrordesc_np(e)));
        }
        iter->ci_done = false;
        iter->ci_cur = DI_NODE_NIL;

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

bool
i2c_ctrl_discover(i2c_hdl_t *hdl, i2c_ctrl_disc_f func, void *arg)
{
        i2c_ctrl_iter_t *iter;
        const i2c_ctrl_disc_t *disc;
        i2c_iter_t ret;

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

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

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

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

        return (i2c_success(hdl));
}

di_node_t
i2c_ctrl_disc_devi(const i2c_ctrl_disc_t *discp)
{
        return (discp->icd_devi);
}

di_minor_t
i2c_ctrl_disc_minor(const i2c_ctrl_disc_t *discp)
{
        return (discp->icd_minor);
}

void
i2c_ctrl_fini(i2c_ctrl_t *ctrl)
{
        if (ctrl == NULL) {
                return;
        }

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

        di_devfs_path_free(ctrl->ctrl_minor);
        di_devfs_path_free(ctrl->ctrl_path);
        free(ctrl->ctrl_name);
        free(ctrl);
}

bool
i2c_ctrl_init(i2c_hdl_t *hdl, di_node_t di, i2c_ctrl_t **ctrlp)
{
        di_minor_t minor;
        i2c_ctrl_t *ctrl;
        ui2c_ctrl_nprops_t nprops;

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

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

        if (!i2c_node_is_type(di, I2C_NODE_T_CTRL)) {
                return (i2c_error(hdl, I2C_ERR_BAD_DEVI, 0, "devi %s@%s isn't "
                    "an i2c controller", di_node_name(di), di_bus_addr(di)));
        }

        /*
         * See if we can find a minor node that corresponds to a controller
         * nexus.
         */
        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 controller: failed to find controller minor",
                    di_node_name(di), di_bus_addr(di)));
        }

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

        ctrl->ctrl_fd = -1;
        ctrl->ctrl_hdl = hdl;
        ctrl->ctrl_inst = di_instance(di);
        ctrl->ctrl_name = strdup(di_bus_addr(di));
        if (ctrl->ctrl_name == NULL) {
                int e = errno;
                i2c_ctrl_fini(ctrl);
                return (i2c_error(hdl, I2C_ERR_NO_MEM, e, "failed to duplicate "
                    "controller bus address"));
        }

        ctrl->ctrl_path = di_devfs_path(di);
        if (ctrl->ctrl_path == NULL) {
                int e = errno;
                i2c_ctrl_fini(ctrl);
                return (i2c_error(hdl, I2C_ERR_LIBDEVINFO, e, "failed to "
                    "obtain controller's devfs path: %s", strerrordesc_np(e)));
        }

        ctrl->ctrl_minor = di_devfs_minor_path(minor);
        if (ctrl->ctrl_minor == NULL) {
                int e = errno;
                i2c_ctrl_fini(ctrl);
                return (i2c_error(hdl, I2C_ERR_LIBDEVINFO, e, "failed to "
                    "obtain controller's minor path: %s", strerrordesc_np(e)));
        }

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

        if (ioctl(ctrl->ctrl_fd, UI2C_IOCTL_CTRL_NPROPS, &nprops) != 0) {
                int e = errno;
                i2c_ctrl_fini(ctrl);
                return (i2c_ioctl_syserror(hdl, e, "controller nprops "
                    "request"));
        }
        ctrl->ctrl_nstd = nprops.ucp_nstd;
        ctrl->ctrl_npriv = nprops.ucp_npriv;

        *ctrlp = ctrl;
        return (i2c_success(hdl));
}

bool
i2c_ctrl_init_by_path(i2c_hdl_t *hdl, const char *name, i2c_ctrl_t **ctrlp)
{
        i2c_node_type_t type;
        di_node_t dn, root;

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

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

        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, name, root, &dn, &type,
            I2C_ERR_BAD_CONTROLLER)) {
                di_fini(root);
                return (false);
        }

        if (type != I2C_NODE_T_CTRL) {
                di_fini(root);
                return (i2c_error(hdl, I2C_ERR_BAD_CONTROLLER, 0, "parsed I2C "
                    "path %s did not end at a controller", name));
        }

        bool ret = i2c_ctrl_init(hdl, dn, ctrlp);
        di_fini(root);
        return (ret);
}

const char *
i2c_ctrl_name(i2c_ctrl_t *ctrl)
{
        return (ctrl->ctrl_name);
}

int32_t
i2c_ctrl_instance(i2c_ctrl_t *ctrl)
{
        return (ctrl->ctrl_inst);
}

const char *
i2c_ctrl_path(i2c_ctrl_t *ctrl)
{
        return (ctrl->ctrl_path);
}

uint32_t
i2c_ctrl_nprops(i2c_ctrl_t *ctrl)
{
        /*
         * Currently we only have standard properties. If we have
         * controller-specific properties in the future then those should be
         * added to this.
         */
        return (ctrl->ctrl_nstd);
}

const char *
i2c_prop_info_name(i2c_prop_info_t *info)
{
        return (info->pinfo_info.upi_name);
}

i2c_prop_t
i2c_prop_info_id(i2c_prop_info_t *info)
{
        return (info->pinfo_info.upi_prop);
}

i2c_prop_type_t
i2c_prop_info_type(i2c_prop_info_t *info)
{
        return (info->pinfo_info.upi_type);
}

bool
i2c_prop_info_sup(i2c_prop_info_t *info)
{
        return (info->pinfo_sup);
}

i2c_prop_perm_t
i2c_prop_info_perm(i2c_prop_info_t *info)
{
        return (info->pinfo_info.upi_perm);
}

bool
i2c_prop_info_def_u32(i2c_prop_info_t *info, uint32_t *defp)
{
        i2c_hdl_t *hdl = info->pinfo_hdl;

        if (defp == NULL) {

        }

        if (!info->pinfo_sup) {
                return (i2c_error(hdl, I2C_ERR_PROP_UNSUP, 0, "default value "
                    "is unavailable because property %s is not supported by "
                    "the controller", info->pinfo_info.upi_name));
        }

        switch (info->pinfo_info.upi_type) {
        case I2C_PROP_TYPE_U32:
        case I2C_PROP_TYPE_BIT32:
                if (info->pinfo_info.upi_def_len != sizeof (uint32_t)) {
                        return (i2c_error(hdl, I2C_ERR_PROP_TYPE_MISMATCH, 0,
                            "property %s does not have a default value",
                            info->pinfo_info.upi_name));
                }
                (void) memcpy(defp, info->pinfo_info.upi_def,
                    sizeof (uint32_t));
                break;
        default:
                return (i2c_error(hdl, I2C_ERR_PROP_TYPE_MISMATCH, 0,
                    "property %s default value does not have a 32-bit "
                    "integer type (found type 0x%x)", info->pinfo_info.upi_name,
                    info->pinfo_info.upi_type));
                break;
        }

        return (i2c_success(hdl));
}

const i2c_prop_range_t *
i2c_prop_info_pos(i2c_prop_info_t *info)
{
        if (!info->pinfo_sup || info->pinfo_info.upi_pos_len <
            sizeof (i2c_prop_range_t)) {
                return (NULL);
        }

        return ((i2c_prop_range_t *)info->pinfo_info.upi_pos);
}

void
i2c_prop_info_free(i2c_prop_info_t *info)
{
        free(info);
}

bool
i2c_prop_info(i2c_ctrl_t *ctrl, i2c_prop_t prop, i2c_prop_info_t **infop)
{
        i2c_hdl_t *hdl = ctrl->ctrl_hdl;
        i2c_prop_info_t *info;

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

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

        info->pinfo_info.upi_prop = prop;
        if (ioctl(ctrl->ctrl_fd, UI2C_IOCTL_CTRL_PROP_INFO,
            &info->pinfo_info) != 0) {
                int e = errno;
                return (i2c_ioctl_syserror(hdl, e, "property info request"));
        }

        i2c_error_t *err = &info->pinfo_info.upi_error;
        if (err->i2c_error != I2C_CORE_E_OK &&
            err->i2c_error != I2C_PROP_E_UNSUP) {
                free(info);
                return (i2c_ioctl_error(hdl, err, "property info request"));
        }

        info->pinfo_hdl = hdl;
        info->pinfo_sup = err->i2c_error == I2C_CORE_E_OK;
        *infop = info;
        return (i2c_success(hdl));
}

/*
 * Find the property that maps to name the max power way. Basically iterate over
 * all known properties and see if the name matches.
 */
bool
i2c_prop_info_by_name(i2c_ctrl_t *ctrl, const char *name,
    i2c_prop_info_t **infop)
{
        i2c_hdl_t *hdl = ctrl->ctrl_hdl;
        i2c_prop_info_t *info;

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

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

        for (uint32_t i = 0; i < ctrl->ctrl_nstd; i++) {
                if (!i2c_prop_info(ctrl, i, &info)) {
                        return (false);
                }

                if (strcmp(name, i2c_prop_info_name(info)) == 0) {
                        *infop = info;
                        return (i2c_success(hdl));
                }

                i2c_prop_info_free(info);
        }

        return (i2c_error(hdl, I2C_ERR_BAD_PROP, 0, "unkonwn property: %s",
            name));
}

bool
i2c_prop_get(i2c_ctrl_t *ctrl, i2c_prop_t id, void *buf, size_t *lenp)
{
        i2c_hdl_t *hdl = ctrl->ctrl_hdl;
        ui2c_prop_t prop;

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

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

        (void) memset(&prop, 0, sizeof (ui2c_prop_t));
        prop.up_prop = id;

        if (ioctl(ctrl->ctrl_fd, UI2C_IOCTL_CTRL_PROP_GET, &prop) != 0) {
                int e = errno;
                return (i2c_ioctl_syserror(hdl, e, "property get request"));
        }

        if (prop.up_error.i2c_error != I2C_CORE_E_OK) {
                return (i2c_ioctl_error(hdl, &prop.up_error,
                    "property get request"));
        }

        size_t orig = *lenp;
        *lenp = prop.up_size;
        if (orig < prop.up_size) {
                return (i2c_error(hdl, I2C_ERR_PROP_BUF_TOO_SMALL, 0,
                    "property requires %u bytes to hold data, but only passed "
                    "a buffer of %zu bytes", prop.up_size, orig));
        }

        (void) memcpy(buf, prop.up_value, prop.up_size);
        return (i2c_success(hdl));
}

bool
i2c_prop_set(i2c_ctrl_t *ctrl, i2c_prop_t id, const void *buf, size_t len)
{
        i2c_hdl_t *hdl = ctrl->ctrl_hdl;
        ui2c_prop_t prop;

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

        if (len == 0) {
                return (i2c_error(hdl, I2C_ERR_PROP_BUF_TOO_SMALL, 0,
                    "property buffer length must be more than 0"));
        }

        if (len > I2C_PROP_SIZE_MAX) {
                return (i2c_error(hdl, I2C_ERR_PROP_BUF_TOO_BIG, 0,
                    "property buffer length must be less than or equal to %u",
                    I2C_PROP_SIZE_MAX));
        }

        (void) memset(&prop, 0, sizeof (ui2c_prop_t));
        prop.up_prop = id;
        prop.up_size = len;
        (void) memcpy(&prop.up_value, buf, len);

        if (ioctl(ctrl->ctrl_fd, UI2C_IOCTL_CTRL_PROP_SET, &prop) != 0) {
                int e = errno;
                return (i2c_ioctl_syserror(hdl, e, "property set request"));
        }

        if (prop.up_error.i2c_error != I2C_CORE_E_OK) {
                return (i2c_ioctl_error(hdl, &prop.up_error,
                    "property set request"));
        }

        return (i2c_success(hdl));
}