// SPDX-License-Identifier: GPL-2.0-only
/*
 * Maxim Integrated
 * 7-bit, Multi-Channel Sink/Source Current DAC Driver
 * Copyright (C) 2017 Maxim Integrated
 */

#include <linux/array_size.h>
#include <linux/bits.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/time64.h>
#include <linux/types.h>

#include <linux/iio/driver.h>
#include <linux/iio/iio.h>
#include <linux/iio/machine.h>

#define DS4422_MAX_DAC_CHANNELS         2
#define DS4424_MAX_DAC_CHANNELS         4

#define DS4424_DAC_MASK                 GENMASK(6, 0)
#define DS4404_DAC_MASK                 GENMASK(4, 0)
#define DS4424_DAC_SOURCE               BIT(7)

#define DS4424_DAC_ADDR(chan)   ((chan) + 0xf8)

#define DS4424_CHANNEL(chan) { \
        .type = IIO_CURRENT, \
        .indexed = 1, \
        .output = 1, \
        .channel = chan, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
}

#define DS4424_CHANNEL_WITH_SCALE(chan) { \
        .type = IIO_CURRENT, \
        .indexed = 1, \
        .output = 1, \
        .channel = chan, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
                              BIT(IIO_CHAN_INFO_SCALE), \
}

struct ds4424_chip_info {
        const char *name;
        int vref_mV;
        int scale_denom;
        u8 result_mask;
        u8 num_channels;
};

static const struct ds4424_chip_info ds4402_info = {
        .name = "ds4402",
        .vref_mV = 1230,
        .scale_denom = 4,
        .result_mask = DS4404_DAC_MASK,
        .num_channels = DS4422_MAX_DAC_CHANNELS,
};

static const struct ds4424_chip_info ds4404_info = {
        .name = "ds4404",
        .vref_mV = 1230,
        .scale_denom = 4,
        .result_mask = DS4404_DAC_MASK,
        .num_channels = DS4424_MAX_DAC_CHANNELS,
};

static const struct ds4424_chip_info ds4422_info = {
        .name = "ds4422",
        .vref_mV = 976,
        .scale_denom = 16,
        .result_mask = DS4424_DAC_MASK,
        .num_channels = DS4422_MAX_DAC_CHANNELS,
};

static const struct ds4424_chip_info ds4424_info = {
        .name = "ds4424",
        .vref_mV = 976,
        .scale_denom = 16,
        .result_mask = DS4424_DAC_MASK,
        .num_channels = DS4424_MAX_DAC_CHANNELS,
};

struct ds4424_data {
        struct regmap *regmap;
        struct regulator *vcc_reg;
        const struct ds4424_chip_info *chip_info;
        u32 rfs_ohms[DS4424_MAX_DAC_CHANNELS];
        bool has_rfs;
};

static const struct iio_chan_spec ds4424_channels[] = {
        DS4424_CHANNEL(0),
        DS4424_CHANNEL(1),
        DS4424_CHANNEL(2),
        DS4424_CHANNEL(3),
};

static const struct iio_chan_spec ds4424_channels_with_scale[] = {
        DS4424_CHANNEL_WITH_SCALE(0),
        DS4424_CHANNEL_WITH_SCALE(1),
        DS4424_CHANNEL_WITH_SCALE(2),
        DS4424_CHANNEL_WITH_SCALE(3),
};

static const struct regmap_range ds44x2_ranges[] = {
        regmap_reg_range(DS4424_DAC_ADDR(0), DS4424_DAC_ADDR(1)),
};

static const struct regmap_range ds44x4_ranges[] = {
        regmap_reg_range(DS4424_DAC_ADDR(0), DS4424_DAC_ADDR(3)),
};

static const struct regmap_access_table ds44x2_table = {
        .yes_ranges = ds44x2_ranges,
        .n_yes_ranges = ARRAY_SIZE(ds44x2_ranges),
};

static const struct regmap_access_table ds44x4_table = {
        .yes_ranges = ds44x4_ranges,
        .n_yes_ranges = ARRAY_SIZE(ds44x4_ranges),
};

static const struct regmap_config ds44x2_regmap_config = {
        .reg_bits = 8,
        .val_bits = 8,
        .cache_type = REGCACHE_MAPLE,
        .max_register = DS4424_DAC_ADDR(1),
        .rd_table = &ds44x2_table,
        .wr_table = &ds44x2_table,
};

static const struct regmap_config ds44x4_regmap_config = {
        .reg_bits = 8,
        .val_bits = 8,
        .cache_type = REGCACHE_MAPLE,
        .max_register = DS4424_DAC_ADDR(3),
        .rd_table = &ds44x4_table,
        .wr_table = &ds44x4_table,
};

static int ds4424_init_regmap(struct i2c_client *client,
                              struct iio_dev *indio_dev)
{
        struct ds4424_data *data = iio_priv(indio_dev);
        const struct regmap_config *regmap_config;
        u8 vals[DS4424_MAX_DAC_CHANNELS];
        int ret;

        if (indio_dev->num_channels == DS4424_MAX_DAC_CHANNELS)
                regmap_config = &ds44x4_regmap_config;
        else
                regmap_config = &ds44x2_regmap_config;

        data->regmap = devm_regmap_init_i2c(client, regmap_config);
        if (IS_ERR(data->regmap))
                return dev_err_probe(&client->dev, PTR_ERR(data->regmap),
                                     "Failed to init regmap.\n");

        /*
         * Prime the cache with the bootloader's configuration.
         * regmap_bulk_read() will automatically populate the cache with
         * the values read from the hardware.
         */
        ret = regmap_bulk_read(data->regmap, DS4424_DAC_ADDR(0), vals,
                               indio_dev->num_channels);
        if (ret)
                return dev_err_probe(&client->dev, ret,
                                     "Failed to read hardware values\n");

        return 0;
}

static int ds4424_read_raw(struct iio_dev *indio_dev,
                           struct iio_chan_spec const *chan,
                           int *val, int *val2, long mask)
{
        struct ds4424_data *data = iio_priv(indio_dev);
        unsigned int regval;
        int ret;

        switch (mask) {
        case IIO_CHAN_INFO_RAW:
                ret = regmap_read(data->regmap, DS4424_DAC_ADDR(chan->channel),
                                  &regval);
                if (ret < 0) {
                        dev_err_ratelimited(indio_dev->dev.parent,
                                            "Failed to read channel %d: %pe\n",
                                            chan->channel, ERR_PTR(ret));
                        return ret;
                }

                *val = regval & data->chip_info->result_mask;
                if (!(regval & DS4424_DAC_SOURCE))
                        *val = -*val;

                return IIO_VAL_INT;
        case IIO_CHAN_INFO_SCALE:
                if (!data->has_rfs)
                        return -EINVAL;

                /* SCALE is mA/step: mV / Ohm = mA. */
                *val = data->chip_info->vref_mV;
                *val2 = data->rfs_ohms[chan->channel] *
                        data->chip_info->scale_denom;
                return IIO_VAL_FRACTIONAL;

        default:
                return -EINVAL;
        }
}

static int ds4424_write_raw(struct iio_dev *indio_dev,
                             struct iio_chan_spec const *chan,
                             int val, int val2, long mask)
{
        struct ds4424_data *data = iio_priv(indio_dev);
        unsigned int abs_val;

        if (val2 != 0)
                return -EINVAL;

        switch (mask) {
        case IIO_CHAN_INFO_RAW:
                abs_val = abs(val);
                if (abs_val > data->chip_info->result_mask)
                        return -EINVAL;

                /*
                 * Currents exiting the IC (Source) are positive. 0 is a valid
                 * value for no current flow; the direction bit (Source vs Sink)
                 * is treated as don't-care by the hardware at 0.
                 */
                if (val > 0)
                        abs_val |= DS4424_DAC_SOURCE;

                return regmap_write(data->regmap, DS4424_DAC_ADDR(chan->channel),
                                    abs_val);

        default:
                return -EINVAL;
        }
}

static int ds4424_parse_rfs(struct i2c_client *client,
                            struct ds4424_data *data,
                            struct iio_dev *indio_dev)
{
        struct device *dev = &client->dev;
        int count, ret;

        if (!device_property_present(dev, "maxim,rfs-ohms"))
                return 0;

        count = device_property_count_u32(dev, "maxim,rfs-ohms");
        if (count < 0)
                return dev_err_probe(dev, count, "Failed to count maxim,rfs-ohms entries\n");
        if (count != indio_dev->num_channels)
                return dev_err_probe(dev, -EINVAL, "maxim,rfs-ohms must have %u entries\n",
                                     indio_dev->num_channels);

        ret = device_property_read_u32_array(dev, "maxim,rfs-ohms",
                                             data->rfs_ohms,
                                             indio_dev->num_channels);
        if (ret)
                return dev_err_probe(dev, ret, "Failed to read maxim,rfs-ohms property\n");

        for (unsigned int i = 0; i < indio_dev->num_channels; i++) {
                if (!data->rfs_ohms[i])
                        return dev_err_probe(dev, -EINVAL, "maxim,rfs-ohms entry %u is zero\n", i);
        }

        data->has_rfs = true;

        return 0;
}

static int ds4424_suspend(struct device *dev)
{
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct ds4424_data *data = iio_priv(indio_dev);
        u8 zero_buf[DS4424_MAX_DAC_CHANNELS] = { };
        int ret;

        /* Disable all outputs, bypass cache so the '0' isn't saved */
        regcache_cache_bypass(data->regmap, true);
        ret = regmap_bulk_write(data->regmap, DS4424_DAC_ADDR(0),
                                zero_buf, indio_dev->num_channels);
        regcache_cache_bypass(data->regmap, false);
        if (ret) {
                dev_err(dev, "Failed to zero outputs: %pe\n", ERR_PTR(ret));
                return ret;
        }

        regcache_cache_only(data->regmap, true);
        regcache_mark_dirty(data->regmap);

        return 0;
}

static int ds4424_resume(struct device *dev)
{
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct ds4424_data *data = iio_priv(indio_dev);

        regcache_cache_only(data->regmap, false);
        return regcache_sync(data->regmap);
}

static DEFINE_SIMPLE_DEV_PM_OPS(ds4424_pm_ops, ds4424_suspend, ds4424_resume);

static const struct iio_info ds4424_iio_info = {
        .read_raw = ds4424_read_raw,
        .write_raw = ds4424_write_raw,
};

static int ds4424_probe(struct i2c_client *client)
{
        const struct ds4424_chip_info *chip_info;
        struct ds4424_data *data;
        struct iio_dev *indio_dev;
        int ret;

        chip_info = i2c_get_match_data(client);
        if (!chip_info)
                return -ENODEV;

        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
        if (!indio_dev)
                return -ENOMEM;

        data = iio_priv(indio_dev);
        i2c_set_clientdata(client, indio_dev);
        indio_dev->name = chip_info->name;
        data->chip_info = chip_info;

        data->vcc_reg = devm_regulator_get(&client->dev, "vcc");
        if (IS_ERR(data->vcc_reg))
                return dev_err_probe(&client->dev, PTR_ERR(data->vcc_reg),
                                     "Failed to get vcc-supply regulator.\n");

        ret = regulator_enable(data->vcc_reg);
        if (ret < 0) {
                dev_err(&client->dev,
                                "Unable to enable the regulator.\n");
                return ret;
        }

        /*
         * The datasheet does not specify a power-up to I2C ready time.
         * Maintain the existing conservative 1ms delay to ensure the
         * device is ready for communication.
         */
        fsleep(1 * USEC_PER_MSEC);

        indio_dev->num_channels = chip_info->num_channels;
        indio_dev->modes = INDIO_DIRECT_MODE;
        indio_dev->info = &ds4424_iio_info;

        ret = ds4424_init_regmap(client, indio_dev);
        if (ret)
                goto fail;

        ret = ds4424_parse_rfs(client, data, indio_dev);
        if (ret)
                goto fail;

        if (data->has_rfs)
                indio_dev->channels = ds4424_channels_with_scale;
        else
                indio_dev->channels = ds4424_channels;

        ret = iio_device_register(indio_dev);
        if (ret < 0) {
                dev_err(&client->dev,
                                "iio_device_register failed. ret: %d\n", ret);
                goto fail;
        }

        return ret;

fail:
        regulator_disable(data->vcc_reg);
        return ret;
}

static void ds4424_remove(struct i2c_client *client)
{
        struct iio_dev *indio_dev = i2c_get_clientdata(client);
        struct ds4424_data *data = iio_priv(indio_dev);

        iio_device_unregister(indio_dev);
        regulator_disable(data->vcc_reg);
}

static const struct i2c_device_id ds4424_id[] = {
        { .name = "ds4402", .driver_data = (kernel_ulong_t)&ds4402_info },
        { .name = "ds4404", .driver_data = (kernel_ulong_t)&ds4404_info },
        { .name = "ds4422", .driver_data = (kernel_ulong_t)&ds4422_info },
        { .name = "ds4424", .driver_data = (kernel_ulong_t)&ds4424_info },
        { }
};

MODULE_DEVICE_TABLE(i2c, ds4424_id);

static const struct of_device_id ds4424_of_match[] = {
        { .compatible = "maxim,ds4402", .data = &ds4402_info },
        { .compatible = "maxim,ds4404", .data = &ds4404_info },
        { .compatible = "maxim,ds4422", .data = &ds4422_info },
        { .compatible = "maxim,ds4424", .data = &ds4424_info },
        { }
};

MODULE_DEVICE_TABLE(of, ds4424_of_match);

static struct i2c_driver ds4424_driver = {
        .driver = {
                .name   = "ds4424",
                .of_match_table = ds4424_of_match,
                .pm     = pm_sleep_ptr(&ds4424_pm_ops),
        },
        .probe          = ds4424_probe,
        .remove         = ds4424_remove,
        .id_table       = ds4424_id,
};
module_i2c_driver(ds4424_driver);

MODULE_DESCRIPTION("Maxim DS4424 DAC Driver");
MODULE_AUTHOR("Ismail H. Kose <ismail.kose@maximintegrated.com>");
MODULE_AUTHOR("Vishal Sood <vishal.sood@maximintegrated.com>");
MODULE_AUTHOR("David Jung <david.jung@maximintegrated.com>");
MODULE_LICENSE("GPL v2");