// SPDX-License-Identifier: GPL-2.0
/*
 * Silicon Labs Si7210 Hall Effect sensor driver
 *
 * Copyright (c) 2024 Antoni Pokusinski <apokusinski01@gmail.com>
 *
 * Datasheet:
 *  https://www.silabs.com/documents/public/data-sheets/si7210-datasheet.pdf
 */

#include <linux/array_size.h>
#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/cleanup.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/iio/iio.h>
#include <linux/math64.h>
#include <linux/mod_devicetable.h>
#include <linux/mutex.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/types.h>
#include <linux/units.h>
#include <asm/byteorder.h>

/* Registers offsets and masks */
#define SI7210_REG_DSPSIGM	0xC1
#define SI7210_REG_DSPSIGL	0xC2

#define SI7210_MASK_DSPSIGSEL	GENMASK(2, 0)
#define SI7210_REG_DSPSIGSEL	0xC3

#define SI7210_MASK_STOP	BIT(1)
#define SI7210_MASK_ONEBURST	BIT(2)
#define SI7210_REG_POWER_CTRL	0xC4

#define SI7210_MASK_ARAUTOINC	BIT(0)
#define SI7210_REG_ARAUTOINC	0xC5

#define SI7210_REG_A0		0xCA
#define SI7210_REG_A1		0xCB
#define SI7210_REG_A2		0xCC
#define SI7210_REG_A3		0xCE
#define SI7210_REG_A4		0xCF
#define SI7210_REG_A5		0xD0

#define SI7210_REG_OTP_ADDR	0xE1
#define SI7210_REG_OTP_DATA	0xE2

#define SI7210_MASK_OTP_READ_EN	BIT(1)
#define SI7210_REG_OTP_CTRL	0xE3

/* OTP data registers offsets */
#define SI7210_OTPREG_TMP_OFF	0x1D
#define SI7210_OTPREG_TMP_GAIN	0x1E

#define SI7210_OTPREG_A0_20	0x21
#define SI7210_OTPREG_A1_20	0x22
#define SI7210_OTPREG_A2_20	0x23
#define SI7210_OTPREG_A3_20	0x24
#define SI7210_OTPREG_A4_20	0x25
#define SI7210_OTPREG_A5_20	0x26

#define SI7210_OTPREG_A0_200	0x27
#define SI7210_OTPREG_A1_200	0x28
#define SI7210_OTPREG_A2_200	0x29
#define SI7210_OTPREG_A3_200	0x2A
#define SI7210_OTPREG_A4_200	0x2B
#define SI7210_OTPREG_A5_200	0x2C

#define A_REGS_COUNT 6

static const unsigned int a20_otp_regs[A_REGS_COUNT] = {
	SI7210_OTPREG_A0_20, SI7210_OTPREG_A1_20, SI7210_OTPREG_A2_20,
	SI7210_OTPREG_A3_20, SI7210_OTPREG_A4_20, SI7210_OTPREG_A5_20,
};

static const unsigned int a200_otp_regs[A_REGS_COUNT] = {
	SI7210_OTPREG_A0_200, SI7210_OTPREG_A1_200, SI7210_OTPREG_A2_200,
	SI7210_OTPREG_A3_200, SI7210_OTPREG_A4_200, SI7210_OTPREG_A5_200,
};

static const struct regmap_range si7210_read_reg_ranges[] = {
	regmap_reg_range(SI7210_REG_DSPSIGM, SI7210_REG_ARAUTOINC),
	regmap_reg_range(SI7210_REG_A0, SI7210_REG_A2),
	regmap_reg_range(SI7210_REG_A3, SI7210_REG_A5),
	regmap_reg_range(SI7210_REG_OTP_ADDR, SI7210_REG_OTP_CTRL),
};

static const struct regmap_access_table si7210_readable_regs = {
	.yes_ranges = si7210_read_reg_ranges,
	.n_yes_ranges = ARRAY_SIZE(si7210_read_reg_ranges),
};

static const struct regmap_range si7210_write_reg_ranges[] = {
	regmap_reg_range(SI7210_REG_DSPSIGSEL, SI7210_REG_ARAUTOINC),
	regmap_reg_range(SI7210_REG_A0, SI7210_REG_A2),
	regmap_reg_range(SI7210_REG_A3, SI7210_REG_A5),
	regmap_reg_range(SI7210_REG_OTP_ADDR, SI7210_REG_OTP_CTRL),
};

static const struct regmap_access_table si7210_writeable_regs = {
	.yes_ranges = si7210_write_reg_ranges,
	.n_yes_ranges = ARRAY_SIZE(si7210_write_reg_ranges),
};

static const struct regmap_range si7210_volatile_reg_ranges[] = {
	regmap_reg_range(SI7210_REG_DSPSIGM, SI7210_REG_DSPSIGL),
	regmap_reg_range(SI7210_REG_POWER_CTRL, SI7210_REG_POWER_CTRL),
};

static const struct regmap_access_table si7210_volatile_regs = {
	.yes_ranges = si7210_volatile_reg_ranges,
	.n_yes_ranges = ARRAY_SIZE(si7210_volatile_reg_ranges),
};

static const struct regmap_config si7210_regmap_conf = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = SI7210_REG_OTP_CTRL,

	.rd_table = &si7210_readable_regs,
	.wr_table = &si7210_writeable_regs,
	.volatile_table = &si7210_volatile_regs,
};

struct si7210_data {
	struct regmap *regmap;
	struct i2c_client *client;
	struct regulator *vdd;
	struct mutex fetch_lock; /* lock for a single measurement fetch */
	s8 temp_offset;
	s8 temp_gain;
	s8 scale_20_a[A_REGS_COUNT];
	s8 scale_200_a[A_REGS_COUNT];
	u8 curr_scale;
};

static const struct iio_chan_spec si7210_channels[] = {
	{
		.type = IIO_MAGN,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
			BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET),
	}, {
		.type = IIO_TEMP,
		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
	},
};

static int si7210_fetch_measurement(struct si7210_data *data,
				    struct iio_chan_spec const *chan,
				    u16 *buf)
{
	u8 dspsigsel = chan->type == IIO_MAGN ? 0 : 1;
	int ret;
	__be16 result;

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

	ret = regmap_update_bits(data->regmap, SI7210_REG_DSPSIGSEL,
				 SI7210_MASK_DSPSIGSEL, dspsigsel);
	if (ret)
		return ret;

	ret = regmap_update_bits(data->regmap, SI7210_REG_POWER_CTRL,
				 SI7210_MASK_ONEBURST | SI7210_MASK_STOP,
				 SI7210_MASK_ONEBURST & ~SI7210_MASK_STOP);
	if (ret)
		return ret;

	/*
	 * Read the contents of the
	 * registers containing the result: DSPSIGM, DSPSIGL
	 */
	ret = regmap_bulk_read(data->regmap, SI7210_REG_DSPSIGM,
			       &result, sizeof(result));
	if (ret)
		return ret;

	*buf = be16_to_cpu(result);

	return 0;
}

static int si7210_read_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan,
			   int *val, int *val2, long mask)
{
	struct si7210_data *data = iio_priv(indio_dev);
	long long temp;
	u16 dspsig;
	int ret;

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		ret = si7210_fetch_measurement(data, chan, &dspsig);
		if (ret)
			return ret;

		*val = dspsig & GENMASK(14, 0);
		return IIO_VAL_INT;
	case IIO_CHAN_INFO_SCALE:
		*val = 0;
		if (data->curr_scale == 20)
			*val2 = 12500;
		else /* data->curr_scale == 200 */
			*val2 = 125000;
		return IIO_VAL_INT_PLUS_MICRO;
	case IIO_CHAN_INFO_OFFSET:
		*val = -16384;
		return IIO_VAL_INT;
	case IIO_CHAN_INFO_PROCESSED:
		ret = si7210_fetch_measurement(data, chan, &dspsig);
		if (ret)
			return ret;

		/* temp = 32 * Dspsigm[6:0] + (Dspsigl[7:0] >> 3) */
		temp = FIELD_GET(GENMASK(14, 3), dspsig);
		temp = div_s64(-383 * temp * temp, 100) + 160940 * temp - 279800000;
		temp *= (1 + (data->temp_gain / 2048));
		temp += (int)(MICRO / 16) * data->temp_offset;

		ret = regulator_get_voltage(data->vdd);
		if (ret < 0)
			return ret;

		/* temp -= 0.222 * VDD */
		temp -= 222 * div_s64(ret, MILLI);

		*val = div_s64(temp, MILLI);

		return IIO_VAL_INT;
	default:
		return -EINVAL;
	}
}

static int si7210_set_scale(struct si7210_data *data, unsigned int scale)
{
	s8 *a_otp_values;
	int ret;

	if (scale == 20)
		a_otp_values = data->scale_20_a;
	else if (scale == 200)
		a_otp_values = data->scale_200_a;
	else
		return -EINVAL;

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

	/* Write the registers 0xCA - 0xCC */
	ret = regmap_bulk_write(data->regmap, SI7210_REG_A0, a_otp_values, 3);
	if (ret)
		return ret;

	/* Write the registers 0xCE - 0xD0 */
	ret = regmap_bulk_write(data->regmap, SI7210_REG_A3, &a_otp_values[3], 3);
	if (ret)
		return ret;

	data->curr_scale = scale;

	return 0;
}

static int si7210_write_raw(struct iio_dev *indio_dev,
			    struct iio_chan_spec const *chan,
			    int val, int val2, long mask)
{
	struct si7210_data *data = iio_priv(indio_dev);
	unsigned int scale;

	switch (mask) {
	case IIO_CHAN_INFO_SCALE:
		if (val == 0 && val2 == 12500)
			scale = 20;
		else if (val == 0 && val2 == 125000)
			scale = 200;
		else
			return -EINVAL;

		return si7210_set_scale(data, scale);
	default:
		return -EINVAL;
	}
}

static int si7210_read_otpreg_val(struct si7210_data *data, unsigned int otpreg, u8 *val)
{
	int ret;
	unsigned int otpdata;

	ret = regmap_write(data->regmap, SI7210_REG_OTP_ADDR, otpreg);
	if (ret)
		return ret;

	ret = regmap_update_bits(data->regmap, SI7210_REG_OTP_CTRL,
				 SI7210_MASK_OTP_READ_EN, SI7210_MASK_OTP_READ_EN);
	if (ret)
		return ret;

	ret = regmap_read(data->regmap, SI7210_REG_OTP_DATA, &otpdata);
	if (ret)
		return ret;

	*val = otpdata;

	return 0;
}

/*
 * According to the datasheet, the primary method to wake up a
 * device is to send an empty write. However this is not feasible
 * using the current API so we use the other method i.e. read a single
 * byte. The device should respond with 0xFF.
 */
static int si7210_device_wake(struct si7210_data *data)
{
	int ret;

	ret = i2c_smbus_read_byte(data->client);
	if (ret < 0)
		return ret;

	if (ret != 0xFF)
		return -EIO;

	return 0;
}

static int si7210_device_init(struct si7210_data *data)
{
	int ret;
	unsigned int i;

	ret = si7210_device_wake(data);
	if (ret)
		return ret;

	fsleep(1000);

	ret = si7210_read_otpreg_val(data, SI7210_OTPREG_TMP_GAIN, &data->temp_gain);
	if (ret)
		return ret;

	ret = si7210_read_otpreg_val(data, SI7210_OTPREG_TMP_OFF, &data->temp_offset);
	if (ret)
		return ret;

	for (i = 0; i < A_REGS_COUNT; i++) {
		ret = si7210_read_otpreg_val(data, a20_otp_regs[i], &data->scale_20_a[i]);
		if (ret)
			return ret;
	}

	for (i = 0; i < A_REGS_COUNT; i++) {
		ret = si7210_read_otpreg_val(data, a200_otp_regs[i], &data->scale_200_a[i]);
		if (ret)
			return ret;
	}

	ret = regmap_update_bits(data->regmap, SI7210_REG_ARAUTOINC,
				 SI7210_MASK_ARAUTOINC, SI7210_MASK_ARAUTOINC);
	if (ret)
		return ret;

	return si7210_set_scale(data, 20);
}

static const struct iio_info si7210_info = {
	.read_raw = si7210_read_raw,
	.write_raw = si7210_write_raw,
};

static int si7210_probe(struct i2c_client *client)
{
	struct si7210_data *data;
	struct iio_dev *indio_dev;
	int ret;

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

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

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

	data->regmap = devm_regmap_init_i2c(client, &si7210_regmap_conf);
	if (IS_ERR(data->regmap))
		return dev_err_probe(&client->dev, PTR_ERR(data->regmap),
				     "failed to register regmap\n");

	data->vdd = devm_regulator_get(&client->dev, "vdd");
	if (IS_ERR(data->vdd))
		return dev_err_probe(&client->dev, PTR_ERR(data->vdd),
				     "failed to get VDD regulator\n");

	ret = regulator_enable(data->vdd);
	if (ret)
		return ret;

	indio_dev->name = dev_name(&client->dev);
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->info = &si7210_info;
	indio_dev->channels = si7210_channels;
	indio_dev->num_channels = ARRAY_SIZE(si7210_channels);

	ret = si7210_device_init(data);
	if (ret)
		return dev_err_probe(&client->dev, ret,
				     "device initialization failed\n");

	return devm_iio_device_register(&client->dev, indio_dev);
}

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

static const struct of_device_id si7210_dt_ids[] = {
	{ .compatible = "silabs,si7210" },
	{ }
};
MODULE_DEVICE_TABLE(of, si7210_dt_ids);

static struct i2c_driver si7210_driver = {
	.driver = {
		.name = "si7210",
		.of_match_table = si7210_dt_ids,
	},
	.probe = si7210_probe,
	.id_table = si7210_id,
};
module_i2c_driver(si7210_driver);

MODULE_AUTHOR("Antoni Pokusinski <apokusinski01@gmail.com>");
MODULE_DESCRIPTION("Silicon Labs Si7210 Hall Effect sensor I2C driver");
MODULE_LICENSE("GPL");