// SPDX-License-Identifier: GPL-2.0
/*
 * Driver for ST Microelectronics TSC1641 I2C power monitor
 *
 * 60 V, 16-bit high-precision power monitor with I2C and MIPI I3C interface
 * Datasheet: https://www.st.com/resource/en/datasheet/tsc1641.pdf
 *
 * Copyright (C) 2025 Igor Reznichenko <igor@reznichenko.net>
 */

#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/hwmon.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/sysfs.h>
#include <linux/util_macros.h>

/* I2C registers */
#define TSC1641_CONFIG          0x00
#define TSC1641_SHUNT_VOLTAGE   0x01
#define TSC1641_LOAD_VOLTAGE    0x02
#define TSC1641_POWER           0x03
#define TSC1641_CURRENT         0x04
#define TSC1641_TEMP            0x05
#define TSC1641_MASK            0x06
#define TSC1641_FLAG            0x07
#define TSC1641_RSHUNT          0x08 /* Shunt resistance */
#define TSC1641_SOL             0x09
#define TSC1641_SUL             0x0A
#define TSC1641_LOL             0x0B
#define TSC1641_LUL             0x0C
#define TSC1641_POL             0x0D
#define TSC1641_TOL             0x0E
#define TSC1641_MANUF_ID        0xFE /* 0x0006 */
#define TSC1641_DIE_ID          0xFF /* 0x1000 */
#define TSC1641_MAX_REG         0xFF

#define TSC1641_RSHUNT_DEFAULT  1000   /* 1mOhm */
#define TSC1641_CONFIG_DEFAULT  0x003F /* Default mode and temperature sensor */
#define TSC1641_MASK_DEFAULT    0xFC00 /* Unmask all alerts */

/* Bit mask for conversion time in the configuration register */
#define TSC1641_CONV_TIME_MASK  GENMASK(7, 4)

#define TSC1641_CONV_TIME_DEFAULT       1024
#define TSC1641_MIN_UPDATE_INTERVAL     1024

/* LSB value of different registers */
#define TSC1641_VLOAD_LSB_MVOLT         2
#define TSC1641_POWER_LSB_UWATT         25000
#define TSC1641_VSHUNT_LSB_NVOLT        2500 /* Use nanovolts to make it integer */
#define TSC1641_RSHUNT_LSB_UOHM         10
#define TSC1641_TEMP_LSB_MDEGC          500

/* Limits based on datasheet */
#define TSC1641_RSHUNT_MIN_UOHM         100
#define TSC1641_RSHUNT_MAX_UOHM         655350
#define TSC1641_CURR_ABS_MAX_MAMP       819200 /* Max current at 100uOhm*/

#define TSC1641_ALERT_POL_MASK          BIT(1)
#define TSC1641_ALERT_LATCH_EN_MASK     BIT(0)

/* Flags indicating alerts in TSC1641_FLAG register*/
#define TSC1641_SAT_FLAG                BIT(13)
#define TSC1641_SHUNT_OV_FLAG           BIT(6)
#define TSC1641_SHUNT_UV_FLAG           BIT(5)
#define TSC1641_LOAD_OV_FLAG            BIT(4)
#define TSC1641_LOAD_UV_FLAG            BIT(3)
#define TSC1641_POWER_OVER_FLAG         BIT(2)
#define TSC1641_TEMP_OVER_FLAG          BIT(1)

static bool tsc1641_writeable_reg(struct device *dev, unsigned int reg)
{
        switch (reg) {
        case TSC1641_CONFIG:
        case TSC1641_MASK:
        case TSC1641_RSHUNT:
        case TSC1641_SOL:
        case TSC1641_SUL:
        case TSC1641_LOL:
        case TSC1641_LUL:
        case TSC1641_POL:
        case TSC1641_TOL:
                return true;
        default:
                return false;
        }
}

static bool tsc1641_volatile_reg(struct device *dev, unsigned int reg)
{
        switch (reg) {
        case TSC1641_SHUNT_VOLTAGE:
        case TSC1641_LOAD_VOLTAGE:
        case TSC1641_POWER:
        case TSC1641_CURRENT:
        case TSC1641_TEMP:
        case TSC1641_FLAG:
        case TSC1641_MANUF_ID:
        case TSC1641_DIE_ID:
                return true;
        default:
                return false;
        }
}

static const struct regmap_config tsc1641_regmap_config = {
        .reg_bits = 8,
        .val_bits = 16,
        .use_single_write = true,
        .use_single_read = true,
        .max_register = TSC1641_MAX_REG,
        .cache_type = REGCACHE_MAPLE,
        .volatile_reg = tsc1641_volatile_reg,
        .writeable_reg = tsc1641_writeable_reg,
};

struct tsc1641_data {
        long rshunt_uohm;
        long current_lsb_ua;
        struct regmap *regmap;
};

/*
 * Upper limit due to chip 16-bit shunt register, lower limit to
 * prevent current and power registers overflow
 */
static inline int tsc1641_validate_shunt(u32 val)
{
        if (val < TSC1641_RSHUNT_MIN_UOHM || val > TSC1641_RSHUNT_MAX_UOHM)
                return -EINVAL;
        return 0;
}

static int tsc1641_set_shunt(struct tsc1641_data *data, u32 val)
{
        struct regmap *regmap = data->regmap;
        long rshunt_reg;

        /* RSHUNT register LSB is 10uOhm so need to divide further */
        rshunt_reg = DIV_ROUND_CLOSEST(val, TSC1641_RSHUNT_LSB_UOHM);
        /*
         * Clamp value to the nearest multiple of TSC1641_RSHUNT_LSB_UOHM
         * in case shunt value provided was not a multiple
         */
        data->rshunt_uohm = rshunt_reg * TSC1641_RSHUNT_LSB_UOHM;
        data->current_lsb_ua = DIV_ROUND_CLOSEST(TSC1641_VSHUNT_LSB_NVOLT * 1000,
                                                 data->rshunt_uohm);

        return regmap_write(regmap, TSC1641_RSHUNT, rshunt_reg);
}

/*
 * Conversion times in uS, value in CONFIG[CT3:CT0] corresponds to index in this array
 * See "Table 14. CT3 to CT0: conversion time" in:
 * https://www.st.com/resource/en/datasheet/tsc1641.pdf
 */
static const int tsc1641_conv_times[] = { 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768 };

static int tsc1641_reg_to_upd_interval(u16 config)
{
        int idx = FIELD_GET(TSC1641_CONV_TIME_MASK, config);

        idx = clamp_val(idx, 0, ARRAY_SIZE(tsc1641_conv_times) - 1);
        int conv_time = tsc1641_conv_times[idx];

        /* Don't support sub-millisecond update interval as it's not supported in hwmon */
        conv_time = max(conv_time, TSC1641_MIN_UPDATE_INTERVAL);
        /* Return nearest value in milliseconds */
        return DIV_ROUND_CLOSEST(conv_time, 1000);
}

static u16 tsc1641_upd_interval_to_reg(long interval)
{
        /* Supported interval is 1ms - 33ms */
        interval = clamp_val(interval, 1, 33);

        int conv = interval * 1000;
        int conv_bits = find_closest(conv, tsc1641_conv_times,
                                     ARRAY_SIZE(tsc1641_conv_times));

        return FIELD_PREP(TSC1641_CONV_TIME_MASK, conv_bits);
}

static int tsc1641_chip_write(struct device *dev, u32 attr, long val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);

        switch (attr) {
        case hwmon_chip_update_interval:
                return regmap_update_bits(data->regmap, TSC1641_CONFIG,
                                          TSC1641_CONV_TIME_MASK,
                                          tsc1641_upd_interval_to_reg(val));
        default:
                return -EOPNOTSUPP;
        }
}

static int tsc1641_chip_read(struct device *dev, u32 attr, long *val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        u32 regval;
        int ret;

        switch (attr) {
        case hwmon_chip_update_interval:
                ret = regmap_read(data->regmap, TSC1641_CONFIG, &regval);
                if (ret)
                        return ret;

                *val = tsc1641_reg_to_upd_interval(regval);
                return 0;
        default:
                return -EOPNOTSUPP;
        }
}

static int tsc1641_flag_read(struct regmap *regmap, u32 flag, long *val)
{
        unsigned int regval;
        int ret;

        ret = regmap_read_bypassed(regmap, TSC1641_FLAG, &regval);
        if (ret)
                return ret;

        *val = !!(regval & flag);
        return 0;
}

static int tsc1641_in_read(struct device *dev, u32 attr, long *val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        struct regmap *regmap = data->regmap;
        unsigned int regval;
        int ret, reg;
        long sat_flag;

        switch (attr) {
        case hwmon_in_input:
                reg = TSC1641_LOAD_VOLTAGE;
                break;
        case hwmon_in_min:
                reg = TSC1641_LUL;
                break;
        case hwmon_in_max:
                reg = TSC1641_LOL;
                break;
        case hwmon_in_min_alarm:
                return tsc1641_flag_read(regmap, TSC1641_LOAD_UV_FLAG, val);
        case hwmon_in_max_alarm:
                return tsc1641_flag_read(regmap, TSC1641_LOAD_OV_FLAG, val);
        default:
                return -EOPNOTSUPP;
        }

        ret = regmap_read(regmap, reg, &regval);
        if (ret)
                return ret;

        /* Check if load voltage is out of range */
        if (reg == TSC1641_LOAD_VOLTAGE) {
                /* Register is 15-bit max */
                if (regval & 0x8000)
                        return -ENODATA;

                ret  = tsc1641_flag_read(regmap, TSC1641_SAT_FLAG, &sat_flag);
                if (ret)
                        return ret;
                /* Out of range conditions per datasheet */
                if (sat_flag && (regval == 0x7FFF || !regval))
                        return -ENODATA;
        }

        *val = regval * TSC1641_VLOAD_LSB_MVOLT;
        return 0;
}

/* Chip supports bidirectional (positive or negative) current */
static int tsc1641_curr_read(struct device *dev, u32 attr, long *val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        struct regmap *regmap = data->regmap;
        int regval;
        int ret, reg;
        long sat_flag;

        /* Current limits are the shunt under/over voltage limits */
        switch (attr) {
        case hwmon_curr_input:
                reg = TSC1641_CURRENT;
                break;
        case hwmon_curr_min:
                reg = TSC1641_SUL;
                break;
        case hwmon_curr_max:
                reg = TSC1641_SOL;
                break;
        case hwmon_curr_min_alarm:
                return tsc1641_flag_read(regmap, TSC1641_SHUNT_UV_FLAG, val);
        case hwmon_curr_max_alarm:
                return tsc1641_flag_read(regmap, TSC1641_SHUNT_OV_FLAG, val);
        default:
                return -EOPNOTSUPP;
        }
        /*
         * Current uses shunt voltage, so check if it's out of range.
         * We report current register in sysfs to stay consistent with internal
         * power calculations which use current register values
         */
        if (reg == TSC1641_CURRENT) {
                ret = regmap_read(regmap, TSC1641_SHUNT_VOLTAGE, &regval);
                if (ret)
                        return ret;

                ret = tsc1641_flag_read(regmap, TSC1641_SAT_FLAG, &sat_flag);
                if (ret)
                        return ret;

                if (sat_flag && (regval == 0x7FFF || regval == 0x8000))
                        return -ENODATA;
        }

        ret = regmap_read(regmap, reg, &regval);
        if (ret)
                return ret;

        /* Current in milliamps, signed */
        *val = DIV_ROUND_CLOSEST((s16)regval * data->current_lsb_ua, 1000);
        return 0;
}

static int tsc1641_power_read(struct device *dev, u32 attr, long *val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        struct regmap *regmap = data->regmap;
        unsigned int regval;
        int ret, reg;

        switch (attr) {
        case hwmon_power_input:
                reg = TSC1641_POWER;
                break;
        case hwmon_power_max:
                reg = TSC1641_POL;
                break;
        case hwmon_power_max_alarm:
                return tsc1641_flag_read(regmap, TSC1641_POWER_OVER_FLAG, val);
        default:
                return -EOPNOTSUPP;
        }

        ret = regmap_read(regmap, reg, &regval);
        if (ret)
                return ret;

        *val = regval * TSC1641_POWER_LSB_UWATT;
        return 0;
}

static int tsc1641_temp_read(struct device *dev, u32 attr, long *val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        struct regmap *regmap = data->regmap;
        unsigned int regval;
        int ret, reg;

        switch (attr) {
        case hwmon_temp_input:
                reg = TSC1641_TEMP;
                break;
        case hwmon_temp_max:
                reg = TSC1641_TOL;
                break;
        case hwmon_temp_max_alarm:
                return tsc1641_flag_read(regmap, TSC1641_TEMP_OVER_FLAG, val);
        default:
                return -EOPNOTSUPP;
        }

        ret = regmap_read(regmap, reg, &regval);
        if (ret)
                return ret;

        /* 0x8000 means that TEMP measurement not enabled */
        if (reg == TSC1641_TEMP && regval == 0x8000)
                return -ENODATA;

        /* Both temperature and limit registers are signed */
        *val = (s16)regval * TSC1641_TEMP_LSB_MDEGC;
        return 0;
}

static int tsc1641_in_write(struct device *dev, u32 attr, long val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        struct regmap *regmap = data->regmap;
        unsigned int regval;
        int reg;

        switch (attr) {
        case hwmon_in_min:
                reg = TSC1641_LUL;
                break;
        case hwmon_in_max:
                reg = TSC1641_LOL;
                break;
        default:
                return -EOPNOTSUPP;
        }
        /* Clamp to full register range */
        val = clamp_val(val, 0, TSC1641_VLOAD_LSB_MVOLT * USHRT_MAX);
        regval = DIV_ROUND_CLOSEST(val, TSC1641_VLOAD_LSB_MVOLT);

        return regmap_write(regmap, reg, regval);
}

static int tsc1641_curr_write(struct device *dev, u32 attr, long val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        struct regmap *regmap = data->regmap;
        int reg, regval;

        switch (attr) {
        case hwmon_curr_min:
                reg = TSC1641_SUL;
                break;
        case hwmon_curr_max:
                reg = TSC1641_SOL;
                break;
        default:
                return -EOPNOTSUPP;
        }

        /* Clamp to prevent over/underflow below */
        val = clamp_val(val, -TSC1641_CURR_ABS_MAX_MAMP, TSC1641_CURR_ABS_MAX_MAMP);
        /* Convert val in milliamps to register */
        regval = DIV_ROUND_CLOSEST(val * 1000, data->current_lsb_ua);
        /*
         * Prevent signed 16-bit overflow.
         * Integer arithmetic and shunt scaling can quantize values near 0x7FFF/0x8000,
         * so reading and writing back may not preserve the exact original register value.
         */
        regval = clamp_val(regval, SHRT_MIN, SHRT_MAX);
        /* SUL and SOL registers are signed */
        return regmap_write(regmap, reg, regval & 0xFFFF);
}

static int tsc1641_power_write(struct device *dev, u32 attr, long val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        struct regmap *regmap = data->regmap;
        unsigned int regval;

        switch (attr) {
        case hwmon_power_max:
                /* Clamp to full register range */
                val = clamp_val(val, 0, TSC1641_POWER_LSB_UWATT * USHRT_MAX);
                regval = DIV_ROUND_CLOSEST(val, TSC1641_POWER_LSB_UWATT);
                return regmap_write(regmap, TSC1641_POL, regval);
        default:
                return -EOPNOTSUPP;
        }
}

static int tsc1641_temp_write(struct device *dev, u32 attr, long val)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        struct regmap *regmap = data->regmap;
        int regval;

        switch (attr) {
        case hwmon_temp_max:
                /* Clamp to full register range */
                val = clamp_val(val, TSC1641_TEMP_LSB_MDEGC * SHRT_MIN,
                                TSC1641_TEMP_LSB_MDEGC * SHRT_MAX);
                regval = DIV_ROUND_CLOSEST(val, TSC1641_TEMP_LSB_MDEGC);
                /* TOL register is signed */
                return regmap_write(regmap, TSC1641_TOL, regval & 0xFFFF);
        default:
                return -EOPNOTSUPP;
        }
}

static umode_t tsc1641_is_visible(const void *data, enum hwmon_sensor_types type,
                                  u32 attr, int channel)
{
        switch (type) {
        case hwmon_chip:
                switch (attr) {
                case hwmon_chip_update_interval:
                        return 0644;
                default:
                        break;
                }
                break;
        case hwmon_in:
                switch (attr) {
                case hwmon_in_input:
                        return 0444;
                case hwmon_in_min:
                case hwmon_in_max:
                        return 0644;
                case hwmon_in_min_alarm:
                case hwmon_in_max_alarm:
                        return 0444;
                default:
                        break;
                }
                break;
        case hwmon_curr:
                switch (attr) {
                case hwmon_curr_input:
                        return 0444;
                case hwmon_curr_min:
                case hwmon_curr_max:
                        return 0644;
                case hwmon_curr_min_alarm:
                case hwmon_curr_max_alarm:
                        return 0444;
                default:
                        break;
                }
                break;
        case hwmon_power:
                switch (attr) {
                case hwmon_power_input:
                        return 0444;
                case hwmon_power_max:
                        return 0644;
                case hwmon_power_max_alarm:
                        return 0444;
                default:
                        break;
                }
                break;
        case hwmon_temp:
                switch (attr) {
                case hwmon_temp_input:
                        return 0444;
                case hwmon_temp_max:
                        return 0644;
                case hwmon_temp_max_alarm:
                        return 0444;
                default:
                        break;
                }
                break;
        default:
                break;
        }
        return 0;
}

static int tsc1641_read(struct device *dev, enum hwmon_sensor_types type,
                        u32 attr, int channel, long *val)
{
        switch (type) {
        case hwmon_chip:
                return tsc1641_chip_read(dev, attr, val);
        case hwmon_in:
                return tsc1641_in_read(dev, attr, val);
        case hwmon_curr:
                return tsc1641_curr_read(dev, attr, val);
        case hwmon_power:
                return tsc1641_power_read(dev, attr, val);
        case hwmon_temp:
                return tsc1641_temp_read(dev, attr, val);
        default:
                return -EOPNOTSUPP;
        }
}

static int tsc1641_write(struct device *dev, enum hwmon_sensor_types type,
                         u32 attr, int channel, long val)
{
        switch (type) {
        case hwmon_chip:
                return tsc1641_chip_write(dev, attr, val);
        case hwmon_in:
                return tsc1641_in_write(dev, attr, val);
        case hwmon_curr:
                return tsc1641_curr_write(dev, attr, val);
        case hwmon_power:
                return tsc1641_power_write(dev, attr, val);
        case hwmon_temp:
                return tsc1641_temp_write(dev, attr, val);
        default:
                return -EOPNOTSUPP;
        }
}

static const struct hwmon_channel_info * const tsc1641_info[] = {
        HWMON_CHANNEL_INFO(chip,
                           HWMON_C_UPDATE_INTERVAL),
        HWMON_CHANNEL_INFO(in,
                           HWMON_I_INPUT | HWMON_I_MAX | HWMON_I_MAX_ALARM |
                           HWMON_I_MIN | HWMON_I_MIN_ALARM),
        HWMON_CHANNEL_INFO(curr,
                           HWMON_C_INPUT | HWMON_C_MAX | HWMON_C_MAX_ALARM |
                           HWMON_C_MIN | HWMON_C_MIN_ALARM),
        HWMON_CHANNEL_INFO(power,
                           HWMON_P_INPUT | HWMON_P_MAX | HWMON_P_MAX_ALARM),
        HWMON_CHANNEL_INFO(temp,
                           HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_ALARM),
        NULL
};

static ssize_t shunt_resistor_show(struct device *dev,
                                   struct device_attribute *da, char *buf)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);

        return sysfs_emit(buf, "%li\n", data->rshunt_uohm);
}

static ssize_t shunt_resistor_store(struct device *dev,
                                    struct device_attribute *da,
                                    const char *buf, size_t count)
{
        struct tsc1641_data *data = dev_get_drvdata(dev);
        unsigned int val;
        int ret;

        ret = kstrtouint(buf, 10, &val);
        if (ret < 0)
                return ret;

        ret = tsc1641_validate_shunt(val);
        if (ret < 0)
                return ret;

        ret = tsc1641_set_shunt(data, val);
        if (ret < 0)
                return ret;
        return count;
}

static const struct hwmon_ops tsc1641_hwmon_ops = {
        .is_visible = tsc1641_is_visible,
        .read = tsc1641_read,
        .write = tsc1641_write,
};

static const struct hwmon_chip_info tsc1641_chip_info = {
        .ops = &tsc1641_hwmon_ops,
        .info = tsc1641_info,
};

static DEVICE_ATTR_RW(shunt_resistor);

/* Shunt resistor value is exposed via sysfs attribute */
static struct attribute *tsc1641_attrs[] = {
        &dev_attr_shunt_resistor.attr,
        NULL,
};
ATTRIBUTE_GROUPS(tsc1641);

static int tsc1641_init(struct device *dev, struct tsc1641_data *data)
{
        struct regmap *regmap = data->regmap;
        bool active_high;
        u32 shunt;
        int ret;

        if (device_property_read_u32(dev, "shunt-resistor-micro-ohms", &shunt) < 0)
                shunt = TSC1641_RSHUNT_DEFAULT;

        if (tsc1641_validate_shunt(shunt) < 0) {
                dev_err(dev, "invalid shunt resistor value %u\n", shunt);
                return -EINVAL;
        }

        ret = tsc1641_set_shunt(data, shunt);
        if (ret < 0)
                return ret;

        ret = regmap_write(regmap, TSC1641_CONFIG, TSC1641_CONFIG_DEFAULT);
        if (ret < 0)
                return ret;

        active_high = device_property_read_bool(dev, "st,alert-polarity-active-high");

        return regmap_write(regmap, TSC1641_MASK, TSC1641_MASK_DEFAULT |
                            FIELD_PREP(TSC1641_ALERT_POL_MASK, active_high));
}

static int tsc1641_probe(struct i2c_client *client)
{
        struct device *dev = &client->dev;
        struct tsc1641_data *data;
        struct device *hwmon_dev;
        int ret;

        data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;

        data->regmap = devm_regmap_init_i2c(client, &tsc1641_regmap_config);
        if (IS_ERR(data->regmap))
                return dev_err_probe(dev, PTR_ERR(data->regmap),
                                     "failed to allocate register map\n");

        ret = tsc1641_init(dev, data);
        if (ret < 0)
                return dev_err_probe(dev, ret, "failed to configure device\n");

        hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
                                                         data, &tsc1641_chip_info, tsc1641_groups);
        if (IS_ERR(hwmon_dev))
                return PTR_ERR(hwmon_dev);

        dev_info(dev, "power monitor %s (Rshunt = %li uOhm)\n",
                 client->name, data->rshunt_uohm);

        return 0;
}

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

static const struct of_device_id __maybe_unused tsc1641_of_match[] = {
        { .compatible = "st,tsc1641" },
        { },
};
MODULE_DEVICE_TABLE(of, tsc1641_of_match);

static struct i2c_driver tsc1641_driver = {
        .driver = {
                .name = "tsc1641",
                .of_match_table = of_match_ptr(tsc1641_of_match),
        },
        .probe = tsc1641_probe,
        .id_table = tsc1641_id,
};

module_i2c_driver(tsc1641_driver);

MODULE_AUTHOR("Igor Reznichenko <igor@reznichenko.net>");
MODULE_DESCRIPTION("tsc1641 driver");
MODULE_LICENSE("GPL");