// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Hardware monitoring driver for ina233
 *
 * Copyright (c) 2025 Leo Yang
 */

#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include "pmbus.h"

#define MFR_READ_VSHUNT 0xd1
#define MFR_CALIBRATION 0xd4

#define INA233_MAX_CURRENT_DEFAULT      32768000 /* uA */
#define INA233_RSHUNT_DEFAULT           2000 /* uOhm */

#define MAX_M_VAL 32767

static void calculate_coef(int *m, int *R, u32 current_lsb, int power_coef)
{
        u64 scaled_m;
        int scale_factor = 0;
        int scale_coef = 1;

        /*
         * 1000000 from Current_LSB A->uA .
         * scale_coef is for scaling up to minimize rounding errors,
         * If there is no decimal information, no need to scale.
         */
        if (1000000 % current_lsb) {
                /* Scaling to keep integer precision */
                scale_factor = -3;
                scale_coef = 1000;
        }

        /*
         * Unit Conversion (Current_LSB A->uA) and use scaling(scale_factor)
         * to keep integer precision.
         * Formulae referenced from spec.
         */
        scaled_m = div64_u64(1000000 * scale_coef, (u64)current_lsb * power_coef);

        /* Maximize while keeping it bounded.*/
        while (scaled_m > MAX_M_VAL) {
                scaled_m = div_u64(scaled_m, 10);
                scale_factor++;
        }
        /* Scale up only if fractional part exists. */
        while (scaled_m * 10 < MAX_M_VAL && scale_coef != 1) {
                scaled_m *= 10;
                scale_factor--;
        }

        *m = scaled_m;
        *R = scale_factor;
}

static int ina233_read_word_data(struct i2c_client *client, int page,
                                 int phase, int reg)
{
        int ret;

        switch (reg) {
        case PMBUS_VIRT_READ_VMON:
                ret = pmbus_read_word_data(client, 0, 0xff, MFR_READ_VSHUNT);
                if (ret < 0)
                        return ret;

                /* Adjust returned value to match VIN coefficients */
                /* VIN: 1.25 mV VSHUNT: 2.5 uV LSB */
                ret = clamp_val(DIV_ROUND_CLOSEST((s16)ret * 25, 12500),
                                S16_MIN, S16_MAX) & 0xffff;
                break;
        default:
                ret = -ENODATA;
                break;
        }
        return ret;
}

static int ina233_probe(struct i2c_client *client)
{
        struct device *dev = &client->dev;
        int ret, m, R;
        u32 rshunt;
        u32 max_current;
        u32 current_lsb;
        u16 calibration;
        struct pmbus_driver_info *info;

        info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info),
                            GFP_KERNEL);
        if (!info)
                return -ENOMEM;

        info->pages = 1;
        info->format[PSC_VOLTAGE_IN] = direct;
        info->format[PSC_VOLTAGE_OUT] = direct;
        info->format[PSC_CURRENT_OUT] = direct;
        info->format[PSC_POWER] = direct;
        info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_INPUT
                | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
                | PMBUS_HAVE_POUT
                | PMBUS_HAVE_VMON | PMBUS_HAVE_STATUS_VMON;
        info->m[PSC_VOLTAGE_IN] = 8;
        info->R[PSC_VOLTAGE_IN] = 2;
        info->m[PSC_VOLTAGE_OUT] = 8;
        info->R[PSC_VOLTAGE_OUT] = 2;
        info->read_word_data = ina233_read_word_data;

        /* If INA233 skips current/power, shunt-resistor and current-lsb aren't needed. */
        /* read rshunt value (uOhm) */
        ret = device_property_read_u32(dev, "shunt-resistor", &rshunt);
        if (ret) {
                if (ret != -EINVAL)
                        return dev_err_probe(dev, ret, "Shunt resistor property read fail.\n");
                rshunt = INA233_RSHUNT_DEFAULT;
        }
        if (!rshunt)
                return dev_err_probe(dev, -EINVAL,
                                     "Shunt resistor cannot be zero.\n");

        /* read Maximum expected current value (uA) */
        ret = device_property_read_u32(dev, "ti,maximum-expected-current-microamp", &max_current);
        if (ret) {
                if (ret != -EINVAL)
                        return dev_err_probe(dev, ret,
                                             "Maximum expected current property read fail.\n");
                max_current = INA233_MAX_CURRENT_DEFAULT;
        }
        if (max_current < 32768)
                return dev_err_probe(dev, -EINVAL,
                                     "Maximum expected current cannot less then 32768.\n");

        /* Calculate Current_LSB according to the spec formula */
        current_lsb = max_current / 32768;

        /* calculate current coefficient */
        calculate_coef(&m, &R, current_lsb, 1);
        info->m[PSC_CURRENT_OUT] = m;
        info->R[PSC_CURRENT_OUT] = R;

        /* calculate power coefficient */
        calculate_coef(&m, &R, current_lsb, 25);
        info->m[PSC_POWER] = m;
        info->R[PSC_POWER] = R;

        /* write MFR_CALIBRATION register, Apply formula from spec with unit scaling. */
        calibration = div64_u64(5120000000ULL, (u64)rshunt * current_lsb);
        if (calibration > 0x7FFF)
                return dev_err_probe(dev, -EINVAL,
                                     "Product of Current_LSB %u and shunt resistor %u too small, MFR_CALIBRATION reg exceeds 0x7FFF.\n",
                                     current_lsb, rshunt);
        ret = i2c_smbus_write_word_data(client, MFR_CALIBRATION, calibration);
        if (ret < 0)
                return dev_err_probe(dev, ret, "Unable to write calibration.\n");

        dev_dbg(dev, "power monitor %s (Rshunt = %u uOhm, Current_LSB = %u uA/bit)\n",
                client->name, rshunt, current_lsb);

        return pmbus_do_probe(client, info);
}

static const struct i2c_device_id ina233_id[] = {
        {"ina233", 0},
        {}
};
MODULE_DEVICE_TABLE(i2c, ina233_id);

static const struct of_device_id __maybe_unused ina233_of_match[] = {
        { .compatible = "ti,ina233" },
        {}
};
MODULE_DEVICE_TABLE(of, ina233_of_match);

static struct i2c_driver ina233_driver = {
        .driver = {
                   .name = "ina233",
                   .of_match_table = of_match_ptr(ina233_of_match),
        },
        .probe = ina233_probe,
        .id_table = ina233_id,
};

module_i2c_driver(ina233_driver);

MODULE_AUTHOR("Leo Yang <leo.yang.sy0@gmail.com>");
MODULE_DESCRIPTION("PMBus driver for INA233 and compatible chips");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("PMBUS");