// 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]) >> 4;
		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>");