/*
 * 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 error manipulation and translation.
 */

#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <upanic.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>

#include "libi2c_impl.h"

static void
i2c_error_common(i2c_err_data_t *ep, i2c_err_t err, int32_t sys,
    const char *fmt, va_list ap)
{
        int ret;

        ep->ie_err = err;
        ep->ie_syserr = sys;
        ep->ie_ctrl_err = I2C_CTRL_E_OK;
        ret = vsnprintf(ep->ie_errmsg, sizeof (ep->ie_errmsg), fmt, ap);
        if (ret >= sizeof (ep->ie_errmsg)) {
                ep->ie_errlen = sizeof (ep->ie_errmsg) - 1;
        } else if (ret <= 0) {
                ep->ie_errlen = 0;
                ep->ie_errmsg[0] = '\0';
        } else {
                ep->ie_errlen = (size_t)ret;
        }
}

bool
i2c_error(i2c_hdl_t *hdl, i2c_err_t err, int32_t sys, const char *fmt, ...)
{
        va_list ap;

        va_start(ap, fmt);
        i2c_error_common(&hdl->ih_err, err, sys, fmt, ap);
        va_end(ap);

        return (false);
}

static bool
i2c_success_common(i2c_err_data_t *err)
{
        err->ie_err = I2C_ERR_OK;
        err->ie_syserr = 0;
        err->ie_ctrl_err = I2C_CTRL_E_OK;
        err->ie_errmsg[0] = '\0';
        err->ie_errlen = 0;

        return (true);
}

bool
i2c_success(i2c_hdl_t *hdl)
{
        return (i2c_success_common(&hdl->ih_err));
}

i2c_err_t
i2c_err(i2c_hdl_t *hdl)
{
        return (hdl->ih_err.ie_err);
}

i2c_ctrl_error_t
i2c_ctrl_err(i2c_hdl_t *hdl)
{
        return (hdl->ih_err.ie_ctrl_err);
}

int32_t
i2c_syserr(i2c_hdl_t *hdl)
{
        return (hdl->ih_err.ie_syserr);
}

const char *
i2c_errmsg(i2c_hdl_t *hdl)
{
        return (hdl->ih_err.ie_errmsg);
}

const char *
i2c_errtostr(i2c_hdl_t *hdl, i2c_err_t err)
{
        switch (err) {
        case I2C_ERR_OK:
                return ("I2C_ERR_OK");
        case I2C_ERR_CONTROLLER:
                return ("I2C_ERR_CONTROLLER");
        case I2C_ERR_BAD_PTR:
                return ("I2C_ERR_BAD_PTR");
        case I2C_ERR_NO_MEM:
                return ("I2C_ERR_NO_MEM");
        case I2C_ERR_LIBDEVINFO:
                return ("I2C_ERR_LIBDEVINFO");
        case I2C_ERR_BAD_DEVI:
                return ("I2C_ERR_BAD_DEVI");
        case I2C_ERR_INTERNAL:
                return ("I2C_ERR_INTERNAL");
        case I2C_ERR_PRIVS:
                return ("I2C_ERR_PRIVS");
        case I2C_ERR_OPEN_DEV:
                return ("I2C_ERR_OPEN_DEV");
        case I2C_ERR_BAD_CONTROLLER:
                return ("I2C_ERR_BAD_CONTROLLER");
        case I2C_ERR_BAD_PORT:
                return ("I2C_ERR_BAD_PORT");
        case I2C_ERR_BAD_DEVICE:
                return ("I2C_ERR_BAD_DEVICE");
        case I2C_ERR_BAD_ADDR_TYPE:
                return ("I2C_ERR_BAD_ADDR_TYPE");
        case I2C_ERR_BAD_ADDR:
                return ("I2C_ERR_BAD_ADDR");
        case I2C_ERR_UNSUP_ADDR_TYPE:
                return ("I2C_ERR_UNSUP_ADDR_TYPE");
        case I2C_ERR_ADDR_RSVD:
                return ("I2C_ERR_ADDR_RSVD");
        case I2C_ERR_ADDR_IN_USE:
                return ("I2C_ERR_ADDR_IN_USE");
        case I2C_ERR_ADDR_UNKNOWN:
                return ("I2C_ERR_ADDR_UNKNOWN");
        case I2C_ERR_IO_READ_LEN_RANGE:
                return ("I2C_ERR_IO_READ_LEN_RANGE");
        case I2C_ERR_IO_WRITE_LEN_RANGE:
                return ("I2C_ERR_IO_WRITE_LEN_RANGE");
        case I2C_ERR_IO_REQ_MISSING_FIELDS:
                return ("I2C_ERR_IO_REQ_MISSING_FIELDS");
        case I2C_ERR_IO_REQ_IO_INVALID:
                return ("I2C_ERR_IO_REQ_IO_INVALID");
        case I2C_ERR_CANT_XLATE_IO_REQ:
                return ("I2C_ERR_CANT_XLATE_IO_REQ");
        case I2C_ERR_SMBUS_OP_UNSUP:
                return ("I2C_ERR_SMBUS_OP_UNSUP");
        case I2C_ERR_LOCK_WAIT_SIGNAL:
                return ("I2C_ERR_LOCK_WAIT_SIGNAL");
        case I2C_ERR_LOCK_WOULD_BLOCK:
                return ("I2C_ERR_LOCK_WOULD_BLOCK");
        case I2C_ERR_NO_KERN_MEM:
                return ("I2C_ERR_NO_KERN_MEM");
        case I2C_ERR_BAD_DEV_NAME:
                return ("I2C_ERR_BAD_DEV_NAME");
        case I2C_ERR_COMPAT_LEN_RANGE:
                return ("I2C_ERR_COMPAT_LEN_RANGE");
        case I2C_ERR_ADD_DEV_REQ_MISSING_FIELDS:
                return ("I2C_ERR_ADD_DEV_REQ_MISSING_FIELDS");
        case I2C_ERR_NEXUS:
                return ("I2C_ERR_NEXUS");
        case I2C_ERR_OP_IN_PROGRESS:
                return ("I2C_ERR_OP_IN_PROGRESS");
        case I2C_ERR_PROP_UNSUP:
                return ("I2C_ERR_PROP_UNSUP");
        case I2C_ERR_BAD_PROP:
                return ("I2C_ERR_BAD_PROP");
        case I2C_ERR_SET_PROP_UNSUP:
                return ("I2C_ERR_SET_PROP_UNSUP");
        case I2C_ERR_PROP_READ_ONLY:
                return ("I2C_ERR_PROP_READ_ONLY");
        case I2C_ERR_PROP_BUF_TOO_SMALL:
                return ("I2C_ERR_PROP_BUF_TOO_SMALL");
        case I2C_ERR_PROP_BUF_TOO_BIG:
                return ("I2C_ERR_PROP_BUF_TOO_BIG");
        case I2C_ERR_BAD_PROP_VAL:
                return ("I2C_ERR_BAD_PROP_VAL");
        case I2C_ERR_NO_PROP_DEF_VAL:
                return ("I2C_ERR_NO_PROP_DEF_VAL");
        case I2C_ERR_PROP_TYPE_MISMATCH:
                return ("I2C_ERR_PROP_TYPE_MISMATCH");
        case I2C_ERR_BUF_TOO_SMALL:
                return ("I2C_ERR_BUF_TOO_SMALL");
        default:
                return ("unknown error");
        }
}

const char *
i2c_ctrl_errtostr(i2c_hdl_t *hdl, i2c_ctrl_error_t err)
{
        switch (err) {
        case I2C_CTRL_E_OK:
                return ("I2C_CTRL_E_OK");
        case I2C_CTRL_E_INTERNAL:
                return ("I2C_CTRL_E_INTERNAL");
        case I2C_CTRL_E_DRIVER:
                return ("I2C_CTRL_E_DRIVER");
        case I2C_CTRL_E_UNSUP_CMD:
                return ("I2C_CTRL_E_UNSUP_CMD");
        case I2C_CTRL_E_BUS_BUSY:
                return ("I2C_CTRL_E_BUS_BUSY");
        case I2C_CTRL_E_ADDR_NACK:
                return ("I2C_CTRL_E_ADDR_NACK");
        case I2C_CTRL_E_DATA_NACK:
                return ("I2C_CTRL_E_DATA_NACK");
        case I2C_CTRL_E_NACK:
                return ("I2C_CTRL_E_NACK");
        case I2C_CTRL_E_ARB_LOST:
                return ("I2C_CTRL_E_ARB_LOST");
        case I2C_CTRL_E_BAD_ACK:
                return ("I2C_CTRL_E_BAD_ACK");
        case I2C_CTRL_E_REQ_TO:
                return ("I2C_CTRL_E_REQ_TO");
        case I2C_CTRL_E_BAD_SMBUS_RLEN:
                return ("I2C_CTRL_E_BAD_SMBUS_RLEN");
        case I2C_CTRL_E_SMBUS_CLOCK_LOW:
                return ("I2C_CTRL_E_SMBUS_CLOCK_LOW");
        default:
                return ("unkonwn error");
        }
}

/*
 * Most of our ioctls are designed to give us a semantic error. However, there
 * are cases where we may fail outside of that. We opt to abort on a subset of
 * these that represent gross library programmer error: mainly EBADF and EFAULT.
 * Note, EFAULT generally covers the core ioctl structures and not any
 * additional buffers that are passed in, therefore if this triggers then we
 * have done something terribly wrong.
 */
bool
i2c_ioctl_syserror(i2c_hdl_t *hdl, int err, const char *desc)
{
        switch (err) {
        case EFAULT:
        case EBADF: {
                const char *base = "fatal libi2c internal programming error: "
                    "failed to issue ioctl";
                char msg[1024];
                int ret;
                const char *up;
                size_t ulen;

                ret = snprintf(msg, sizeof (msg), "%s %s: %s (hdl %p)",
                    base, desc, strerror(err), hdl);
                if (ret >= sizeof (msg)) {
                        ulen = sizeof (msg);
                        up = msg;
                } else if (ret <= 0) {
                        up = base;
                        ulen = strlen(base) + 1;
                } else {
                        ulen = (size_t)ret;
                        up = msg;
                }

                upanic(up, ulen);
        }
        case EPERM:
                return (i2c_error(hdl, I2C_ERR_PRIVS, err, "failed to issue %s "
                    "ioctl due to missing privileges", desc));
        default:
                return (i2c_error(hdl, I2C_ERR_INTERNAL, err,
                    "failed to issue %s ioctl due to unexpected system error: "
                    "%s", desc, strerrordesc_np(err)));
        }
}

typedef struct {
        i2c_errno_t kl_kern;
        i2c_err_t kl_lib;
        const char *kl_desc;
} i2c_ktolmap_t;

/*
 * This facilitates mapping kernel errors to user library errors along with a
 * short description. This is ordered based on the order of the kernel ioctls so
 * we can more easily spot missing entries. The description is used to help
 * users understand what happened.
 */
static const i2c_ktolmap_t i2c_ktolmap[] = {
        /*
         * We skip I2C_CORE_E_OK because it not reach here. We also handle the
         * controller error, I2C_CORE_E_CONTROLLER, specifically so it is not
         * translated here
         */
        { I2C_CORE_E_BAD_ADDR_TYPE, I2C_ERR_BAD_ADDR_TYPE, "invalid I2C "
            "address family type" },
        { I2C_CORE_E_BAD_ADDR, I2C_ERR_BAD_ADDR, "invalid I2C address" },
        { I2C_CORE_E_UNSUP_ADDR_TYPE, I2C_ERR_UNSUP_ADDR_TYPE, "address "
            "family not supported by the controller" },
        { I2C_CORE_E_ADDR_RSVD, I2C_ERR_ADDR_RSVD, "I2C address is reserved" },
        { I2C_CORE_E_ADDR_IN_USE, I2C_ERR_ADDR_IN_USE, "I2C addrses is already "
            "used" },
        { I2C_CORE_E_ADDR_REFCNT, I2C_ERR_INTERNAL, "address could not be "
            "assigned due to kernel reference count exhaustion" },
        { I2C_CORE_E_UNKNOWN_ADDR, I2C_ERR_ADDR_UNKNOWN, "I2C address does not "
            "map to a known device" },
        { I2C_CORE_E_CANT_XLATE_REQ, I2C_ERR_CANT_XLATE_IO_REQ, "I/O request "
            "could not be translated to something the controller supports" },
        { I2C_CORE_E_NEED_READ_OR_WRITE, I2C_ERR_IO_REQ_IO_INVALID, "request "
            "requires data to transmit or receive, but neither specified" },
        /*
         * We have purposefully skipped I2C_CORE_E_BAD_I2C_REQ_FLAGS and
         * I2C_CORE_E_BAD_SMBUS_REQ_FLAGS as these are not flags that users are
         * able to set and therefore the only reason these should be wrong is if
         * we screwed something up in the library.
         */
        { I2C_CORE_E_BAD_I2C_REQ_READ_LEN, I2C_ERR_IO_READ_LEN_RANGE, "invalid "
            "receive length" },
        { I2C_CORE_E_BAD_I2C_REQ_WRITE_LEN, I2C_ERR_IO_WRITE_LEN_RANGE,
            "invalid transmit length" },
        { I2C_CORE_E_BAD_SMBUS_READ_LEN, I2C_ERR_IO_READ_LEN_RANGE, "invalid "
            "receive length" },
        { I2C_CORE_E_BAD_SMBUS_WRITE_LEN, I2C_ERR_IO_WRITE_LEN_RANGE,
            "invalid transmit length" },
        { I2C_CORE_E_UNSUP_SMBUS_OP, I2C_ERR_SMBUS_OP_UNSUP, "SMBus operation "
            "unsupported by controller or system" },
        { I2C_CORE_E_LOCK_WOULD_BLOCK, I2C_ERR_LOCK_WOULD_BLOCK, "lock not "
            "available and no blocking allowed" },
        { I2C_CORE_E_LOCK_WAIT_SIGNAL, I2C_ERR_LOCK_WAIT_SIGNAL, "signal "
            "received while blocking" },
        /*
         * We have purposefully skipped the nvlist device related errors,
         * I2C_IOCTL_E_NVL_TOO_BIG, I2C_IOCTL_E_NVL_INVALID,
         * I2C_IOCTL_E_NVL_KEY_MISSING, I2C_IOCTL_E_NVL_KEY_UNKNOWN, and
         * I2C_IOCTL_E_NVL_KEY_BAD_TYPE. These are things that generally only
         * the library can screw up.
         */
        { I2C_IOCTL_E_BAD_USER_DATA, I2C_ERR_BAD_PTR, "the kernel detected an "
            "invalid user buffer while trying to read/write the passed in "
            "buffer" },
        { I2C_IOCTL_E_NO_KERN_MEM, I2C_ERR_NO_KERN_MEM, "the kerenl failed "
            "to allocate memory for this operation" },
        { I2C_IOCTL_E_BAD_DEV_NAME, I2C_ERR_BAD_DEV_NAME, "invalid device "
            "or compatible name" },
        { I2C_IOCTL_E_COMPAT_LEN_RANGE, I2C_ERR_COMPAT_LEN_RANGE, "invalid "
            "compatible string length" },
        { I2C_IOCTL_E_NEXUS, I2C_ERR_NEXUS, "unexpected kernel nexus driver "
            "error" },
        /*
         * We have purposefully skipped I2C_IOCTL_E_NO_BUS_LOCK_NEXUS as there
         * is no way to take an explicit lock in userland right now.
         */
        { I2C_IOCTL_E_IN_PROGRESS, I2C_ERR_OP_IN_PROGRESS, "cannot perform "
            "requested operation, handle already performing one" },
        /*
         * All I2C_CLIENT class errors are skipped as they should not be
         * returned to userland.
         */
        { I2C_PROP_E_UNSUP, I2C_ERR_PROP_UNSUP, "property unsupported by "
            "controller" },
        { I2C_PROP_E_UNKNOWN, I2C_ERR_BAD_PROP, "unknown property" },
        { I2C_PROP_E_READ_ONLY, I2C_ERR_PROP_READ_ONLY, "property is "
            "read-only" },
        { I2C_PROP_E_SMALL_BUF, I2C_ERR_PROP_BUF_TOO_SMALL, "data buffer too "
            "small for property" },
        { I2C_PROP_E_TOO_BIG_BUF, I2C_ERR_PROP_BUF_TOO_BIG, "data buffer too "
            "big for property" },
        /*
         * Indicates that the property value is invalid.
         */
        { I2C_PROP_E_BAD_VAL, I2C_ERR_BAD_PROP, "invalid property value" },
        /*
         * Indicates that the controller doesn't support setting properties.
         */
        { I2C_PROP_E_SET_UNSUP, I2C_ERR_SET_PROP_UNSUP, "controller does not "
            "support setting properties" },
        /*
         * Currently all MUX class errors are skipped as they aren't really
         * expected here.
         */
};

bool
i2c_ioctl_error(i2c_hdl_t *hdl, const i2c_error_t *ioc, const char *desc)
{
        int ret;
        i2c_err_data_t *err = &hdl->ih_err;
        VERIFY3U(ioc->i2c_error, !=, I2C_CORE_E_OK);

        err->ie_syserr = 0;

        if (ioc->i2c_error == I2C_CORE_E_CONTROLLER) {
                const char *code = i2c_ctrl_errtostr(hdl, ioc->i2c_ctrl);

                err->ie_err = I2C_ERR_CONTROLLER;
                err->ie_ctrl_err = ioc->i2c_ctrl;
                ret = snprintf(err->ie_errmsg, sizeof (err->ie_errmsg),
                    "failed to execute %s command: received controller "
                    "error %s (0x%x)", desc, code, ioc->i2c_ctrl);
        } else {
                const i2c_ktolmap_t *map = NULL;
                for (size_t i = 0; i < ARRAY_SIZE(i2c_ktolmap); i++) {
                        if (i2c_ktolmap[i].kl_kern == ioc->i2c_error) {
                                map = &i2c_ktolmap[i];
                                break;
                        }
                }

                if (map != NULL) {
                        err->ie_err = map->kl_lib;
                        ret = snprintf(err->ie_errmsg, sizeof (err->ie_errmsg),
                            "failed to execute %s command: %s", desc,
                            map->kl_desc);
                } else {
                        err->ie_err = I2C_ERR_INTERNAL;
                        ret = snprintf(err->ie_errmsg, sizeof (err->ie_errmsg),
                            "failed to execute %s command: failed to map "
                            "kernel error 0x%x to a known cause", desc,
                            ioc->i2c_error);
                }
        }

        if (ret >= sizeof (err->ie_errmsg)) {
                err->ie_errlen = sizeof (err->ie_errlen) - 1;
        } else if (ret <= 0) {
                err->ie_errlen = 0;
                err->ie_errmsg[0] = '\0';
        } else {
                err->ie_errlen = (size_t)ret;
        }

        return (false);
}

bool
i2c_nvlist_error(i2c_hdl_t *hdl, int ret, const char *desc)
{
        if (ret == 0) {
                return (true);
        }

        if (ret == ENOMEM) {
                return (i2c_error(hdl, I2C_ERR_NO_MEM, ret, "failed to "
                    "allocate memory to %s", desc));
        }

        return (i2c_error(hdl, I2C_ERR_INTERNAL, ret, "unexpected internal "
            "error while trying to %s", desc));
}