// SPDX-License-Identifier: GPL-2.0-only
/*
 * Driver for the Infineon TLV493D Low-Power 3D Magnetic Sensor
 *
 * Copyright (C) 2025 Dixit Parmar <dixitparmar19@gmail.com>
 */

#include <linux/array_size.h>
#include <linux/bits.h>
#include <linux/bitfield.h>
#include <linux/cleanup.h>
#include <linux/delay.h>
#include <linux/dev_printk.h>
#include <linux/i2c.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/pm.h>
#include <linux/pm_runtime.h>
#include <linux/regulator/consumer.h>
#include <linux/types.h>
#include <linux/units.h>

#include <linux/iio/buffer.h>
#include <linux/iio/iio.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>

/*
 * TLV493D sensor I2C communication note:
 *
 * The sensor supports only direct byte-stream write starting from the
 * register address 0x0. So for any modification to be made to any write
 * registers, it must be written starting from the register address  0x0.
 * I2C write operation should not contain the register address in the I2C
 * frame, it should contain only raw byte stream for the write registers.
 * I2C Frame: |S|SlaveAddr Wr|Ack|Byte[0]|Ack|Byte[1]|Ack|.....|Sp|
 *
 * Same as the write operation, reading from the sensor registers is also
 * performed starting from the register address 0x0 for as many bytes as
 * need to be read.
 * I2C read operation should not contain the register address in the I2C frame.
 * I2C Frame: |S|SlaveAddr Rd|Ack|Byte[0]|Ack|Byte[1]|Ack|.....|Sp|
 */

#define TLV493D_RD_REG_BX       0x00
#define TLV493D_RD_REG_BY       0x01
#define TLV493D_RD_REG_BZ       0x02
#define TLV493D_RD_REG_TEMP     0x03
#define TLV493D_RD_REG_BX2      0x04
#define TLV493D_RD_REG_BZ2      0x05
#define TLV493D_RD_REG_TEMP2    0x06
#define TLV493D_RD_REG_RES1     0x07
#define TLV493D_RD_REG_RES2     0x08
#define TLV493D_RD_REG_RES3     0x09
#define TLV493D_RD_REG_MAX      0x0a

#define TLV493D_WR_REG_MODE1    0x01
#define TLV493D_WR_REG_MODE2    0x03
#define TLV493D_WR_REG_MAX      0x04

#define TLV493D_BX_MAG_X_AXIS_MSB       GENMASK(7, 0)
#define TLV493D_BX2_MAG_X_AXIS_LSB      GENMASK(7, 4)
#define TLV493D_BY_MAG_Y_AXIS_MSB       GENMASK(7, 0)
#define TLV493D_BX2_MAG_Y_AXIS_LSB      GENMASK(3, 0)
#define TLV493D_BZ_MAG_Z_AXIS_MSB       GENMASK(7, 0)
#define TLV493D_BZ2_MAG_Z_AXIS_LSB      GENMASK(3, 0)
#define TLV493D_TEMP_TEMP_MSB           GENMASK(7, 4)
#define TLV493D_TEMP2_TEMP_LSB          GENMASK(7, 0)
#define TLV493D_TEMP_CHANNEL            GENMASK(1, 0)
#define TLV493D_MODE1_MOD_LOWFAST       GENMASK(1, 0)
#define TLV493D_MODE2_LP_PERIOD BIT(6)
#define TLV493D_RD_REG_RES1_WR_MASK     GENMASK(4, 3)
#define TLV493D_RD_REG_RES2_WR_MASK     GENMASK(7, 0)
#define TLV493D_RD_REG_RES3_WR_MASK     GENMASK(4, 0)

enum tlv493d_channels {
        TLV493D_AXIS_X,
        TLV493D_AXIS_Y,
        TLV493D_AXIS_Z,
        TLV493D_TEMPERATURE,
};

enum tlv493d_op_mode {
        TLV493D_OP_MODE_POWERDOWN,
        TLV493D_OP_MODE_FAST,
        TLV493D_OP_MODE_LOWPOWER,
        TLV493D_OP_MODE_ULTRA_LOWPOWER,
        TLV493D_OP_MODE_MASTERCONTROLLED,
};

struct tlv493d_data {
        struct i2c_client *client;
        /* protects from simultaneous sensor access and register readings */
        struct mutex lock;
        enum tlv493d_op_mode mode;
        u8 wr_regs[TLV493D_WR_REG_MAX];
};

/*
 * Different mode has different measurement sampling time, this time is
 * used in deriving the sleep and timeout while reading the data from
 * sensor in polling.
 * Power-down mode: No measurement.
 * Fast mode: Freq:3.3 KHz. Measurement time:305 usec.
 * Low-power mode: Freq:100 Hz. Measurement time:10 msec.
 * Ultra low-power mode: Freq:10 Hz. Measurement time:100 msec.
 * Master controlled mode: Freq:3.3 Khz. Measurement time:305 usec.
 */
static const u32 tlv493d_sample_rate_us[] = {
        [TLV493D_OP_MODE_POWERDOWN] = 0,
        [TLV493D_OP_MODE_FAST] = 305,
        [TLV493D_OP_MODE_LOWPOWER] = 10 * USEC_PER_MSEC,
        [TLV493D_OP_MODE_ULTRA_LOWPOWER] = 100 * USEC_PER_MSEC,
        [TLV493D_OP_MODE_MASTERCONTROLLED] = 305,
};

static int tlv493d_write_all_regs(struct tlv493d_data *data)
{
        int ret;
        struct device *dev = &data->client->dev;

        ret = i2c_master_send(data->client, data->wr_regs, ARRAY_SIZE(data->wr_regs));
        if (ret < 0) {
                dev_err(dev, "i2c write registers failed, error: %d\n", ret);
                return ret;
        }

        return 0;
}

static int tlv493d_set_operating_mode(struct tlv493d_data *data, enum tlv493d_op_mode mode)
{
        u8 *mode1_cfg = &data->wr_regs[TLV493D_WR_REG_MODE1];
        u8 *mode2_cfg = &data->wr_regs[TLV493D_WR_REG_MODE2];

        switch (mode) {
        case TLV493D_OP_MODE_POWERDOWN:
                FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 0);
                FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 0);
                break;

        case TLV493D_OP_MODE_FAST:
                FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 1);
                FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 0);
                break;

        case TLV493D_OP_MODE_LOWPOWER:
                FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 2);
                FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 1);
                break;

        case TLV493D_OP_MODE_ULTRA_LOWPOWER:
                FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 2);
                FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 0);
                break;

        case TLV493D_OP_MODE_MASTERCONTROLLED:
                FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 3);
                FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 0);
                break;
        }

        return tlv493d_write_all_regs(data);
}

static s16 tlv493d_get_channel_data(u8 *b, enum tlv493d_channels ch)
{
        u16 val;

        switch (ch) {
        case TLV493D_AXIS_X:
                val = FIELD_GET(TLV493D_BX_MAG_X_AXIS_MSB, b[TLV493D_RD_REG_BX]) << 4 |
                      FIELD_GET(TLV493D_BX2_MAG_X_AXIS_LSB, b[TLV493D_RD_REG_BX2]);
                break;
        case TLV493D_AXIS_Y:
                val = FIELD_GET(TLV493D_BY_MAG_Y_AXIS_MSB, b[TLV493D_RD_REG_BY]) << 4 |
                      FIELD_GET(TLV493D_BX2_MAG_Y_AXIS_LSB, b[TLV493D_RD_REG_BX2]);
                break;
        case TLV493D_AXIS_Z:
                val = FIELD_GET(TLV493D_BZ_MAG_Z_AXIS_MSB, b[TLV493D_RD_REG_BZ]) << 4 |
                      FIELD_GET(TLV493D_BZ2_MAG_Z_AXIS_LSB, b[TLV493D_RD_REG_BZ2]);
                break;
        case TLV493D_TEMPERATURE:
                val = FIELD_GET(TLV493D_TEMP_TEMP_MSB, b[TLV493D_RD_REG_TEMP]) << 8 |
                      FIELD_GET(TLV493D_TEMP2_TEMP_LSB, b[TLV493D_RD_REG_TEMP2]);
                break;
        }

        return sign_extend32(val, 11);
}

static int tlv493d_get_measurements(struct tlv493d_data *data, s16 *x, s16 *y,
                                    s16 *z, s16 *t)
{
        u8 buff[7] = {};
        int err, ret;
        struct device *dev = &data->client->dev;
        u32 sleep_us = tlv493d_sample_rate_us[data->mode];

        guard(mutex)(&data->lock);

        ret = pm_runtime_resume_and_get(dev);
        if (ret < 0)
                return ret;

        /*
         * Poll until data is valid.
         * For a valid data TLV493D_TEMP_CHANNEL bit of TLV493D_RD_REG_TEMP
         * should be set to 0. The sampling time depends on the sensor mode.
         * Poll 3x the time of the sampling time.
         */
        ret = read_poll_timeout(i2c_master_recv, err,
                        err || !FIELD_GET(TLV493D_TEMP_CHANNEL, buff[TLV493D_RD_REG_TEMP]),
                        sleep_us, 3 * sleep_us, false, data->client, buff,
                        ARRAY_SIZE(buff));
        if (ret) {
                dev_err(dev, "i2c read poll timeout, error:%d\n", ret);
                goto out_put_autosuspend;
        }
        if (err < 0) {
                dev_err(dev, "i2c read data failed, error:%d\n", err);
                ret = err;
                goto out_put_autosuspend;
        }

        *x = tlv493d_get_channel_data(buff, TLV493D_AXIS_X);
        *y = tlv493d_get_channel_data(buff, TLV493D_AXIS_Y);
        *z = tlv493d_get_channel_data(buff, TLV493D_AXIS_Z);
        *t = tlv493d_get_channel_data(buff, TLV493D_TEMPERATURE);

out_put_autosuspend:
        pm_runtime_put_autosuspend(dev);
        return ret;
}

static int tlv493d_init(struct tlv493d_data *data)
{
        int ret;
        u8 buff[TLV493D_RD_REG_MAX];
        struct device *dev = &data->client->dev;

        /*
         * The sensor initialization requires below steps to be followed,
         * 1. Power-up sensor.
         * 2. Read and store read-registers map (0x0-0x9).
         * 3. Copy values from read reserved registers to write reserved fields
         *    (0x0-0x3).
         * 4. Set operating mode.
         * 5. Write to all registers.
         */
        ret = i2c_master_recv(data->client, buff, ARRAY_SIZE(buff));
        if (ret < 0)
                return dev_err_probe(dev, ret, "i2c read failed\n");

        /* Write register 0x0 is reserved. Does not require to be updated.*/
        data->wr_regs[0] = 0;
        data->wr_regs[1] = buff[TLV493D_RD_REG_RES1] & TLV493D_RD_REG_RES1_WR_MASK;
        data->wr_regs[2] = buff[TLV493D_RD_REG_RES2] & TLV493D_RD_REG_RES2_WR_MASK;
        data->wr_regs[3] = buff[TLV493D_RD_REG_RES3] & TLV493D_RD_REG_RES3_WR_MASK;

        ret = tlv493d_set_operating_mode(data, data->mode);
        if (ret < 0)
                return dev_err_probe(dev, ret, "failed to set operating mode\n");

        return 0;
}

static int tlv493d_read_raw(struct iio_dev *indio_dev,
                        const struct iio_chan_spec *chan, int *val,
                        int *val2, long mask)
{
        struct tlv493d_data *data = iio_priv(indio_dev);
        s16 x, y, z, t;
        int ret;

        switch (mask) {
        case IIO_CHAN_INFO_RAW:
                ret = tlv493d_get_measurements(data, &x, &y, &z, &t);
                if (ret)
                        return ret;

                switch (chan->address) {
                case TLV493D_AXIS_X:
                        *val = x;
                        return IIO_VAL_INT;
                case TLV493D_AXIS_Y:
                        *val = y;
                        return IIO_VAL_INT;
                case TLV493D_AXIS_Z:
                        *val = z;
                        return IIO_VAL_INT;
                case TLV493D_TEMPERATURE:
                        *val = t;
                        return IIO_VAL_INT;
                default:
                        return -EINVAL;
                }
        case IIO_CHAN_INFO_SCALE:
                switch (chan->type) {
                case IIO_MAGN:
                        /*
                         * Magnetic field scale: 0.0098 mTesla (i.e. 9.8 µT)
                         * Magnetic field in Gauss: mT * 10 = 0.098.
                         */
                        *val = 98;
                        *val2 = 1000;
                        return IIO_VAL_FRACTIONAL;
                case IIO_TEMP:
                        /*
                         * Temperature scale: 1.1 °C per LSB, expressed as 1100 m°C
                         * Returned as integer for IIO core to apply:
                         * temp = (raw + offset) * scale
                         */
                        *val = 1100;
                        return IIO_VAL_INT;
                default:
                        return -EINVAL;
                }
        case IIO_CHAN_INFO_OFFSET:
                switch (chan->type) {
                case IIO_TEMP:
                        /*
                         * Temperature offset includes sensor-specific raw offset
                         * plus compensation for +25°C bias in formula.
                         * offset = -raw_offset + (25000 / 1100)
                         * -340 + 22.72 = -317.28
                         */
                        *val = -31728;
                        *val2 = 100;
                        return IIO_VAL_FRACTIONAL;
                default:
                        return -EINVAL;
                }
        default:
                return -EINVAL;
        }
}

static irqreturn_t tlv493d_trigger_handler(int irq, void *ptr)
{
        int ret;
        s16 x, y, z, t;
        struct iio_poll_func *pf = ptr;
        struct iio_dev *indio_dev = pf->indio_dev;
        struct tlv493d_data *data = iio_priv(indio_dev);
        struct device *dev = &data->client->dev;
        struct {
                s16 channels[3];
                s16 temperature;
                aligned_s64 timestamp;
        } scan;

        ret = tlv493d_get_measurements(data, &x, &y, &z, &t);
        if (ret) {
                dev_err(dev, "failed to read sensor data\n");
                goto out_trigger_notify;
        }

        scan.channels[0] = x;
        scan.channels[1] = y;
        scan.channels[2] = z;
        scan.temperature = t;
        iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan), pf->timestamp);

out_trigger_notify:
        iio_trigger_notify_done(indio_dev->trig);

        return IRQ_HANDLED;
}

#define TLV493D_AXIS_CHANNEL(axis, index)                       \
        {                                                       \
                .type = IIO_MAGN,                               \
                .modified = 1,                                  \
                .channel2 = IIO_MOD_##axis,                     \
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |  \
                                BIT(IIO_CHAN_INFO_SCALE),       \
                .address = index,                               \
                .scan_index = index,                            \
                .scan_type = {                                  \
                        .sign = 's',                            \
                        .realbits = 12,                         \
                        .storagebits = 16,                      \
                        .endianness = IIO_CPU,                  \
                },                                              \
        }

static const struct iio_chan_spec tlv493d_channels[] = {
        TLV493D_AXIS_CHANNEL(X, TLV493D_AXIS_X),
        TLV493D_AXIS_CHANNEL(Y, TLV493D_AXIS_Y),
        TLV493D_AXIS_CHANNEL(Z, TLV493D_AXIS_Z),
        {
                .type = IIO_TEMP,
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
                                BIT(IIO_CHAN_INFO_SCALE) |
                                BIT(IIO_CHAN_INFO_OFFSET),
                .address = TLV493D_TEMPERATURE,
                .scan_index = TLV493D_TEMPERATURE,
                .scan_type = {
                        .sign = 's',
                        .realbits = 12,
                        .storagebits = 16,
                        .endianness = IIO_CPU,
                },
        },
        IIO_CHAN_SOFT_TIMESTAMP(4),
};

static const struct iio_info tlv493d_info = {
        .read_raw = tlv493d_read_raw,
};

static const unsigned long tlv493d_scan_masks[] = { GENMASK(3, 0), 0 };

static int tlv493d_probe(struct i2c_client *client)
{
        struct device *dev = &client->dev;
        struct iio_dev *indio_dev;
        struct tlv493d_data *data;
        int ret;

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

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

        ret = devm_mutex_init(dev, &data->lock);
        if (ret)
                return ret;

        ret = devm_regulator_get_enable(dev, "vdd");
        if (ret)
                return dev_err_probe(dev, ret, "failed to enable regulator\n");

        /*
         * Setting Sensor default operating mode to Master-Controlled mode since
         * it performs measurement cycle only on-request and stays in Power-Down
         * state until next cycle is initiated.
         */
        data->mode = TLV493D_OP_MODE_MASTERCONTROLLED;
        ret = tlv493d_init(data);
        if (ret)
                return dev_err_probe(dev, ret, "failed to initialize\n");

        indio_dev->info = &tlv493d_info;
        indio_dev->modes = INDIO_DIRECT_MODE;
        indio_dev->name = client->name;
        indio_dev->channels = tlv493d_channels;
        indio_dev->num_channels = ARRAY_SIZE(tlv493d_channels);
        indio_dev->available_scan_masks = tlv493d_scan_masks;

        ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
                                              iio_pollfunc_store_time,
                                              tlv493d_trigger_handler,
                                              NULL);
        if (ret)
                return dev_err_probe(dev, ret, "iio triggered buffer setup failed\n");

        ret = pm_runtime_set_active(dev);
        if (ret)
                return ret;

        ret = devm_pm_runtime_enable(dev);
        if (ret)
                return ret;

        pm_runtime_get_noresume(dev);
        pm_runtime_set_autosuspend_delay(dev, 500);
        pm_runtime_use_autosuspend(dev);

        pm_runtime_put_autosuspend(dev);

        ret = devm_iio_device_register(dev, indio_dev);
        if (ret)
                return dev_err_probe(dev, ret, "iio device register failed\n");

        return 0;
}

static int tlv493d_runtime_suspend(struct device *dev)
{
        struct tlv493d_data *data = iio_priv(dev_get_drvdata(dev));

        return tlv493d_set_operating_mode(data, TLV493D_OP_MODE_POWERDOWN);
}

static int tlv493d_runtime_resume(struct device *dev)
{
        struct tlv493d_data *data = iio_priv(dev_get_drvdata(dev));

        return tlv493d_set_operating_mode(data, data->mode);
}

static DEFINE_RUNTIME_DEV_PM_OPS(tlv493d_pm_ops, tlv493d_runtime_suspend,
                                 tlv493d_runtime_resume, NULL);

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

static const struct of_device_id tlv493d_of_match[] = {
        { .compatible = "infineon,tlv493d-a1b6" },
        { }
};
MODULE_DEVICE_TABLE(of, tlv493d_of_match);

static struct i2c_driver tlv493d_driver = {
        .driver = {
                .name = "tlv493d",
                .of_match_table = tlv493d_of_match,
                .pm = pm_ptr(&tlv493d_pm_ops),
        },
        .probe = tlv493d_probe,
        .id_table = tlv493d_id,
};
module_i2c_driver(tlv493d_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Infineon TLV493D Low-Power 3D Magnetic Sensor");
MODULE_AUTHOR("Dixit Parmar <dixitparmar19@gmail.com>");