| // SPDX-License-Identifier: GPL-2.0-only |
| /* |
| * ADA4250 driver |
| * |
| * Copyright 2022 Analog Devices Inc. |
| */ |
| |
| #include <linux/bitfield.h> |
| #include <linux/bits.h> |
| #include <linux/device.h> |
| #include <linux/iio/iio.h> |
| #include <linux/module.h> |
| #include <linux/regmap.h> |
| #include <linux/regulator/consumer.h> |
| #include <linux/spi/spi.h> |
| |
| #include <asm/unaligned.h> |
| |
| /* ADA4250 Register Map */ |
| #define ADA4250_REG_GAIN_MUX 0x00 |
| #define ADA4250_REG_REFBUF_EN 0x01 |
| #define ADA4250_REG_RESET 0x02 |
| #define ADA4250_REG_SNSR_CAL_VAL 0x04 |
| #define ADA4250_REG_SNSR_CAL_CNFG 0x05 |
| #define ADA4250_REG_DIE_REV 0x18 |
| #define ADA4250_REG_CHIP_ID 0x19 |
| |
| /* ADA4250_REG_GAIN_MUX Map */ |
| #define ADA4250_GAIN_MUX_MSK GENMASK(2, 0) |
| |
| /* ADA4250_REG_REFBUF Map */ |
| #define ADA4250_REFBUF_MSK BIT(0) |
| |
| /* ADA4250_REG_RESET Map */ |
| #define ADA4250_RESET_MSK BIT(0) |
| |
| /* ADA4250_REG_SNSR_CAL_VAL Map */ |
| #define ADA4250_CAL_CFG_BIAS_MSK GENMASK(7, 0) |
| |
| /* ADA4250_REG_SNSR_CAL_CNFG Bit Definition */ |
| #define ADA4250_BIAS_SET_MSK GENMASK(3, 2) |
| #define ADA4250_RANGE_SET_MSK GENMASK(1, 0) |
| |
| /* Miscellaneous definitions */ |
| #define ADA4250_CHIP_ID 0x4250 |
| #define ADA4250_RANGE1 0 |
| #define ADA4250_RANGE4 3 |
| |
| /* ADA4250 current bias set */ |
| enum ada4250_current_bias { |
| ADA4250_BIAS_DISABLED, |
| ADA4250_BIAS_BANDGAP, |
| ADA4250_BIAS_AVDD, |
| }; |
| |
| struct ada4250_state { |
| struct spi_device *spi; |
| struct regmap *regmap; |
| struct regulator *reg; |
| /* Protect against concurrent accesses to the device and data content */ |
| struct mutex lock; |
| u8 bias; |
| u8 gain; |
| int offset_uv; |
| bool refbuf_en; |
| }; |
| |
| /* ADA4250 Current Bias Source Settings: Disabled, Bandgap Reference, AVDD */ |
| static const int calibbias_table[] = {0, 1, 2}; |
| |
| /* ADA4250 Gain (V/V) values: 1, 2, 4, 8, 16, 32, 64, 128 */ |
| static const int hwgain_table[] = {1, 2, 4, 8, 16, 32, 64, 128}; |
| |
| static const struct regmap_config ada4250_regmap_config = { |
| .reg_bits = 8, |
| .val_bits = 8, |
| .read_flag_mask = BIT(7), |
| .max_register = 0x1A, |
| }; |
| |
| static int ada4250_set_offset_uv(struct iio_dev *indio_dev, |
| const struct iio_chan_spec *chan, |
| int offset_uv) |
| { |
| struct ada4250_state *st = iio_priv(indio_dev); |
| |
| int i, ret, x[8], max_vos, min_vos, voltage_v, vlsb = 0; |
| u8 offset_raw, range = ADA4250_RANGE1; |
| u32 lsb_coeff[6] = {1333, 2301, 4283, 8289, 16311, 31599}; |
| |
| if (st->bias == 0 || st->bias == 3) |
| return -EINVAL; |
| |
| voltage_v = regulator_get_voltage(st->reg); |
| voltage_v = DIV_ROUND_CLOSEST(voltage_v, 1000000); |
| |
| if (st->bias == ADA4250_BIAS_AVDD) |
| x[0] = voltage_v; |
| else |
| x[0] = 5; |
| |
| x[1] = 126 * (x[0] - 1); |
| |
| for (i = 0; i < 6; i++) |
| x[i + 2] = DIV_ROUND_CLOSEST(x[1] * 1000, lsb_coeff[i]); |
| |
| if (st->gain == 0) |
| return -EINVAL; |
| |
| /* |
| * Compute Range and Voltage per LSB for the Sensor Offset Calibration |
| * Example of computation for Range 1 and Range 2 (Curren Bias Set = AVDD): |
| * Range 1 Range 2 |
| * Gain | Max Vos(mV) | LSB(mV) | Max Vos(mV) | LSB(mV) | |
| * 2 | X1*127 | X1=0.126(AVDD-1) | X1*3*127 | X1*3 | |
| * 4 | X2*127 | X2=X1/1.3333 | X2*3*127 | X2*3 | |
| * 8 | X3*127 | X3=X1/2.301 | X3*3*127 | X3*3 | |
| * 16 | X4*127 | X4=X1/4.283 | X4*3*127 | X4*3 | |
| * 32 | X5*127 | X5=X1/8.289 | X5*3*127 | X5*3 | |
| * 64 | X6*127 | X6=X1/16.311 | X6*3*127 | X6*3 | |
| * 128 | X7*127 | X7=X1/31.599 | X7*3*127 | X7*3 | |
| */ |
| for (i = ADA4250_RANGE1; i <= ADA4250_RANGE4; i++) { |
| max_vos = x[st->gain] * 127 * ((1 << (i + 1)) - 1); |
| min_vos = -1 * max_vos; |
| if (offset_uv > min_vos && offset_uv < max_vos) { |
| range = i; |
| vlsb = x[st->gain] * ((1 << (i + 1)) - 1); |
| break; |
| } |
| } |
| |
| if (vlsb <= 0) |
| return -EINVAL; |
| |
| offset_raw = DIV_ROUND_CLOSEST(abs(offset_uv), vlsb); |
| |
| mutex_lock(&st->lock); |
| ret = regmap_update_bits(st->regmap, ADA4250_REG_SNSR_CAL_CNFG, |
| ADA4250_RANGE_SET_MSK, |
| FIELD_PREP(ADA4250_RANGE_SET_MSK, range)); |
| if (ret) |
| goto exit; |
| |
| st->offset_uv = offset_raw * vlsb; |
| |
| /* |
| * To set the offset calibration value, use bits [6:0] and bit 7 as the |
| * polarity bit (set to "0" for a negative offset and "1" for a positive |
| * offset). |
| */ |
| if (offset_uv < 0) { |
| offset_raw |= BIT(7); |
| st->offset_uv *= (-1); |
| } |
| |
| ret = regmap_write(st->regmap, ADA4250_REG_SNSR_CAL_VAL, offset_raw); |
| |
| exit: |
| mutex_unlock(&st->lock); |
| |
| return ret; |
| } |
| |
| static int ada4250_read_raw(struct iio_dev *indio_dev, |
| struct iio_chan_spec const *chan, |
| int *val, int *val2, long info) |
| { |
| struct ada4250_state *st = iio_priv(indio_dev); |
| int ret; |
| |
| switch (info) { |
| case IIO_CHAN_INFO_HARDWAREGAIN: |
| ret = regmap_read(st->regmap, ADA4250_REG_GAIN_MUX, val); |
| if (ret) |
| return ret; |
| |
| *val = BIT(*val); |
| |
| return IIO_VAL_INT; |
| case IIO_CHAN_INFO_OFFSET: |
| *val = st->offset_uv; |
| |
| return IIO_VAL_INT; |
| case IIO_CHAN_INFO_CALIBBIAS: |
| ret = regmap_read(st->regmap, ADA4250_REG_SNSR_CAL_CNFG, val); |
| if (ret) |
| return ret; |
| |
| *val = FIELD_GET(ADA4250_BIAS_SET_MSK, *val); |
| |
| return IIO_VAL_INT; |
| case IIO_CHAN_INFO_SCALE: |
| *val = 1; |
| *val2 = 1000000; |
| |
| return IIO_VAL_FRACTIONAL; |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| static int ada4250_write_raw(struct iio_dev *indio_dev, |
| struct iio_chan_spec const *chan, |
| int val, int val2, long info) |
| { |
| struct ada4250_state *st = iio_priv(indio_dev); |
| int ret; |
| |
| switch (info) { |
| case IIO_CHAN_INFO_HARDWAREGAIN: |
| ret = regmap_write(st->regmap, ADA4250_REG_GAIN_MUX, |
| FIELD_PREP(ADA4250_GAIN_MUX_MSK, ilog2(val))); |
| if (ret) |
| return ret; |
| |
| st->gain = ilog2(val); |
| |
| return ret; |
| case IIO_CHAN_INFO_OFFSET: |
| return ada4250_set_offset_uv(indio_dev, chan, val); |
| case IIO_CHAN_INFO_CALIBBIAS: |
| ret = regmap_update_bits(st->regmap, ADA4250_REG_SNSR_CAL_CNFG, |
| ADA4250_BIAS_SET_MSK, |
| FIELD_PREP(ADA4250_BIAS_SET_MSK, val)); |
| if (ret) |
| return ret; |
| |
| st->bias = val; |
| |
| return ret; |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| static int ada4250_read_avail(struct iio_dev *indio_dev, |
| struct iio_chan_spec const *chan, |
| const int **vals, int *type, int *length, |
| long mask) |
| { |
| switch (mask) { |
| case IIO_CHAN_INFO_CALIBBIAS: |
| *vals = calibbias_table; |
| *type = IIO_VAL_INT; |
| *length = ARRAY_SIZE(calibbias_table); |
| |
| return IIO_AVAIL_LIST; |
| case IIO_CHAN_INFO_HARDWAREGAIN: |
| *vals = hwgain_table; |
| *type = IIO_VAL_INT; |
| *length = ARRAY_SIZE(hwgain_table); |
| |
| return IIO_AVAIL_LIST; |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| static int ada4250_reg_access(struct iio_dev *indio_dev, |
| unsigned int reg, |
| unsigned int write_val, |
| unsigned int *read_val) |
| { |
| struct ada4250_state *st = iio_priv(indio_dev); |
| |
| if (read_val) |
| return regmap_read(st->regmap, reg, read_val); |
| else |
| return regmap_write(st->regmap, reg, write_val); |
| } |
| |
| static const struct iio_info ada4250_info = { |
| .read_raw = ada4250_read_raw, |
| .write_raw = ada4250_write_raw, |
| .read_avail = &ada4250_read_avail, |
| .debugfs_reg_access = &ada4250_reg_access, |
| }; |
| |
| static const struct iio_chan_spec ada4250_channels[] = { |
| { |
| .type = IIO_VOLTAGE, |
| .output = 1, |
| .indexed = 1, |
| .channel = 0, |
| .info_mask_separate = BIT(IIO_CHAN_INFO_HARDWAREGAIN) | |
| BIT(IIO_CHAN_INFO_OFFSET) | |
| BIT(IIO_CHAN_INFO_CALIBBIAS) | |
| BIT(IIO_CHAN_INFO_SCALE), |
| .info_mask_separate_available = BIT(IIO_CHAN_INFO_CALIBBIAS) | |
| BIT(IIO_CHAN_INFO_HARDWAREGAIN), |
| } |
| }; |
| |
| static void ada4250_reg_disable(void *data) |
| { |
| regulator_disable(data); |
| } |
| |
| static int ada4250_init(struct ada4250_state *st) |
| { |
| int ret; |
| u16 chip_id; |
| u8 data[2] __aligned(8) = {}; |
| struct spi_device *spi = st->spi; |
| |
| st->refbuf_en = device_property_read_bool(&spi->dev, "adi,refbuf-enable"); |
| |
| st->reg = devm_regulator_get(&spi->dev, "avdd"); |
| if (IS_ERR(st->reg)) |
| return dev_err_probe(&spi->dev, PTR_ERR(st->reg), |
| "failed to get the AVDD voltage\n"); |
| |
| ret = regulator_enable(st->reg); |
| if (ret) { |
| dev_err(&spi->dev, "Failed to enable specified AVDD supply\n"); |
| return ret; |
| } |
| |
| ret = devm_add_action_or_reset(&spi->dev, ada4250_reg_disable, st->reg); |
| if (ret) |
| return ret; |
| |
| ret = regmap_write(st->regmap, ADA4250_REG_RESET, |
| FIELD_PREP(ADA4250_RESET_MSK, 1)); |
| if (ret) |
| return ret; |
| |
| ret = regmap_bulk_read(st->regmap, ADA4250_REG_CHIP_ID, data, 2); |
| if (ret) |
| return ret; |
| |
| chip_id = get_unaligned_le16(data); |
| |
| if (chip_id != ADA4250_CHIP_ID) { |
| dev_err(&spi->dev, "Invalid chip ID.\n"); |
| return -EINVAL; |
| } |
| |
| return regmap_write(st->regmap, ADA4250_REG_REFBUF_EN, |
| FIELD_PREP(ADA4250_REFBUF_MSK, st->refbuf_en)); |
| } |
| |
| static int ada4250_probe(struct spi_device *spi) |
| { |
| struct iio_dev *indio_dev; |
| struct regmap *regmap; |
| struct ada4250_state *st; |
| int ret; |
| |
| indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); |
| if (!indio_dev) |
| return -ENOMEM; |
| |
| regmap = devm_regmap_init_spi(spi, &ada4250_regmap_config); |
| if (IS_ERR(regmap)) |
| return PTR_ERR(regmap); |
| |
| st = iio_priv(indio_dev); |
| st->regmap = regmap; |
| st->spi = spi; |
| |
| indio_dev->info = &ada4250_info; |
| indio_dev->name = "ada4250"; |
| indio_dev->channels = ada4250_channels; |
| indio_dev->num_channels = ARRAY_SIZE(ada4250_channels); |
| |
| mutex_init(&st->lock); |
| |
| ret = ada4250_init(st); |
| if (ret) { |
| dev_err(&spi->dev, "ADA4250 init failed\n"); |
| return ret; |
| } |
| |
| return devm_iio_device_register(&spi->dev, indio_dev); |
| } |
| |
| static const struct spi_device_id ada4250_id[] = { |
| { "ada4250", 0 }, |
| {} |
| }; |
| MODULE_DEVICE_TABLE(spi, ada4250_id); |
| |
| static const struct of_device_id ada4250_of_match[] = { |
| { .compatible = "adi,ada4250" }, |
| {}, |
| }; |
| MODULE_DEVICE_TABLE(of, ada4250_of_match); |
| |
| static struct spi_driver ada4250_driver = { |
| .driver = { |
| .name = "ada4250", |
| .of_match_table = ada4250_of_match, |
| }, |
| .probe = ada4250_probe, |
| .id_table = ada4250_id, |
| }; |
| module_spi_driver(ada4250_driver); |
| |
| MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com"); |
| MODULE_DESCRIPTION("Analog Devices ADA4250"); |
| MODULE_LICENSE("GPL v2"); |
