public-mirrors/linux
1
0
Fork 0
mirror of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-08-05 16:54:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
linux/drivers/iio/adc/ad4695.c
David Lechner 76a67e394d iio: adc: ad4695: rename AD4695_MAX_VIN_CHANNELS 
Rename AD4695_MAX_CHANNELS to AD4695_MAX_VIN_CHANNELS. It has been a
point of confusion that this macro is only the voltage input channels
and not all channels.

Reviewed-by: Trevor Gamblin <tgamblin@baylibre.com>
Reviewed-by: Nuno Sá <nuno.sa@analog.com>
Signed-off-by: David Lechner <dlechner@baylibre.com>
Link: https://patch.msgid.link/20250507-iio-introduce-iio_declare_buffer_with_ts-v6-4-4aee1b9f1b89@baylibre.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
2025-05-21 14:20:31 +01:00

2026 lines
55 KiB
C
Raw Permalink Blame History

// SPDX-License-Identifier: GPL-2.0-only
/*
* SPI ADC driver for Analog Devices Inc. AD4695 and similar chips
*
* https://www.analog.com/en/products/ad4695.html
* https://www.analog.com/en/products/ad4696.html
* https://www.analog.com/en/products/ad4697.html
* https://www.analog.com/en/products/ad4698.html
*
* Copyright 2024 Analog Devices Inc.
* Copyright 2024 BayLibre, SAS
*/
#include <linux/align.h>
#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/compiler.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/iio/buffer-dmaengine.h>
#include <linux/iio/buffer.h>
#include <linux/iio/iio.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/minmax.h>
#include <linux/mutex.h>
#include <linux/property.h>
#include <linux/pwm.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/spi/offload/consumer.h>
#include <linux/spi/offload/provider.h>
#include <linux/spi/spi.h>
#include <linux/units.h>
#include <dt-bindings/iio/adc/adi,ad4695.h>
/* AD4695 registers */
#define AD4695_REG_SPI_CONFIG_A 0x0000
#define AD4695_REG_SPI_CONFIG_A_SW_RST (BIT(7) | BIT(0))
#define AD4695_REG_SPI_CONFIG_A_ADDR_DIR BIT(5)
#define AD4695_REG_SPI_CONFIG_B 0x0001
#define AD4695_REG_SPI_CONFIG_B_INST_MODE BIT(7)
#define AD4695_REG_DEVICE_TYPE 0x0003
#define AD4695_REG_SCRATCH_PAD 0x000A
#define AD4695_REG_VENDOR_L 0x000C
#define AD4695_REG_VENDOR_H 0x000D
#define AD4695_REG_LOOP_MODE 0x000E
#define AD4695_REG_SPI_CONFIG_C 0x0010
#define AD4695_REG_SPI_CONFIG_C_MB_STRICT BIT(7)
#define AD4695_REG_SPI_STATUS 0x0011
#define AD4695_REG_STATUS 0x0014
#define AD4695_REG_ALERT_STATUS1 0x0015
#define AD4695_REG_ALERT_STATUS2 0x0016
#define AD4695_REG_CLAMP_STATUS 0x001A
#define AD4695_REG_SETUP 0x0020
#define AD4695_REG_SETUP_LDO_EN BIT(4)
#define AD4695_REG_SETUP_SPI_MODE BIT(2)
#define AD4695_REG_SETUP_SPI_CYC_CTRL BIT(1)
#define AD4695_REG_REF_CTRL 0x0021
#define AD4695_REG_REF_CTRL_OV_MODE BIT(7)
#define AD4695_REG_REF_CTRL_VREF_SET GENMASK(4, 2)
#define AD4695_REG_REF_CTRL_REFHIZ_EN BIT(1)
#define AD4695_REG_REF_CTRL_REFBUF_EN BIT(0)
#define AD4695_REG_SEQ_CTRL 0x0022
#define AD4695_REG_SEQ_CTRL_STD_SEQ_EN BIT(7)
#define AD4695_REG_SEQ_CTRL_NUM_SLOTS_AS GENMASK(6, 0)
#define AD4695_REG_AC_CTRL 0x0023
#define AD4695_REG_STD_SEQ_CONFIG 0x0024
#define AD4695_REG_GPIO_CTRL 0x0026
#define AD4695_REG_GP_MODE 0x0027
#define AD4695_REG_GP_MODE_BUSY_GP_SEL BIT(5)
#define AD4695_REG_GP_MODE_BUSY_GP_EN BIT(1)
#define AD4695_REG_TEMP_CTRL 0x0029
#define AD4695_REG_TEMP_CTRL_TEMP_EN BIT(0)
#define AD4695_REG_CONFIG_IN(n) (0x0030 | (n))
#define AD4695_REG_CONFIG_IN_MODE BIT(6)
#define AD4695_REG_CONFIG_IN_PAIR GENMASK(5, 4)
#define AD4695_REG_CONFIG_IN_AINHIGHZ_EN BIT(3)
#define AD4695_REG_CONFIG_IN_OSR_SET GENMASK(1, 0)
#define AD4695_REG_UPPER_IN(n) (0x0040 | (2 * (n)))
#define AD4695_REG_LOWER_IN(n) (0x0060 | (2 * (n)))
#define AD4695_REG_HYST_IN(n) (0x0080 | (2 * (n)))
#define AD4695_REG_OFFSET_IN(n) (0x00A0 | (2 * (n)))
#define AD4695_REG_GAIN_IN(n) (0x00C0 | (2 * (n)))
#define AD4695_REG_AS_SLOT(n) (0x0100 | (n))
#define AD4695_REG_AS_SLOT_INX GENMASK(3, 0)
/* Conversion mode commands */
#define AD4695_CMD_EXIT_CNV_MODE 0x0A
#define AD4695_CMD_TEMP_CHAN 0x0F
#define AD4695_CMD_VOLTAGE_CHAN(n) (0x10 | (n))
/* timing specs */
#define AD4695_T_CONVERT_NS 415
#define AD4695_T_WAKEUP_HW_MS 3
#define AD4695_T_WAKEUP_SW_MS 3
#define AD4695_T_REFBUF_MS 100
#define AD4695_T_REGCONFIG_NS 20
#define AD4695_T_SCK_CNV_DELAY_NS 80
#define AD4695_T_CNVL_NS 80
#define AD4695_T_CNVH_NS 10
#define AD4695_REG_ACCESS_SCLK_HZ (10 * MEGA)
/* Max number of voltage input channels. */
#define AD4695_MAX_VIN_CHANNELS 16
enum ad4695_in_pair {
AD4695_IN_PAIR_REFGND,
AD4695_IN_PAIR_COM,
AD4695_IN_PAIR_EVEN_ODD,
};
struct ad4695_chip_info {
const char *name;
int max_sample_rate;
u32 t_acq_ns;
u8 num_voltage_inputs;
};
struct ad4695_channel_config {
unsigned int channel;
bool highz_en;
bool bipolar;
enum ad4695_in_pair pin_pairing;
unsigned int common_mode_mv;
unsigned int oversampling_ratio;
};
struct ad4695_state {
struct spi_device *spi;
struct spi_offload *offload;
struct spi_offload_trigger *offload_trigger;
struct regmap *regmap;
struct regmap *regmap16;
struct gpio_desc *reset_gpio;
/* currently PWM CNV only supported with SPI offload use */
struct pwm_device *cnv_pwm;
/* protects against concurrent use of cnv_pwm */
struct mutex cnv_pwm_lock;
/* offload also requires separate gpio to manually control CNV */
struct gpio_desc *cnv_gpio;
/* voltages channels plus temperature and timestamp */
struct iio_chan_spec iio_chan[AD4695_MAX_VIN_CHANNELS + 2];
struct ad4695_channel_config channels_cfg[AD4695_MAX_VIN_CHANNELS];
const struct ad4695_chip_info *chip_info;
int sample_freq_range[3];
/* Reference voltage. */
unsigned int vref_mv;
/* Common mode input pin voltage. */
unsigned int com_mv;
/*
* 2 per voltage and temperature chan plus 1 xfer to trigger 1st
* CNV. Excluding the trigger xfer, every 2nd xfer only serves
* to control CS and add a delay between the last SCLK and next
* CNV rising edges.
*/
struct spi_transfer buf_read_xfer[AD4695_MAX_VIN_CHANNELS * 2 + 3];
struct spi_message buf_read_msg;
/* Raw conversion data received. */
IIO_DECLARE_DMA_BUFFER_WITH_TS(u16, buf, AD4695_MAX_VIN_CHANNELS + 1);
u16 raw_data;
/* Commands to send for single conversion. */
u16 cnv_cmd;
u8 cnv_cmd2;
/* Buffer for storing data from regmap bus reads/writes */
u8 regmap_bus_data[4];
};
static const struct regmap_range ad4695_regmap_rd_ranges[] = {
regmap_reg_range(AD4695_REG_SPI_CONFIG_A, AD4695_REG_SPI_CONFIG_B),
regmap_reg_range(AD4695_REG_DEVICE_TYPE, AD4695_REG_DEVICE_TYPE),
regmap_reg_range(AD4695_REG_SCRATCH_PAD, AD4695_REG_SCRATCH_PAD),
regmap_reg_range(AD4695_REG_VENDOR_L, AD4695_REG_LOOP_MODE),
regmap_reg_range(AD4695_REG_SPI_CONFIG_C, AD4695_REG_SPI_STATUS),
regmap_reg_range(AD4695_REG_STATUS, AD4695_REG_ALERT_STATUS2),
regmap_reg_range(AD4695_REG_CLAMP_STATUS, AD4695_REG_CLAMP_STATUS),
regmap_reg_range(AD4695_REG_SETUP, AD4695_REG_AC_CTRL),
regmap_reg_range(AD4695_REG_GPIO_CTRL, AD4695_REG_TEMP_CTRL),
regmap_reg_range(AD4695_REG_CONFIG_IN(0), AD4695_REG_CONFIG_IN(15)),
regmap_reg_range(AD4695_REG_AS_SLOT(0), AD4695_REG_AS_SLOT(127)),
};
static const struct regmap_access_table ad4695_regmap_rd_table = {
.yes_ranges = ad4695_regmap_rd_ranges,
.n_yes_ranges = ARRAY_SIZE(ad4695_regmap_rd_ranges),
};
static const struct regmap_range ad4695_regmap_wr_ranges[] = {
regmap_reg_range(AD4695_REG_SPI_CONFIG_A, AD4695_REG_SPI_CONFIG_B),
regmap_reg_range(AD4695_REG_SCRATCH_PAD, AD4695_REG_SCRATCH_PAD),
regmap_reg_range(AD4695_REG_LOOP_MODE, AD4695_REG_LOOP_MODE),
regmap_reg_range(AD4695_REG_SPI_CONFIG_C, AD4695_REG_SPI_STATUS),
regmap_reg_range(AD4695_REG_SETUP, AD4695_REG_AC_CTRL),
regmap_reg_range(AD4695_REG_GPIO_CTRL, AD4695_REG_TEMP_CTRL),
regmap_reg_range(AD4695_REG_CONFIG_IN(0), AD4695_REG_CONFIG_IN(15)),
regmap_reg_range(AD4695_REG_AS_SLOT(0), AD4695_REG_AS_SLOT(127)),
};
static const struct regmap_access_table ad4695_regmap_wr_table = {
.yes_ranges = ad4695_regmap_wr_ranges,
.n_yes_ranges = ARRAY_SIZE(ad4695_regmap_wr_ranges),
};
static const struct regmap_config ad4695_regmap_config = {
.name = "ad4695-8",
.reg_bits = 16,
.val_bits = 8,
.max_register = AD4695_REG_AS_SLOT(127),
.rd_table = &ad4695_regmap_rd_table,
.wr_table = &ad4695_regmap_wr_table,
};
static const struct regmap_range ad4695_regmap16_rd_ranges[] = {
regmap_reg_range(AD4695_REG_STD_SEQ_CONFIG, AD4695_REG_STD_SEQ_CONFIG),
regmap_reg_range(AD4695_REG_UPPER_IN(0), AD4695_REG_GAIN_IN(15)),
};
static const struct regmap_access_table ad4695_regmap16_rd_table = {
.yes_ranges = ad4695_regmap16_rd_ranges,
.n_yes_ranges = ARRAY_SIZE(ad4695_regmap16_rd_ranges),
};
static const struct regmap_range ad4695_regmap16_wr_ranges[] = {
regmap_reg_range(AD4695_REG_STD_SEQ_CONFIG, AD4695_REG_STD_SEQ_CONFIG),
regmap_reg_range(AD4695_REG_UPPER_IN(0), AD4695_REG_GAIN_IN(15)),
};
static const struct regmap_access_table ad4695_regmap16_wr_table = {
.yes_ranges = ad4695_regmap16_wr_ranges,
.n_yes_ranges = ARRAY_SIZE(ad4695_regmap16_wr_ranges),
};
static const struct regmap_config ad4695_regmap16_config = {
.name = "ad4695-16",
.reg_bits = 16,
.reg_stride = 2,
.val_bits = 16,
.val_format_endian = REGMAP_ENDIAN_LITTLE,
.max_register = AD4695_REG_GAIN_IN(15),
.rd_table = &ad4695_regmap16_rd_table,
.wr_table = &ad4695_regmap16_wr_table,
};
static int ad4695_regmap_bus_reg_write(void *context, const void *data,
size_t count)
{
struct ad4695_state *st = context;
struct spi_transfer xfer = {
.speed_hz = AD4695_REG_ACCESS_SCLK_HZ,
.len = count,
.tx_buf = st->regmap_bus_data,
};
if (count > ARRAY_SIZE(st->regmap_bus_data))
return -EINVAL;
memcpy(st->regmap_bus_data, data, count);
return spi_sync_transfer(st->spi, &xfer, 1);
}
static int ad4695_regmap_bus_reg_read(void *context, const void *reg,
size_t reg_size, void *val,
size_t val_size)
{
struct ad4695_state *st = context;
struct spi_transfer xfers[] = {
{
.speed_hz = AD4695_REG_ACCESS_SCLK_HZ,
.len = reg_size,
.tx_buf = &st->regmap_bus_data[0],
}, {
.speed_hz = AD4695_REG_ACCESS_SCLK_HZ,
.len = val_size,
.rx_buf = &st->regmap_bus_data[2],
},
};
int ret;
if (reg_size > 2)
return -EINVAL;
if (val_size > 2)
return -EINVAL;
memcpy(&st->regmap_bus_data[0], reg, reg_size);
ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
if (ret)
return ret;
memcpy(val, &st->regmap_bus_data[2], val_size);
return 0;
}
static const struct regmap_bus ad4695_regmap_bus = {
.write = ad4695_regmap_bus_reg_write,
.read = ad4695_regmap_bus_reg_read,
.read_flag_mask = 0x80,
.reg_format_endian_default = REGMAP_ENDIAN_BIG,
.val_format_endian_default = REGMAP_ENDIAN_BIG,
};
enum {
AD4695_SCAN_TYPE_OSR_1,
AD4695_SCAN_TYPE_OSR_4,
AD4695_SCAN_TYPE_OSR_16,
AD4695_SCAN_TYPE_OSR_64,
};
static const struct iio_scan_type ad4695_scan_type_offload_u[] = {
[AD4695_SCAN_TYPE_OSR_1] = {
.sign = 'u',
.realbits = 16,
.shift = 3,
.storagebits = 32,
},
[AD4695_SCAN_TYPE_OSR_4] = {
.sign = 'u',
.realbits = 17,
.shift = 2,
.storagebits = 32,
},
[AD4695_SCAN_TYPE_OSR_16] = {
.sign = 'u',
.realbits = 18,
.shift = 1,
.storagebits = 32,
},
[AD4695_SCAN_TYPE_OSR_64] = {
.sign = 'u',
.realbits = 19,
.storagebits = 32,
},
};
static const struct iio_scan_type ad4695_scan_type_offload_s[] = {
[AD4695_SCAN_TYPE_OSR_1] = {
.sign = 's',
.realbits = 16,
.shift = 3,
.storagebits = 32,
},
[AD4695_SCAN_TYPE_OSR_4] = {
.sign = 's',
.realbits = 17,
.shift = 2,
.storagebits = 32,
},
[AD4695_SCAN_TYPE_OSR_16] = {
.sign = 's',
.realbits = 18,
.shift = 1,
.storagebits = 32,
},
[AD4695_SCAN_TYPE_OSR_64] = {
.sign = 's',
.realbits = 19,
.storagebits = 32,
},
};
static const struct iio_chan_spec ad4695_channel_template = {
.type = IIO_VOLTAGE,
.indexed = 1,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE) |
BIT(IIO_CHAN_INFO_OFFSET) |
BIT(IIO_CHAN_INFO_CALIBSCALE) |
BIT(IIO_CHAN_INFO_CALIBBIAS),
.info_mask_separate_available = BIT(IIO_CHAN_INFO_CALIBSCALE) |
BIT(IIO_CHAN_INFO_CALIBBIAS),
.scan_type = {
.sign = 'u',
.realbits = 16,
.storagebits = 16,
},
};
static const struct iio_chan_spec ad4695_temp_channel_template = {
.address = AD4695_CMD_TEMP_CHAN,
.type = IIO_TEMP,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE) |
BIT(IIO_CHAN_INFO_OFFSET),
.scan_type = {
.sign = 's',
.realbits = 16,
.storagebits = 16,
},
};
static const struct iio_chan_spec ad4695_soft_timestamp_channel_template =
IIO_CHAN_SOFT_TIMESTAMP(0);
static const char * const ad4695_power_supplies[] = {
"avdd", "vio"
};
static const int ad4695_oversampling_ratios[] = {
1, 4, 16, 64,
};
static const struct ad4695_chip_info ad4695_chip_info = {
.name = "ad4695",
.max_sample_rate = 500 * KILO,
.t_acq_ns = 1715,
.num_voltage_inputs = 16,
};
static const struct ad4695_chip_info ad4696_chip_info = {
.name = "ad4696",
.max_sample_rate = 1 * MEGA,
.t_acq_ns = 715,
.num_voltage_inputs = 16,
};
static const struct ad4695_chip_info ad4697_chip_info = {
.name = "ad4697",
.max_sample_rate = 500 * KILO,
.t_acq_ns = 1715,
.num_voltage_inputs = 8,
};
static const struct ad4695_chip_info ad4698_chip_info = {
.name = "ad4698",
.max_sample_rate = 1 * MEGA,
.t_acq_ns = 715,
.num_voltage_inputs = 8,
};
static void ad4695_cnv_manual_trigger(struct ad4695_state *st)
{
gpiod_set_value_cansleep(st->cnv_gpio, 1);
ndelay(10);
gpiod_set_value_cansleep(st->cnv_gpio, 0);
}
/**
* ad4695_set_single_cycle_mode - Set the device in single cycle mode
* @st: The AD4695 state
* @channel: The first channel to read
*
* As per the datasheet, to enable single cycle mode, we need to set
* STD_SEQ_EN=0, NUM_SLOTS_AS=0 and CYC_CTRL=1 (Table 15). Setting SPI_MODE=1
* triggers the first conversion using the channel in AS_SLOT0.
*
* Context: can sleep, must be called with iio_device_claim_direct held
* Return: 0 on success, a negative error code on failure
*/
static int ad4695_set_single_cycle_mode(struct ad4695_state *st,
unsigned int channel)
{
int ret;
ret = regmap_clear_bits(st->regmap, AD4695_REG_SEQ_CTRL,
AD4695_REG_SEQ_CTRL_STD_SEQ_EN |
AD4695_REG_SEQ_CTRL_NUM_SLOTS_AS);
if (ret)
return ret;
ret = regmap_write(st->regmap, AD4695_REG_AS_SLOT(0),
FIELD_PREP(AD4695_REG_AS_SLOT_INX, channel));
if (ret)
return ret;
return regmap_set_bits(st->regmap, AD4695_REG_SETUP,
AD4695_REG_SETUP_SPI_MODE |
AD4695_REG_SETUP_SPI_CYC_CTRL);
}
/**
* ad4695_enter_advanced_sequencer_mode - Put the ADC in advanced sequencer mode
* @st: The driver state
* @n: The number of slots to use - must be >= 2, <= 128
*
* As per the datasheet, to enable advanced sequencer, we need to set
* STD_SEQ_EN=0, NUM_SLOTS_AS=n-1 and CYC_CTRL=0 (Table 15). Setting SPI_MODE=1
* triggers the first conversion using the channel in AS_SLOT0.
*
* Return: 0 on success, a negative error code on failure
*/
static int ad4695_enter_advanced_sequencer_mode(struct ad4695_state *st, u32 n)
{
int ret;
ret = regmap_update_bits(st->regmap, AD4695_REG_SEQ_CTRL,
AD4695_REG_SEQ_CTRL_STD_SEQ_EN |
AD4695_REG_SEQ_CTRL_NUM_SLOTS_AS,
FIELD_PREP(AD4695_REG_SEQ_CTRL_STD_SEQ_EN, 0) |
FIELD_PREP(AD4695_REG_SEQ_CTRL_NUM_SLOTS_AS, n - 1));
if (ret)
return ret;
return regmap_update_bits(st->regmap, AD4695_REG_SETUP,
AD4695_REG_SETUP_SPI_MODE | AD4695_REG_SETUP_SPI_CYC_CTRL,
FIELD_PREP(AD4695_REG_SETUP_SPI_MODE, 1) |
FIELD_PREP(AD4695_REG_SETUP_SPI_CYC_CTRL, 0));
}
/**
* ad4695_exit_conversion_mode - Exit conversion mode
* @st: The AD4695 state
*
* Sends SPI command to exit conversion mode.
*
* Return: 0 on success, a negative error code on failure
*/
static int ad4695_exit_conversion_mode(struct ad4695_state *st)
{
/*
* An extra transfer is needed to trigger a conversion here so
* that we can be 100% sure the command will be processed by the
* ADC, rather than relying on it to be in the correct state
* when this function is called (this chip has a quirk where the
* command only works when reading a conversion, and if the
* previous conversion was already read then it won't work). The
* actual conversion command is then run at the slower
* AD4695_REG_ACCESS_SCLK_HZ speed to guarantee this works.
*/
struct spi_transfer xfers[] = {
{
.delay.value = AD4695_T_CNVL_NS,
.delay.unit = SPI_DELAY_UNIT_NSECS,
.cs_change = 1,
.cs_change_delay.value = AD4695_T_CNVH_NS,
.cs_change_delay.unit = SPI_DELAY_UNIT_NSECS,
},
{
.speed_hz = AD4695_REG_ACCESS_SCLK_HZ,
.tx_buf = &st->cnv_cmd2,
.len = 1,
.delay.value = AD4695_T_REGCONFIG_NS,
.delay.unit = SPI_DELAY_UNIT_NSECS,
},
};
/*
* Technically, could do a 5-bit transfer, but shifting to start of
* 8 bits instead for better SPI controller support.
*/
st->cnv_cmd2 = AD4695_CMD_EXIT_CNV_MODE << 3;
if (st->cnv_gpio) {
ad4695_cnv_manual_trigger(st);
/*
* In this case, CNV is not connected to CS, so we don't need
* the extra CS toggle to trigger the conversion and toggling
* CS would have no effect.
*/
return spi_sync_transfer(st->spi, &xfers[1], 1);
}
return spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
}
static int ad4695_set_ref_voltage(struct ad4695_state *st, int vref_mv)
{
u8 val;
if (vref_mv >= 2400 && vref_mv <= 2750)
val = 0;
else if (vref_mv > 2750 && vref_mv <= 3250)
val = 1;
else if (vref_mv > 3250 && vref_mv <= 3750)
val = 2;
else if (vref_mv > 3750 && vref_mv <= 4500)
val = 3;
else if (vref_mv > 4500 && vref_mv <= 5100)
val = 4;
else
return -EINVAL;
return regmap_update_bits(st->regmap, AD4695_REG_REF_CTRL,
AD4695_REG_REF_CTRL_VREF_SET,
FIELD_PREP(AD4695_REG_REF_CTRL_VREF_SET, val));
}
/**
* ad4695_osr_to_regval - convert ratio to OSR register value
* @ratio: ratio to check
*
* Check if ratio is present in the list of available ratios and return
* the corresponding value that needs to be written to the register to
* select that ratio.
*
* Returns: register value (0 to 3) or -EINVAL if there is not an exact
* match
*/
static int ad4695_osr_to_regval(int ratio)
{
int i;
for (i = 0; i < ARRAY_SIZE(ad4695_oversampling_ratios); i++) {
if (ratio == ad4695_oversampling_ratios[i])
return i;
}
return -EINVAL;
}
static int ad4695_write_chn_cfg(struct ad4695_state *st,
struct ad4695_channel_config *cfg)
{
u32 mask, val;
mask = AD4695_REG_CONFIG_IN_MODE;
val = FIELD_PREP(AD4695_REG_CONFIG_IN_MODE, cfg->bipolar ? 1 : 0);
mask |= AD4695_REG_CONFIG_IN_PAIR;
val |= FIELD_PREP(AD4695_REG_CONFIG_IN_PAIR, cfg->pin_pairing);
mask |= AD4695_REG_CONFIG_IN_AINHIGHZ_EN;
val |= FIELD_PREP(AD4695_REG_CONFIG_IN_AINHIGHZ_EN,
cfg->highz_en ? 1 : 0);
return regmap_update_bits(st->regmap,
AD4695_REG_CONFIG_IN(cfg->channel),
mask, val);
}
static int ad4695_buffer_preenable(struct iio_dev *indio_dev)
{
struct ad4695_state *st = iio_priv(indio_dev);
struct spi_transfer *xfer;
u8 temp_chan_bit = st->chip_info->num_voltage_inputs;
u32 bit, num_xfer, num_slots;
u32 temp_en = 0;
int ret, rx_buf_offset = 0;
/*
* We are using the advanced sequencer since it is the only way to read
* multiple channels that allows individual configuration of each
* voltage input channel. Slot 0 in the advanced sequencer is used to
* account for the gap between trigger polls - we don't read data from
* this slot. Each enabled voltage channel is assigned a slot starting
* with slot 1.
*/
num_slots = 1;
memset(st->buf_read_xfer, 0, sizeof(st->buf_read_xfer));
/* First xfer is only to trigger conversion of slot 1, so no rx. */
xfer = &st->buf_read_xfer[0];
xfer->cs_change = 1;
xfer->delay.value = st->chip_info->t_acq_ns;
xfer->delay.unit = SPI_DELAY_UNIT_NSECS;
xfer->cs_change_delay.value = AD4695_T_CONVERT_NS;
xfer->cs_change_delay.unit = SPI_DELAY_UNIT_NSECS;
num_xfer = 1;
iio_for_each_active_channel(indio_dev, bit) {
xfer = &st->buf_read_xfer[num_xfer];
xfer->bits_per_word = 16;
xfer->rx_buf = &st->buf[rx_buf_offset++];
xfer->len = 2;
if (bit == temp_chan_bit) {
temp_en = 1;
} else {
ret = regmap_write(st->regmap,
AD4695_REG_AS_SLOT(num_slots),
FIELD_PREP(AD4695_REG_AS_SLOT_INX, bit));
if (ret)
return ret;
num_slots++;
}
num_xfer++;
/*
* We need to add a blank xfer in data reads, to meet the timing
* requirement of a minimum delay between the last SCLK rising
* edge and the CS deassert.
*/
xfer = &st->buf_read_xfer[num_xfer];
xfer->delay.value = AD4695_T_SCK_CNV_DELAY_NS;
xfer->delay.unit = SPI_DELAY_UNIT_NSECS;
xfer->cs_change = 1;
xfer->cs_change_delay.value = AD4695_T_CONVERT_NS;
xfer->cs_change_delay.unit = SPI_DELAY_UNIT_NSECS;
num_xfer++;
}
/*
* The advanced sequencer requires that at least 2 slots are enabled.
* Since slot 0 is always used for other purposes, we need only 1
* enabled voltage channel to meet this requirement. If the temperature
* channel is the only enabled channel, we need to add one more slot in
* the sequence but not read from it. This is because the temperature
* sensor is sampled at the end of the channel sequence in advanced
* sequencer mode (see datasheet page 38).
*
* From the iio_for_each_active_channel() block above, we now have an
* xfer with data followed by a blank xfer to allow us to meet the
* timing spec, so move both of those up before adding an extra to
* handle the temperature-only case.
*/
if (num_slots < 2) {
/* Move last two xfers */
st->buf_read_xfer[num_xfer] = st->buf_read_xfer[num_xfer - 1];
st->buf_read_xfer[num_xfer - 1] = st->buf_read_xfer[num_xfer - 2];
num_xfer++;
/* Modify inserted xfer for extra slot. */
xfer = &st->buf_read_xfer[num_xfer - 3];
memset(xfer, 0, sizeof(*xfer));
xfer->cs_change = 1;
xfer->delay.value = st->chip_info->t_acq_ns;
xfer->delay.unit = SPI_DELAY_UNIT_NSECS;
xfer->cs_change_delay.value = AD4695_T_CONVERT_NS;
xfer->cs_change_delay.unit = SPI_DELAY_UNIT_NSECS;
xfer++;
/* and add the extra slot in the sequencer */
ret = regmap_write(st->regmap,
AD4695_REG_AS_SLOT(num_slots),
FIELD_PREP(AD4695_REG_AS_SLOT_INX, 0));
if (ret)
return ret;
num_slots++;
/*
* We still want to point at the last xfer when finished, so
* update the pointer.
*/
xfer = &st->buf_read_xfer[num_xfer - 1];
}
/*
* Don't keep CS asserted after last xfer. Also triggers conversion of
* slot 0.
*/
xfer->cs_change = 0;
/*
* Temperature channel isn't included in the sequence, but rather
* controlled by setting a bit in the TEMP_CTRL register.
*/
ret = regmap_update_bits(st->regmap, AD4695_REG_TEMP_CTRL,
AD4695_REG_TEMP_CTRL_TEMP_EN,
FIELD_PREP(AD4695_REG_TEMP_CTRL_TEMP_EN, temp_en));
if (ret)
return ret;
spi_message_init_with_transfers(&st->buf_read_msg, st->buf_read_xfer,
num_xfer);
ret = spi_optimize_message(st->spi, &st->buf_read_msg);
if (ret)
return ret;
/* This triggers conversion of slot 0. */
ret = ad4695_enter_advanced_sequencer_mode(st, num_slots);
if (ret)
spi_unoptimize_message(&st->buf_read_msg);
return ret;
}
static int ad4695_buffer_postdisable(struct iio_dev *indio_dev)
{
struct ad4695_state *st = iio_priv(indio_dev);
int ret;
ret = ad4695_exit_conversion_mode(st);
if (ret)
return ret;
spi_unoptimize_message(&st->buf_read_msg);
return 0;
}
static const struct iio_buffer_setup_ops ad4695_buffer_setup_ops = {
.preenable = ad4695_buffer_preenable,
.postdisable = ad4695_buffer_postdisable,
};
static irqreturn_t ad4695_trigger_handler(int irq, void *p)
{
struct iio_poll_func *pf = p;
struct iio_dev *indio_dev = pf->indio_dev;
struct ad4695_state *st = iio_priv(indio_dev);
int ret;
ret = spi_sync(st->spi, &st->buf_read_msg);
if (ret)
goto out;
iio_push_to_buffers_with_ts(indio_dev, st->buf, sizeof(st->buf),
pf->timestamp);
out:
iio_trigger_notify_done(indio_dev->trig);
return IRQ_HANDLED;
}
static int ad4695_offload_buffer_postenable(struct iio_dev *indio_dev)
{
struct ad4695_state *st = iio_priv(indio_dev);
struct spi_offload_trigger_config config = {
.type = SPI_OFFLOAD_TRIGGER_DATA_READY,
};
struct spi_transfer *xfer = &st->buf_read_xfer[0];
struct pwm_state state;
u8 temp_chan_bit = st->chip_info->num_voltage_inputs;
u8 num_slots = 0;
u8 temp_en = 0;
unsigned int bit;
int ret;
iio_for_each_active_channel(indio_dev, bit) {
if (bit == temp_chan_bit) {
temp_en = 1;
continue;
}
ret = regmap_write(st->regmap, AD4695_REG_AS_SLOT(num_slots),
FIELD_PREP(AD4695_REG_AS_SLOT_INX, bit));
if (ret)
return ret;
num_slots++;
}
/*
* For non-offload, we could discard data to work around this
* restriction, but with offload, that is not possible.
*/
if (num_slots < 2) {
dev_err(&st->spi->dev,
"At least two voltage channels must be enabled.\n");
return -EINVAL;
}
ret = regmap_update_bits(st->regmap, AD4695_REG_TEMP_CTRL,
AD4695_REG_TEMP_CTRL_TEMP_EN,
FIELD_PREP(AD4695_REG_TEMP_CTRL_TEMP_EN,
temp_en));
if (ret)
return ret;
/* Each BUSY event means just one sample for one channel is ready. */
memset(xfer, 0, sizeof(*xfer));
xfer->offload_flags = SPI_OFFLOAD_XFER_RX_STREAM;
/* Using 19 bits per word to allow for possible oversampling */
xfer->bits_per_word = 19;
xfer->len = 4;
spi_message_init_with_transfers(&st->buf_read_msg, xfer, 1);
st->buf_read_msg.offload = st->offload;
ret = spi_optimize_message(st->spi, &st->buf_read_msg);
if (ret)
return ret;
/*
* NB: technically, this is part the SPI offload trigger enable, but it
* doesn't work to call it from the offload trigger enable callback
* because it requires accessing the SPI bus. Calling it from the
* trigger enable callback could cause a deadlock.
*/
ret = regmap_set_bits(st->regmap, AD4695_REG_GP_MODE,
AD4695_REG_GP_MODE_BUSY_GP_EN);
if (ret)
goto err_unoptimize_message;
ret = spi_offload_trigger_enable(st->offload, st->offload_trigger,
&config);
if (ret)
goto err_disable_busy_output;
ret = ad4695_enter_advanced_sequencer_mode(st, num_slots);
if (ret)
goto err_offload_trigger_disable;
mutex_lock(&st->cnv_pwm_lock);
pwm_get_state(st->cnv_pwm, &state);
/*
* PWM subsystem generally rounds down, so requesting 2x minimum high
* time ensures that we meet the minimum high time in any case.
*/
state.duty_cycle = AD4695_T_CNVH_NS * 2;
ret = pwm_apply_might_sleep(st->cnv_pwm, &state);
mutex_unlock(&st->cnv_pwm_lock);
if (ret)
goto err_offload_exit_conversion_mode;
return 0;
err_offload_exit_conversion_mode:
/*
* We have to unwind in a different order to avoid triggering offload.
* ad4695_exit_conversion_mode() triggers a conversion, so it has to be
* done after spi_offload_trigger_disable().
*/
spi_offload_trigger_disable(st->offload, st->offload_trigger);
ad4695_exit_conversion_mode(st);
goto err_disable_busy_output;
err_offload_trigger_disable:
spi_offload_trigger_disable(st->offload, st->offload_trigger);
err_disable_busy_output:
regmap_clear_bits(st->regmap, AD4695_REG_GP_MODE,
AD4695_REG_GP_MODE_BUSY_GP_EN);
err_unoptimize_message:
spi_unoptimize_message(&st->buf_read_msg);
return ret;
}
static int ad4695_offload_buffer_predisable(struct iio_dev *indio_dev)
{
struct ad4695_state *st = iio_priv(indio_dev);
struct pwm_state state;
int ret;
scoped_guard(mutex, &st->cnv_pwm_lock) {
pwm_get_state(st->cnv_pwm, &state);
state.duty_cycle = 0;
ret = pwm_apply_might_sleep(st->cnv_pwm, &state);
if (ret)
return ret;
}
spi_offload_trigger_disable(st->offload, st->offload_trigger);
/*
* ad4695_exit_conversion_mode() triggers a conversion, so it has to be
* done after spi_offload_trigger_disable().
*/
ret = ad4695_exit_conversion_mode(st);
if (ret)
return ret;
ret = regmap_clear_bits(st->regmap, AD4695_REG_GP_MODE,
AD4695_REG_GP_MODE_BUSY_GP_EN);
if (ret)
return ret;
spi_unoptimize_message(&st->buf_read_msg);
return 0;
}
static const struct iio_buffer_setup_ops ad4695_offload_buffer_setup_ops = {
.postenable = ad4695_offload_buffer_postenable,
.predisable = ad4695_offload_buffer_predisable,
};
/**
* ad4695_read_one_sample - Read a single sample using single-cycle mode
* @st: The AD4695 state
* @address: The address of the channel to read
*
* Upon successful return, the sample will be stored in `st->raw_data`.
*
* Context: can sleep, must be called with iio_device_claim_direct held
* Return: 0 on success, a negative error code on failure
*/
static int ad4695_read_one_sample(struct ad4695_state *st, unsigned int address)
{
struct spi_transfer xfers[2] = {
{
.speed_hz = AD4695_REG_ACCESS_SCLK_HZ,
.bits_per_word = 16,
.tx_buf = &st->cnv_cmd,
.len = 2,
},
{
/* Required delay between last SCLK and CNV/CS */
.delay.value = AD4695_T_SCK_CNV_DELAY_NS,
.delay.unit = SPI_DELAY_UNIT_NSECS,
}
};
int ret;
ret = ad4695_set_single_cycle_mode(st, address);
if (ret)
return ret;
/*
* If CNV is connected to CS, the previous function will have triggered
* the conversion, otherwise, we do it manually.
*/
if (st->cnv_gpio)
ad4695_cnv_manual_trigger(st);
/*
* Setting the first channel to the temperature channel isn't supported
* in single-cycle mode, so we have to do an extra conversion to read
* the temperature.
*/
if (address == AD4695_CMD_TEMP_CHAN) {
st->cnv_cmd = AD4695_CMD_TEMP_CHAN << 11;
ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
if (ret)
return ret;
/*
* If CNV is connected to CS, the previous function will have
* triggered the conversion, otherwise, we do it manually.
*/
if (st->cnv_gpio)
ad4695_cnv_manual_trigger(st);
}
/* Then read the result and exit conversion mode. */
st->cnv_cmd = AD4695_CMD_EXIT_CNV_MODE << 11;
xfers[0].rx_buf = &st->raw_data;
return spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
}
static int __ad4695_read_info_raw(struct ad4695_state *st,
struct iio_chan_spec const *chan,
int *val)
{
u8 realbits = chan->scan_type.realbits;
int ret;
ret = ad4695_read_one_sample(st, chan->address);
if (ret)
return ret;
if (chan->scan_type.sign == 's')
*val = sign_extend32(st->raw_data, realbits - 1);
else
*val = st->raw_data;
return IIO_VAL_INT;
}
static int ad4695_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
struct ad4695_state *st = iio_priv(indio_dev);
const struct iio_scan_type *scan_type;
struct ad4695_channel_config *cfg;
unsigned int reg_val;
int ret, tmp;
u8 realbits;
if (chan->type == IIO_VOLTAGE)
cfg = &st->channels_cfg[chan->scan_index];
scan_type = iio_get_current_scan_type(indio_dev, chan);
if (IS_ERR(scan_type))
return PTR_ERR(scan_type);
realbits = scan_type->realbits;
switch (mask) {
case IIO_CHAN_INFO_RAW:
if (!iio_device_claim_direct(indio_dev))
return -EBUSY;
ret = __ad4695_read_info_raw(st, chan, val);
iio_device_release_direct(indio_dev);
return ret;
case IIO_CHAN_INFO_SCALE:
switch (chan->type) {
case IIO_VOLTAGE:
*val = st->vref_mv;
*val2 = realbits;
return IIO_VAL_FRACTIONAL_LOG2;
case IIO_TEMP:
/* T_scale (°C) = raw * V_REF (mV) / (-1.8 mV/°C * 2^16) */
*val = st->vref_mv * -556;
*val2 = 16;
return IIO_VAL_FRACTIONAL_LOG2;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_OFFSET:
switch (chan->type) {
case IIO_VOLTAGE:
if (cfg->pin_pairing == AD4695_IN_PAIR_COM)
*val = st->com_mv * (1 << realbits) / st->vref_mv;
else if (cfg->pin_pairing == AD4695_IN_PAIR_EVEN_ODD)
*val = cfg->common_mode_mv * (1 << realbits) / st->vref_mv;
else
*val = 0;
return IIO_VAL_INT;
case IIO_TEMP:
/* T_offset (°C) = -725 mV / (-1.8 mV/°C) */
/* T_offset (raw) = T_offset (°C) * (-1.8 mV/°C) * 2^16 / V_REF (mV) */
*val = -47513600;
*val2 = st->vref_mv;
return IIO_VAL_FRACTIONAL;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_CALIBSCALE:
switch (chan->type) {
case IIO_VOLTAGE:
if (!iio_device_claim_direct(indio_dev))
return -EBUSY;
ret = regmap_read(st->regmap16,
AD4695_REG_GAIN_IN(chan->scan_index),
&reg_val);
iio_device_release_direct(indio_dev);
if (ret)
return ret;
*val = reg_val;
*val2 = 15;
return IIO_VAL_FRACTIONAL_LOG2;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_CALIBBIAS:
switch (chan->type)
case IIO_VOLTAGE: {
if (!iio_device_claim_direct(indio_dev))
return -EBUSY;
ret = regmap_read(st->regmap16,
AD4695_REG_OFFSET_IN(chan->scan_index),
&reg_val);
iio_device_release_direct(indio_dev);
if (ret)
return ret;
tmp = sign_extend32(reg_val, 15);
switch (cfg->oversampling_ratio) {
case 1:
*val = tmp / 4;
*val2 = abs(tmp) % 4 * MICRO / 4;
break;
case 4:
*val = tmp / 2;
*val2 = abs(tmp) % 2 * MICRO / 2;
break;
case 16:
*val = tmp;
*val2 = 0;
break;
case 64:
*val = tmp * 2;
*val2 = 0;
break;
default:
return -EINVAL;
}
if (tmp < 0 && *val2) {
*val *= -1;
*val2 *= -1;
}
return IIO_VAL_INT_PLUS_MICRO;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
switch (chan->type) {
case IIO_VOLTAGE:
*val = cfg->oversampling_ratio;
return IIO_VAL_INT;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_SAMP_FREQ: {
struct pwm_state state;
unsigned int osr = 1;
if (chan->type == IIO_VOLTAGE)
osr = cfg->oversampling_ratio;
ret = pwm_get_state_hw(st->cnv_pwm, &state);
if (ret)
return ret;
/*
* The effective sampling frequency for a channel is the input
* frequency divided by the channel's OSR value.
*/
*val = DIV_ROUND_UP_ULL(NSEC_PER_SEC, state.period * osr);
return IIO_VAL_INT;
}
default:
return -EINVAL;
}
}
static int ad4695_write_raw_get_fmt(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
long mask)
{
switch (mask) {
case IIO_CHAN_INFO_SAMP_FREQ:
return IIO_VAL_INT;
default:
return IIO_VAL_INT_PLUS_MICRO;
}
}
static int ad4695_set_osr_val(struct ad4695_state *st,
struct iio_chan_spec const *chan,
int val)
{
int osr = ad4695_osr_to_regval(val);
if (osr < 0)
return osr;
switch (chan->type) {
case IIO_VOLTAGE:
st->channels_cfg[chan->scan_index].oversampling_ratio = val;
return regmap_update_bits(st->regmap,
AD4695_REG_CONFIG_IN(chan->scan_index),
AD4695_REG_CONFIG_IN_OSR_SET,
FIELD_PREP(AD4695_REG_CONFIG_IN_OSR_SET, osr));
default:
return -EINVAL;
}
}
static unsigned int ad4695_get_calibbias(int val, int val2, int osr)
{
int val_calc, scale;
switch (osr) {
case 4:
scale = 4;
break;
case 16:
scale = 2;
break;
case 64:
scale = 1;
break;
default:
scale = 8;
break;
}
val = clamp_t(int, val, S32_MIN / 8, S32_MAX / 8);
/* val2 range is (-MICRO, MICRO) if val == 0, otherwise [0, MICRO) */
if (val < 0)
val_calc = val * scale - val2 * scale / MICRO;
else if (val2 < 0)
/* if val2 < 0 then val == 0 */
val_calc = val2 * scale / (int)MICRO;
else
val_calc = val * scale + val2 * scale / MICRO;
val_calc /= 2;
return clamp_t(int, val_calc, S16_MIN, S16_MAX);
}
static int __ad4695_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val, int val2, long mask)
{
struct ad4695_state *st = iio_priv(indio_dev);
unsigned int reg_val;
unsigned int osr = 1;
if (chan->type == IIO_VOLTAGE)
osr = st->channels_cfg[chan->scan_index].oversampling_ratio;
switch (mask) {
case IIO_CHAN_INFO_CALIBSCALE:
switch (chan->type) {
case IIO_VOLTAGE:
if (val < 0 || val2 < 0)
reg_val = 0;
else if (val > 1)
reg_val = U16_MAX;
else
reg_val = (val * (1 << 16) +
mul_u64_u32_div(val2, 1 << 16,
MICRO)) / 2;
return regmap_write(st->regmap16,
AD4695_REG_GAIN_IN(chan->scan_index),
reg_val);
default:
return -EINVAL;
}
case IIO_CHAN_INFO_CALIBBIAS:
switch (chan->type) {
case IIO_VOLTAGE:
reg_val = ad4695_get_calibbias(val, val2, osr);
return regmap_write(st->regmap16,
AD4695_REG_OFFSET_IN(chan->scan_index),
reg_val);
default:
return -EINVAL;
}
case IIO_CHAN_INFO_SAMP_FREQ: {
struct pwm_state state;
/*
* Limit the maximum acceptable sample rate according to
* the channel's oversampling ratio.
*/
u64 max_osr_rate = DIV_ROUND_UP_ULL(st->chip_info->max_sample_rate,
osr);
if (val <= 0 || val > max_osr_rate)
return -EINVAL;
guard(mutex)(&st->cnv_pwm_lock);
pwm_get_state(st->cnv_pwm, &state);
/*
* The required sample frequency for a given OSR is the
* input frequency multiplied by it.
*/
state.period = DIV_ROUND_UP_ULL(NSEC_PER_SEC, val * osr);
return pwm_apply_might_sleep(st->cnv_pwm, &state);
}
case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
return ad4695_set_osr_val(st, chan, val);
default:
return -EINVAL;
}
}
static int ad4695_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val, int val2, long mask)
{
int ret;
if (!iio_device_claim_direct(indio_dev))
return -EBUSY;
ret = __ad4695_write_raw(indio_dev, chan, val, val2, mask);
iio_device_release_direct(indio_dev);
return ret;
}
static int ad4695_read_avail(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
const int **vals, int *type, int *length,
long mask)
{
int ret;
static const int ad4695_calibscale_available[6] = {
/* Range of 0 (inclusive) to 2 (exclusive) */
0, 15, 1, 15, U16_MAX, 15
};
static const int ad4695_calibbias_available[4][6] = {
/*
* Datasheet says FSR/8 which translates to signed/4. The step
* depends on oversampling ratio, so we need four different
* ranges to select from.
*/
{
S16_MIN / 4, 0,
0, MICRO / 4,
S16_MAX / 4, S16_MAX % 4 * MICRO / 4
},
{
S16_MIN / 2, 0,
0, MICRO / 2,
S16_MAX / 2, S16_MAX % 2 * MICRO / 2,
},
{
S16_MIN, 0,
1, 0,
S16_MAX, 0,
},
{
S16_MIN * 2, 0,
2, 0,
S16_MAX * 2, 0,
},
};
struct ad4695_state *st = iio_priv(indio_dev);
unsigned int osr = 1;
if (chan->type == IIO_VOLTAGE)
osr = st->channels_cfg[chan->scan_index].oversampling_ratio;
switch (mask) {
case IIO_CHAN_INFO_CALIBSCALE:
switch (chan->type) {
case IIO_VOLTAGE:
*vals = ad4695_calibscale_available;
*type = IIO_VAL_FRACTIONAL_LOG2;
return IIO_AVAIL_RANGE;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_CALIBBIAS:
switch (chan->type) {
case IIO_VOLTAGE:
ret = ad4695_osr_to_regval(osr);
if (ret < 0)
return ret;
/*
* Select the appropriate calibbias array based on the
* OSR value in the register.
*/
*vals = ad4695_calibbias_available[ret];
*type = IIO_VAL_INT_PLUS_MICRO;
return IIO_AVAIL_RANGE;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_SAMP_FREQ:
/* Max sample rate for the channel depends on OSR */
st->sample_freq_range[2] =
DIV_ROUND_UP_ULL(st->chip_info->max_sample_rate, osr);
*vals = st->sample_freq_range;
*type = IIO_VAL_INT;
return IIO_AVAIL_RANGE;
case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
switch (chan->type) {
case IIO_VOLTAGE:
*vals = ad4695_oversampling_ratios;
*length = ARRAY_SIZE(ad4695_oversampling_ratios);
*type = IIO_VAL_INT;
return IIO_AVAIL_LIST;
default:
return -EINVAL;
}
default:
return -EINVAL;
}
}
static int ad4695_debugfs_reg_access(struct iio_dev *indio_dev,
unsigned int reg,
unsigned int writeval,
unsigned int *readval)
{
struct ad4695_state *st = iio_priv(indio_dev);
int ret = -EINVAL;
if (!iio_device_claim_direct(indio_dev))
return -EBUSY;
if (readval) {
if (regmap_check_range_table(st->regmap, reg,
&ad4695_regmap_rd_table))
ret = regmap_read(st->regmap, reg, readval);
if (regmap_check_range_table(st->regmap16, reg,
&ad4695_regmap16_rd_table))
ret = regmap_read(st->regmap16, reg, readval);
} else {
if (regmap_check_range_table(st->regmap, reg,
&ad4695_regmap_wr_table))
ret = regmap_write(st->regmap, reg, writeval);
if (regmap_check_range_table(st->regmap16, reg,
&ad4695_regmap16_wr_table))
ret = regmap_write(st->regmap16, reg, writeval);
}
iio_device_release_direct(indio_dev);
return ret;
}
static int ad4695_get_current_scan_type(const struct iio_dev *indio_dev,
const struct iio_chan_spec *chan)
{
struct ad4695_state *st = iio_priv(indio_dev);
unsigned int osr = st->channels_cfg[chan->scan_index].oversampling_ratio;
switch (osr) {
case 1:
return AD4695_SCAN_TYPE_OSR_1;
case 4:
return AD4695_SCAN_TYPE_OSR_4;
case 16:
return AD4695_SCAN_TYPE_OSR_16;
case 64:
return AD4695_SCAN_TYPE_OSR_64;
default:
return -EINVAL;
}
}
static const struct iio_info ad4695_info = {
.read_raw = &ad4695_read_raw,
.write_raw_get_fmt = &ad4695_write_raw_get_fmt,
.write_raw = &ad4695_write_raw,
.read_avail = &ad4695_read_avail,
.debugfs_reg_access = &ad4695_debugfs_reg_access,
};
static const struct iio_info ad4695_offload_info = {
.read_raw = &ad4695_read_raw,
.write_raw_get_fmt = &ad4695_write_raw_get_fmt,
.write_raw = &ad4695_write_raw,
.get_current_scan_type = &ad4695_get_current_scan_type,
.read_avail = &ad4695_read_avail,
.debugfs_reg_access = &ad4695_debugfs_reg_access,
};
static int ad4695_parse_channel_cfg(struct ad4695_state *st)
{
struct device *dev = &st->spi->dev;
struct ad4695_channel_config *chan_cfg;
struct iio_chan_spec *iio_chan;
int ret, i;
/* populate defaults */
for (i = 0; i < st->chip_info->num_voltage_inputs; i++) {
chan_cfg = &st->channels_cfg[i];
iio_chan = &st->iio_chan[i];
chan_cfg->highz_en = true;
chan_cfg->channel = i;
/* This is the default OSR after reset */
chan_cfg->oversampling_ratio = 1;
*iio_chan = ad4695_channel_template;
iio_chan->channel = i;
iio_chan->scan_index = i;
iio_chan->address = AD4695_CMD_VOLTAGE_CHAN(i);
}
/* modify based on firmware description */
device_for_each_child_node_scoped(dev, child) {
u32 reg, val;
ret = fwnode_property_read_u32(child, "reg", &reg);
if (ret)
return dev_err_probe(dev, ret,
"failed to read reg property (%s)\n",
fwnode_get_name(child));
if (reg >= st->chip_info->num_voltage_inputs)
return dev_err_probe(dev, -EINVAL,
"reg out of range (%s)\n",
fwnode_get_name(child));
iio_chan = &st->iio_chan[reg];
chan_cfg = &st->channels_cfg[reg];
chan_cfg->highz_en =
!fwnode_property_read_bool(child, "adi,no-high-z");
chan_cfg->bipolar = fwnode_property_read_bool(child, "bipolar");
ret = fwnode_property_read_u32(child, "common-mode-channel",
&val);
if (ret && ret != -EINVAL)
return dev_err_probe(dev, ret,
"failed to read common-mode-channel (%s)\n",
fwnode_get_name(child));
if (ret == -EINVAL || val == AD4695_COMMON_MODE_REFGND)
chan_cfg->pin_pairing = AD4695_IN_PAIR_REFGND;
else if (val == AD4695_COMMON_MODE_COM)
chan_cfg->pin_pairing = AD4695_IN_PAIR_COM;
else
chan_cfg->pin_pairing = AD4695_IN_PAIR_EVEN_ODD;
if (chan_cfg->pin_pairing == AD4695_IN_PAIR_EVEN_ODD &&
val % 2 == 0)
return dev_err_probe(dev, -EINVAL,
"common-mode-channel must be odd number (%s)\n",
fwnode_get_name(child));
if (chan_cfg->pin_pairing == AD4695_IN_PAIR_EVEN_ODD &&
val != reg + 1)
return dev_err_probe(dev, -EINVAL,
"common-mode-channel must be next consecutive channel (%s)\n",
fwnode_get_name(child));
if (chan_cfg->pin_pairing == AD4695_IN_PAIR_EVEN_ODD) {
char name[5];
snprintf(name, sizeof(name), "in%d", reg + 1);
ret = devm_regulator_get_enable_read_voltage(dev, name);
if (ret < 0)
return dev_err_probe(dev, ret,
"failed to get %s voltage (%s)\n",
name, fwnode_get_name(child));
chan_cfg->common_mode_mv = ret / 1000;
}
if (chan_cfg->bipolar &&
chan_cfg->pin_pairing == AD4695_IN_PAIR_REFGND)
return dev_err_probe(dev, -EINVAL,
"bipolar mode is not available for inputs paired with REFGND (%s).\n",
fwnode_get_name(child));
if (chan_cfg->bipolar)
iio_chan->scan_type.sign = 's';
ret = ad4695_write_chn_cfg(st, chan_cfg);
if (ret)
return ret;
}
/* Temperature channel must be next scan index after voltage channels. */
st->iio_chan[i] = ad4695_temp_channel_template;
st->iio_chan[i].scan_index = i;
i++;
st->iio_chan[i] = ad4695_soft_timestamp_channel_template;
st->iio_chan[i].scan_index = i;
return 0;
}
static bool ad4695_offload_trigger_match(struct spi_offload_trigger *trigger,
enum spi_offload_trigger_type type,
u64 *args, u32 nargs)
{
if (type != SPI_OFFLOAD_TRIGGER_DATA_READY)
return false;
/*
* Requires 2 args:
* args[0] is the trigger event.
* args[1] is the GPIO pin number.
*/
if (nargs != 2 || args[0] != AD4695_TRIGGER_EVENT_BUSY)
return false;
return true;
}
static int ad4695_offload_trigger_request(struct spi_offload_trigger *trigger,
enum spi_offload_trigger_type type,
u64 *args, u32 nargs)
{
struct ad4695_state *st = spi_offload_trigger_get_priv(trigger);
/* Should already be validated by match, but just in case. */
if (nargs != 2)
return -EINVAL;
/* DT tells us if BUSY event uses GP0 or GP3. */
if (args[1] == AD4695_TRIGGER_PIN_GP3)
return regmap_set_bits(st->regmap, AD4695_REG_GP_MODE,
AD4695_REG_GP_MODE_BUSY_GP_SEL);
return regmap_clear_bits(st->regmap, AD4695_REG_GP_MODE,
AD4695_REG_GP_MODE_BUSY_GP_SEL);
}
static int
ad4695_offload_trigger_validate(struct spi_offload_trigger *trigger,
struct spi_offload_trigger_config *config)
{
if (config->type != SPI_OFFLOAD_TRIGGER_DATA_READY)
return -EINVAL;
return 0;
}
/*
* NB: There are no enable/disable callbacks here due to requiring a SPI
* message to enable or disable the BUSY output on the ADC.
*/
static const struct spi_offload_trigger_ops ad4695_offload_trigger_ops = {
.match = ad4695_offload_trigger_match,
.request = ad4695_offload_trigger_request,
.validate = ad4695_offload_trigger_validate,
};
static void ad4695_pwm_disable(void *pwm)
{
pwm_disable(pwm);
}
static int ad4695_probe_spi_offload(struct iio_dev *indio_dev,
struct ad4695_state *st)
{
struct device *dev = &st->spi->dev;
struct spi_offload_trigger_info trigger_info = {
.fwnode = dev_fwnode(dev),
.ops = &ad4695_offload_trigger_ops,
.priv = st,
};
struct pwm_state pwm_state;
struct dma_chan *rx_dma;
int ret, i;
indio_dev->info = &ad4695_offload_info;
indio_dev->num_channels = st->chip_info->num_voltage_inputs + 1;
indio_dev->setup_ops = &ad4695_offload_buffer_setup_ops;
if (!st->cnv_gpio)
return dev_err_probe(dev, -ENODEV,
"CNV GPIO is required for SPI offload\n");
ret = devm_spi_offload_trigger_register(dev, &trigger_info);
if (ret)
return dev_err_probe(dev, ret,
"failed to register offload trigger\n");
st->offload_trigger = devm_spi_offload_trigger_get(dev, st->offload,
SPI_OFFLOAD_TRIGGER_DATA_READY);
if (IS_ERR(st->offload_trigger))
return dev_err_probe(dev, PTR_ERR(st->offload_trigger),
"failed to get offload trigger\n");
ret = devm_mutex_init(dev, &st->cnv_pwm_lock);
if (ret)
return ret;
st->cnv_pwm = devm_pwm_get(dev, NULL);
if (IS_ERR(st->cnv_pwm))
return dev_err_probe(dev, PTR_ERR(st->cnv_pwm),
"failed to get CNV PWM\n");
pwm_init_state(st->cnv_pwm, &pwm_state);
/* If firmware didn't provide default rate, use 10kHz (arbitrary). */
if (pwm_state.period == 0)
pwm_state.period = 100 * MILLI;
pwm_state.enabled = true;
ret = pwm_apply_might_sleep(st->cnv_pwm, &pwm_state);
if (ret)
return dev_err_probe(dev, ret, "failed to apply CNV PWM\n");
ret = devm_add_action_or_reset(dev, ad4695_pwm_disable, st->cnv_pwm);
if (ret)
return ret;
rx_dma = devm_spi_offload_rx_stream_request_dma_chan(dev, st->offload);
if (IS_ERR(rx_dma))
return dev_err_probe(dev, PTR_ERR(rx_dma),
"failed to get offload RX DMA\n");
for (i = 0; i < indio_dev->num_channels; i++) {
struct iio_chan_spec *chan = &st->iio_chan[i];
struct ad4695_channel_config *cfg;
/*
* NB: When using offload support, all channels need to have the
* same bits_per_word because they all use the same SPI message
* for reading one sample. In order to prevent breaking
* userspace in the future when oversampling support is added,
* all channels are set read 19 bits with a shift of 3 to mask
* out the extra bits even though we currently only support 16
* bit samples (oversampling ratio == 1).
*/
chan->scan_type.shift = 3;
chan->scan_type.storagebits = 32;
/* add sample frequency for PWM CNV trigger */
chan->info_mask_separate |= BIT(IIO_CHAN_INFO_SAMP_FREQ);
chan->info_mask_separate_available |= BIT(IIO_CHAN_INFO_SAMP_FREQ);
/* Add the oversampling properties only for voltage channels */
if (chan->type != IIO_VOLTAGE)
continue;
cfg = &st->channels_cfg[i];
chan->info_mask_separate |= BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO);
chan->info_mask_separate_available |=
BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO);
chan->has_ext_scan_type = 1;
if (cfg->bipolar) {
chan->ext_scan_type = ad4695_scan_type_offload_s;
chan->num_ext_scan_type =
ARRAY_SIZE(ad4695_scan_type_offload_s);
} else {
chan->ext_scan_type = ad4695_scan_type_offload_u;
chan->num_ext_scan_type =
ARRAY_SIZE(ad4695_scan_type_offload_u);
}
}
return devm_iio_dmaengine_buffer_setup_with_handle(dev, indio_dev,
rx_dma, IIO_BUFFER_DIRECTION_IN);
}
static const struct spi_offload_config ad4695_spi_offload_config = {
.capability_flags = SPI_OFFLOAD_CAP_TRIGGER |
SPI_OFFLOAD_CAP_RX_STREAM_DMA,
};
static int ad4695_probe(struct spi_device *spi)
{
struct device *dev = &spi->dev;
struct ad4695_state *st;
struct iio_dev *indio_dev;
bool use_internal_ldo_supply;
bool use_internal_ref_buffer;
int ret;
indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
if (!indio_dev)
return -ENOMEM;
st = iio_priv(indio_dev);
st->spi = spi;
st->chip_info = spi_get_device_match_data(spi);
if (!st->chip_info)
return -EINVAL;
st->sample_freq_range[0] = 1; /* min */
st->sample_freq_range[1] = 1; /* step */
st->sample_freq_range[2] = st->chip_info->max_sample_rate; /* max */
st->regmap = devm_regmap_init(dev, &ad4695_regmap_bus, st,
&ad4695_regmap_config);
if (IS_ERR(st->regmap))
return dev_err_probe(dev, PTR_ERR(st->regmap),
"Failed to initialize regmap\n");
st->regmap16 = devm_regmap_init(dev, &ad4695_regmap_bus, st,
&ad4695_regmap16_config);
if (IS_ERR(st->regmap16))
return dev_err_probe(dev, PTR_ERR(st->regmap16),
"Failed to initialize regmap16\n");
st->cnv_gpio = devm_gpiod_get_optional(dev, "cnv", GPIOD_OUT_LOW);
if (IS_ERR(st->cnv_gpio))
return dev_err_probe(dev, PTR_ERR(st->cnv_gpio),
"Failed to get CNV GPIO\n");
ret = devm_regulator_bulk_get_enable(dev,
ARRAY_SIZE(ad4695_power_supplies),
ad4695_power_supplies);
if (ret)
return dev_err_probe(dev, ret,
"Failed to enable power supplies\n");
/* If LDO_IN supply is present, then we are using internal LDO. */
ret = devm_regulator_get_enable_optional(dev, "ldo-in");
if (ret < 0 && ret != -ENODEV)
return dev_err_probe(dev, ret,
"Failed to enable LDO_IN supply\n");
use_internal_ldo_supply = ret == 0;
if (!use_internal_ldo_supply) {
/* Otherwise we need an external VDD supply. */
ret = devm_regulator_get_enable(dev, "vdd");
if (ret < 0)
return dev_err_probe(dev, ret,
"Failed to enable VDD supply\n");
}
/* If REFIN supply is given, then we are using internal buffer */
ret = devm_regulator_get_enable_read_voltage(dev, "refin");
if (ret < 0 && ret != -ENODEV)
return dev_err_probe(dev, ret, "Failed to get REFIN voltage\n");
if (ret != -ENODEV) {
st->vref_mv = ret / 1000;
use_internal_ref_buffer = true;
} else {
/* Otherwise, we need an external reference. */
ret = devm_regulator_get_enable_read_voltage(dev, "ref");
if (ret < 0)
return dev_err_probe(dev, ret,
"Failed to get REF voltage\n");
st->vref_mv = ret / 1000;
use_internal_ref_buffer = false;
}
ret = devm_regulator_get_enable_read_voltage(dev, "com");
if (ret < 0 && ret != -ENODEV)
return dev_err_probe(dev, ret, "Failed to get COM voltage\n");
st->com_mv = ret == -ENODEV ? 0 : ret / 1000;
/*
* Reset the device using hardware reset if available or fall back to
* software reset.
*/
st->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
if (IS_ERR(st->reset_gpio))
return PTR_ERR(st->reset_gpio);
if (st->reset_gpio) {
gpiod_set_value(st->reset_gpio, 0);
msleep(AD4695_T_WAKEUP_HW_MS);
} else {
ret = regmap_write(st->regmap, AD4695_REG_SPI_CONFIG_A,
AD4695_REG_SPI_CONFIG_A_SW_RST);
if (ret)
return ret;
msleep(AD4695_T_WAKEUP_SW_MS);
}
/* Needed for regmap16 to be able to work correctly. */
ret = regmap_set_bits(st->regmap, AD4695_REG_SPI_CONFIG_A,
AD4695_REG_SPI_CONFIG_A_ADDR_DIR);
if (ret)
return ret;
/* Disable internal LDO if it isn't needed. */
ret = regmap_update_bits(st->regmap, AD4695_REG_SETUP,
AD4695_REG_SETUP_LDO_EN,
FIELD_PREP(AD4695_REG_SETUP_LDO_EN,
use_internal_ldo_supply ? 1 : 0));
if (ret)
return ret;
/* configure reference supply */
if (device_property_present(dev, "adi,no-ref-current-limit")) {
ret = regmap_set_bits(st->regmap, AD4695_REG_REF_CTRL,
AD4695_REG_REF_CTRL_OV_MODE);
if (ret)
return ret;
}
if (device_property_present(dev, "adi,no-ref-high-z")) {
if (use_internal_ref_buffer)
return dev_err_probe(dev, -EINVAL,
"Cannot disable high-Z mode for internal reference buffer\n");
ret = regmap_clear_bits(st->regmap, AD4695_REG_REF_CTRL,
AD4695_REG_REF_CTRL_REFHIZ_EN);
if (ret)
return ret;
}
ret = ad4695_set_ref_voltage(st, st->vref_mv);
if (ret)
return ret;
if (use_internal_ref_buffer) {
ret = regmap_set_bits(st->regmap, AD4695_REG_REF_CTRL,
AD4695_REG_REF_CTRL_REFBUF_EN);
if (ret)
return ret;
/* Give the capacitor some time to charge up. */
msleep(AD4695_T_REFBUF_MS);
}
ret = ad4695_parse_channel_cfg(st);
if (ret)
return ret;
indio_dev->name = st->chip_info->name;
indio_dev->info = &ad4695_info;
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->channels = st->iio_chan;
indio_dev->num_channels = st->chip_info->num_voltage_inputs + 2;
st->offload = devm_spi_offload_get(dev, spi, &ad4695_spi_offload_config);
ret = PTR_ERR_OR_ZERO(st->offload);
if (ret && ret != -ENODEV)
return dev_err_probe(dev, ret, "failed to get SPI offload\n");
/* If no SPI offload, fall back to low speed usage. */
if (ret == -ENODEV) {
/* Driver currently requires CNV pin to be connected to SPI CS */
if (st->cnv_gpio)
return dev_err_probe(dev, -EINVAL,
"CNV GPIO is not supported\n");
indio_dev->num_channels = st->chip_info->num_voltage_inputs + 2;
ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
iio_pollfunc_store_time,
ad4695_trigger_handler,
&ad4695_buffer_setup_ops);
if (ret)
return ret;
} else {
ret = ad4695_probe_spi_offload(indio_dev, st);
if (ret)
return ret;
}
return devm_iio_device_register(dev, indio_dev);
}
static const struct spi_device_id ad4695_spi_id_table[] = {
{ .name = "ad4695", .driver_data = (kernel_ulong_t)&ad4695_chip_info },
{ .name = "ad4696", .driver_data = (kernel_ulong_t)&ad4696_chip_info },
{ .name = "ad4697", .driver_data = (kernel_ulong_t)&ad4697_chip_info },
{ .name = "ad4698", .driver_data = (kernel_ulong_t)&ad4698_chip_info },
{ }
};
MODULE_DEVICE_TABLE(spi, ad4695_spi_id_table);
static const struct of_device_id ad4695_of_match_table[] = {
{ .compatible = "adi,ad4695", .data = &ad4695_chip_info, },
{ .compatible = "adi,ad4696", .data = &ad4696_chip_info, },
{ .compatible = "adi,ad4697", .data = &ad4697_chip_info, },
{ .compatible = "adi,ad4698", .data = &ad4698_chip_info, },
{ }
};
MODULE_DEVICE_TABLE(of, ad4695_of_match_table);
static struct spi_driver ad4695_driver = {
.driver = {
.name = "ad4695",
.of_match_table = ad4695_of_match_table,
},
.probe = ad4695_probe,
.id_table = ad4695_spi_id_table,
};
module_spi_driver(ad4695_driver);
MODULE_AUTHOR("Ramona Gradinariu <ramona.gradinariu@analog.com>");
MODULE_AUTHOR("David Lechner <dlechner@baylibre.com>");
MODULE_DESCRIPTION("Analog Devices AD4695 ADC driver");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("IIO_DMAENGINE_BUFFER");
Reference in a new issue View git blame Copy permalink