#include <linux/bitfield.h>
#include <linux/bitmap.h>
#include <linux/cleanup.h>
#include <linux/clk.h>
#include <linux/completion.h>
#include <linux/crc8.h>
#include <linux/delay.h>
#include <linux/dev_printk.h>
#include <linux/device/devres.h>
#include <linux/i2c.h>
#include <linux/iio/buffer.h>
#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/interrupt.h>
#include <linux/math64.h>
#include <linux/minmax.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/sysfs.h>
#include <linux/time64.h>
#include <linux/types.h>
#include <linux/unaligned.h>
#include <linux/units.h>
#define ADS112C14_MAX_MEASUREMENT_CHANNELS 16
#define ADS112C14_DELAY_RESET_US 500
#define ADS112C14_CMD_RDATA 0x00
#define ADS112C14_CMD_RREG 0x40
#define ADS112C14_CMD_WREG 0x80
#define ADS112C14_REG_DEVICE_ID 0x00
#define ADS112C14_DEVICE_ID_BITS GENMASK(3, 0)
#define ADS112C14_REG_REVISION_ID 0x01
#define ADS112C14_REG_STATUS_MSB 0x02
#define ADS112C14_STATUS_MSB_RESETN BIT(7)
#define ADS112C14_STATUS_MSB_AVDD_UVN BIT(6)
#define ADS112C14_STATUS_MSB_REF_UVN BIT(5)
#define ADS112C14_STATUS_MSB_REG_MAP_CRC_FAULTN BIT(3)
#define ADS112C14_STATUS_MSB_MEM_FAULTN BIT(2)
#define ADS112C14_STATUS_MSB_REG_WRITE_FAULTN BIT(1)
#define ADS112C14_STATUS_MSB_DRDY BIT(0)
#define ADS112C14_REG_STATUS_LSB 0x03
#define ADS112C14_STATUS_LSB_CONV_COUNT GENMASK(7, 4)
#define ADS112C14_STATUS_LSB_GPIO3_DAT_IN BIT(3)
#define ADS112C14_STATUS_LSB_GPIO2_DAT_IN BIT(2)
#define ADS112C14_STATUS_LSB_GPIO1_DAT_IN BIT(1)
#define ADS112C14_STATUS_LSB_GPIO0_DAT_IN BIT(0)
#define ADS112C14_REG_CONVERSION_CTRL 0x04
#define ADS112C14_CONVERSION_CTRL_RESET GENMASK(7, 2)
#define ADS112C14_CONVERSION_CTRL_START BIT(1)
#define ADS112C14_CONVERSION_CTRL_STOP BIT(0)
#define ADS112C14_REG_DEVICE_CFG 0x05
#define ADS112C14_DEVICE_CFG_PWDN BIT(7)
#define ADS112C14_DEVICE_CFG_STBY_MODE BIT(6)
#define ADS112C14_DEVICE_CFG_BOCS GENMASK(5, 4)
#define ADS112C14_DEVICE_CFG_BOCS_DISABLED 0
#define ADS112C14_DEVICE_CFG_BOCS_200_nA 1
#define ADS112C14_DEVICE_CFG_BOCS_1_uA 2
#define ADS112C14_DEVICE_CFG_BOCS_10_uA 3
#define ADS112C14_DEVICE_CFG_CLK_SEL BIT(3)
#define ADS112C14_DEVICE_CFG_CLK_SEL_INTERNAL 0
#define ADS112C14_DEVICE_CFG_CLK_SEL_EXTERNAL 1
#define ADS112C14_DEVICE_CFG_CONV_MODE BIT(2)
#define ADS112C14_DEVICE_CFG_CONV_MODE_CONTINUOUS 0
#define ADS112C14_DEVICE_CFG_CONV_MODE_SINGLE_SHOT 1
#define ADS112C14_DEVICE_CFG_SPEED_MODE GENMASK(1, 0)
#define ADS112C14_REG_DATA_RATE_CFG 0x06
#define ADS112C14_DATA_RATE_CFG_DELAY GENMASK(7, 4)
#define ADS112C14_DATA_RATE_CFG_GC_EN BIT(3)
#define ADS112C14_DATA_RATE_CFG_FLTR_OSR GENMASK(2, 0)
#define ADS112C14_DATA_RATE_CFG_FLTR_OSR_16 0
#define ADS112C14_DATA_RATE_CFG_FLTR_OSR_32 1
#define ADS112C14_DATA_RATE_CFG_FLTR_OSR_128 2
#define ADS112C14_DATA_RATE_CFG_FLTR_OSR_256 3
#define ADS112C14_DATA_RATE_CFG_FLTR_OSR_512 4
#define ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024 5
#define ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS 6
#define ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS 7
#define ADS112C14_REG_MUX_CFG 0x07
#define ADS112C14_MUX_CFG_AINP GENMASK(7, 4)
#define ADS112C14_MUX_CFG_AINN GENMASK(3, 0)
#define ADS112C14_MUX_CFG_AIN_GND 8
#define ADS112C14_REG_GAIN_CFG 0x08
#define ADS112C14_GAIN_CFG_SPARE BIT(7)
#define ADS112C14_GAIN_CFG_SYS_MON GENMASK(6, 4)
#define ADS112C14_GAIN_CFG_GAIN GENMASK(3, 0)
#define ADS112C14_REG_REFERENCE_CFG 0x09
#define ADS112C14_REFERENCE_CFG_REF_UV_EN BIT(7)
#define ADS112C14_REFERENCE_CFG_REFP_BUF_EN BIT(5)
#define ADS112C14_REFERENCE_CFG_REFN_BUF_EN BIT(4)
#define ADS112C14_REFERENCE_CFG_REF_VAL BIT(2)
#define ADS112C14_REFERENCE_CFG_REF_VAL_1_25V 0
#define ADS112C14_REFERENCE_CFG_REF_VAL_2_5V 1
#define ADS112C14_REFERENCE_CFG_REF_SEL GENMASK(1, 0)
#define ADS112C14_REFERENCE_CFG_REF_SEL_INTERNAL 0
#define ADS112C14_REFERENCE_CFG_REF_SEL_EXTERNAL 1
#define ADS112C14_REFERENCE_CFG_REF_SEL_AVDD 2
#define ADS112C14_REG_DIGITAL_CFG 0x0A
#define ADS112C14_DIGITAL_CFG_REG_MAP_CRC_EN BIT(6)
#define ADS112C14_DIGITAL_CFG_I2C_CRC_EN BIT(5)
#define ADS112C14_DIGITAL_CFG_STATUS_EN BIT(4)
#define ADS112C14_DIGITAL_CFG_FAULT_PIN_BEHAVIOR BIT(3)
#define ADS112C14_DIGITAL_CFG_CODING BIT(1)
#define ADS112C14_REG_GPIO_CFG 0x0B
#define ADS112C14_GPIO_CFG_GPIO3_CFG GENMASK(7, 6)
#define ADS112C14_GPIO_CFG_GPIO2_CFG GENMASK(5, 4)
#define ADS112C14_GPIO_CFG_GPIO1_CFG GENMASK(3, 2)
#define ADS112C14_GPIO_CFG_GPIO0_CFG GENMASK(1, 0)
#define ADS112C14_GPIO_CFG_GPIO_CFG_DISABLED 0
#define ADS112C14_GPIO_CFG_GPIO_CFG_INPUT 1
#define ADS112C14_GPIO_CFG_GPIO_CFG_OUTPUT_PUSH_PULL 2
#define ADS112C14_GPIO_CFG_GPIO_CFG_OUTPUT_OPEN_DRAIN 3
#define ADS112C14_REG_GPIO_DATA_OUTPUT 0x0C
#define ADS112C14_GPIO_DATA_OUTPUT_GPIO3_SRC BIT(7)
#define ADS112C14_GPIO_DATA_OUTPUT_GPIO3_SRC_DAT_OUT 0
#define ADS112C14_GPIO_DATA_OUTPUT_GPIO3_SRC_DRDY 1
#define ADS112C14_GPIO_DATA_OUTPUT_GPIO2_SRC BIT(6)
#define ADS112C14_GPIO_DATA_OUTPUT_GPIO3_DAT_OUT BIT(3)
#define ADS112C14_GPIO_DATA_OUTPUT_GPIO2_DAT_OUT BIT(2)
#define ADS112C14_GPIO_DATA_OUTPUT_GPIO1_DAT_OUT BIT(1)
#define ADS112C14_GPIO_DATA_OUTPUT_GPIO0_DAT_OUT BIT(0)
#define ADS112C14_REG_IDAC_MAG_CFG 0x0D
#define ADS112C14_IDAC_MAG_CFG_I2MAG GENMASK(7, 4)
#define ADS112C14_IDAC_MAG_CFG_I1MAG GENMASK(3, 0)
#define ADS112C14_REG_IDAC_MUX_CFG 0x0E
#define ADS112C14_IDAC_MUX_CFG_IUNIT BIT(7)
#define ADS112C14_IDAC_MUX_CFG_I2MUX GENMASK(6, 4)
#define ADS112C14_IDAC_MUX_CFG_I1MUX GENMASK(2, 0)
#define ADS112C14_REG_REG_MAP_CRC 0x0F
#define ADS112C14_INT_REF0_mV 1250
#define ADS112C14_INT_REF1_mV 2500
enum {
ADS112C14_VREF_SOURCE_INTERNAL_2_5V,
ADS112C14_VREF_SOURCE_INTERNAL_1_25V,
ADS112C14_VREF_SOURCE_EXTERNAL,
ADS112C14_VREF_SOURCE_AVDD,
};
static const char * const ads112c14_vref_source_names[] = {
[ADS112C14_VREF_SOURCE_INTERNAL_2_5V] = "internal-2.5v",
[ADS112C14_VREF_SOURCE_INTERNAL_1_25V] = "internal-1.25v",
[ADS112C14_VREF_SOURCE_EXTERNAL] = "external",
[ADS112C14_VREF_SOURCE_AVDD] = "avdd",
};
static const u32 ads112c14_pga_gains_x10[] = {
5, 10, 20, 40, 50, 80, 100, 160,
200, 320, 500, 640, 1000, 1280, 2000, 2560,
};
#define ADS112C14_INTERNAL_CLK_Hz (4096 * HZ_PER_KHZ)
static const int ads112c14_sinc4_osr_available[] = {
16, 32
};
static const int ads112c14_sinc4_sinc1_osr_available[] = {
128, 256, 512, 1024
};
static const int ads112c14_sinc4_sinc1_pf1_20sps_osr_available[] = {
1600, 12800, 25600, 51200
};
static const int ads112c14_sinc4_sinc1_pf1_25sps_osr_available[] = {
1280, 10240, 20480, 40960
};
static const int ads112c14_fmod_div[] = {
128, 16, 8, 4
};
#define ADS112C14_DELAY_MAX FIELD_MAX(ADS112C14_DATA_RATE_CFG_DELAY)
static const int ads112c14_sinc_latency_tmod[][ARRAY_SIZE(ads112c14_fmod_div)] = {
{ 80, 88, 88, 104 },
{ 144, 152, 152, 168 },
{ 240, 248, 248, 264 },
{ 368, 376, 376, 392 },
{ 624, 632, 632, 648 },
{ 1136, 1144, 1144, 1160 },
};
static const int ads112c14_fir_latency_tmod[][ARRAY_SIZE(ads112c14_fmod_div)] = {
{ 1416, 10384, 20624, 41120 },
{ 1736, 12944, 25744, 51360 },
};
enum ads112c14_filter_type {
ADS112C14_FILTER_TYPE_SINC4,
ADS112C14_FILTER_TYPE_SINC4_SINC1,
ADS112C14_FILTER_TYPE_SINC4_SINC1_PF1,
};
static const char * const ads112c14_filter_type_names[] = {
[ADS112C14_FILTER_TYPE_SINC4] = "sinc4",
[ADS112C14_FILTER_TYPE_SINC4_SINC1] = "sinc4+sinc1",
[ADS112C14_FILTER_TYPE_SINC4_SINC1_PF1] = "sinc4+sinc1+pf1",
};
#define ADS112C14_I2C_CRC8_POLYNOMIAL 0x07
DECLARE_CRC8_TABLE(ads112c14_crc8_table);
struct ads112c14_chip_info {
const char *name;
u8 device_id;
u32 resolution_bits;
};
#define ADS112C14_SYS_MON_CHANNEL_BASE 100
enum {
ADS112C14_SYS_MON_CHANNEL_TEMP = ADS112C14_SYS_MON_CHANNEL_BASE,
ADS112C14_SYS_MON_CHANNEL_EXT_REF,
ADS112C14_SYS_MON_CHANNEL_AVDD,
ADS112C14_SYS_MON_CHANNEL_DVDD,
ADS112C14_SYS_MON_CHANNEL_SHORT,
};
static const struct iio_chan_spec_ext_info ads112c14_ext_info[];
static const struct iio_chan_spec ads112c14_sys_mon_channels[] = {
{
.type = IIO_TEMP,
.indexed = 1,
.channel = ADS112C14_SYS_MON_CHANNEL_TEMP,
.address = 2,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
| BIT(IIO_CHAN_INFO_SCALE)
| BIT(IIO_CHAN_INFO_OFFSET)
| BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.ext_info = ads112c14_ext_info,
},
{
.type = IIO_VOLTAGE,
.indexed = 1,
.channel = ADS112C14_SYS_MON_CHANNEL_EXT_REF,
.address = 3,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
| BIT(IIO_CHAN_INFO_SCALE)
| BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.ext_info = ads112c14_ext_info,
},
{
.type = IIO_VOLTAGE,
.indexed = 1,
.channel = ADS112C14_SYS_MON_CHANNEL_AVDD,
.address = 4,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
| BIT(IIO_CHAN_INFO_SCALE)
| BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.ext_info = ads112c14_ext_info,
},
{
.type = IIO_VOLTAGE,
.indexed = 1,
.channel = ADS112C14_SYS_MON_CHANNEL_DVDD,
.address = 5,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
| BIT(IIO_CHAN_INFO_SCALE)
| BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.ext_info = ads112c14_ext_info,
},
{
.type = IIO_VOLTAGE,
.indexed = 1,
.channel = ADS112C14_SYS_MON_CHANNEL_SHORT,
.channel2 = ADS112C14_SYS_MON_CHANNEL_SHORT,
.differential = 1,
.address = 1,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
| BIT(IIO_CHAN_INFO_SCALE)
| BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.info_mask_separate_available = BIT(IIO_CHAN_INFO_SCALE)
| BIT(IIO_CHAN_INFO_SAMP_FREQ)
| BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
.ext_info = ads112c14_ext_info,
},
};
struct ads112c14_measurement {
const char *label;
u32 vref_source;
u8 iunit;
u8 idac1_mag;
u8 idac2_mag;
u8 idac1_mux;
u8 idac2_mux;
u8 iadc_count;
u8 gain_val;
u8 burnout;
bool global_chop;
bool bipolar;
int scale_available[ARRAY_SIZE(ads112c14_pga_gains_x10)][2];
};
struct ads112c14_channel_state {
u8 speed_mode;
u8 filter_osr;
u8 delay;
};
struct ads112c14_data {
const struct ads112c14_chip_info *chip_info;
struct regmap *regmap;
struct iio_trigger *drdy_trig;
struct mutex lock;
long fclk_Hz;
int drdy_irq;
struct completion drdy_completion;
bool continuous_mode;
bool i2c_crc_enabled;
u32 avdd_uV;
u32 ext_ref_uV;
bool refp_is_avdd;
bool refn_is_gnd;
u32 ext_ref_ohms;
struct ads112c14_measurement *measurements;
struct ads112c14_channel_state *channel_states;
u32 num_measurements;
u8 sys_mon_chan_short_gain_val;
int sys_mon_chan_short_scale_available[ARRAY_SIZE(ads112c14_pga_gains_x10)][2];
int sinc4_sample_rate_available[ARRAY_SIZE(ads112c14_sinc4_osr_available)][ARRAY_SIZE(ads112c14_fmod_div)][2];
int sinc4_sinc1_sample_rate_available[ARRAY_SIZE(ads112c14_sinc4_sinc1_osr_available)][ARRAY_SIZE(ads112c14_fmod_div)][2];
int sinc4_sinc1_pf1_sample_rate_available[2][2];
int sinc_settling_time_range_available[ARRAY_SIZE(ads112c14_sinc_latency_tmod)][ARRAY_SIZE(ads112c14_fmod_div)][3][2];
int fir_settling_time_range_available[ARRAY_SIZE(ads112c14_fir_latency_tmod)][ARRAY_SIZE(ads112c14_fmod_div)][3][2];
IIO_DECLARE_BUFFER_WITH_TS(__be32, scan, ADS112C14_MAX_MEASUREMENT_CHANNELS +
ARRAY_SIZE(ads112c14_sys_mon_channels));
};
static irqreturn_t ads112c14_drdy_irq_handler(int irq, void *private)
{
struct iio_dev *indio_dev = private;
struct ads112c14_data *data = iio_priv(indio_dev);
if (READ_ONCE(data->continuous_mode))
iio_trigger_poll(data->drdy_trig);
else
complete(&data->drdy_completion);
return IRQ_HANDLED;
}
static const struct iio_trigger_ops ads112c14_trigger_ops = {
.validate_device = iio_trigger_validate_own_device,
};
static bool ads112c14_writeable_reg(struct device *dev, unsigned int reg)
{
switch (reg) {
case ADS112C14_REG_DEVICE_ID:
case ADS112C14_REG_REVISION_ID:
case ADS112C14_REG_STATUS_LSB:
return false;
default:
return true;
}
}
static bool ads112c14_volatile_reg(struct device *dev, unsigned int reg)
{
switch (reg) {
case ADS112C14_REG_STATUS_MSB:
case ADS112C14_REG_STATUS_LSB:
case ADS112C14_REG_CONVERSION_CTRL:
return true;
default:
return false;
}
}
static const struct reg_default ads112c14_reg_defaults[] = {
{ ADS112C14_REG_DEVICE_CFG, 0 },
{ ADS112C14_REG_DATA_RATE_CFG, 0 },
{ ADS112C14_REG_MUX_CFG, 0 },
{ ADS112C14_REG_GAIN_CFG, FIELD_PREP_CONST(ADS112C14_GAIN_CFG_GAIN, 1) },
{ ADS112C14_REG_REFERENCE_CFG, 0 },
{ ADS112C14_REG_DIGITAL_CFG, 0 },
{ ADS112C14_REG_GPIO_CFG, 0 },
{ ADS112C14_REG_GPIO_DATA_OUTPUT, 0 },
{ ADS112C14_REG_IDAC_MAG_CFG, 0 },
{ ADS112C14_REG_IDAC_MUX_CFG, FIELD_PREP_CONST(ADS112C14_IDAC_MUX_CFG_I2MUX, 1) },
};
static int ads112c14_i2c_read_bytes(struct i2c_client *client, u8 cmd,
u8 *buf, u8 len, bool use_crc)
{
u8 rx_buf[4];
u8 rx_len;
int ret;
rx_len = len + (use_crc ? 1 : 0);
if (rx_len > sizeof(rx_buf))
return -EINVAL;
ret = i2c_smbus_read_i2c_block_data(client, cmd, rx_len, rx_buf);
if (ret < 0)
return ret;
if (use_crc) {
u8 crc = crc8(ads112c14_crc8_table, rx_buf, len, CRC8_INIT_VALUE);
if (crc != rx_buf[len])
return -EBADMSG;
}
memcpy(buf, rx_buf, len);
return 0;
}
static int ads112c14_regmap_bus_read(void *context, const void *reg_buf,
size_t reg_size, void *val_buf,
size_t val_size)
{
struct ads112c14_data *data = context;
struct device *dev = regmap_get_device(data->regmap);
struct i2c_client *client = to_i2c_client(dev);
const u8 *cmd = reg_buf;
if (reg_size != 1)
return -EINVAL;
return ads112c14_i2c_read_bytes(client, cmd[0], val_buf, val_size,
data->i2c_crc_enabled);
}
static int ads112c14_regmap_bus_write(void *context, const void *data_buf,
size_t count)
{
struct ads112c14_data *data = context;
struct device *dev = regmap_get_device(data->regmap);
struct i2c_client *client = to_i2c_client(dev);
const u8 *tx = data_buf;
u8 reg, readback;
int ret;
if (count != 2)
return -EINVAL;
ret = i2c_smbus_write_byte_data(client, tx[0], tx[1]);
if (ret)
return ret;
reg = tx[0] & ~ADS112C14_CMD_WREG;
if (!data->i2c_crc_enabled || ads112c14_volatile_reg(dev, reg))
return 0;
ret = ads112c14_i2c_read_bytes(client, reg | ADS112C14_CMD_RREG,
&readback, sizeof(readback), true);
if (ret)
return ret;
if (readback != tx[1])
return -EIO;
return 0;
}
static const struct regmap_bus ads112c14_regmap_bus = {
.read = ads112c14_regmap_bus_read,
.write = ads112c14_regmap_bus_write,
.reg_format_endian_default = REGMAP_ENDIAN_BIG,
.val_format_endian_default = REGMAP_ENDIAN_BIG,
};
static const struct regmap_config ads112c14_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.read_flag_mask = ADS112C14_CMD_RREG,
.write_flag_mask = ADS112C14_CMD_WREG,
.max_register = ADS112C14_REG_REG_MAP_CRC,
.writeable_reg = ads112c14_writeable_reg,
.volatile_reg = ads112c14_volatile_reg,
.reg_defaults = ads112c14_reg_defaults,
.num_reg_defaults = ARRAY_SIZE(ads112c14_reg_defaults),
.cache_type = REGCACHE_MAPLE,
};
static int ads112c14_get_osr(struct ads112c14_channel_state *channel_state)
{
u8 i;
switch (channel_state->filter_osr) {
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_16...ADS112C14_DATA_RATE_CFG_FLTR_OSR_32:
i = channel_state->filter_osr;
return ads112c14_sinc4_osr_available[i];
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_128...ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024:
i = channel_state->filter_osr - ADS112C14_DATA_RATE_CFG_FLTR_OSR_128;
return ads112c14_sinc4_sinc1_osr_available[i];
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS:
i = channel_state->speed_mode;
return ads112c14_sinc4_sinc1_pf1_25sps_osr_available[i];
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS:
i = channel_state->speed_mode;
return ads112c14_sinc4_sinc1_pf1_20sps_osr_available[i];
default:
return -EINVAL;
}
}
static int ads112c14_get_fmod_Hz(struct ads112c14_data *data,
struct ads112c14_channel_state *channel_state)
{
return data->fclk_Hz / ads112c14_fmod_div[channel_state->speed_mode];
}
static int ads112c14_delay_to_tmod(u8 delay)
{
if (!delay)
return 0;
return BIT(delay - 1);
}
static int ads112c14_get_latency_tmod(struct ads112c14_channel_state *channel_state)
{
u8 speed_mode = channel_state->speed_mode;
u8 filter_osr = channel_state->filter_osr;
if (speed_mode >= ARRAY_SIZE(ads112c14_fmod_div))
return -EINVAL;
if (filter_osr <= ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024)
return ads112c14_sinc_latency_tmod[filter_osr][speed_mode];
if (filter_osr == ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS)
return ads112c14_fir_latency_tmod[0][speed_mode];
if (filter_osr == ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS)
return ads112c14_fir_latency_tmod[1][speed_mode];
return -EINVAL;
}
static int ads112c14_get_settling_time_us(struct ads112c14_data *data,
struct ads112c14_channel_state *channel_state,
u8 delay, u32 *settling_time_us)
{
int fmod_Hz, latency_tmod;
u64 total_tmod;
fmod_Hz = ads112c14_get_fmod_Hz(data, channel_state);
if (fmod_Hz <= 0)
return -EINVAL;
latency_tmod = ads112c14_get_latency_tmod(channel_state);
if (latency_tmod < 0)
return latency_tmod;
total_tmod = latency_tmod + ads112c14_delay_to_tmod(delay);
*settling_time_us = div64_u64(total_tmod * USEC_PER_SEC, fmod_Hz);
return 0;
}
static int ads112c14_find_delay_for_settling_time_us(struct ads112c14_data *data,
struct ads112c14_channel_state *channel_state,
s64 settling_time_us, u8 *delay)
{
u64 delay_us, delay_tmod_needed;
u32 fixed_latency_us;
int ret, fmod_Hz;
u8 i;
ret = ads112c14_get_settling_time_us(data, channel_state, 0, &fixed_latency_us);
if (ret)
return ret;
if (settling_time_us <= fixed_latency_us) {
*delay = 0;
return 0;
}
fmod_Hz = ads112c14_get_fmod_Hz(data, channel_state);
if (fmod_Hz <= 0)
return -EINVAL;
delay_us = settling_time_us - fixed_latency_us;
delay_tmod_needed = DIV_ROUND_UP_ULL(delay_us * fmod_Hz, USEC_PER_SEC);
for (i = 1; i < ADS112C14_DELAY_MAX; i++) {
if (ads112c14_delay_to_tmod(i) >= delay_tmod_needed)
break;
}
*delay = i;
return 0;
}
static ssize_t ads112c14_read_settling_time(struct iio_dev *indio_dev,
uintptr_t private,
const struct iio_chan_spec *chan,
char *buf)
{
struct ads112c14_data *data = iio_priv(indio_dev);
struct ads112c14_channel_state *channel_state;
u32 settling_time_us;
int vals[2];
int ret;
guard(mutex)(&data->lock);
channel_state = &data->channel_states[chan->scan_index];
ret = ads112c14_get_settling_time_us(data, channel_state,
channel_state->delay,
&settling_time_us);
if (ret)
return ret;
iio_val_s64_decompose(settling_time_us, &vals[0], &vals[1]);
return iio_format_value(buf, IIO_VAL_DECIMAL64_MICRO, ARRAY_SIZE(vals), vals);
}
static ssize_t ads112c14_write_settling_time(struct iio_dev *indio_dev,
uintptr_t private,
const struct iio_chan_spec *chan,
const char *buf, size_t len)
{
struct ads112c14_data *data = iio_priv(indio_dev);
struct ads112c14_channel_state *channel_state;
s64 settling_time_us;
int integer;
int fract;
u8 delay;
int ret;
ret = iio_str_to_fixpoint(buf, 100000, &integer, &fract);
if (ret)
return ret;
settling_time_us = integer * MICRO + fract;
if (settling_time_us < 0)
return -EINVAL;
IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim);
if (IIO_DEV_ACQUIRE_FAILED(claim))
return -EBUSY;
guard(mutex)(&data->lock);
channel_state = &data->channel_states[chan->scan_index];
ret = ads112c14_find_delay_for_settling_time_us(data, channel_state,
settling_time_us, &delay);
if (ret)
return ret;
channel_state->delay = delay;
return len;
}
static ssize_t ads112c14_read_settling_time_available(struct iio_dev *indio_dev,
uintptr_t private,
const struct iio_chan_spec *chan,
char *buf)
{
struct ads112c14_data *data = iio_priv(indio_dev);
struct ads112c14_channel_state *channel_state;
u8 filter_osr, speed_mode;
const int (*range)[2];
size_t len = 0;
int i;
guard(mutex)(&data->lock);
channel_state = &data->channel_states[chan->scan_index];
filter_osr = channel_state->filter_osr;
speed_mode = channel_state->speed_mode;
if (speed_mode >= ARRAY_SIZE(ads112c14_fmod_div))
return -EINVAL;
if (filter_osr <= ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024)
range = data->sinc_settling_time_range_available[filter_osr][speed_mode];
else if (filter_osr == ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS)
range = data->fir_settling_time_range_available[0][speed_mode];
else if (filter_osr == ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS)
range = data->fir_settling_time_range_available[1][speed_mode];
else
return -EINVAL;
len += sysfs_emit_at(buf, len, "[");
for (i = 0; i < 3; i++) {
s64 range_val;
s32 int_val, rem;
range_val = iio_val_s64_compose(range[i][0], range[i][1]);
int_val = div_s64_rem(range_val, MICRO, &rem);
if (i)
len += sysfs_emit_at(buf, len, " ");
len += sysfs_emit_at(buf, len, "%d.%06d", int_val, rem);
}
len += sysfs_emit_at(buf, len, "]\n");
return len;
}
static int ads112c14_prepare_measurement_channel(struct ads112c14_data *data,
const struct iio_chan_spec *chan,
bool en_burnout)
{
struct ads112c14_measurement *measurement = &data->measurements[chan->scan_index];
struct ads112c14_channel_state *channel_state;
u32 refp_buf_en, refn_buf_en, ref_val, ref_sel;
int ret;
channel_state = &data->channel_states[chan->scan_index];
ret = regmap_update_bits(data->regmap, ADS112C14_REG_DEVICE_CFG,
ADS112C14_DEVICE_CFG_SPEED_MODE,
FIELD_PREP(ADS112C14_DEVICE_CFG_SPEED_MODE,
channel_state->speed_mode));
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_MUX_CFG,
ADS112C14_MUX_CFG_AINP | ADS112C14_MUX_CFG_AINN,
FIELD_PREP(ADS112C14_MUX_CFG_AINP, chan->channel) |
FIELD_PREP(ADS112C14_MUX_CFG_AINN, chan->channel2));
if (ret)
return ret;
ret = regmap_assign_bits(data->regmap, ADS112C14_REG_DIGITAL_CFG,
ADS112C14_DIGITAL_CFG_CODING,
!measurement->bipolar);
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_GAIN_CFG,
ADS112C14_GAIN_CFG_SYS_MON |
ADS112C14_GAIN_CFG_GAIN,
FIELD_PREP(ADS112C14_GAIN_CFG_SYS_MON, 0) |
FIELD_PREP(ADS112C14_GAIN_CFG_GAIN,
measurement->gain_val));
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_IDAC_MAG_CFG,
ADS112C14_IDAC_MAG_CFG_I2MAG |
ADS112C14_IDAC_MAG_CFG_I1MAG,
FIELD_PREP(ADS112C14_IDAC_MAG_CFG_I2MAG,
measurement->idac2_mag) |
FIELD_PREP(ADS112C14_IDAC_MAG_CFG_I1MAG,
measurement->idac1_mag));
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_IDAC_MUX_CFG,
ADS112C14_IDAC_MUX_CFG_IUNIT |
ADS112C14_IDAC_MUX_CFG_I2MUX |
ADS112C14_IDAC_MUX_CFG_I1MUX,
FIELD_PREP(ADS112C14_IDAC_MUX_CFG_IUNIT,
measurement->iunit) |
FIELD_PREP(ADS112C14_IDAC_MUX_CFG_I2MUX,
measurement->idac2_mux) |
FIELD_PREP(ADS112C14_IDAC_MUX_CFG_I1MUX,
measurement->idac1_mux));
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_DATA_RATE_CFG,
ADS112C14_DATA_RATE_CFG_DELAY |
ADS112C14_DATA_RATE_CFG_GC_EN |
ADS112C14_DATA_RATE_CFG_FLTR_OSR,
FIELD_PREP(ADS112C14_DATA_RATE_CFG_DELAY,
channel_state->delay) |
FIELD_PREP(ADS112C14_DATA_RATE_CFG_GC_EN,
(measurement->global_chop &&
!en_burnout) ? 1 : 0) |
FIELD_PREP(ADS112C14_DATA_RATE_CFG_FLTR_OSR,
channel_state->filter_osr));
if (ret)
return ret;
refp_buf_en = !data->refp_is_avdd &&
measurement->vref_source == ADS112C14_VREF_SOURCE_EXTERNAL;
refn_buf_en = !data->refn_is_gnd &&
measurement->vref_source == ADS112C14_VREF_SOURCE_EXTERNAL;
ref_val = measurement->vref_source == ADS112C14_VREF_SOURCE_INTERNAL_2_5V ?
ADS112C14_REFERENCE_CFG_REF_VAL_2_5V :
ADS112C14_REFERENCE_CFG_REF_VAL_1_25V;
switch (measurement->vref_source) {
case ADS112C14_VREF_SOURCE_AVDD:
ref_sel = ADS112C14_REFERENCE_CFG_REF_SEL_AVDD;
break;
case ADS112C14_VREF_SOURCE_EXTERNAL:
ref_sel = ADS112C14_REFERENCE_CFG_REF_SEL_EXTERNAL;
break;
default:
ref_sel = ADS112C14_REFERENCE_CFG_REF_SEL_INTERNAL;
break;
}
return regmap_update_bits(data->regmap, ADS112C14_REG_REFERENCE_CFG,
ADS112C14_REFERENCE_CFG_REFP_BUF_EN |
ADS112C14_REFERENCE_CFG_REFN_BUF_EN |
ADS112C14_REFERENCE_CFG_REF_VAL |
ADS112C14_REFERENCE_CFG_REF_SEL,
FIELD_PREP(ADS112C14_REFERENCE_CFG_REFP_BUF_EN,
refp_buf_en) |
FIELD_PREP(ADS112C14_REFERENCE_CFG_REFN_BUF_EN,
refn_buf_en) |
FIELD_PREP(ADS112C14_REFERENCE_CFG_REF_VAL,
ref_val) |
FIELD_PREP(ADS112C14_REFERENCE_CFG_REF_SEL,
ref_sel));
}
static int ads112c14_prepare_sys_mon_channel(struct ads112c14_data *data,
const struct iio_chan_spec *chan)
{
struct ads112c14_channel_state *channel_state;
u32 gain_val;
int ret;
channel_state = &data->channel_states[chan->scan_index];
gain_val = chan->channel == ADS112C14_SYS_MON_CHANNEL_SHORT ?
data->sys_mon_chan_short_gain_val : 1;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_GAIN_CFG,
ADS112C14_GAIN_CFG_SYS_MON |
ADS112C14_GAIN_CFG_GAIN,
FIELD_PREP(ADS112C14_GAIN_CFG_SYS_MON, chan->address) |
FIELD_PREP(ADS112C14_GAIN_CFG_GAIN, gain_val));
if (ret)
return ret;
ret = regmap_clear_bits(data->regmap, ADS112C14_REG_DIGITAL_CFG,
ADS112C14_DIGITAL_CFG_CODING);
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_DEVICE_CFG,
ADS112C14_DEVICE_CFG_SPEED_MODE,
FIELD_PREP(ADS112C14_DEVICE_CFG_SPEED_MODE,
channel_state->speed_mode));
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_DATA_RATE_CFG,
ADS112C14_DATA_RATE_CFG_DELAY |
ADS112C14_DATA_RATE_CFG_GC_EN |
ADS112C14_DATA_RATE_CFG_FLTR_OSR,
FIELD_PREP(ADS112C14_DATA_RATE_CFG_DELAY,
channel_state->delay) |
FIELD_PREP(ADS112C14_DATA_RATE_CFG_GC_EN, 0) |
FIELD_PREP(ADS112C14_DATA_RATE_CFG_FLTR_OSR,
channel_state->filter_osr));
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_REFERENCE_CFG,
ADS112C14_REFERENCE_CFG_REF_VAL |
ADS112C14_REFERENCE_CFG_REF_SEL,
FIELD_PREP(ADS112C14_REFERENCE_CFG_REF_VAL,
ADS112C14_REFERENCE_CFG_REF_VAL_2_5V) |
FIELD_PREP(ADS112C14_REFERENCE_CFG_REF_SEL,
ADS112C14_REFERENCE_CFG_REF_SEL_INTERNAL));
if (ret)
return ret;
return 0;
}
static int ads112c14_prepare_channel(struct ads112c14_data *data,
const struct iio_chan_spec *chan,
bool en_burnout)
{
if (chan->channel < ADS112C14_SYS_MON_CHANNEL_BASE)
return ads112c14_prepare_measurement_channel(data, chan, en_burnout);
return ads112c14_prepare_sys_mon_channel(data, chan);
}
static int ads112c14_scan_read(struct ads112c14_data *data, u8 *buf)
{
struct i2c_client *client = to_i2c_client(regmap_get_device(data->regmap));
int ret;
u8 len;
len = BITS_TO_BYTES(data->chip_info->resolution_bits);
if (data->i2c_crc_enabled)
len += 1;
ret = i2c_smbus_read_i2c_block_data(client, ADS112C14_CMD_RDATA, len, buf);
if (ret < 0)
return ret;
return 0;
}
static int ads112c14_wait_for_conversion_irq(struct ads112c14_data *data,
u32 settle_time_us)
{
unsigned long remaining;
int ret;
reinit_completion(&data->drdy_completion);
ret = regmap_write(data->regmap, ADS112C14_REG_CONVERSION_CTRL,
ADS112C14_CONVERSION_CTRL_START);
if (ret)
return ret;
remaining = wait_for_completion_timeout(&data->drdy_completion,
usecs_to_jiffies(settle_time_us +
1 * USEC_PER_MSEC));
return remaining ? 0 : -ETIMEDOUT;
}
static int ads112c14_wait_for_conversion_poll(struct ads112c14_data *data,
u32 settle_time_us)
{
u32 reg_val;
int ret;
ret = regmap_write(data->regmap, ADS112C14_REG_CONVERSION_CTRL,
ADS112C14_CONVERSION_CTRL_START);
if (ret)
return ret;
return regmap_read_poll_timeout(data->regmap,
ADS112C14_REG_STATUS_MSB, reg_val,
FIELD_GET(ADS112C14_STATUS_MSB_DRDY, reg_val),
1 * USEC_PER_MSEC,
settle_time_us + 1 * USEC_PER_MSEC);
}
static int ads112c14_single_conversion(struct ads112c14_data *data,
const struct iio_chan_spec *chan,
u8 *buf, bool en_burnout, bool for_scan)
{
struct i2c_client *client = to_i2c_client(regmap_get_device(data->regmap));
struct ads112c14_channel_state *channel_state;
u32 settle_time_us;
int ret;
guard(mutex)(&data->lock);
ret = ads112c14_prepare_channel(data, chan, en_burnout);
if (ret)
return ret;
channel_state = &data->channel_states[chan->scan_index];
ret = ads112c14_get_settling_time_us(data, channel_state,
channel_state->delay,
&settle_time_us);
if (ret)
return ret;
ret = regmap_test_bits(data->regmap, ADS112C14_REG_DATA_RATE_CFG,
ADS112C14_DATA_RATE_CFG_GC_EN);
if (ret < 0)
return ret;
if (ret)
settle_time_us *= 2;
if (data->drdy_irq)
ret = ads112c14_wait_for_conversion_irq(data, settle_time_us);
else
ret = ads112c14_wait_for_conversion_poll(data, settle_time_us);
if (ret)
return ret;
if (for_scan)
return ads112c14_scan_read(data, buf);
return ads112c14_i2c_read_bytes(client, ADS112C14_CMD_RDATA, buf,
BITS_TO_BYTES(data->chip_info->resolution_bits),
data->i2c_crc_enabled);
}
static bool ads112c14_using_drdy_trigger(struct iio_dev *indio_dev)
{
struct ads112c14_data *data = iio_priv(indio_dev);
return data->drdy_trig && indio_dev->trig == data->drdy_trig;
}
static int ads112c14_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
struct ads112c14_data *data = iio_priv(indio_dev);
struct ads112c14_measurement *measurement = NULL;
const int *scale_avail;
u32 vref_uV, fsr_bits;
vref_uV = ADS112C14_INT_REF1_mV * (MICRO / MILLI);
if (chan->channel < ADS112C14_SYS_MON_CHANNEL_BASE) {
measurement = &data->measurements[chan->scan_index];
fsr_bits = data->chip_info->resolution_bits - measurement->bipolar;
} else {
fsr_bits = data->chip_info->resolution_bits - 1;
}
switch (mask) {
case IIO_CHAN_INFO_RAW: {
u8 buf[3];
int ret;
IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim);
if (IIO_DEV_ACQUIRE_FAILED(claim))
return -EBUSY;
ret = ads112c14_single_conversion(data, chan, buf, false, false);
if (ret)
return ret;
switch (data->chip_info->resolution_bits) {
case 16:
*val = get_unaligned_be16(buf);
break;
case 24:
*val = get_unaligned_be24(buf);
break;
default:
return -EINVAL;
}
if (!measurement || measurement->bipolar)
*val = sign_extend32(*val, fsr_bits);
return IIO_VAL_INT;
}
case IIO_CHAN_INFO_SCALE:
if (chan->type == IIO_TEMP) {
*val = MILLI * vref_uV / 405;
*val2 = fsr_bits;
return IIO_VAL_FRACTIONAL_LOG2;
}
if (chan->channel < ADS112C14_SYS_MON_CHANNEL_BASE) {
guard(mutex)(&data->lock);
scale_avail = measurement->scale_available[measurement->gain_val];
*val = scale_avail[0];
*val2 = scale_avail[1];
return IIO_VAL_DECIMAL64_PICO;
}
if (chan->channel == ADS112C14_SYS_MON_CHANNEL_SHORT) {
u8 idx;
guard(mutex)(&data->lock);
idx = data->sys_mon_chan_short_gain_val;
scale_avail = data->sys_mon_chan_short_scale_available[idx];
*val = scale_avail[0];
*val2 = scale_avail[1];
return IIO_VAL_DECIMAL64_PICO;
}
*val = vref_uV / (MICRO / MILLI);
switch (chan->address) {
case 3 ... 5:
*val2 = fsr_bits - 3;
break;
default:
*val2 = fsr_bits;
break;
}
return IIO_VAL_FRACTIONAL_LOG2;
case IIO_CHAN_INFO_OFFSET:
if (chan->type != IIO_TEMP)
return -EINVAL;
*val = div_s64((s64)(25 * 405 - 119500) * BIT(fsr_bits), vref_uV);
return IIO_VAL_INT;
case IIO_CHAN_INFO_SAMP_FREQ: {
struct ads112c14_channel_state *channel_state;
const int (*available)[2];
u8 i, j;
guard(mutex)(&data->lock);
channel_state = &data->channel_states[chan->scan_index];
switch (channel_state->filter_osr) {
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_16...ADS112C14_DATA_RATE_CFG_FLTR_OSR_32:
j = channel_state->filter_osr;
available = data->sinc4_sample_rate_available[j];
i = channel_state->speed_mode;
break;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_128...ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024:
j = channel_state->filter_osr - ADS112C14_DATA_RATE_CFG_FLTR_OSR_128;
available = data->sinc4_sinc1_sample_rate_available[j];
i = channel_state->speed_mode;
break;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS:
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS:
available = data->sinc4_sinc1_pf1_sample_rate_available;
i = channel_state->filter_osr - ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS;
break;
default:
return -EINVAL;
}
*val = available[i][0];
*val2 = available[i][1];
return IIO_VAL_INT_PLUS_MICRO;
}
case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
guard(mutex)(&data->lock);
*val = ads112c14_get_osr(&data->channel_states[chan->scan_index]);
return IIO_VAL_INT;
}
default:
return -EINVAL;
}
}
static int ads112c14_read_avail(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan, const int **vals,
int *type, int *length, long mask)
{
struct ads112c14_data *data = iio_priv(indio_dev);
struct ads112c14_channel_state *channel_state;
channel_state = &data->channel_states[chan->scan_index];
switch (mask) {
case IIO_CHAN_INFO_SCALE:
if (chan->channel < ADS112C14_SYS_MON_CHANNEL_BASE) {
struct ads112c14_measurement *measurement;
guard(mutex)(&data->lock);
measurement = &data->measurements[chan->scan_index];
*vals = (const int *)measurement->scale_available;
*length = 2 * ARRAY_SIZE(measurement->scale_available);
*type = IIO_VAL_DECIMAL64_PICO;
return IIO_AVAIL_LIST;
}
if (chan->channel == ADS112C14_SYS_MON_CHANNEL_SHORT) {
guard(mutex)(&data->lock);
*vals = (const int *)data->sys_mon_chan_short_scale_available;
*length = 2 * ARRAY_SIZE(data->sys_mon_chan_short_scale_available);
*type = IIO_VAL_DECIMAL64_PICO;
return IIO_AVAIL_LIST;
}
return -EINVAL;
case IIO_CHAN_INFO_SAMP_FREQ: {
guard(mutex)(&data->lock);
switch (channel_state->filter_osr) {
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_16...ADS112C14_DATA_RATE_CFG_FLTR_OSR_32:
*vals = (const int *)data->sinc4_sample_rate_available[channel_state->filter_osr];
*length = 2 * ARRAY_SIZE(data->sinc4_sample_rate_available[0]);
*type = IIO_VAL_INT_PLUS_MICRO;
return IIO_AVAIL_LIST;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_128...ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024:
*vals = (const int *)data->sinc4_sinc1_sample_rate_available[channel_state->filter_osr - ADS112C14_DATA_RATE_CFG_FLTR_OSR_128];
*length = 2 * ARRAY_SIZE(data->sinc4_sinc1_sample_rate_available[0]);
*type = IIO_VAL_INT_PLUS_MICRO;
return IIO_AVAIL_LIST;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS...ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS:
*vals = (const int *)data->sinc4_sinc1_pf1_sample_rate_available;
*length = 2 * ARRAY_SIZE(data->sinc4_sinc1_pf1_sample_rate_available);
*type = IIO_VAL_INT_PLUS_MICRO;
return IIO_AVAIL_LIST;
default:
return -EINVAL;
}
}
case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
guard(mutex)(&data->lock);
switch (channel_state->filter_osr) {
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_16...ADS112C14_DATA_RATE_CFG_FLTR_OSR_32:
*vals = ads112c14_sinc4_osr_available;
*length = ARRAY_SIZE(ads112c14_sinc4_osr_available);
*type = IIO_VAL_INT;
return IIO_AVAIL_LIST;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_128...ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024:
*vals = ads112c14_sinc4_sinc1_osr_available;
*length = ARRAY_SIZE(ads112c14_sinc4_sinc1_osr_available);
*type = IIO_VAL_INT;
return IIO_AVAIL_LIST;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS:
*vals = ads112c14_sinc4_sinc1_pf1_25sps_osr_available;
*length = ARRAY_SIZE(ads112c14_sinc4_sinc1_pf1_25sps_osr_available);
*type = IIO_VAL_INT;
return IIO_AVAIL_LIST;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS:
*vals = ads112c14_sinc4_sinc1_pf1_20sps_osr_available;
*length = ARRAY_SIZE(ads112c14_sinc4_sinc1_pf1_20sps_osr_available);
*type = IIO_VAL_INT;
return IIO_AVAIL_LIST;
default:
return -EINVAL;
}
}
default:
return -EINVAL;
}
}
static int ads112c14_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan, int val,
int val2, long mask)
{
struct ads112c14_data *data = iio_priv(indio_dev);
const int (*scale_avail)[2];
u8 *gain_val;
IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim);
if (IIO_DEV_ACQUIRE_FAILED(claim))
return -EBUSY;
switch (mask) {
case IIO_CHAN_INFO_SCALE: {
guard(mutex)(&data->lock);
if (chan->channel < ADS112C14_SYS_MON_CHANNEL_BASE) {
struct ads112c14_measurement *measurement;
measurement = &data->measurements[chan->scan_index];
scale_avail = measurement->scale_available;
gain_val = &measurement->gain_val;
} else if (chan->channel == ADS112C14_SYS_MON_CHANNEL_SHORT) {
scale_avail = data->sys_mon_chan_short_scale_available;
gain_val = &data->sys_mon_chan_short_gain_val;
} else {
return -EINVAL;
}
for (u32 i = 0; i < ARRAY_SIZE(ads112c14_pga_gains_x10); i++) {
if (iio_val_s64_compose(val, val2) ==
iio_val_s64_compose(scale_avail[i][0], scale_avail[i][1])) {
*gain_val = i;
return 0;
}
}
return -EINVAL;
}
case IIO_CHAN_INFO_SAMP_FREQ: {
struct ads112c14_channel_state *channel_state;
const int (*available)[2];
guard(mutex)(&data->lock);
channel_state = &data->channel_states[chan->scan_index];
switch (channel_state->filter_osr) {
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_16...ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024:
if (channel_state->filter_osr < ADS112C14_DATA_RATE_CFG_FLTR_OSR_128) {
u8 idx = channel_state->filter_osr;
available = data->sinc4_sample_rate_available[idx];
} else {
u8 idx = channel_state->filter_osr - ADS112C14_DATA_RATE_CFG_FLTR_OSR_128;
available = data->sinc4_sinc1_sample_rate_available[idx];
}
for (unsigned int i = 0; i < ARRAY_SIZE(ads112c14_fmod_div); i++) {
if (val == available[i][0] && val2 == available[i][1]) {
channel_state->speed_mode = i;
return 0;
}
}
return -EINVAL;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS:
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS: {
available = data->sinc4_sinc1_pf1_sample_rate_available;
for (unsigned int i = 0; i < ARRAY_SIZE(data->sinc4_sinc1_pf1_sample_rate_available); i++) {
if (val == available[i][0] && val2 == available[i][1]) {
channel_state->filter_osr = i + ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS;
return 0;
}
}
return -EINVAL;
}
default:
return -EINVAL;
}
}
case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
struct ads112c14_channel_state *channel_state;
guard(mutex)(&data->lock);
channel_state = &data->channel_states[chan->scan_index];
switch (channel_state->filter_osr) {
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_16...ADS112C14_DATA_RATE_CFG_FLTR_OSR_32:
for (unsigned int i = 0; i < ARRAY_SIZE(ads112c14_sinc4_osr_available); i++) {
if (val == ads112c14_sinc4_osr_available[i]) {
channel_state->filter_osr = i;
return 0;
}
}
return -EINVAL;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_128...ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024:
for (unsigned int i = 0; i < ARRAY_SIZE(ads112c14_sinc4_sinc1_osr_available); i++) {
if (val == ads112c14_sinc4_sinc1_osr_available[i]) {
channel_state->filter_osr = i + ADS112C14_DATA_RATE_CFG_FLTR_OSR_128;
return 0;
}
}
return -EINVAL;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS:
for (unsigned int i = 0; i < ARRAY_SIZE(ads112c14_sinc4_sinc1_pf1_25sps_osr_available); i++) {
if (val == ads112c14_sinc4_sinc1_pf1_25sps_osr_available[i]) {
channel_state->speed_mode = i;
return 0;
}
}
return -EINVAL;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS:
for (unsigned int i = 0; i < ARRAY_SIZE(ads112c14_sinc4_sinc1_pf1_20sps_osr_available); i++) {
if (val == ads112c14_sinc4_sinc1_pf1_20sps_osr_available[i]) {
channel_state->speed_mode = i;
return 0;
}
}
return -EINVAL;
default:
return -EINVAL;
}
}
default:
return -EINVAL;
}
}
static int ads112c14_write_raw_get_fmt(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
long mask)
{
switch (mask) {
case IIO_CHAN_INFO_SCALE:
return IIO_VAL_DECIMAL64_PICO;
default:
return IIO_VAL_INT_PLUS_MICRO;
}
}
static int ads112c14_update_scan_mode(struct iio_dev *indio_dev,
const unsigned long *scan_mask)
{
if (!ads112c14_using_drdy_trigger(indio_dev))
return 0;
if (!iio_validate_scan_mask_onehot(indio_dev, scan_mask))
return -EINVAL;
return 0;
}
static int ads112c14_debugfs_reg_access(struct iio_dev *indio_dev,
unsigned int reg,
unsigned int writeval,
unsigned int *readval)
{
struct ads112c14_data *data = iio_priv(indio_dev);
if (readval)
return regmap_read(data->regmap, reg, readval);
return regmap_write(data->regmap, reg, writeval);
}
static int ads112c14_read_label(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan, char *label)
{
struct ads112c14_data *data = iio_priv(indio_dev);
const char *label_source;
if (chan->channel < ADS112C14_SYS_MON_CHANNEL_BASE) {
struct ads112c14_measurement *measurement;
measurement = &data->measurements[chan->scan_index];
if (!measurement->label)
return -EINVAL;
return sysfs_emit(label, "%s\n", measurement->label);
}
switch (chan->channel) {
case ADS112C14_SYS_MON_CHANNEL_TEMP:
label_source = "Internal temperature sensor";
break;
case ADS112C14_SYS_MON_CHANNEL_EXT_REF:
label_source = "External reference";
break;
case ADS112C14_SYS_MON_CHANNEL_AVDD:
label_source = "AVDD";
break;
case ADS112C14_SYS_MON_CHANNEL_DVDD:
label_source = "DVDD";
break;
case ADS112C14_SYS_MON_CHANNEL_SHORT:
label_source = "Internal short (internal reference source)";
break;
default:
return -EINVAL;
}
return sysfs_emit(label, "%s\n", label_source);
}
static const struct iio_chan_spec *
ads112c14_first_active_channel(struct iio_dev *indio_dev)
{
unsigned int scan_mask_len = iio_get_masklength(indio_dev);
unsigned int i;
i = find_first_bit(indio_dev->active_scan_mask, scan_mask_len);
if (i == scan_mask_len)
return NULL;
return &indio_dev->channels[i];
}
static irqreturn_t ads112c14_trigger_handler(int irq, void *private)
{
struct iio_poll_func *pf = private;
struct iio_dev *indio_dev = pf->indio_dev;
struct ads112c14_data *data = iio_priv(indio_dev);
u32 offset = 0;
u32 i;
int ret;
if (ads112c14_using_drdy_trigger(indio_dev)) {
const struct iio_chan_spec *chan;
chan = ads112c14_first_active_channel(indio_dev);
if (!chan)
goto out;
ret = ads112c14_scan_read(data, (u8 *)&data->scan[0]);
if (ret) {
dev_err_once(indio_dev->dev.parent,
"failed to read channel %d: %pe; additional errors will be suppressed\n",
chan->channel, ERR_PTR(ret));
goto out;
}
iio_push_to_buffers_with_ts(indio_dev, data->scan,
sizeof(data->scan), pf->timestamp);
goto out;
}
iio_for_each_active_channel(indio_dev, i) {
const struct iio_chan_spec *chan = &indio_dev->channels[i];
ret = ads112c14_single_conversion(data, chan,
(u8 *)&data->scan[offset++],
false, true);
if (ret) {
dev_err_once(indio_dev->dev.parent,
"failed to read channel %d: %pe; additional errors will be suppressed\n",
chan->channel, ERR_PTR(ret));
goto out;
}
}
iio_push_to_buffers_with_ts(indio_dev, data->scan,
sizeof(data->scan), pf->timestamp);
out:
iio_trigger_notify_done(indio_dev->trig);
return IRQ_HANDLED;
}
static const struct iio_info ads112c14_info = {
.read_raw = ads112c14_read_raw,
.read_avail = ads112c14_read_avail,
.write_raw = ads112c14_write_raw,
.write_raw_get_fmt = ads112c14_write_raw_get_fmt,
.update_scan_mode = ads112c14_update_scan_mode,
.debugfs_reg_access = ads112c14_debugfs_reg_access,
.read_label = ads112c14_read_label,
};
static int ads112c14_buffer_postenable(struct iio_dev *indio_dev)
{
struct ads112c14_data *data = iio_priv(indio_dev);
const struct iio_chan_spec *chan;
int ret;
if (!ads112c14_using_drdy_trigger(indio_dev))
return 0;
chan = ads112c14_first_active_channel(indio_dev);
if (!chan)
return -EINVAL;
guard(mutex)(&data->lock);
ret = ads112c14_prepare_channel(data, chan, false);
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_DEVICE_CFG,
ADS112C14_DEVICE_CFG_CONV_MODE,
FIELD_PREP(ADS112C14_DEVICE_CFG_CONV_MODE,
ADS112C14_DEVICE_CFG_CONV_MODE_CONTINUOUS));
if (ret)
return ret;
WRITE_ONCE(data->continuous_mode, true);
ret = regmap_write(data->regmap, ADS112C14_REG_CONVERSION_CTRL,
ADS112C14_CONVERSION_CTRL_START);
if (ret) {
WRITE_ONCE(data->continuous_mode, false);
regmap_update_bits(data->regmap, ADS112C14_REG_DEVICE_CFG,
ADS112C14_DEVICE_CFG_CONV_MODE,
FIELD_PREP(ADS112C14_DEVICE_CFG_CONV_MODE,
ADS112C14_DEVICE_CFG_CONV_MODE_SINGLE_SHOT));
return ret;
}
return 0;
}
static int ads112c14_buffer_predisable(struct iio_dev *indio_dev)
{
struct ads112c14_data *data = iio_priv(indio_dev);
int ret;
if (!ads112c14_using_drdy_trigger(indio_dev))
return 0;
guard(mutex)(&data->lock);
WRITE_ONCE(data->continuous_mode, false);
ret = regmap_write(data->regmap, ADS112C14_REG_CONVERSION_CTRL,
ADS112C14_CONVERSION_CTRL_STOP);
if (ret)
return ret;
return regmap_update_bits(data->regmap, ADS112C14_REG_DEVICE_CFG,
ADS112C14_DEVICE_CFG_CONV_MODE,
FIELD_PREP(ADS112C14_DEVICE_CFG_CONV_MODE,
ADS112C14_DEVICE_CFG_CONV_MODE_SINGLE_SHOT));
}
static const struct iio_buffer_setup_ops ads112c14_buffer_setup_ops = {
.postenable = ads112c14_buffer_postenable,
.predisable = ads112c14_buffer_predisable,
};
static ssize_t ads112c14_read_burnout_raw(struct iio_dev *indio_dev,
uintptr_t private,
struct iio_chan_spec const *chan,
char *buf)
{
struct ads112c14_data *data = iio_priv(indio_dev);
struct ads112c14_measurement *measurement;
int ret, ret2, val;
u8 raw_buf[3];
if (chan->channel >= ADS112C14_SYS_MON_CHANNEL_BASE)
return -EINVAL;
measurement = &data->measurements[chan->scan_index];
if (!measurement->burnout)
return -EINVAL;
IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim);
if (IIO_DEV_ACQUIRE_FAILED(claim))
return -EBUSY;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_DEVICE_CFG,
ADS112C14_DEVICE_CFG_BOCS,
FIELD_PREP(ADS112C14_DEVICE_CFG_BOCS,
measurement->burnout));
if (ret)
return ret;
ret = ads112c14_single_conversion(data, chan, raw_buf, true, false);
ret2 = regmap_update_bits(data->regmap, ADS112C14_REG_DEVICE_CFG,
ADS112C14_DEVICE_CFG_BOCS,
FIELD_PREP(ADS112C14_DEVICE_CFG_BOCS,
ADS112C14_DEVICE_CFG_BOCS_DISABLED));
if (ret < 0)
return ret;
if (ret2)
return ret2;
switch (data->chip_info->resolution_bits) {
case 16:
val = get_unaligned_be16(raw_buf);
break;
case 24:
val = get_unaligned_be24(raw_buf);
break;
default:
return -EINVAL;
}
if (measurement->bipolar)
val = sign_extend32(val, data->chip_info->resolution_bits - 1);
return sysfs_emit(buf, "%d\n", val);
}
static int ads112c14_get_filter_type_from_state(struct ads112c14_channel_state *channel_state)
{
switch (channel_state->filter_osr) {
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_16...ADS112C14_DATA_RATE_CFG_FLTR_OSR_32:
return ADS112C14_FILTER_TYPE_SINC4;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_128...ADS112C14_DATA_RATE_CFG_FLTR_OSR_1024:
return ADS112C14_FILTER_TYPE_SINC4_SINC1;
case ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS...ADS112C14_DATA_RATE_CFG_FLTR_OSR_20SPS:
return ADS112C14_FILTER_TYPE_SINC4_SINC1_PF1;
default:
return -EINVAL;
}
}
static int ads112c14_set_filter_type(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
unsigned int val)
{
struct ads112c14_data *data = iio_priv(indio_dev);
struct ads112c14_channel_state *channel_state;
int ret;
IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim);
if (IIO_DEV_ACQUIRE_FAILED(claim))
return -EBUSY;
guard(mutex)(&data->lock);
channel_state = &data->channel_states[chan->scan_index];
ret = ads112c14_get_filter_type_from_state(channel_state);
if (ret < 0)
return ret;
if (ret == val)
return 0;
switch (val) {
case ADS112C14_FILTER_TYPE_SINC4:
channel_state->filter_osr = ADS112C14_DATA_RATE_CFG_FLTR_OSR_16;
break;
case ADS112C14_FILTER_TYPE_SINC4_SINC1:
channel_state->filter_osr = ADS112C14_DATA_RATE_CFG_FLTR_OSR_128;
break;
case ADS112C14_FILTER_TYPE_SINC4_SINC1_PF1:
channel_state->filter_osr = ADS112C14_DATA_RATE_CFG_FLTR_OSR_25SPS;
break;
default:
return -EINVAL;
}
return 0;
}
static int ads112c14_get_filter_type(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan)
{
struct ads112c14_data *data = iio_priv(indio_dev);
struct ads112c14_channel_state *channel_state;
guard(mutex)(&data->lock);
channel_state = &data->channel_states[chan->scan_index];
return ads112c14_get_filter_type_from_state(channel_state);
}
static const struct iio_enum ads112c14_filter_type_enum = {
.items = ads112c14_filter_type_names,
.num_items = ARRAY_SIZE(ads112c14_filter_type_names),
.set = ads112c14_set_filter_type,
.get = ads112c14_get_filter_type,
};
static const struct iio_chan_spec_ext_info ads112c14_ext_info[] = {
{
.name = "settlingtime",
.read = ads112c14_read_settling_time,
.write = ads112c14_write_settling_time,
.shared = IIO_SEPARATE,
},
{
.name = "settlingtime_available",
.read = ads112c14_read_settling_time_available,
.shared = IIO_SEPARATE,
},
IIO_ENUM("filter_type", IIO_SEPARATE, &ads112c14_filter_type_enum),
IIO_ENUM_AVAILABLE("filter_type", IIO_SEPARATE, &ads112c14_filter_type_enum),
{ }
};
static const struct iio_chan_spec_ext_info ads112c14_ext_info_burnout[] = {
{
.name = "burnoutraw",
.read = ads112c14_read_burnout_raw,
},
{
.name = "settlingtime",
.read = ads112c14_read_settling_time,
.write = ads112c14_write_settling_time,
.shared = IIO_SEPARATE,
},
{
.name = "settlingtime_available",
.read = ads112c14_read_settling_time_available,
.shared = IIO_SEPARATE,
},
IIO_ENUM("filter_type", IIO_SEPARATE, &ads112c14_filter_type_enum),
IIO_ENUM_AVAILABLE("filter_type", IIO_SEPARATE, &ads112c14_filter_type_enum),
{ }
};
static int ads112c14_populate_idac_mag(u32 current_nA, u8 *idac_mag)
{
u32 current_uA = current_nA / (NANO / MICRO);
if (current_uA == 1)
*idac_mag = 1;
else if (in_range(current_uA, 10, 100) && current_uA % 10 == 0)
*idac_mag = current_uA / 10 + 1;
else
return dev_err_probe(NULL, -EINVAL,
"invalid excitation-current-nanoamp value\n");
return 0;
}
static int ads112c14_parse_channels(struct iio_dev *indio_dev,
bool *need_avdd_ref, bool *need_ext_ref)
{
struct ads112c14_data *data = iio_priv(indio_dev);
struct device *dev = indio_dev->dev.parent;
struct iio_chan_spec *channels;
u32 num_child_nodes, num_data_chans, i, pair[2];
int ret;
*need_avdd_ref = false;
*need_ext_ref = false;
num_child_nodes = device_get_named_child_node_count(dev, "channel");
data->measurements = devm_kzalloc_objs(dev, *data->measurements,
num_child_nodes);
if (!data->measurements)
return -ENOMEM;
num_data_chans = num_child_nodes + ARRAY_SIZE(ads112c14_sys_mon_channels);
data->channel_states = devm_kzalloc_objs(dev, *data->channel_states,
num_data_chans);
if (!data->channel_states)
return -ENOMEM;
channels = devm_kzalloc_objs(dev, *channels, num_data_chans + 1);
if (!channels)
return -ENOMEM;
i = 0;
device_for_each_named_child_node_scoped(dev, child, "channel") {
struct ads112c14_measurement *measurement = &data->measurements[i];
struct iio_chan_spec *spec = &channels[i];
const char *propname;
spec->indexed = 1;
spec->scan_index = i;
spec->ext_info = ads112c14_ext_info;
measurement->gain_val = 1;
data->channel_states[i].filter_osr = ADS112C14_DATA_RATE_CFG_FLTR_OSR_16;
if (fwnode_property_present(child, "label")) {
ret = fwnode_property_read_string(child, "label", &measurement->label);
if (ret)
return dev_err_probe(dev, ret,
"failed to read label property\n");
}
if (fwnode_property_present(child, "single-channel")) {
ret = fwnode_property_read_u32(child, "single-channel",
&pair[0]);
if (ret)
return dev_err_probe(dev, ret,
"failed to read single-channel property\n");
if (pair[0] >= 8)
return dev_err_probe(dev, -EINVAL,
"single-channel value must be between 0 and 7\n");
spec->channel = pair[0];
spec->channel2 = ADS112C14_MUX_CFG_AIN_GND;
} else if (fwnode_property_present(child, "diff-channels")) {
ret = fwnode_property_read_u32_array(child, "diff-channels",
pair, ARRAY_SIZE(pair));
if (ret)
return dev_err_probe(dev, ret,
"failed to read diff-channels property\n");
if (pair[0] >= 8 || pair[1] >= 8)
return dev_err_probe(dev, -EINVAL,
"diff-channels values must be between 0 and 7\n");
spec->differential = 1;
spec->channel = pair[0];
spec->channel2 = pair[1];
} else {
return dev_err_probe(dev, -EINVAL,
"channel node missing channel type property\n");
}
if (fwnode_property_present(child, "excitation-channels")) {
ret = fwnode_property_count_u32(child, "excitation-channels");
if (ret < 0)
return dev_err_probe(dev, ret,
"failed to read excitation-channels property\n");
if (ret < 1 || ret > 2)
return dev_err_probe(dev, -EINVAL,
"excitation-channels property must have 1 or 2 values\n");
measurement->iadc_count = ret;
pair[1] = 0;
ret = fwnode_property_read_u32_array(child, "excitation-channels",
pair, measurement->iadc_count);
if (ret)
return dev_err_probe(dev, ret,
"failed to read excitation-channels property\n");
if (pair[0] >= 8 || pair[1] >= 8)
return dev_err_probe(dev, -EINVAL,
"excitation-channels values must be between 0 and 7\n");
measurement->idac1_mux = pair[0];
measurement->idac2_mux = measurement->iadc_count > 1 ? pair[1] : 0;
ret = fwnode_property_read_u32_array(child, "excitation-current-nanoamp",
pair, measurement->iadc_count);
if (ret)
return dev_err_probe(dev, ret,
"failed to read excitation-current-nanoamp property\n");
if (pair[0] <= 100 * (NANO / MICRO) &&
(measurement->iadc_count == 1 || pair[1] <= 100 * (NANO / MICRO))) {
ret = ads112c14_populate_idac_mag(pair[0],
&measurement->idac1_mag);
if (ret)
return ret;
if (measurement->iadc_count > 1) {
ret = ads112c14_populate_idac_mag(pair[1],
&measurement->idac2_mag);
if (ret)
return ret;
}
} else {
measurement->iunit = 1;
ret = ads112c14_populate_idac_mag(pair[0] / 10,
&measurement->idac1_mag);
if (ret)
return ret;
if (measurement->iadc_count > 1) {
ret = ads112c14_populate_idac_mag(pair[1] / 10,
&measurement->idac2_mag);
if (ret)
return ret;
}
}
}
measurement->bipolar = fwnode_property_read_bool(child, "bipolar");
measurement->global_chop = fwnode_property_read_bool(child,
"input-chopping");
propname = "burn-out-current-nanoamp";
if (fwnode_property_present(child, propname)) {
u32 burnout_nA;
ret = fwnode_property_read_u32(child, propname, &burnout_nA);
if (ret)
return dev_err_probe(dev, ret,
"failed to read %s property\n",
propname);
switch (burnout_nA) {
case 200:
measurement->burnout = ADS112C14_DEVICE_CFG_BOCS_200_nA;
break;
case 1000:
measurement->burnout = ADS112C14_DEVICE_CFG_BOCS_1_uA;
break;
case 10000:
measurement->burnout = ADS112C14_DEVICE_CFG_BOCS_10_uA;
break;
default:
return dev_err_probe(dev, -EINVAL,
"invalid %s value\n", propname);
}
if (measurement->burnout != ADS112C14_DEVICE_CFG_BOCS_DISABLED)
spec->ext_info = ads112c14_ext_info_burnout;
}
if (fwnode_property_present(child, "reference-sources")) {
ret = fwnode_property_match_property_string(child,
"reference-sources", ads112c14_vref_source_names,
ARRAY_SIZE(ads112c14_vref_source_names));
if (ret < 0)
return dev_err_probe(dev, ret,
"invalid reference-sources value\n");
measurement->vref_source = ret;
}
if (measurement->vref_source == ADS112C14_VREF_SOURCE_AVDD)
*need_avdd_ref = true;
if (measurement->vref_source == ADS112C14_VREF_SOURCE_EXTERNAL)
*need_ext_ref = true;
spec->info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE) |
BIT(IIO_CHAN_INFO_SAMP_FREQ) |
BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO);
spec->info_mask_separate_available = BIT(IIO_CHAN_INFO_SCALE) |
BIT(IIO_CHAN_INFO_SAMP_FREQ) |
BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO);
spec->type = (measurement->vref_source == ADS112C14_VREF_SOURCE_EXTERNAL &&
data->ext_ref_ohms) ? IIO_RESISTANCE : IIO_VOLTAGE;
if (spec->type == IIO_RESISTANCE)
spec->differential = 0;
spec->scan_type = (struct iio_scan_type){
.format = measurement->bipolar ?
IIO_SCAN_FORMAT_SIGNED_INT :
IIO_SCAN_FORMAT_UNSIGNED_INT,
.realbits = data->chip_info->resolution_bits,
.storagebits = 32,
.shift = 32 - data->chip_info->resolution_bits,
.endianness = IIO_BE,
};
i++;
}
data->num_measurements = i;
if (data->num_measurements > ADS112C14_MAX_MEASUREMENT_CHANNELS)
return dev_err_probe(dev, -EINVAL,
"too many measurement channels defined\n");
memcpy(channels + i, ads112c14_sys_mon_channels, sizeof(ads112c14_sys_mon_channels));
for (u32 j = 0; j < ARRAY_SIZE(ads112c14_sys_mon_channels); j++) {
struct iio_chan_spec *spec = &channels[i];
struct ads112c14_channel_state *channel_state;
channel_state = &data->channel_states[i];
channel_state->filter_osr = ADS112C14_DATA_RATE_CFG_FLTR_OSR_16;
spec->scan_index = i;
spec->scan_type = (struct iio_scan_type){
.format = IIO_SCAN_FORMAT_SIGNED_INT,
.realbits = data->chip_info->resolution_bits,
.storagebits = 32,
.shift = 32 - data->chip_info->resolution_bits,
.endianness = IIO_BE,
};
i++;
}
channels[i] = IIO_CHAN_SOFT_TIMESTAMP(i);
i++;
indio_dev->channels = channels;
indio_dev->num_channels = i;
return 0;
}
static void ads112c14_populate_scale_available(int (*scale_avail)[2],
u32 full_scale, u32 fsr_bits)
{
for (u32 i = 0; i < ARRAY_SIZE(ads112c14_pga_gains_x10); i++) {
u64 gain_x10 = ads112c14_pga_gains_x10[i];
s64 scale;
scale = div64_u64((u64)PICO * 10U * full_scale,
gain_x10 * BIT(fsr_bits));
iio_val_s64_decompose(scale, &scale_avail[i][0],
&scale_avail[i][1]);
}
}
static void ads112c14_populate_odr_tables(struct ads112c14_data *data)
{
int *available;
u32 osr, fmod_Hz;
u64 odr_uHz;
u32 rem;
for (unsigned int i = 0; i < ARRAY_SIZE(ads112c14_sinc4_osr_available); i++) {
osr = ads112c14_sinc4_osr_available[i];
for (unsigned int j = 0; j < ARRAY_SIZE(ads112c14_fmod_div); j++) {
fmod_Hz = data->fclk_Hz / ads112c14_fmod_div[j];
odr_uHz = div_u64((u64)fmod_Hz * MICRO, osr);
available = data->sinc4_sample_rate_available[i][j];
available[0] = div_u64_rem(odr_uHz, MICRO, &rem);
available[1] = rem;
}
}
for (unsigned int i = 0; i < ARRAY_SIZE(ads112c14_sinc4_sinc1_osr_available); i++) {
osr = ads112c14_sinc4_sinc1_osr_available[i];
for (unsigned int j = 0; j < ARRAY_SIZE(ads112c14_fmod_div); j++) {
fmod_Hz = data->fclk_Hz / ads112c14_fmod_div[j];
odr_uHz = div_u64((u64)fmod_Hz * MICRO, osr);
available = data->sinc4_sinc1_sample_rate_available[i][j];
available[0] = div_u64_rem(odr_uHz, MICRO, &rem);
available[1] = rem;
}
}
odr_uHz = div_u64((u64)25 * data->fclk_Hz * MICRO, ADS112C14_INTERNAL_CLK_Hz);
available = data->sinc4_sinc1_pf1_sample_rate_available[0];
available[0] = div_u64_rem(odr_uHz, MICRO, &rem);
available[1] = rem;
odr_uHz = div_u64((u64)20 * data->fclk_Hz * MICRO, ADS112C14_INTERNAL_CLK_Hz);
available = data->sinc4_sinc1_pf1_sample_rate_available[1];
available[0] = div_u64_rem(odr_uHz, MICRO, &rem);
available[1] = rem;
}
static void ads112c14_populate_settling_range_tables(struct ads112c14_data *data)
{
s32 (*avail)[2];
u32 i, j;
for (i = 0; i < ARRAY_SIZE(ads112c14_sinc_latency_tmod); i++) {
for (j = 0; j < ARRAY_SIZE(ads112c14_fmod_div); j++) {
u64 fmod_Hz = data->fclk_Hz / ads112c14_fmod_div[j];
u64 start_tmod = ads112c14_sinc_latency_tmod[i][j];
u64 step_tmod = ads112c14_delay_to_tmod(1);
u64 stop_tmod = start_tmod + ads112c14_delay_to_tmod(ADS112C14_DELAY_MAX);
s64 start_us, step_us, stop_us;
start_us = DIV_ROUND_CLOSEST_ULL(start_tmod * USEC_PER_SEC, fmod_Hz);
step_us = DIV_ROUND_CLOSEST_ULL(step_tmod * USEC_PER_SEC, fmod_Hz);
stop_us = DIV_ROUND_CLOSEST_ULL(stop_tmod * USEC_PER_SEC, fmod_Hz);
avail = data->sinc_settling_time_range_available[i][j];
iio_val_s64_decompose(start_us, &avail[0][0], &avail[0][1]);
iio_val_s64_decompose(step_us, &avail[1][0], &avail[1][1]);
iio_val_s64_decompose(stop_us, &avail[2][0], &avail[2][1]);
}
}
for (i = 0; i < ARRAY_SIZE(ads112c14_fir_latency_tmod); i++) {
for (j = 0; j < ARRAY_SIZE(ads112c14_fmod_div); j++) {
u64 fmod_Hz = data->fclk_Hz / ads112c14_fmod_div[j];
u64 start_tmod = ads112c14_fir_latency_tmod[i][j];
u64 step_tmod = ads112c14_delay_to_tmod(1);
u64 stop_tmod = start_tmod + ads112c14_delay_to_tmod(ADS112C14_DELAY_MAX);
s64 start_us, step_us, stop_us;
start_us = DIV_ROUND_CLOSEST_ULL(start_tmod * USEC_PER_SEC, fmod_Hz);
step_us = DIV_ROUND_CLOSEST_ULL(step_tmod * USEC_PER_SEC, fmod_Hz);
stop_us = DIV_ROUND_CLOSEST_ULL(stop_tmod * USEC_PER_SEC, fmod_Hz);
avail = data->fir_settling_time_range_available[i][j];
iio_val_s64_decompose(start_us, &avail[0][0], &avail[0][1]);
iio_val_s64_decompose(step_us, &avail[1][0], &avail[1][1]);
iio_val_s64_decompose(stop_us, &avail[2][0], &avail[2][1]);
}
}
}
static void ads112c14_populate_tables(struct ads112c14_data *data)
{
u32 full_scale, fsr_bits;
for (u32 i = 0; i < data->num_measurements; i++) {
struct ads112c14_measurement *measurement = &data->measurements[i];
switch (measurement->vref_source) {
case ADS112C14_VREF_SOURCE_EXTERNAL:
if (data->ext_ref_ohms)
full_scale = data->ext_ref_ohms;
else
full_scale = data->ext_ref_uV / (MICRO / MILLI);
break;
case ADS112C14_VREF_SOURCE_AVDD:
full_scale = data->avdd_uV / (MICRO / MILLI);
break;
case ADS112C14_VREF_SOURCE_INTERNAL_1_25V:
full_scale = ADS112C14_INT_REF0_mV;
break;
default:
full_scale = ADS112C14_INT_REF1_mV;
break;
}
fsr_bits = data->chip_info->resolution_bits - measurement->bipolar;
ads112c14_populate_scale_available(measurement->scale_available,
full_scale, fsr_bits);
}
full_scale = ADS112C14_INT_REF1_mV;
fsr_bits = data->chip_info->resolution_bits - 1;
ads112c14_populate_scale_available(data->sys_mon_chan_short_scale_available,
full_scale, fsr_bits);
ads112c14_populate_odr_tables(data);
ads112c14_populate_settling_range_tables(data);
}
static int ads112c14_probe(struct i2c_client *client)
{
struct device *dev = &client->dev;
const struct ads112c14_chip_info *info;
struct iio_dev *indio_dev;
struct ads112c14_data *data;
struct clk *clk;
bool need_avdd_ref, need_ext_ref;
u32 refp_uV = 0;
u32 refn_uV = 0;
u32 reg_val;
int ret;
info = i2c_get_match_data(client);
if (!info)
return dev_err_probe(dev, -ENODEV, "missing match data\n");
indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
if (!indio_dev)
return -ENOMEM;
data = iio_priv(indio_dev);
data->chip_info = info;
ret = devm_mutex_init(dev, &data->lock);
if (ret)
return ret;
if (device_property_present(dev, "ti,refp-refn-resistor-ohms")) {
ret = device_property_read_u32(dev, "ti,refp-refn-resistor-ohms",
&data->ext_ref_ohms);
if (ret)
return dev_err_probe(dev, ret,
"failed to read ti,refp-refn-resistor-ohms property\n");
}
ret = ads112c14_parse_channels(indio_dev, &need_avdd_ref, &need_ext_ref);
if (ret)
return ret;
ret = devm_regulator_get_enable(dev, "dvdd");
if (ret)
return dev_err_probe(dev, ret, "failed to get dvdd regulator\n");
if (need_avdd_ref) {
ret = devm_regulator_get_enable_read_voltage(dev, "avdd");
if (ret < 0)
return dev_err_probe(dev, ret, "failed to get avdd voltage\n");
data->avdd_uV = ret;
} else {
ret = devm_regulator_get_enable(dev, "avdd");
if (ret)
return dev_err_probe(dev, ret, "failed to get avdd regulator\n");
}
if (device_property_present(dev, "refp-supply")) {
ret = devm_regulator_get_enable_read_voltage(dev, "refp");
if (ret < 0)
return dev_err_probe(dev, ret, "failed to get refp voltage\n");
refp_uV = ret;
struct fwnode_handle *refp_fwnode __free(fwnode_handle) =
fwnode_find_reference(dev->fwnode, "refp-supply", 0);
if (IS_ERR(refp_fwnode))
return dev_err_probe(dev, PTR_ERR(refp_fwnode),
"failed to get refp fwnode\n");
struct fwnode_handle *avdd_fwnode __free(fwnode_handle) =
fwnode_find_reference(dev->fwnode, "avdd-supply", 0);
if (IS_ERR(avdd_fwnode))
return dev_err_probe(dev, PTR_ERR(avdd_fwnode),
"failed to get avdd fwnode\n");
data->refp_is_avdd = refp_fwnode == avdd_fwnode;
}
if (device_property_present(dev, "refn-supply")) {
ret = devm_regulator_get_enable_read_voltage(dev, "refn");
if (ret < 0)
return dev_err_probe(dev, ret, "failed to get refn voltage\n");
refn_uV = ret;
} else {
data->refn_is_gnd = true;
}
data->ext_ref_uV = refp_uV - refn_uV;
if (data->ext_ref_uV && data->ext_ref_ohms)
return dev_err_probe(dev, -EINVAL,
"ti,refp-refn-resistor-ohms property should not be present when refp-supply or refn-supply is present\n");
if (need_ext_ref && !data->ext_ref_uV && !data->ext_ref_ohms)
return dev_err_probe(dev, -EINVAL,
"external reference measurements require either refp-supply or ti,refp-refn-resistor-ohms property\n");
clk = devm_clk_get_optional_enabled(dev, NULL);
if (IS_ERR(clk))
return dev_err_probe(dev, PTR_ERR(clk), "failed to get clk\n");
if (clk) {
data->fclk_Hz = clk_get_rate(clk);
if (!data->fclk_Hz)
return dev_err_probe(dev, -EINVAL, "clk rate is 0\n");
} else {
data->fclk_Hz = ADS112C14_INTERNAL_CLK_Hz;
}
fsleep(10 * USEC_PER_MSEC);
data->regmap = devm_regmap_init(dev, &ads112c14_regmap_bus, data,
&ads112c14_regmap_config);
if (IS_ERR(data->regmap))
return dev_err_probe(dev, PTR_ERR(data->regmap),
"failed to init regmap\n");
regmap_write(data->regmap, ADS112C14_REG_CONVERSION_CTRL,
FIELD_PREP(ADS112C14_CONVERSION_CTRL_RESET, 0x16));
fsleep(ADS112C14_DELAY_RESET_US);
ret = regmap_read(data->regmap, ADS112C14_REG_STATUS_MSB, ®_val);
if (ret)
return ret;
if (FIELD_GET(ADS112C14_STATUS_MSB_RESETN, reg_val))
return dev_err_probe(dev, -EIO, "reset failed\n");
data->sys_mon_chan_short_gain_val = 1;
ret = regmap_write(data->regmap, ADS112C14_REG_STATUS_MSB,
ADS112C14_STATUS_MSB_RESETN |
ADS112C14_STATUS_MSB_AVDD_UVN);
if (ret)
return ret;
ret = regmap_set_bits(data->regmap, ADS112C14_REG_DIGITAL_CFG,
ADS112C14_DIGITAL_CFG_I2C_CRC_EN);
if (ret)
return ret;
data->i2c_crc_enabled = true;
ret = regmap_read(data->regmap, ADS112C14_REG_DEVICE_ID, ®_val);
if (ret)
return ret;
if (FIELD_GET(ADS112C14_DEVICE_ID_BITS, reg_val) != info->device_id)
dev_info(dev, "device ID mismatch, expected 0x%X, got 0x%lX\n",
info->device_id,
FIELD_GET(ADS112C14_DEVICE_ID_BITS, reg_val));
ret = regmap_update_bits(data->regmap, ADS112C14_REG_DEVICE_CFG,
ADS112C14_DEVICE_CFG_CONV_MODE,
FIELD_PREP(ADS112C14_DEVICE_CFG_CONV_MODE,
ADS112C14_DEVICE_CFG_CONV_MODE_SINGLE_SHOT));
if (ret)
return ret;
if (fwnode_property_match_string(dev_fwnode(dev), "interrupt-names", "drdy") >= 0) {
data->drdy_irq = fwnode_irq_get_byname(dev_fwnode(dev), "drdy");
if (data->drdy_irq < 0)
return dev_err_probe(dev, data->drdy_irq,
"failed to get drdy interrupt\n");
if (clk)
return dev_err_probe(dev, -EINVAL,
"cannot use both DRDY and CLK - they share the same pin\n");
ret = regmap_update_bits(data->regmap, ADS112C14_REG_GPIO_CFG,
ADS112C14_GPIO_CFG_GPIO3_CFG,
FIELD_PREP(ADS112C14_GPIO_CFG_GPIO3_CFG,
ADS112C14_GPIO_CFG_GPIO_CFG_OUTPUT_PUSH_PULL));
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_GPIO_DATA_OUTPUT,
ADS112C14_GPIO_DATA_OUTPUT_GPIO3_SRC,
FIELD_PREP(ADS112C14_GPIO_DATA_OUTPUT_GPIO3_SRC,
ADS112C14_GPIO_DATA_OUTPUT_GPIO3_SRC_DRDY));
if (ret)
return ret;
init_completion(&data->drdy_completion);
data->drdy_trig = devm_iio_trigger_alloc(dev, "%s-dev%d-drdy",
info->name,
iio_device_id(indio_dev));
if (!data->drdy_trig)
return -ENOMEM;
data->drdy_trig->ops = &ads112c14_trigger_ops;
iio_trigger_set_drvdata(data->drdy_trig, indio_dev);
ret = devm_iio_trigger_register(dev, data->drdy_trig);
if (ret)
return ret;
ret = devm_request_irq(dev, data->drdy_irq, ads112c14_drdy_irq_handler,
0, dev_name(dev), indio_dev);
if (ret)
return ret;
}
if (clk) {
ret = regmap_update_bits(data->regmap, ADS112C14_REG_GPIO_CFG,
ADS112C14_GPIO_CFG_GPIO3_CFG,
FIELD_PREP(ADS112C14_GPIO_CFG_GPIO3_CFG,
ADS112C14_GPIO_CFG_GPIO_CFG_INPUT));
if (ret)
return ret;
ret = regmap_update_bits(data->regmap, ADS112C14_REG_DEVICE_CFG,
ADS112C14_DEVICE_CFG_CLK_SEL,
FIELD_PREP(ADS112C14_DEVICE_CFG_CLK_SEL,
ADS112C14_DEVICE_CFG_CLK_SEL_EXTERNAL));
if (ret)
return ret;
}
ads112c14_populate_tables(data);
indio_dev->name = info->name;
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->info = &ads112c14_info;
ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
iio_pollfunc_store_time,
ads112c14_trigger_handler,
&ads112c14_buffer_setup_ops);
if (ret)
return ret;
return devm_iio_device_register(dev, indio_dev);
}
static const struct ads112c14_chip_info ads112c14_chip_info = {
.name = "ads112c14",
.device_id = 0xE,
.resolution_bits = 16,
};
static const struct ads112c14_chip_info ads122c14_chip_info = {
.name = "ads122c14",
.device_id = 0xF,
.resolution_bits = 24,
};
static const struct of_device_id ads112c14_of_match[] = {
{ .compatible = "ti,ads112c14", .data = &ads112c14_chip_info },
{ .compatible = "ti,ads122c14", .data = &ads122c14_chip_info },
{ }
};
MODULE_DEVICE_TABLE(of, ads112c14_of_match);
static const struct i2c_device_id ads112c14_id[] = {
{ .name = "ads112c14", .driver_data = (kernel_ulong_t)&ads112c14_chip_info },
{ .name = "ads122c14", .driver_data = (kernel_ulong_t)&ads122c14_chip_info },
{ }
};
MODULE_DEVICE_TABLE(i2c, ads112c14_id);
static int ads112c14_i2c_add_driver(struct i2c_driver *driver)
{
crc8_populate_msb(ads112c14_crc8_table, ADS112C14_I2C_CRC8_POLYNOMIAL);
return i2c_add_driver(driver);
}
static struct i2c_driver ads112c14_driver = {
.driver = {
.name = "ads112c14",
.of_match_table = ads112c14_of_match,
},
.probe = ads112c14_probe,
.id_table = ads112c14_id,
};
module_driver(ads112c14_driver, ads112c14_i2c_add_driver, i2c_del_driver);
MODULE_AUTHOR("David Lechner (TI) <dlechner@baylibre.com>");
MODULE_DESCRIPTION("TI ADS112C14 I2C ADC driver");
MODULE_LICENSE("GPL"