// SPDX-License-Identifier: GPL-2.0+
/*
 * Battery monitor driver for the uPI uG3105 battery monitor
 *
 * Note the uG3105 is not a full-featured autonomous fuel-gauge. Instead it is
 * expected to be use in combination with some always on microcontroller reading
 * its coulomb-counter before it can wrap (must be read every 400 seconds!).
 *
 * Since Linux does not monitor coulomb-counter changes while the device
 * is off or suspended, the coulomb counter is not used atm.
 *
 * Possible improvements:
 * 1. Add coulumb counter reading, e.g. something like this:
 * Read + reset coulomb counter every 10 polls (every 300 seconds)
 *
 * if ((chip->poll_count % 10) == 0) {
 *      val = ug3105_read_word(chip->client, UG3105_REG_COULOMB_CNT);
 *      if (val < 0)
 *              goto out;
 *
 *      i2c_smbus_write_byte_data(chip->client, UG3105_REG_CTRL1,
 *                                UG3105_CTRL1_RESET_COULOMB_CNT);
 *
 *      chip->total_coulomb_count += (s16)val;
 *      dev_dbg(&chip->client->dev, "coulomb count %d total %d\n",
 *              (s16)val, chip->total_coulomb_count);
 * }
 *
 * 2. Reset total_coulomb_count val to 0 when the battery is as good as empty
 *    and remember that we did this (and clear the flag for this on susp/resume)
 * 3. When the battery is full check if the flag that we set total_coulomb_count
 *    to when the battery was empty is set. If so we now know the capacity,
 *    not the design, but actual capacity, of the battery
 * 4. Add some mechanism (needs userspace help, or maybe use efivar?) to remember
 *    the actual capacity of the battery over reboots
 * 5. When we know the actual capacity at probe time, add energy_now and
 *    energy_full attributes. Guess boot + resume energy_now value based on ocv
 *    and then use total_coulomb_count to report energy_now over time, resetting
 *    things to adjust for drift when empty/full. This should give more accurate
 *    readings, esp. in the 30-70% range and allow userspace to estimate time
 *    remaining till empty/full
 * 6. Maybe unregister + reregister the psy device when we learn the actual
 *    capacity during run-time ?
 *
 * The above will also require some sort of mwh_per_unit calculation. Testing
 * has shown that an estimated 7404mWh increase of the battery's energy results
 * in a total_coulomb_count increase of 3277 units with a 5 milli-ohm sense R.
 *
 * Copyright (C) 2021 - 2025 Hans de Goede <hansg@kernel.org>
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/mod_devicetable.h>
#include <linux/power_supply.h>

#include "adc-battery-helper.h"

#define UG3105_REG_MODE                                         0x00
#define UG3105_REG_CTRL1                                        0x01
#define UG3105_REG_COULOMB_CNT                                  0x02
#define UG3105_REG_BAT_VOLT                                     0x08
#define UG3105_REG_BAT_CURR                                     0x0c

#define UG3105_MODE_STANDBY                                     0x00
#define UG3105_MODE_RUN                                         0x10

#define UG3105_CTRL1_RESET_COULOMB_CNT                          0x03

struct ug3105_chip {
        /* Must be the first member see adc-battery-helper documentation */
        struct adc_battery_helper helper;
        struct i2c_client *client;
        struct power_supply *psy;
        int uv_per_unit;
        int ua_per_unit;
};

static int ug3105_read_word(struct i2c_client *client, u8 reg)
{
        int val;

        val = i2c_smbus_read_word_data(client, reg);
        if (val < 0)
                dev_err(&client->dev, "Error reading reg 0x%02x\n", reg);

        return val;
}

static int ug3105_get_voltage_and_current_now(struct power_supply *psy, int *volt, int *curr)
{
        struct ug3105_chip *chip = power_supply_get_drvdata(psy);
        int ret;

        ret = ug3105_read_word(chip->client, UG3105_REG_BAT_VOLT);
        if (ret < 0)
                return ret;

        *volt = ret * chip->uv_per_unit;

        ret = ug3105_read_word(chip->client, UG3105_REG_BAT_CURR);
        if (ret < 0)
                return ret;

        *curr = (s16)ret * chip->ua_per_unit;
        return 0;
}

static const struct power_supply_desc ug3105_psy_desc = {
        .name           = "ug3105_battery",
        .type           = POWER_SUPPLY_TYPE_BATTERY,
        .get_property   = adc_battery_helper_get_property,
        .external_power_changed = adc_battery_helper_external_power_changed,
        .properties     = adc_battery_helper_properties,
        .num_properties = ADC_HELPER_NUM_PROPERTIES,
};

static void ug3105_start(struct i2c_client *client)
{
        i2c_smbus_write_byte_data(client, UG3105_REG_MODE, UG3105_MODE_RUN);
        i2c_smbus_write_byte_data(client, UG3105_REG_CTRL1, UG3105_CTRL1_RESET_COULOMB_CNT);
}

static void ug3105_stop(struct i2c_client *client)
{
        i2c_smbus_write_byte_data(client, UG3105_REG_MODE, UG3105_MODE_STANDBY);
}

static int ug3105_probe(struct i2c_client *client)
{
        struct power_supply_config psy_cfg = {};
        struct device *dev = &client->dev;
        u32 curr_sense_res_uohm = 10000;
        struct ug3105_chip *chip;
        int ret;

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

        chip->client = client;

        ug3105_start(client);

        device_property_read_u32(dev, "upisemi,rsns-microohm", &curr_sense_res_uohm);

        /*
         * DAC maximum is 4.5V divided by 65536 steps + an unknown factor of 10
         * coming from somewhere for some reason (verified with a volt-meter).
         */
        chip->uv_per_unit = 45000000 / 65536;
        /* Datasheet says 8.1 uV per unit for the current ADC */
        chip->ua_per_unit = 8100000 / curr_sense_res_uohm;

        psy_cfg.drv_data = chip;
        chip->psy = devm_power_supply_register(dev, &ug3105_psy_desc, &psy_cfg);
        if (IS_ERR(chip->psy)) {
                ret = PTR_ERR(chip->psy);
                goto stop;
        }

        ret = adc_battery_helper_init(&chip->helper, chip->psy,
                                      ug3105_get_voltage_and_current_now, NULL);
        if (ret)
                goto stop;

        i2c_set_clientdata(client, chip);
        return 0;

stop:
        ug3105_stop(client);
        return ret;
}

static int __maybe_unused ug3105_suspend(struct device *dev)
{
        struct ug3105_chip *chip = dev_get_drvdata(dev);

        adc_battery_helper_suspend(dev);
        ug3105_stop(chip->client);
        return 0;
}

static int __maybe_unused ug3105_resume(struct device *dev)
{
        struct ug3105_chip *chip = dev_get_drvdata(dev);

        ug3105_start(chip->client);
        adc_battery_helper_resume(dev);
        return 0;
}

static SIMPLE_DEV_PM_OPS(ug3105_pm_ops, ug3105_suspend,
                        ug3105_resume);

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

static struct i2c_driver ug3105_i2c_driver = {
        .driver = {
                .name = "ug3105",
                .pm = &ug3105_pm_ops,
        },
        .probe = ug3105_probe,
        .remove = ug3105_stop,
        .shutdown = ug3105_stop,
        .id_table = ug3105_id,
};
module_i2c_driver(ug3105_i2c_driver);

MODULE_AUTHOR("Hans de Goede <hansg@kernel.org");
MODULE_DESCRIPTION("uPI uG3105 battery monitor driver");
MODULE_LICENSE("GPL");