// SPDX-License-Identifier: GPL-2.0-only
//
// SGMicro SGM3804 regulator Driver
//
// Copyright (C) 2025 Kancy Joe <kancy2333@outlook.com>
// Copyright (C) 2026 Linaro Limited
// Author: Neil Armstrong <neil.armstrong@linaro.org>

#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/of_regulator.h>
#include <linux/gpio/consumer.h>

#define SGM3804_POS_RAIL_VOLTAGE_REG    0x0
#define SGM3804_NEG_RAIL_VOLTAGE_REG    0x1
#define SGM3804_RAIL_DISCHARGE_REG      0x3

#define RAIL_VOLTAGE_MASK       GENMASK(5, 0)

#define POS_RAIL_DISCHARGE_EN   BIT(1)
#define NEG_RAIL_DISCHARGE_EN   BIT(0)

#define RAIL_VOLTAGE_INVALID            RAIL_VOLTAGE_MASK
#define RAIL_DISCHARGE_REG_DEFAULT      (POS_RAIL_DISCHARGE_EN | NEG_RAIL_DISCHARGE_EN)

#define SGM3804_VOLTAGES_MAX_SELECTOR   0x2f

enum {
        SGM3804_POS_RAIL = 0,
        SGM3804_NEG_RAIL,
        SGM3804_RAIL_COUNT,
};

/*
 * The registers are only writable when the gpio is enabled, so
 * we need to use the cache for read operations and set the regmap
 * as cache_only when both GPIOs are down.
 */
struct sgm3804_data {
        struct regmap *regmap;
        /* Protects the regcache state update */
        struct mutex lock;
        struct gpio_desc *gpios[SGM3804_RAIL_COUNT];
};

static const struct linear_range sgm3804_voltages[] = {
        REGULATOR_LINEAR_RANGE(2400000, 0x20, 0x2f, 100000),
        REGULATOR_LINEAR_RANGE(4000000, 0x00, 0x17, 100000),
};

/*
 * The cache is populated with those hardware default values
 * so the regmap_update_bits operation will use the cached
 * value to build a new register value and write it when GPIOs
 * are enabled.
 */
static const struct reg_default sgm3804_reg_defaults[] = {
        { SGM3804_POS_RAIL_VOLTAGE_REG, RAIL_VOLTAGE_INVALID },
        { SGM3804_NEG_RAIL_VOLTAGE_REG, RAIL_VOLTAGE_INVALID },
        { SGM3804_RAIL_DISCHARGE_REG, RAIL_DISCHARGE_REG_DEFAULT },
};

/* Registers are only writable */
static bool sgm3804_writeable_reg(struct device *dev, unsigned int reg)
{
        switch (reg) {
        case SGM3804_POS_RAIL_VOLTAGE_REG:
        case SGM3804_NEG_RAIL_VOLTAGE_REG:
        case SGM3804_RAIL_DISCHARGE_REG:
                return true;
        default:
                return false;
        }
}

/*
 * Since all registers are only writeable, regmap will only read from the cache data.
 */
static bool sgm3804_readable_reg(struct device *dev, unsigned int reg)
{
        return false;
}

static const struct regmap_config sgm3804_regmap_config = {
        .reg_bits = 8,
        .val_bits = 8,
        .max_register = 0x03,
        .writeable_reg = sgm3804_writeable_reg,
        .readable_reg = sgm3804_readable_reg,
        .cache_type = REGCACHE_MAPLE,
        .reg_defaults = sgm3804_reg_defaults,
        .num_reg_defaults = ARRAY_SIZE(sgm3804_reg_defaults),
};

static int sgm3804_sync_regcache_state(struct sgm3804_data *ctx)
{
        guard(mutex)(&ctx->lock);

        /* If both GPIOs are down, IC is powered down and I2C writes will fail */
        if (!gpiod_get_value_cansleep(ctx->gpios[SGM3804_POS_RAIL]) &&
            !gpiod_get_value_cansleep(ctx->gpios[SGM3804_NEG_RAIL])) {
                regcache_cache_only(ctx->regmap, true);
                regcache_mark_dirty(ctx->regmap);
        } else {
                int ret;

                /* At least a GPIO is up, we can write registers */
                regcache_cache_only(ctx->regmap, false);
                ret = regcache_sync(ctx->regmap);
                if (ret) {
                        regcache_cache_only(ctx->regmap, true);
                        return ret;
                }
        }

        return 0;
}

static int sgm3804_get_voltage_sel(struct regulator_dev *rdev)
{
        int ret;

        ret = regulator_get_voltage_sel_regmap(rdev);
        if (ret < 0)
                return ret;

        /* Force setting a voltage on probe */
        if (ret == RAIL_VOLTAGE_INVALID)
                return -ENOTRECOVERABLE;

        return ret;
}

static int sgm3804_enable(struct regulator_dev *rdev)
{
        struct sgm3804_data *ctx = rdev->reg_data;
        int ret;

        ret = gpiod_set_value_cansleep(ctx->gpios[rdev_get_id(rdev)], 1);
        if (ret)
                return ret;

        ret = sgm3804_sync_regcache_state(ctx);
        if (ret)
                goto err;

        return 0;

err:
        gpiod_set_value_cansleep(ctx->gpios[rdev_get_id(rdev)], 0);
        return ret;
}

static int sgm3804_disable(struct regulator_dev *rdev)
{
        struct sgm3804_data *ctx = rdev->reg_data;
        int ret;

        ret = gpiod_set_value_cansleep(ctx->gpios[rdev_get_id(rdev)], 0);
        if (ret)
                return ret;

        return sgm3804_sync_regcache_state(ctx);
}

static int sgm3804_is_enabled(struct regulator_dev *rdev)
{
        struct sgm3804_data *ctx = rdev->reg_data;

        return gpiod_get_value_cansleep(ctx->gpios[rdev_get_id(rdev)]);
}

static const struct regulator_ops sgm3804_ops = {
        .list_voltage = regulator_list_voltage_linear_range,
        .map_voltage = regulator_map_voltage_linear_range,
        .set_voltage_sel = regulator_set_voltage_sel_regmap,
        .get_voltage_sel = sgm3804_get_voltage_sel,
        .set_active_discharge = regulator_set_active_discharge_regmap,
        .enable = sgm3804_enable,
        .disable = sgm3804_disable,
        .is_enabled = sgm3804_is_enabled,
};

static const struct regulator_desc sgm3804_regulator_desc[] = {
        /* Positive Output */
        {
                .name = "pos",
                .of_match = "pos",
                .supply_name = "vin",
                .id = SGM3804_POS_RAIL,
                .ops = &sgm3804_ops,
                .type = REGULATOR_VOLTAGE,
                .linear_ranges = sgm3804_voltages,
                .n_linear_ranges = ARRAY_SIZE(sgm3804_voltages),
                .n_voltages = SGM3804_VOLTAGES_MAX_SELECTOR + 1,
                .vsel_reg = SGM3804_POS_RAIL_VOLTAGE_REG,
                .vsel_mask = RAIL_VOLTAGE_MASK,
                .active_discharge_on = POS_RAIL_DISCHARGE_EN,
                .active_discharge_mask = POS_RAIL_DISCHARGE_EN,
                .active_discharge_reg = SGM3804_RAIL_DISCHARGE_REG,
                .enable_time = 40000,
                .owner = THIS_MODULE,
        },
        /* Negative Output */
        {
                .name = "neg",
                .of_match = "neg",
                .supply_name = "vin",
                .id = SGM3804_NEG_RAIL,
                .ops = &sgm3804_ops,
                .type = REGULATOR_VOLTAGE,
                .linear_ranges = sgm3804_voltages,
                .n_linear_ranges = ARRAY_SIZE(sgm3804_voltages),
                .n_voltages = SGM3804_VOLTAGES_MAX_SELECTOR + 1,
                .vsel_reg = SGM3804_NEG_RAIL_VOLTAGE_REG,
                .vsel_mask = RAIL_VOLTAGE_MASK,
                .active_discharge_on = NEG_RAIL_DISCHARGE_EN,
                .active_discharge_mask = NEG_RAIL_DISCHARGE_EN,
                .active_discharge_reg = SGM3804_RAIL_DISCHARGE_REG,
                .enable_time = 40000,
                .owner = THIS_MODULE,
        },
};

static int sgm3804_probe(struct i2c_client *i2c)
{
        struct device *dev = &i2c->dev;
        struct sgm3804_data *ctx;
        int ret, i;

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

        mutex_init(&ctx->lock);

        ctx->regmap = devm_regmap_init_i2c(i2c, &sgm3804_regmap_config);
        if (IS_ERR(ctx->regmap))
                return dev_err_probe(dev, PTR_ERR(ctx->regmap),
                                     "failed to init regmap\n");

        /* Get enable GPIOs */
        for (i = 0; i < ARRAY_SIZE(sgm3804_regulator_desc); i++) {
                const struct regulator_desc *reg = &sgm3804_regulator_desc[i];
                struct fwnode_handle *child;

                child = device_get_named_child_node(dev, reg->of_match);
                if (!child) {
                        dev_err(dev, "missing child '%s'\n", reg->of_match);
                        return -EINVAL;
                }

                ctx->gpios[i] = devm_fwnode_gpiod_get(dev, child, "enable",
                                                      GPIOD_ASIS, reg->name);
                fwnode_handle_put(child);
                if (IS_ERR(ctx->gpios[i]))
                        return dev_err_probe(dev, PTR_ERR(ctx->gpios[i]),
                                             "failed to get '%s' enable GPIO\n",
                                             reg->name);
        }

        ret = sgm3804_sync_regcache_state(ctx);
        if (ret)
                return ret;

        for (i = 0; i < ARRAY_SIZE(sgm3804_regulator_desc); i++) {
                struct regulator_config config = { };
                struct regulator_dev *rdev;

                config.dev = dev;
                config.regmap = ctx->regmap;
                config.of_node = dev_of_node(dev);
                config.driver_data = ctx;
                rdev = devm_regulator_register(dev, &sgm3804_regulator_desc[i],
                                               &config);
                if (IS_ERR(rdev))
                        return dev_err_probe(dev, PTR_ERR(rdev),
                                             "failed to register regulator %d\n", i);
        }

        return 0;
}

static const struct i2c_device_id sgm3804_id[] = {
        { "sgm3804" },
        { }
};
MODULE_DEVICE_TABLE(i2c, sgm3804_id);

static const struct of_device_id sgm3804_of_match[] = {
        { .compatible = "sgmicro,sgm3804" },
        { }
};
MODULE_DEVICE_TABLE(of, sgm3804_of_match);

static struct i2c_driver sgm3804_regulator_driver = {
        .driver = {
                .name = "sgm3804",
                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = sgm3804_of_match,
        },
        .probe = sgm3804_probe,
        .id_table = sgm3804_id,
};

module_i2c_driver(sgm3804_regulator_driver);

MODULE_DESCRIPTION("SGMicro SGM3804 regulator Driver");
MODULE_AUTHOR("Kancy Joe <kancy2333@outlook.com>");
MODULE_AUTHOR("Neil Armstrong <neil.armstrong@linaro.org>");
MODULE_LICENSE("GPL");