* [PATCH v4 1/3] dt-bindings: iio: accel: add ADXL380 @ 2024-07-01 8:30 Antoniu Miclaus 2024-07-01 8:30 ` [PATCH v4 2/3] iio: accel: add ADXL380 driver Antoniu Miclaus 2024-07-01 8:30 ` [PATCH v4 3/3] docs: iio: add documentation for adxl380 driver Antoniu Miclaus 0 siblings, 2 replies; 7+ messages in thread From: Antoniu Miclaus @ 2024-07-01 8:30 UTC (permalink / raw) To: Ramona Gradinariu, Antoniu Miclaus, Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Jonathan Corbet, Jun Yan, Matti Vaittinen, Mehdi Djait, Mario Limonciello, linux-iio, devicetree, linux-kernel, linux-doc Cc: Conor Dooley Add dt-bindings for ADXL380/ADLX382 low noise density, low power, 3-axis accelerometer with selectable measurement ranges. Reviewed-by: Conor Dooley <conor.dooley@microchip.com> Signed-off-by: Ramona Gradinariu <ramona.gradinariu@analog.com> Signed-off-by: Antoniu Miclaus <antoniu.miclaus@analog.com> --- changes in v4: - drop marketing from description. .../bindings/iio/accel/adi,adxl380.yaml | 92 +++++++++++++++++++ MAINTAINERS | 7 ++ 2 files changed, 99 insertions(+) create mode 100644 Documentation/devicetree/bindings/iio/accel/adi,adxl380.yaml diff --git a/Documentation/devicetree/bindings/iio/accel/adi,adxl380.yaml b/Documentation/devicetree/bindings/iio/accel/adi,adxl380.yaml new file mode 100644 index 000000000000..f1ff5ff4f478 --- /dev/null +++ b/Documentation/devicetree/bindings/iio/accel/adi,adxl380.yaml @@ -0,0 +1,92 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/iio/accel/adi,adxl380.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Analog Devices ADXL380/382 3-Axis Digital Accelerometer + +maintainers: + - Ramona Gradinariu <ramona.gradinariu@analog.com> + - Antoniu Miclaus <antoniu.miclaus@analog.com> + +description: | + The ADXL380/ADXL382 is a low noise density, low power, 3-axis + accelerometer with selectable measurement ranges. The ADXL380 + supports the ±4 g, ±8 g, and ±16 g ranges, and the ADXL382 supports + ±15 g, ±30 g, and ±60 g ranges. + + https://www.analog.com/en/products/adxl380.html + +properties: + compatible: + enum: + - adi,adxl380 + - adi,adxl382 + + reg: + maxItems: 1 + + interrupts: + minItems: 1 + maxItems: 2 + + interrupt-names: + minItems: 1 + items: + - enum: [INT0, INT1] + - const: INT1 + + vddio-supply: true + + vsupply-supply: true + +required: + - compatible + - reg + - interrupts + - interrupt-names + - vddio-supply + - vsupply-supply + +allOf: + - $ref: /schemas/spi/spi-peripheral-props.yaml# + +unevaluatedProperties: false + +examples: + - | + #include <dt-bindings/interrupt-controller/irq.h> + + i2c { + #address-cells = <1>; + #size-cells = <0>; + + accelerometer@54 { + compatible = "adi,adxl380"; + reg = <0x54>; + vddio-supply = <&vddio>; + vsupply-supply = <&vsupply>; + interrupt-parent = <&gpio>; + interrupts = <25 IRQ_TYPE_LEVEL_HIGH>; + interrupt-names = "INT0"; + }; + }; + - | + #include <dt-bindings/interrupt-controller/irq.h> + + spi { + #address-cells = <1>; + #size-cells = <0>; + + accelerometer@0 { + compatible = "adi,adxl380"; + reg = <0>; + spi-max-frequency = <8000000>; + vddio-supply = <&vddio>; + vsupply-supply = <&vsupply>; + interrupt-parent = <&gpio>; + interrupts = <25 IRQ_TYPE_LEVEL_HIGH>; + interrupt-names = "INT0"; + }; + }; diff --git a/MAINTAINERS b/MAINTAINERS index be590c462d91..1425182c85e2 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -618,6 +618,13 @@ F: drivers/iio/accel/adxl372.c F: drivers/iio/accel/adxl372_i2c.c F: drivers/iio/accel/adxl372_spi.c +ADXL380 THREE-AXIS DIGITAL ACCELEROMETER DRIVER +M: Ramona Gradinariu <ramona.gradinariu@analog.com> +M: Antoniu Miclaus <antoniu.miclaus@analog.com> +S: Supported +W: https://ez.analog.com/linux-software-drivers +F: Documentation/devicetree/bindings/iio/accel/adi,adxl380.yaml + AF8133J THREE-AXIS MAGNETOMETER DRIVER M: Ondřej Jirman <megi@xff.cz> S: Maintained -- 2.45.2 ^ permalink raw reply related [flat|nested] 7+ messages in thread
* [PATCH v4 2/3] iio: accel: add ADXL380 driver 2024-07-01 8:30 [PATCH v4 1/3] dt-bindings: iio: accel: add ADXL380 Antoniu Miclaus @ 2024-07-01 8:30 ` Antoniu Miclaus 2024-07-03 7:06 ` Alexandru Ardelean 2024-07-01 8:30 ` [PATCH v4 3/3] docs: iio: add documentation for adxl380 driver Antoniu Miclaus 1 sibling, 1 reply; 7+ messages in thread From: Antoniu Miclaus @ 2024-07-01 8:30 UTC (permalink / raw) To: Ramona Gradinariu, Antoniu Miclaus, Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Jonathan Corbet, Jun Yan, Matti Vaittinen, Mario Limonciello, Mehdi Djait, linux-iio, devicetree, linux-kernel, linux-doc The ADXL380/ADXL382 is a low noise density, low power, 3-axis accelerometer with selectable measurement ranges. The ADXL380 supports the +/-4 g, +/-8 g, and +/-16 g ranges, and the ADXL382 supports +/-15 g, +/-30 g and +/-60 g ranges. The ADXL380/ADXL382 offers industry leading noise, enabling precision applications with minimal calibration. The low noise, and low power ADXL380/ADXL382 enables accurate measurement in an environment with high vibration, heart sounds and audio. In addition to its low power consumption, the ADXL380/ADXL382 has many features to enable true system level performance. These include a built-in micropower temperature sensor, single / double / triple tap detection and a state machine to prevent a false triggering. In addition, the ADXL380/ADXL382 has provisions for external control of the sampling time and/or an external clock. Signed-off-by: Ramona Gradinariu <ramona.gradinariu@analog.com> Signed-off-by: Antoniu Miclaus <antoniu.miclaus@analog.com> --- changes in v4: - drop __aligned(IIO_DMA_MINALIGN); from tables and use it on fifo_buf - drop brackets around odr >> 1 and odr & 1 - wrap long line - drop comma on null terminator - fix odd indentation - drop extra space before > - add space before } on arrays where missing MAINTAINERS | 4 + drivers/iio/accel/Kconfig | 27 + drivers/iio/accel/Makefile | 3 + drivers/iio/accel/adxl380.c | 1908 +++++++++++++++++++++++++++++++ drivers/iio/accel/adxl380.h | 26 + drivers/iio/accel/adxl380_i2c.c | 64 ++ drivers/iio/accel/adxl380_spi.c | 66 ++ 7 files changed, 2098 insertions(+) create mode 100644 drivers/iio/accel/adxl380.c create mode 100644 drivers/iio/accel/adxl380.h create mode 100644 drivers/iio/accel/adxl380_i2c.c create mode 100644 drivers/iio/accel/adxl380_spi.c diff --git a/MAINTAINERS b/MAINTAINERS index 1425182c85e2..67583f13da51 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -624,6 +624,10 @@ M: Antoniu Miclaus <antoniu.miclaus@analog.com> S: Supported W: https://ez.analog.com/linux-software-drivers F: Documentation/devicetree/bindings/iio/accel/adi,adxl380.yaml +F: drivers/iio/accel/adxl380.c +F: drivers/iio/accel/adxl380.h +F: drivers/iio/accel/adxl380_i2c.c +F: drivers/iio/accel/adxl380_spi.c AF8133J THREE-AXIS MAGNETOMETER DRIVER M: Ondřej Jirman <megi@xff.cz> diff --git a/drivers/iio/accel/Kconfig b/drivers/iio/accel/Kconfig index c2da5066e9a7..6572ab447e14 100644 --- a/drivers/iio/accel/Kconfig +++ b/drivers/iio/accel/Kconfig @@ -177,6 +177,33 @@ config ADXL372_I2C To compile this driver as a module, choose M here: the module will be called adxl372_i2c. +config ADXL380 + tristate + select IIO_BUFFER + select IIO_TRIGGERED_BUFFER + +config ADXL380_SPI + tristate "Analog Devices ADXL380 3-Axis Accelerometer SPI Driver" + depends on SPI + select ADXL380 + select REGMAP_SPI + help + Say yes here to add support for the Analog Devices ADXL380 triaxial + acceleration sensor. + To compile this driver as a module, choose M here: the + module will be called adxl380_spi. + +config ADXL380_I2C + tristate "Analog Devices ADXL380 3-Axis Accelerometer I2C Driver" + depends on I2C + select ADXL380 + select REGMAP_I2C + help + Say yes here to add support for the Analog Devices ADXL380 triaxial + acceleration sensor. + To compile this driver as a module, choose M here: the + module will be called adxl380_i2c. + config BMA180 tristate "Bosch BMA023/BMA1x0/BMA250 3-Axis Accelerometer Driver" depends on I2C && INPUT_BMA150=n diff --git a/drivers/iio/accel/Makefile b/drivers/iio/accel/Makefile index db90532ba24a..ca8569e25aba 100644 --- a/drivers/iio/accel/Makefile +++ b/drivers/iio/accel/Makefile @@ -21,6 +21,9 @@ obj-$(CONFIG_ADXL367_SPI) += adxl367_spi.o obj-$(CONFIG_ADXL372) += adxl372.o obj-$(CONFIG_ADXL372_I2C) += adxl372_i2c.o obj-$(CONFIG_ADXL372_SPI) += adxl372_spi.o +obj-$(CONFIG_ADXL380) += adxl380.o +obj-$(CONFIG_ADXL380_I2C) += adxl380_i2c.o +obj-$(CONFIG_ADXL380_SPI) += adxl380_spi.o obj-$(CONFIG_BMA180) += bma180.o obj-$(CONFIG_BMA220) += bma220_spi.o obj-$(CONFIG_BMA400) += bma400_core.o diff --git a/drivers/iio/accel/adxl380.c b/drivers/iio/accel/adxl380.c new file mode 100644 index 000000000000..d37f4d85cf84 --- /dev/null +++ b/drivers/iio/accel/adxl380.c @@ -0,0 +1,1908 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * ADXL380 3-Axis Digital Accelerometer core driver + * + * Copyright 2024 Analog Devices Inc. + */ + +#include <linux/bitfield.h> +#include <linux/interrupt.h> +#include <linux/irq.h> +#include <linux/module.h> +#include <linux/property.h> +#include <linux/regmap.h> +#include <linux/units.h> + +#include <asm/unaligned.h> + +#include <linux/iio/buffer.h> +#include <linux/iio/events.h> +#include <linux/iio/iio.h> +#include <linux/iio/kfifo_buf.h> +#include <linux/iio/sysfs.h> + +#include <linux/regulator/consumer.h> + +#include "adxl380.h" + +#define ADXL380_ID_VAL 380 +#define ADXL382_ID_VAL 382 + +#define ADXL380_DEVID_AD_REG 0x00 +#define ADLX380_PART_ID_REG 0x02 + +#define ADXL380_X_DATA_H_REG 0x15 +#define ADXL380_Y_DATA_H_REG 0x17 +#define ADXL380_Z_DATA_H_REG 0x19 +#define ADXL380_T_DATA_H_REG 0x1B + +#define ADXL380_MISC_0_REG 0x20 +#define ADXL380_XL382_MSK BIT(7) + +#define ADXL380_MISC_1_REG 0x21 + +#define ADXL380_X_DSM_OFFSET_REG 0x4D + +#define ADXL380_ACT_INACT_CTL_REG 0x37 +#define ADXL380_INACT_EN_MSK BIT(2) +#define ADXL380_ACT_EN_MSK BIT(0) + +#define ADXL380_SNSR_AXIS_EN_REG 0x38 +#define ADXL380_ACT_INACT_AXIS_EN_MSK GENMASK(2, 0) + +#define ADXL380_THRESH_ACT_H_REG 0x39 +#define ADXL380_TIME_ACT_H_REG 0x3B +#define ADXL380_THRESH_INACT_H_REG 0x3E +#define ADXL380_TIME_INACT_H_REG 0x40 +#define ADXL380_THRESH_MAX GENMASK(12, 0) +#define ADXL380_TIME_MAX GENMASK(24, 0) + +#define ADXL380_FIFO_CONFIG_0_REG 0x30 +#define ADXL380_FIFO_SAMPLES_8_MSK BIT(0) +#define ADXL380_FIFO_MODE_MSK GENMASK(5, 4) + +#define ADXL380_FIFO_DISABLED 0 +#define ADXL380_FIFO_NORMAL 1 +#define ADXL380_FIFO_STREAMED 2 +#define ADXL380_FIFO_TRIGGERED 3 + +#define ADXL380_FIFO_CONFIG_1_REG 0x31 +#define ADXL380_FIFO_STATUS_0_REG 0x1E + +#define ADXL380_TAP_THRESH_REG 0x43 +#define ADXL380_TAP_DUR_REG 0x44 +#define ADXL380_TAP_LATENT_REG 0x45 +#define ADXL380_TAP_WINDOW_REG 0x46 +#define ADXL380_TAP_TIME_MAX GENMASK(7, 0) + +#define ADXL380_TAP_CFG_REG 0x47 +#define ADXL380_TAP_AXIS_MSK GENMASK(1, 0) + +#define ADXL380_TRIG_CFG_REG 0x49 +#define ADXL380_TRIG_CFG_DEC_2X_MSK BIT(7) +#define ADXL380_TRIG_CFG_SINC_RATE_MSK BIT(6) + +#define ADXL380_FILTER_REG 0x50 +#define ADXL380_FILTER_EQ_FILT_MSK BIT(6) +#define ADXL380_FILTER_LPF_MODE_MSK GENMASK(5, 4) +#define ADXL380_FILTER_HPF_PATH_MSK BIT(3) +#define ADXL380_FILTER_HPF_CORNER_MSK GENMASK(2, 0) + +#define ADXL380_OP_MODE_REG 0x26 +#define ADXL380_OP_MODE_RANGE_MSK GENMASK(7, 6) +#define ADXL380_OP_MODE_MSK GENMASK(3, 0) +#define ADXL380_OP_MODE_STANDBY 0 +#define ADXL380_OP_MODE_HEART_SOUND 1 +#define ADXL380_OP_MODE_ULP 2 +#define ADXL380_OP_MODE_VLP 3 +#define ADXL380_OP_MODE_LP 4 +#define ADXL380_OP_MODE_LP_ULP 6 +#define ADXL380_OP_MODE_LP_VLP 7 +#define ADXL380_OP_MODE_RBW 8 +#define ADXL380_OP_MODE_RBW_ULP 10 +#define ADXL380_OP_MODE_RBW_VLP 11 +#define ADXL380_OP_MODE_HP 12 +#define ADXL380_OP_MODE_HP_ULP 14 +#define ADXL380_OP_MODE_HP_VLP 15 + +#define ADXL380_OP_MODE_4G_RANGE 0 +#define ADXL382_OP_MODE_15G_RANGE 0 +#define ADXL380_OP_MODE_8G_RANGE 1 +#define ADXL382_OP_MODE_30G_RANGE 1 +#define ADXL380_OP_MODE_16G_RANGE 2 +#define ADXL382_OP_MODE_60G_RANGE 2 + +#define ADXL380_DIG_EN_REG 0x27 +#define ADXL380_CHAN_EN_MSK(chan) BIT(4 + (chan)) +#define ADXL380_FIFO_EN_MSK BIT(3) + +#define ADXL380_INT0_MAP0_REG 0x2B +#define ADXL380_INT1_MAP0_REG 0x2D +#define ADXL380_INT_MAP0_INACT_INT0_MSK BIT(6) +#define ADXL380_INT_MAP0_ACT_INT0_MSK BIT(5) +#define ADXL380_INT_MAP0_FIFO_WM_INT0_MSK BIT(3) + +#define ADXL380_INT0_MAP1_REG 0x2C +#define ADXL380_INT1_MAP1_REG 0x2E +#define ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK BIT(1) +#define ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK BIT(0) + +#define ADXL380_INT0_REG 0x5D +#define ADXL380_INT0_POL_MSK BIT(7) + +#define ADXL380_RESET_REG 0x2A +#define ADXL380_FIFO_DATA 0x1D + +#define ADXL380_DEVID_AD_VAL 0xAD +#define ADXL380_RESET_CODE 0x52 + +#define ADXL380_STATUS_0_REG 0x11 +#define ADXL380_STATUS_0_FIFO_FULL_MSK BIT(1) +#define ADXL380_STATUS_0_FIFO_WM_MSK BIT(3) + +#define ADXL380_STATUS_1_INACT_MSK BIT(6) +#define ADXL380_STATUS_1_ACT_MSK BIT(5) +#define ADXL380_STATUS_1_DOUBLE_TAP_MSK BIT(1) +#define ADXL380_STATUS_1_SINGLE_TAP_MSK BIT(0) + +#define ADXL380_FIFO_SAMPLES 315UL + +enum adxl380_channels { + ADXL380_ACCEL_X, + ADXL380_ACCEL_Y, + ADXL380_ACCEL_Z, + ADXL380_TEMP, + ADXL380_CH_NUM, +}; + +enum adxl380_axis { + ADXL380_X_AXIS, + ADXL380_Y_AXIS, + ADXL380_Z_AXIS, +}; + +enum adxl380_activity_type { + ADXL380_ACTIVITY, + ADXL380_INACTIVITY, +}; + +enum adxl380_tap_type { + ADXL380_SINGLE_TAP, + ADXL380_DOUBLE_TAP, +}; + +enum adxl380_tap_time_type { + ADXL380_TAP_TIME_LATENT, + ADXL380_TAP_TIME_WINDOW, +}; + +static const int adxl380_range_scale_factor_tbl[] = { 1, 2, 4 }; + +const struct adxl380_chip_info adxl380_chip_info = { + .name = "adxl380", + .chip_id = ADXL380_ID_VAL, + .scale_tbl = { + [ADXL380_OP_MODE_4G_RANGE] = { 0, 1307226 }, + [ADXL380_OP_MODE_8G_RANGE] = { 0, 2615434 }, + [ADXL380_OP_MODE_16G_RANGE] = { 0, 5229886 }, + }, + .samp_freq_tbl = { 8000, 16000, 32000 }, + /* + * The datasheet defines an intercept of 470 LSB at 25 degC + * and a sensitivity of 10.2 LSB/C. + */ + .temp_offset = 25 * 102 / 10 - 470, + +}; +EXPORT_SYMBOL_NS_GPL(adxl380_chip_info, IIO_ADXL380); + +const struct adxl380_chip_info adxl382_chip_info = { + .name = "adxl382", + .chip_id = ADXL382_ID_VAL, + .scale_tbl = { + [ADXL382_OP_MODE_15G_RANGE] = { 0, 4903325 }, + [ADXL382_OP_MODE_30G_RANGE] = { 0, 9806650 }, + [ADXL382_OP_MODE_60G_RANGE] = { 0, 19613300 }, + }, + .samp_freq_tbl = { 16000, 32000, 64000 }, + /* + * The datasheet defines an intercept of 570 LSB at 25 degC + * and a sensitivity of 10.2 LSB/C. + */ + .temp_offset = 25 * 102 / 10 - 570, +}; +EXPORT_SYMBOL_NS_GPL(adxl382_chip_info, IIO_ADXL380); + +static const unsigned int adxl380_th_reg_high_addr[2] = { + [ADXL380_ACTIVITY] = ADXL380_THRESH_ACT_H_REG, + [ADXL380_INACTIVITY] = ADXL380_THRESH_INACT_H_REG, +}; + +static const unsigned int adxl380_time_reg_high_addr[2] = { + [ADXL380_ACTIVITY] = ADXL380_TIME_ACT_H_REG, + [ADXL380_INACTIVITY] = ADXL380_TIME_INACT_H_REG, +}; + +static const unsigned int adxl380_tap_time_reg[2] = { + [ADXL380_TAP_TIME_LATENT] = ADXL380_TAP_LATENT_REG, + [ADXL380_TAP_TIME_WINDOW] = ADXL380_TAP_WINDOW_REG, +}; + +struct adxl380_state { + struct regmap *regmap; + struct device *dev; + const struct adxl380_chip_info *chip_info; + /* + * Synchronize access to members of driver state, and ensure atomicity + * of consecutive regmap operations. + */ + struct mutex lock; + enum adxl380_axis tap_axis_en; + u8 range; + u8 odr; + u8 fifo_set_size; + u8 transf_buf[3]; + u16 watermark; + u32 act_time_ms; + u32 act_threshold; + u32 inact_time_ms; + u32 inact_threshold; + u32 tap_latent_us; + u32 tap_window_us; + u32 tap_duration_us; + u32 tap_threshold; + int irq; + int int_map[2]; + int lpf_tbl[4]; + int hpf_tbl[7][2]; + + __be16 fifo_buf[ADXL380_FIFO_SAMPLES] __aligned(IIO_DMA_MINALIGN); +}; + +bool adxl380_readable_noinc_reg(struct device *dev, unsigned int reg) +{ + return reg == ADXL380_FIFO_DATA; +} +EXPORT_SYMBOL_NS_GPL(adxl380_readable_noinc_reg, IIO_ADXL380); + +static int adxl380_set_measure_en(struct adxl380_state *st, bool en) +{ + int ret; + unsigned int act_inact_ctl; + u8 op_mode = ADXL380_OP_MODE_STANDBY; + + if (en) { + ret = regmap_read(st->regmap, ADXL380_ACT_INACT_CTL_REG, &act_inact_ctl); + if (ret) + return ret; + + /* Activity/ Inactivity detection available only in VLP/ULP mode */ + if (FIELD_GET(ADXL380_ACT_EN_MSK, act_inact_ctl) || + FIELD_GET(ADXL380_INACT_EN_MSK, act_inact_ctl)) + op_mode = ADXL380_OP_MODE_VLP; + else + op_mode = ADXL380_OP_MODE_HP; + } + + return regmap_update_bits(st->regmap, ADXL380_OP_MODE_REG, + ADXL380_OP_MODE_MSK, + FIELD_PREP(ADXL380_OP_MODE_MSK, op_mode)); +} + +static void adxl380_scale_act_inact_thresholds(struct adxl380_state *st, + u8 old_range, + u8 new_range) +{ + st->act_threshold = mult_frac(st->act_threshold, + adxl380_range_scale_factor_tbl[old_range], + adxl380_range_scale_factor_tbl[new_range]); + st->inact_threshold = mult_frac(st->inact_threshold, + adxl380_range_scale_factor_tbl[old_range], + adxl380_range_scale_factor_tbl[new_range]); +} + +static int adxl380_write_act_inact_threshold(struct adxl380_state *st, + enum adxl380_activity_type act, + unsigned int th) +{ + int ret; + u8 reg = adxl380_th_reg_high_addr[act]; + + if (th > ADXL380_THRESH_MAX) + return -EINVAL; + + ret = regmap_write(st->regmap, reg + 1, th & GENMASK(7, 0)); + if (ret) + return ret; + + ret = regmap_update_bits(st->regmap, reg, GENMASK(2, 0), th >> 8); + if (ret) + return ret; + + if (act == ADXL380_ACTIVITY) + st->act_threshold = th; + else + st->inact_threshold = th; + + return 0; +} + +static int adxl380_set_act_inact_threshold(struct iio_dev *indio_dev, + enum adxl380_activity_type act, + u16 th) +{ + struct adxl380_state *st = iio_priv(indio_dev); + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = adxl380_write_act_inact_threshold(st, act, th); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_set_tap_threshold_value(struct iio_dev *indio_dev, u8 th) +{ + int ret; + struct adxl380_state *st = iio_priv(indio_dev); + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = regmap_write(st->regmap, ADXL380_TAP_THRESH_REG, th); + if (ret) + return ret; + + st->tap_threshold = th; + + return adxl380_set_measure_en(st, true); +} + +static int _adxl380_write_tap_time_us(struct adxl380_state *st, + enum adxl380_tap_time_type tap_time_type, + u32 us) +{ + u8 reg = adxl380_tap_time_reg[tap_time_type]; + unsigned int reg_val; + int ret; + + /* scale factor for tap window is 1250us / LSB */ + reg_val = DIV_ROUND_CLOSEST(us, 1250); + if (reg_val > ADXL380_TAP_TIME_MAX) + reg_val = ADXL380_TAP_TIME_MAX; + + ret = regmap_write(st->regmap, reg, reg_val); + if (ret) + return ret; + + if (tap_time_type == ADXL380_TAP_TIME_WINDOW) + st->tap_window_us = us; + else + st->tap_latent_us = us; + + return 0; +} + +static int adxl380_write_tap_time_us(struct adxl380_state *st, + enum adxl380_tap_time_type tap_time_type, u32 us) +{ + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = _adxl380_write_tap_time_us(st, tap_time_type, us); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_write_tap_dur_us(struct iio_dev *indio_dev, u32 us) +{ + int ret; + unsigned int reg_val; + struct adxl380_state *st = iio_priv(indio_dev); + + /* 625us per code is the scale factor of TAP_DUR register */ + reg_val = DIV_ROUND_CLOSEST(us, 625); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = regmap_write(st->regmap, ADXL380_TAP_DUR_REG, reg_val); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_read_chn(struct adxl380_state *st, u8 addr) +{ + int ret; + + guard(mutex)(&st->lock); + + ret = regmap_bulk_read(st->regmap, addr, &st->transf_buf, 2); + if (ret) + return ret; + + return get_unaligned_be16(st->transf_buf); +} + +static int adxl380_get_odr(struct adxl380_state *st, int *odr) +{ + int ret; + unsigned int trig_cfg, odr_idx; + + ret = regmap_read(st->regmap, ADXL380_TRIG_CFG_REG, &trig_cfg); + if (ret) + return ret; + + odr_idx = (FIELD_GET(ADXL380_TRIG_CFG_SINC_RATE_MSK, trig_cfg) << 1) | + (FIELD_GET(ADXL380_TRIG_CFG_DEC_2X_MSK, trig_cfg) & 1); + + *odr = st->chip_info->samp_freq_tbl[odr_idx]; + + return 0; +} + +static const int adxl380_lpf_div[] = { + 1, 4, 8, 16, +}; + +static int adxl380_fill_lpf_tbl(struct adxl380_state *st) +{ + int ret, i; + int odr; + + ret = adxl380_get_odr(st, &odr); + if (ret) + return ret; + + for (i = 0; i < ARRAY_SIZE(st->lpf_tbl); i++) + st->lpf_tbl[i] = DIV_ROUND_CLOSEST(odr, adxl380_lpf_div[i]); + + return 0; +} + +static const int adxl380_hpf_mul[] = { + 0, 247000, 62084, 15545, 3862, 954, 238, +}; + +static int adxl380_fill_hpf_tbl(struct adxl380_state *st) +{ + int i, ret, odr_hz; + u32 multiplier; + u64 div, rem, odr; + + ret = adxl380_get_odr(st, &odr_hz); + if (ret) + return ret; + + for (i = 0; i < ARRAY_SIZE(adxl380_hpf_mul); i++) { + odr = mul_u64_u32_shr(odr_hz, MEGA, 0); + multiplier = adxl380_hpf_mul[i]; + div = div64_u64_rem(mul_u64_u32_shr(odr, multiplier, 0), + TERA * 100, &rem); + + st->hpf_tbl[i][0] = div; + st->hpf_tbl[i][1] = div_u64(rem, MEGA * 100); + } + + return 0; +} + +static int adxl380_set_odr(struct adxl380_state *st, u8 odr) +{ + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = regmap_update_bits(st->regmap, ADXL380_TRIG_CFG_REG, + ADXL380_TRIG_CFG_DEC_2X_MSK, + FIELD_PREP(ADXL380_TRIG_CFG_DEC_2X_MSK, odr & 1)); + if (ret) + return ret; + + ret = regmap_update_bits(st->regmap, ADXL380_TRIG_CFG_REG, + ADXL380_TRIG_CFG_SINC_RATE_MSK, + FIELD_PREP(ADXL380_TRIG_CFG_SINC_RATE_MSK, odr >> 1)); + if (ret) + return ret; + + ret = adxl380_set_measure_en(st, true); + if (ret) + return ret; + + ret = adxl380_fill_lpf_tbl(st); + if (ret) + return ret; + + return adxl380_fill_hpf_tbl(st); +} + +static int adxl380_find_match_1d_tbl(const int *array, unsigned int size, + int val) +{ + int i; + + for (i = 0; i < size; i++) { + if (val == array[i]) + return i; + } + + return size - 1; +} + +static int adxl380_find_match_2d_tbl(const int (*freq_tbl)[2], int n, int val, int val2) +{ + int i; + + for (i = 0; i < n; i++) { + if (freq_tbl[i][0] == val && freq_tbl[i][1] == val2) + return i; + } + + return -EINVAL; +} + +static int adxl380_get_lpf(struct adxl380_state *st, int *lpf) +{ + int ret; + unsigned int trig_cfg, lpf_idx; + + guard(mutex)(&st->lock); + + ret = regmap_read(st->regmap, ADXL380_FILTER_REG, &trig_cfg); + if (ret) + return ret; + + lpf_idx = FIELD_GET(ADXL380_FILTER_LPF_MODE_MSK, trig_cfg); + + *lpf = st->lpf_tbl[lpf_idx]; + + return 0; +} + +static int adxl380_set_lpf(struct adxl380_state *st, u8 lpf) +{ + int ret; + u8 eq_bypass = 0; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + if (lpf) + eq_bypass = 1; + + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, + ADXL380_FILTER_EQ_FILT_MSK, + FIELD_PREP(ADXL380_FILTER_EQ_FILT_MSK, eq_bypass)); + if (ret) + return ret; + + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, + ADXL380_FILTER_LPF_MODE_MSK, + FIELD_PREP(ADXL380_FILTER_LPF_MODE_MSK, lpf)); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_get_hpf(struct adxl380_state *st, int *hpf_int, int *hpf_frac) +{ + int ret; + unsigned int trig_cfg, hpf_idx; + + guard(mutex)(&st->lock); + + ret = regmap_read(st->regmap, ADXL380_FILTER_REG, &trig_cfg); + if (ret) + return ret; + + hpf_idx = FIELD_GET(ADXL380_FILTER_HPF_CORNER_MSK, trig_cfg); + + *hpf_int = st->hpf_tbl[hpf_idx][0]; + *hpf_frac = st->hpf_tbl[hpf_idx][1]; + + return 0; +} + +static int adxl380_set_hpf(struct adxl380_state *st, u8 hpf) +{ + int ret; + u8 hpf_path = 0; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + if (hpf) + hpf_path = 1; + + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, + ADXL380_FILTER_HPF_PATH_MSK, + FIELD_PREP(ADXL380_FILTER_HPF_PATH_MSK, hpf_path)); + if (ret) + return ret; + + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, + ADXL380_FILTER_HPF_CORNER_MSK, + FIELD_PREP(ADXL380_FILTER_HPF_CORNER_MSK, hpf)); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int _adxl380_set_act_inact_time_ms(struct adxl380_state *st, + enum adxl380_activity_type act, + u32 ms) +{ + u8 reg = adxl380_time_reg_high_addr[act]; + unsigned int reg_val; + int ret; + + /* 500us per code is the scale factor of TIME_ACT / TIME_INACT registers */ + reg_val = min(DIV_ROUND_CLOSEST(ms * 1000, 500), ADXL380_TIME_MAX); + + put_unaligned_be24(reg_val, &st->transf_buf[0]); + + ret = regmap_bulk_write(st->regmap, reg, st->transf_buf, sizeof(st->transf_buf)); + if (ret) + return ret; + + if (act == ADXL380_ACTIVITY) + st->act_time_ms = ms; + else + st->inact_time_ms = ms; + + return 0; +} + +static int adxl380_set_act_inact_time_ms(struct adxl380_state *st, + enum adxl380_activity_type act, + u32 ms) +{ + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = _adxl380_set_act_inact_time_ms(st, act, ms); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_set_range(struct adxl380_state *st, u8 range) +{ + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = regmap_update_bits(st->regmap, ADXL380_OP_MODE_REG, + ADXL380_OP_MODE_RANGE_MSK, + FIELD_PREP(ADXL380_OP_MODE_RANGE_MSK, range)); + + if (ret) + return ret; + + adxl380_scale_act_inact_thresholds(st, st->range, range); + + /* Activity thresholds depend on range */ + ret = adxl380_write_act_inact_threshold(st, ADXL380_ACTIVITY, + st->act_threshold); + if (ret) + return ret; + + ret = adxl380_write_act_inact_threshold(st, ADXL380_INACTIVITY, + st->inact_threshold); + if (ret) + return ret; + + st->range = range; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_write_act_inact_en(struct adxl380_state *st, + enum adxl380_activity_type type, + bool en) +{ + if (type == ADXL380_ACTIVITY) + return regmap_update_bits(st->regmap, ADXL380_ACT_INACT_CTL_REG, + ADXL380_ACT_EN_MSK, + FIELD_PREP(ADXL380_ACT_EN_MSK, en)); + + return regmap_update_bits(st->regmap, ADXL380_ACT_INACT_CTL_REG, + ADXL380_INACT_EN_MSK, + FIELD_PREP(ADXL380_INACT_EN_MSK, en)); +} + +static int adxl380_read_act_inact_int(struct adxl380_state *st, + enum adxl380_activity_type type, + bool *en) +{ + int ret; + unsigned int reg_val; + + guard(mutex)(&st->lock); + + ret = regmap_read(st->regmap, st->int_map[0], ®_val); + if (ret) + return ret; + + if (type == ADXL380_ACTIVITY) + *en = FIELD_GET(ADXL380_INT_MAP0_ACT_INT0_MSK, reg_val); + else + *en = FIELD_GET(ADXL380_INT_MAP0_INACT_INT0_MSK, reg_val); + + return 0; +} + +static int adxl380_write_act_inact_int(struct adxl380_state *st, + enum adxl380_activity_type act, + bool en) +{ + if (act == ADXL380_ACTIVITY) + return regmap_update_bits(st->regmap, st->int_map[0], + ADXL380_INT_MAP0_ACT_INT0_MSK, + FIELD_PREP(ADXL380_INT_MAP0_ACT_INT0_MSK, en)); + + return regmap_update_bits(st->regmap, st->int_map[0], + ADXL380_INT_MAP0_INACT_INT0_MSK, + FIELD_PREP(ADXL380_INT_MAP0_INACT_INT0_MSK, en)); +} + +static int adxl380_act_inact_config(struct adxl380_state *st, + enum adxl380_activity_type type, + bool en) +{ + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = adxl380_write_act_inact_en(st, type, en); + if (ret) + return ret; + + ret = adxl380_write_act_inact_int(st, type, en); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_write_tap_axis(struct adxl380_state *st, + enum adxl380_axis axis) +{ + int ret; + + ret = regmap_update_bits(st->regmap, ADXL380_TAP_CFG_REG, + ADXL380_TAP_AXIS_MSK, + FIELD_PREP(ADXL380_TAP_AXIS_MSK, axis)); + + if (ret) + return ret; + + st->tap_axis_en = axis; + + return 0; +} + +static int adxl380_read_tap_int(struct adxl380_state *st, enum adxl380_tap_type type, bool *en) +{ + int ret; + unsigned int reg_val; + + ret = regmap_read(st->regmap, st->int_map[1], ®_val); + if (ret) + return ret; + + if (type == ADXL380_SINGLE_TAP) + *en = FIELD_GET(ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK, reg_val); + else + *en = FIELD_GET(ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK, reg_val); + + return 0; +} + +static int adxl380_write_tap_int(struct adxl380_state *st, enum adxl380_tap_type type, bool en) +{ + if (type == ADXL380_SINGLE_TAP) + return regmap_update_bits(st->regmap, st->int_map[1], + ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK, + FIELD_PREP(ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK, en)); + + return regmap_update_bits(st->regmap, st->int_map[1], + ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK, + FIELD_PREP(ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK, en)); +} + +static int adxl380_tap_config(struct adxl380_state *st, + enum adxl380_axis axis, + enum adxl380_tap_type type, + bool en) +{ + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = adxl380_write_tap_axis(st, axis); + if (ret) + return ret; + + ret = adxl380_write_tap_int(st, type, en); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_set_fifo_samples(struct adxl380_state *st) +{ + int ret; + u16 fifo_samples = st->watermark * st->fifo_set_size; + + ret = regmap_update_bits(st->regmap, ADXL380_FIFO_CONFIG_0_REG, + ADXL380_FIFO_SAMPLES_8_MSK, + FIELD_PREP(ADXL380_FIFO_SAMPLES_8_MSK, + (fifo_samples & BIT(8)))); + if (ret) + return ret; + + return regmap_write(st->regmap, ADXL380_FIFO_CONFIG_1_REG, + fifo_samples & 0xFF); +} + +static int adxl380_get_status(struct adxl380_state *st, u8 *status0, u8 *status1) +{ + int ret; + + /* STATUS0, STATUS1 are adjacent regs */ + ret = regmap_bulk_read(st->regmap, ADXL380_STATUS_0_REG, + &st->transf_buf, 2); + if (ret) + return ret; + + *status0 = st->transf_buf[0]; + *status1 = st->transf_buf[1]; + + return 0; +} + +static int adxl380_get_fifo_entries(struct adxl380_state *st, u16 *fifo_entries) +{ + int ret; + + ret = regmap_bulk_read(st->regmap, ADXL380_FIFO_STATUS_0_REG, + &st->transf_buf, 2); + if (ret) + return ret; + + *fifo_entries = st->transf_buf[0] | ((BIT(0) & st->transf_buf[1]) << 8); + + return 0; +} + +static void adxl380_push_event(struct iio_dev *indio_dev, s64 timestamp, + u8 status1) +{ + if (FIELD_GET(ADXL380_STATUS_1_ACT_MSK, status1)) + iio_push_event(indio_dev, + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X_OR_Y_OR_Z, + IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), + timestamp); + + if (FIELD_GET(ADXL380_STATUS_1_INACT_MSK, status1)) + iio_push_event(indio_dev, + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X_OR_Y_OR_Z, + IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING), + timestamp); + if (FIELD_GET(ADXL380_STATUS_1_SINGLE_TAP_MSK, status1)) + iio_push_event(indio_dev, + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X_OR_Y_OR_Z, + IIO_EV_TYPE_GESTURE, IIO_EV_DIR_SINGLETAP), + timestamp); + + if (FIELD_GET(ADXL380_STATUS_1_DOUBLE_TAP_MSK, status1)) + iio_push_event(indio_dev, + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X_OR_Y_OR_Z, + IIO_EV_TYPE_GESTURE, IIO_EV_DIR_DOUBLETAP), + timestamp); +} + +static irqreturn_t adxl380_irq_handler(int irq, void *p) +{ + struct iio_dev *indio_dev = p; + struct adxl380_state *st = iio_priv(indio_dev); + u8 status0, status1; + u16 fifo_entries; + int i; + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_get_status(st, &status0, &status1); + if (ret) + return IRQ_HANDLED; + + adxl380_push_event(indio_dev, iio_get_time_ns(indio_dev), status1); + + if (!FIELD_GET(ADXL380_STATUS_0_FIFO_WM_MSK, status0)) + return IRQ_HANDLED; + + ret = adxl380_get_fifo_entries(st, &fifo_entries); + if (ret) + return IRQ_HANDLED; + + for (i = 0; i < fifo_entries; i += st->fifo_set_size) { + ret = regmap_noinc_read(st->regmap, ADXL380_FIFO_DATA, + &st->fifo_buf[i], + 2 * st->fifo_set_size); + if (ret) + return IRQ_HANDLED; + iio_push_to_buffers(indio_dev, &st->fifo_buf[i]); + } + + return IRQ_HANDLED; +} + +static int adxl380_write_calibbias_value(struct adxl380_state *st, + unsigned long chan_addr, + s8 calibbias) +{ + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = regmap_write(st->regmap, ADXL380_X_DSM_OFFSET_REG + chan_addr, calibbias); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_read_calibbias_value(struct adxl380_state *st, + unsigned long chan_addr, + int *calibbias) +{ + int ret; + unsigned int reg_val; + + guard(mutex)(&st->lock); + + ret = regmap_read(st->regmap, ADXL380_X_DSM_OFFSET_REG + chan_addr, ®_val); + if (ret) + return ret; + + *calibbias = sign_extend32(reg_val, 7); + + return 0; +} + +static ssize_t hwfifo_watermark_min_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + return sysfs_emit(buf, "1\n"); +} + +static ssize_t hwfifo_watermark_max_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + return sysfs_emit(buf, "%lu\n", ADXL380_FIFO_SAMPLES); +} + +static ssize_t adxl380_get_fifo_watermark(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct iio_dev *indio_dev = dev_to_iio_dev(dev); + struct adxl380_state *st = iio_priv(indio_dev); + + return sysfs_emit(buf, "%d\n", st->watermark); +} + +static ssize_t adxl380_get_fifo_enabled(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct iio_dev *indio_dev = dev_to_iio_dev(dev); + struct adxl380_state *st = iio_priv(indio_dev); + int ret; + unsigned int reg_val; + + ret = regmap_read(st->regmap, ADXL380_DIG_EN_REG, ®_val); + if (ret) + return ret; + + return sysfs_emit(buf, "%lu\n", + FIELD_GET(ADXL380_FIFO_EN_MSK, reg_val)); +} + +static IIO_DEVICE_ATTR_RO(hwfifo_watermark_min, 0); +static IIO_DEVICE_ATTR_RO(hwfifo_watermark_max, 0); +static IIO_DEVICE_ATTR(hwfifo_watermark, 0444, + adxl380_get_fifo_watermark, NULL, 0); +static IIO_DEVICE_ATTR(hwfifo_enabled, 0444, + adxl380_get_fifo_enabled, NULL, 0); + +static const struct iio_dev_attr *adxl380_fifo_attributes[] = { + &iio_dev_attr_hwfifo_watermark_min, + &iio_dev_attr_hwfifo_watermark_max, + &iio_dev_attr_hwfifo_watermark, + &iio_dev_attr_hwfifo_enabled, + NULL +}; + +static int adxl380_buffer_postenable(struct iio_dev *indio_dev) +{ + struct adxl380_state *st = iio_priv(indio_dev); + int i; + int ret; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = regmap_update_bits(st->regmap, + st->int_map[0], + ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, + FIELD_PREP(ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, 1)); + if (ret) + return ret; + + for_each_clear_bit(i, indio_dev->active_scan_mask, ADXL380_CH_NUM) { + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, + ADXL380_CHAN_EN_MSK(i), + 0 << (4 + i)); + if (ret) + return ret; + } + + st->fifo_set_size = bitmap_weight(indio_dev->active_scan_mask, + indio_dev->masklength); + + if ((st->watermark * st->fifo_set_size) > ADXL380_FIFO_SAMPLES) + st->watermark = (ADXL380_FIFO_SAMPLES / st->fifo_set_size); + + ret = adxl380_set_fifo_samples(st); + if (ret) + return ret; + + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, ADXL380_FIFO_EN_MSK, + FIELD_PREP(ADXL380_FIFO_EN_MSK, 1)); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static int adxl380_buffer_predisable(struct iio_dev *indio_dev) +{ + struct adxl380_state *st = iio_priv(indio_dev); + int ret, i; + + guard(mutex)(&st->lock); + + ret = adxl380_set_measure_en(st, false); + if (ret) + return ret; + + ret = regmap_update_bits(st->regmap, + st->int_map[0], + ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, + FIELD_PREP(ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, 0)); + if (ret) + return ret; + + for (i = 0; i < indio_dev->num_channels; i++) { + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, + ADXL380_CHAN_EN_MSK(i), + 1 << (4 + i)); + if (ret) + return ret; + } + + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, ADXL380_FIFO_EN_MSK, + FIELD_PREP(ADXL380_FIFO_EN_MSK, 0)); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +static const struct iio_buffer_setup_ops adxl380_buffer_ops = { + .postenable = adxl380_buffer_postenable, + .predisable = adxl380_buffer_predisable, +}; + +static int adxl380_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long info) +{ + struct adxl380_state *st = iio_priv(indio_dev); + int ret; + + switch (info) { + case IIO_CHAN_INFO_RAW: + ret = iio_device_claim_direct_mode(indio_dev); + if (ret) + return ret; + + ret = adxl380_read_chn(st, chan->address); + if (ret) + return ret; + + iio_device_release_direct_mode(indio_dev); + + *val = sign_extend32(ret >> chan->scan_type.shift, + chan->scan_type.realbits - 1); + return IIO_VAL_INT; + case IIO_CHAN_INFO_SCALE: + switch (chan->type) { + case IIO_ACCEL: + scoped_guard(mutex, &st->lock) { + *val = st->chip_info->scale_tbl[st->range][0]; + *val2 = st->chip_info->scale_tbl[st->range][1]; + } + return IIO_VAL_INT_PLUS_NANO; + case IIO_TEMP: + /* 10.2 LSB / Degree Celsius */ + *val = 10000; + *val2 = 102; + return IIO_VAL_FRACTIONAL; + default: + return -EINVAL; + } + case IIO_CHAN_INFO_OFFSET: + switch (chan->type) { + case IIO_TEMP: + *val = st->chip_info->temp_offset; + return IIO_VAL_INT; + default: + return -EINVAL; + } + case IIO_CHAN_INFO_CALIBBIAS: + switch (chan->type) { + case IIO_ACCEL: + ret = adxl380_read_calibbias_value(st, chan->scan_index, val); + if (ret) + return ret; + return IIO_VAL_INT; + default: + return -EINVAL; + } + case IIO_CHAN_INFO_SAMP_FREQ: + ret = adxl380_get_odr(st, val); + if (ret) + return ret; + return IIO_VAL_INT; + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: + ret = adxl380_get_lpf(st, val); + if (ret) + return ret; + return IIO_VAL_INT; + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: + ret = adxl380_get_hpf(st, val, val2); + if (ret) + return ret; + return IIO_VAL_INT_PLUS_MICRO; + } + + return -EINVAL; +} + +static int adxl380_read_avail(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + const int **vals, int *type, int *length, + long mask) +{ + struct adxl380_state *st = iio_priv(indio_dev); + + if (chan->type != IIO_ACCEL) + return -EINVAL; + + switch (mask) { + case IIO_CHAN_INFO_SCALE: + *vals = (const int *)st->chip_info->scale_tbl; + *type = IIO_VAL_INT_PLUS_NANO; + *length = ARRAY_SIZE(st->chip_info->scale_tbl) * 2; + return IIO_AVAIL_LIST; + case IIO_CHAN_INFO_SAMP_FREQ: + *vals = (const int *)st->chip_info->samp_freq_tbl; + *type = IIO_VAL_INT; + *length = ARRAY_SIZE(st->chip_info->samp_freq_tbl); + return IIO_AVAIL_LIST; + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: + *vals = (const int *)st->lpf_tbl; + *type = IIO_VAL_INT; + *length = ARRAY_SIZE(st->lpf_tbl); + return IIO_AVAIL_LIST; + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: + *vals = (const int *)st->hpf_tbl; + *type = IIO_VAL_INT_PLUS_MICRO; + /* Values are stored in a 2D matrix */ + *length = ARRAY_SIZE(st->hpf_tbl) * 2; + return IIO_AVAIL_LIST; + default: + return -EINVAL; + } +} + +static int adxl380_write_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int val, int val2, long info) +{ + struct adxl380_state *st = iio_priv(indio_dev); + int odr_index, lpf_index, hpf_index, range_index; + + switch (info) { + case IIO_CHAN_INFO_SAMP_FREQ: + odr_index = adxl380_find_match_1d_tbl(st->chip_info->samp_freq_tbl, + ARRAY_SIZE(st->chip_info->samp_freq_tbl), + val); + return adxl380_set_odr(st, odr_index); + case IIO_CHAN_INFO_CALIBBIAS: + return adxl380_write_calibbias_value(st, chan->scan_index, val); + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: + lpf_index = adxl380_find_match_1d_tbl(st->lpf_tbl, + ARRAY_SIZE(st->lpf_tbl), + val); + if (lpf_index < 0) + return lpf_index; + return adxl380_set_lpf(st, lpf_index); + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: + hpf_index = adxl380_find_match_2d_tbl(st->hpf_tbl, + ARRAY_SIZE(st->hpf_tbl), + val, val2); + if (hpf_index < 0) + return hpf_index; + return adxl380_set_hpf(st, hpf_index); + case IIO_CHAN_INFO_SCALE: + range_index = adxl380_find_match_2d_tbl(st->chip_info->scale_tbl, + ARRAY_SIZE(st->chip_info->scale_tbl), + val, val2); + if (range_index < 0) + return range_index; + return adxl380_set_range(st, range_index); + default: + return -EINVAL; + } +} + +static int adxl380_write_raw_get_fmt(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + long info) +{ + switch (info) { + case IIO_CHAN_INFO_SCALE: + if (chan->type != IIO_ACCEL) + return -EINVAL; + + return IIO_VAL_INT_PLUS_NANO; + default: + return IIO_VAL_INT_PLUS_MICRO; + } +} + +static int adxl380_read_event_config(struct iio_dev *indio_dev, + const struct iio_chan_spec *chan, + enum iio_event_type type, + enum iio_event_direction dir) +{ + struct adxl380_state *st = iio_priv(indio_dev); + int ret; + bool int_en; + bool tap_axis_en = false; + + switch (chan->channel2) { + case IIO_MOD_X: + tap_axis_en = st->tap_axis_en == ADXL380_X_AXIS; + break; + case IIO_MOD_Y: + tap_axis_en = st->tap_axis_en == ADXL380_Y_AXIS; + break; + case IIO_MOD_Z: + tap_axis_en = st->tap_axis_en == ADXL380_Z_AXIS; + break; + default: + return -EINVAL; + } + + switch (dir) { + case IIO_EV_DIR_RISING: + ret = adxl380_read_act_inact_int(st, ADXL380_ACTIVITY, &int_en); + if (ret) + return ret; + return int_en; + case IIO_EV_DIR_FALLING: + ret = adxl380_read_act_inact_int(st, ADXL380_INACTIVITY, &int_en); + if (ret) + return ret; + return int_en; + case IIO_EV_DIR_SINGLETAP: + ret = adxl380_read_tap_int(st, ADXL380_SINGLE_TAP, &int_en); + if (ret) + return ret; + return int_en && tap_axis_en; + case IIO_EV_DIR_DOUBLETAP: + ret = adxl380_read_tap_int(st, ADXL380_DOUBLE_TAP, &int_en); + if (ret) + return ret; + return int_en && tap_axis_en; + default: + return -EINVAL; + } +} + +static int adxl380_write_event_config(struct iio_dev *indio_dev, + const struct iio_chan_spec *chan, + enum iio_event_type type, + enum iio_event_direction dir, + int state) +{ + struct adxl380_state *st = iio_priv(indio_dev); + enum adxl380_axis axis; + + switch (chan->channel2) { + case IIO_MOD_X: + axis = ADXL380_X_AXIS; + break; + case IIO_MOD_Y: + axis = ADXL380_Y_AXIS; + break; + case IIO_MOD_Z: + axis = ADXL380_Z_AXIS; + break; + default: + return -EINVAL; + } + + switch (dir) { + case IIO_EV_DIR_RISING: + return adxl380_act_inact_config(st, ADXL380_ACTIVITY, state); + case IIO_EV_DIR_FALLING: + return adxl380_act_inact_config(st, ADXL380_INACTIVITY, state); + case IIO_EV_DIR_SINGLETAP: + return adxl380_tap_config(st, axis, ADXL380_SINGLE_TAP, state); + case IIO_EV_DIR_DOUBLETAP: + return adxl380_tap_config(st, axis, ADXL380_DOUBLE_TAP, state); + default: + return -EINVAL; + } +} + +static int adxl380_read_event_value(struct iio_dev *indio_dev, + const struct iio_chan_spec *chan, + enum iio_event_type type, + enum iio_event_direction dir, + enum iio_event_info info, + int *val, int *val2) +{ + struct adxl380_state *st = iio_priv(indio_dev); + + guard(mutex)(&st->lock); + + switch (type) { + case IIO_EV_TYPE_THRESH: + switch (info) { + case IIO_EV_INFO_VALUE: { + switch (dir) { + case IIO_EV_DIR_RISING: + *val = st->act_threshold; + return IIO_VAL_INT; + case IIO_EV_DIR_FALLING: + *val = st->inact_threshold; + return IIO_VAL_INT; + default: + return -EINVAL; + } + } + case IIO_EV_INFO_PERIOD: + switch (dir) { + case IIO_EV_DIR_RISING: + *val = st->act_time_ms; + *val2 = 1000; + return IIO_VAL_FRACTIONAL; + case IIO_EV_DIR_FALLING: + *val = st->inact_time_ms; + *val2 = 1000; + return IIO_VAL_FRACTIONAL; + default: + return -EINVAL; + } + default: + return -EINVAL; + } + case IIO_EV_TYPE_GESTURE: + switch (info) { + case IIO_EV_INFO_VALUE: + *val = st->tap_threshold; + return IIO_VAL_INT; + case IIO_EV_INFO_RESET_TIMEOUT: + *val = st->tap_window_us; + *val2 = 1000000; + return IIO_VAL_FRACTIONAL; + case IIO_EV_INFO_TAP2_MIN_DELAY: + *val = st->tap_latent_us; + *val2 = 1000000; + return IIO_VAL_FRACTIONAL; + default: + return -EINVAL; + } + default: + return -EINVAL; + } +} + +static int adxl380_write_event_value(struct iio_dev *indio_dev, + const struct iio_chan_spec *chan, + enum iio_event_type type, enum iio_event_direction dir, + enum iio_event_info info, int val, int val2) +{ + struct adxl380_state *st = iio_priv(indio_dev); + u32 val_ms, val_us; + + if (chan->type != IIO_ACCEL) + return -EINVAL; + + switch (type) { + case IIO_EV_TYPE_THRESH: + switch (info) { + case IIO_EV_INFO_VALUE: + switch (dir) { + case IIO_EV_DIR_RISING: + return adxl380_set_act_inact_threshold(indio_dev, + ADXL380_ACTIVITY, val); + case IIO_EV_DIR_FALLING: + return adxl380_set_act_inact_threshold(indio_dev, + ADXL380_INACTIVITY, val); + default: + return -EINVAL; + } + case IIO_EV_INFO_PERIOD: + val_ms = val * 1000 + DIV_ROUND_UP(val2, 1000); + switch (dir) { + case IIO_EV_DIR_RISING: + return adxl380_set_act_inact_time_ms(st, + ADXL380_ACTIVITY, val_ms); + case IIO_EV_DIR_FALLING: + return adxl380_set_act_inact_time_ms(st, + ADXL380_INACTIVITY, val_ms); + default: + return -EINVAL; + } + + default: + return -EINVAL; + } + case IIO_EV_TYPE_GESTURE: + switch (info) { + case IIO_EV_INFO_VALUE: + return adxl380_set_tap_threshold_value(indio_dev, val); + case IIO_EV_INFO_RESET_TIMEOUT: + val_us = val * 1000000 + val2; + return adxl380_write_tap_time_us(st, + ADXL380_TAP_TIME_WINDOW, + val_us); + case IIO_EV_INFO_TAP2_MIN_DELAY: + val_us = val * 1000000 + val2; + return adxl380_write_tap_time_us(st, + ADXL380_TAP_TIME_LATENT, + val_us); + default: + return -EINVAL; + } + default: + return -EINVAL; + } +} + +static ssize_t in_accel_gesture_tap_maxtomin_time_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + int vals[2]; + struct iio_dev *indio_dev = dev_to_iio_dev(dev); + struct adxl380_state *st = iio_priv(indio_dev); + + guard(mutex)(&st->lock); + + vals[0] = st->tap_duration_us; + vals[1] = MICRO; + + return iio_format_value(buf, IIO_VAL_FRACTIONAL, 2, vals); +} + +static ssize_t in_accel_gesture_tap_maxtomin_time_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t len) +{ + struct iio_dev *indio_dev = dev_to_iio_dev(dev); + struct adxl380_state *st = iio_priv(indio_dev); + int ret, val_int, val_fract_us; + + guard(mutex)(&st->lock); + + ret = iio_str_to_fixpoint(buf, 100000, &val_int, &val_fract_us); + if (ret) + return ret; + + /* maximum value is 255 * 625 us = 0.159375 seconds */ + if (val_int || val_fract_us > 159375 || val_fract_us < 0) + return -EINVAL; + + ret = adxl380_write_tap_dur_us(indio_dev, val_fract_us); + if (ret) + return ret; + + return len; +} + +static IIO_DEVICE_ATTR_RW(in_accel_gesture_tap_maxtomin_time, 0); + +static struct attribute *adxl380_event_attributes[] = { + &iio_dev_attr_in_accel_gesture_tap_maxtomin_time.dev_attr.attr, + NULL +}; + +static const struct attribute_group adxl380_event_attribute_group = { + .attrs = adxl380_event_attributes, +}; + +static int adxl380_reg_access(struct iio_dev *indio_dev, + unsigned int reg, + unsigned int writeval, + unsigned int *readval) +{ + struct adxl380_state *st = iio_priv(indio_dev); + + if (readval) + return regmap_read(st->regmap, reg, readval); + + return regmap_write(st->regmap, reg, writeval); +} + +static int adxl380_set_watermark(struct iio_dev *indio_dev, unsigned int val) +{ + struct adxl380_state *st = iio_priv(indio_dev); + + st->watermark = min(val, ADXL380_FIFO_SAMPLES); + + return 0; +} + +static const struct iio_info adxl380_info = { + .read_raw = adxl380_read_raw, + .read_avail = &adxl380_read_avail, + .write_raw = adxl380_write_raw, + .write_raw_get_fmt = adxl380_write_raw_get_fmt, + .read_event_config = adxl380_read_event_config, + .write_event_config = adxl380_write_event_config, + .read_event_value = adxl380_read_event_value, + .write_event_value = adxl380_write_event_value, + .event_attrs = &adxl380_event_attribute_group, + .debugfs_reg_access = &adxl380_reg_access, + .hwfifo_set_watermark = adxl380_set_watermark, +}; + +static const struct iio_event_spec adxl380_events[] = { + { + .type = IIO_EV_TYPE_THRESH, + .dir = IIO_EV_DIR_RISING, + .mask_shared_by_type = BIT(IIO_EV_INFO_ENABLE) | + BIT(IIO_EV_INFO_VALUE) | + BIT(IIO_EV_INFO_PERIOD), + }, + { + .type = IIO_EV_TYPE_THRESH, + .dir = IIO_EV_DIR_FALLING, + .mask_shared_by_type = BIT(IIO_EV_INFO_ENABLE) | + BIT(IIO_EV_INFO_VALUE) | + BIT(IIO_EV_INFO_PERIOD), + }, + { + .type = IIO_EV_TYPE_GESTURE, + .dir = IIO_EV_DIR_SINGLETAP, + .mask_separate = BIT(IIO_EV_INFO_ENABLE), + .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) | + BIT(IIO_EV_INFO_RESET_TIMEOUT), + }, + { + .type = IIO_EV_TYPE_GESTURE, + .dir = IIO_EV_DIR_DOUBLETAP, + .mask_separate = BIT(IIO_EV_INFO_ENABLE), + .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) | + BIT(IIO_EV_INFO_RESET_TIMEOUT) | + BIT(IIO_EV_INFO_TAP2_MIN_DELAY), + }, +}; + +#define ADXL380_ACCEL_CHANNEL(index, reg, axis) { \ + .type = IIO_ACCEL, \ + .address = reg, \ + .modified = 1, \ + .channel2 = IIO_MOD_##axis, \ + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ + BIT(IIO_CHAN_INFO_CALIBBIAS), \ + .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ + .info_mask_shared_by_all_available = \ + BIT(IIO_CHAN_INFO_SAMP_FREQ), \ + .info_mask_shared_by_type = \ + BIT(IIO_CHAN_INFO_SCALE) | \ + BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \ + BIT(IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY), \ + .info_mask_shared_by_type_available = \ + BIT(IIO_CHAN_INFO_SCALE) | \ + BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \ + BIT(IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY), \ + .scan_index = index, \ + .scan_type = { \ + .sign = 's', \ + .realbits = 16, \ + .storagebits = 16, \ + .endianness = IIO_BE, \ + }, \ + .event_spec = adxl380_events, \ + .num_event_specs = ARRAY_SIZE(adxl380_events) \ +} + +static const struct iio_chan_spec adxl380_channels[] = { + ADXL380_ACCEL_CHANNEL(0, ADXL380_X_DATA_H_REG, X), + ADXL380_ACCEL_CHANNEL(1, ADXL380_Y_DATA_H_REG, Y), + ADXL380_ACCEL_CHANNEL(2, ADXL380_Z_DATA_H_REG, Z), + { + .type = IIO_TEMP, + .address = ADXL380_T_DATA_H_REG, + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | + BIT(IIO_CHAN_INFO_SCALE) | + BIT(IIO_CHAN_INFO_OFFSET), + .scan_index = 3, + .scan_type = { + .sign = 's', + .realbits = 12, + .storagebits = 16, + .shift = 4, + .endianness = IIO_BE, + }, + }, +}; + +static int adxl380_config_irq(struct iio_dev *indio_dev) +{ + struct adxl380_state *st = iio_priv(indio_dev); + unsigned long irq_flag; + struct irq_data *desc; + u32 irq_type; + u8 polarity; + int ret; + + desc = irq_get_irq_data(st->irq); + if (!desc) + return dev_err_probe(st->dev, -EINVAL, "Could not find IRQ %d\n", st->irq); + + irq_type = irqd_get_trigger_type(desc); + if (irq_type == IRQ_TYPE_LEVEL_HIGH) { + polarity = 0; + irq_flag = IRQF_TRIGGER_HIGH | IRQF_ONESHOT; + } else if (irq_type == IRQ_TYPE_LEVEL_LOW) { + polarity = 1; + irq_flag = IRQF_TRIGGER_LOW | IRQF_ONESHOT; + } else { + return dev_err_probe(st->dev, -EINVAL, + "Invalid interrupt 0x%x. Only level interrupts supported\n", + irq_type); + } + + ret = regmap_update_bits(st->regmap, ADXL380_INT0_REG, + ADXL380_INT0_POL_MSK, + FIELD_PREP(ADXL380_INT0_POL_MSK, polarity)); + if (ret) + return ret; + + return devm_request_threaded_irq(st->dev, st->irq, NULL, + adxl380_irq_handler, irq_flag, + indio_dev->name, indio_dev); +} + +static int adxl380_setup(struct iio_dev *indio_dev) +{ + unsigned int reg_val; + u16 part_id, chip_id; + int ret, i; + struct adxl380_state *st = iio_priv(indio_dev); + + ret = regmap_read(st->regmap, ADXL380_DEVID_AD_REG, ®_val); + if (ret) + return ret; + + if (reg_val != ADXL380_DEVID_AD_VAL) + dev_warn(st->dev, "Unknown chip id %x\n", reg_val); + + ret = regmap_bulk_read(st->regmap, ADLX380_PART_ID_REG, + &st->transf_buf, 2); + if (ret) + return ret; + + part_id = get_unaligned_be16(st->transf_buf); + part_id >>= 4; + + if (part_id != ADXL380_ID_VAL) + dev_warn(st->dev, "Unknown part id %x\n", part_id); + + ret = regmap_read(st->regmap, ADXL380_MISC_0_REG, ®_val); + if (ret) + return ret; + + /* Bit to differentiate between ADXL380/382. */ + if (reg_val & ADXL380_XL382_MSK) + chip_id = ADXL382_ID_VAL; + else + chip_id = ADXL380_ID_VAL; + + if (chip_id != st->chip_info->chip_id) + dev_warn(st->dev, "Unknown chip id %x\n", chip_id); + + ret = regmap_write(st->regmap, ADXL380_RESET_REG, ADXL380_RESET_CODE); + if (ret) + return ret; + + /* + * A latency of approximately 0.5 ms is required after soft reset. + * Stated in the register REG_RESET description. + */ + fsleep(500); + + for (i = 0; i < indio_dev->num_channels; i++) { + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, + ADXL380_CHAN_EN_MSK(i), + 1 << (4 + i)); + if (ret) + return ret; + } + + ret = regmap_update_bits(st->regmap, ADXL380_FIFO_CONFIG_0_REG, + ADXL380_FIFO_MODE_MSK, + FIELD_PREP(ADXL380_FIFO_MODE_MSK, ADXL380_FIFO_STREAMED)); + if (ret) + return ret; + + /* Select all 3 axis for act/inact detection. */ + ret = regmap_update_bits(st->regmap, ADXL380_SNSR_AXIS_EN_REG, + ADXL380_ACT_INACT_AXIS_EN_MSK, + FIELD_PREP(ADXL380_ACT_INACT_AXIS_EN_MSK, + ADXL380_ACT_INACT_AXIS_EN_MSK)); + if (ret) + return ret; + + ret = adxl380_config_irq(indio_dev); + if (ret) + return ret; + + ret = adxl380_fill_lpf_tbl(st); + if (ret) + return ret; + + ret = adxl380_fill_hpf_tbl(st); + if (ret) + return ret; + + return adxl380_set_measure_en(st, true); +} + +int adxl380_probe(struct device *dev, struct regmap *regmap, + const struct adxl380_chip_info *chip_info) +{ + struct iio_dev *indio_dev; + struct adxl380_state *st; + int ret; + + indio_dev = devm_iio_device_alloc(dev, sizeof(*st)); + if (!indio_dev) + return -ENOMEM; + + st = iio_priv(indio_dev); + + st->dev = dev; + st->regmap = regmap; + st->chip_info = chip_info; + + mutex_init(&st->lock); + + indio_dev->channels = adxl380_channels; + indio_dev->num_channels = ARRAY_SIZE(adxl380_channels); + indio_dev->name = chip_info->name; + indio_dev->info = &adxl380_info; + indio_dev->modes = INDIO_DIRECT_MODE; + + ret = devm_regulator_get_enable(dev, "vddio"); + if (ret) + return dev_err_probe(st->dev, ret, + "Failed to get vddio regulator\n"); + + ret = devm_regulator_get_enable(st->dev, "vsupply"); + if (ret) + return dev_err_probe(st->dev, ret, + "Failed to get vsupply regulator\n"); + + st->irq = fwnode_irq_get_byname(dev_fwnode(dev), "INT0"); + if (st->irq > 0) { + st->int_map[0] = ADXL380_INT0_MAP0_REG; + st->int_map[1] = ADXL380_INT0_MAP1_REG; + } else { + st->irq = fwnode_irq_get_byname(dev_fwnode(dev), "INT1"); + if (st->irq > 0) + return dev_err_probe(dev, -ENODEV, + "no interrupt name specified"); + st->int_map[0] = ADXL380_INT1_MAP0_REG; + st->int_map[1] = ADXL380_INT1_MAP1_REG; + } + + ret = adxl380_setup(indio_dev); + if (ret) + return ret; + + ret = devm_iio_kfifo_buffer_setup_ext(st->dev, indio_dev, + &adxl380_buffer_ops, + adxl380_fifo_attributes); + if (ret) + return ret; + + return devm_iio_device_register(dev, indio_dev); +} +EXPORT_SYMBOL_NS_GPL(adxl380_probe, IIO_ADXL380); + +MODULE_AUTHOR("Ramona Gradinariu <ramona.gradinariu@analog.com>"); +MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com>"); +MODULE_DESCRIPTION("Analog Devices ADXL380 3-axis accelerometer driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/iio/accel/adxl380.h b/drivers/iio/accel/adxl380.h new file mode 100644 index 000000000000..a683625d897a --- /dev/null +++ b/drivers/iio/accel/adxl380.h @@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * ADXL380 3-Axis Digital Accelerometer + * + * Copyright 2024 Analog Devices Inc. + */ + +#ifndef _ADXL380_H_ +#define _ADXL380_H_ + +struct adxl380_chip_info { + const char *name; + const int scale_tbl[3][2]; + const int samp_freq_tbl[3]; + const int temp_offset; + const u16 chip_id; +}; + +extern const struct adxl380_chip_info adxl380_chip_info; +extern const struct adxl380_chip_info adxl382_chip_info; + +int adxl380_probe(struct device *dev, struct regmap *regmap, + const struct adxl380_chip_info *chip_info); +bool adxl380_readable_noinc_reg(struct device *dev, unsigned int reg); + +#endif /* _ADXL380_H_ */ diff --git a/drivers/iio/accel/adxl380_i2c.c b/drivers/iio/accel/adxl380_i2c.c new file mode 100644 index 000000000000..1dc1e77be815 --- /dev/null +++ b/drivers/iio/accel/adxl380_i2c.c @@ -0,0 +1,64 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * ADXL380 3-Axis Digital Accelerometer I2C driver + * + * Copyright 2024 Analog Devices Inc. + */ + +#include <linux/i2c.h> +#include <linux/mod_devicetable.h> +#include <linux/module.h> +#include <linux/regmap.h> + +#include "adxl380.h" + +static const struct regmap_config adxl380_regmap_config = { + .reg_bits = 8, + .val_bits = 8, + .readable_noinc_reg = adxl380_readable_noinc_reg, +}; + +static int adxl380_i2c_probe(struct i2c_client *client) +{ + struct regmap *regmap; + const struct adxl380_chip_info *chip_data; + + chip_data = i2c_get_match_data(client); + + regmap = devm_regmap_init_i2c(client, &adxl380_regmap_config); + if (IS_ERR(regmap)) + return PTR_ERR(regmap); + + return adxl380_probe(&client->dev, regmap, chip_data); +} + +static const struct i2c_device_id adxl380_i2c_id[] = { + { "adxl380", (kernel_ulong_t)&adxl380_chip_info }, + { "adxl382", (kernel_ulong_t)&adxl382_chip_info }, + { } +}; +MODULE_DEVICE_TABLE(i2c, adxl380_i2c_id); + +static const struct of_device_id adxl380_of_match[] = { + { .compatible = "adi,adxl380", .data = &adxl380_chip_info }, + { .compatible = "adi,adxl382", .data = &adxl382_chip_info }, + { } +}; +MODULE_DEVICE_TABLE(of, adxl380_of_match); + +static struct i2c_driver adxl380_i2c_driver = { + .driver = { + .name = "adxl380_i2c", + .of_match_table = adxl380_of_match, + }, + .probe = adxl380_i2c_probe, + .id_table = adxl380_i2c_id, +}; + +module_i2c_driver(adxl380_i2c_driver); + +MODULE_AUTHOR("Ramona Gradinariu <ramona.gradinariu@analog.com>"); +MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com>"); +MODULE_DESCRIPTION("Analog Devices ADXL380 3-axis accelerometer I2C driver"); +MODULE_LICENSE("GPL"); +MODULE_IMPORT_NS(IIO_ADXL380); diff --git a/drivers/iio/accel/adxl380_spi.c b/drivers/iio/accel/adxl380_spi.c new file mode 100644 index 000000000000..e7b5778cb6cf --- /dev/null +++ b/drivers/iio/accel/adxl380_spi.c @@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * ADXL380 3-Axis Digital Accelerometer SPI driver + * + * Copyright 2024 Analog Devices Inc. + */ + +#include <linux/mod_devicetable.h> +#include <linux/module.h> +#include <linux/regmap.h> +#include <linux/spi/spi.h> + +#include "adxl380.h" + +static const struct regmap_config adxl380_spi_regmap_config = { + .reg_bits = 7, + .pad_bits = 1, + .val_bits = 8, + .read_flag_mask = BIT(0), + .readable_noinc_reg = adxl380_readable_noinc_reg, +}; + +static int adxl380_spi_probe(struct spi_device *spi) +{ + const struct adxl380_chip_info *chip_data; + struct regmap *regmap; + + chip_data = spi_get_device_match_data(spi); + + regmap = devm_regmap_init_spi(spi, &adxl380_spi_regmap_config); + if (IS_ERR(regmap)) + return PTR_ERR(regmap); + + return adxl380_probe(&spi->dev, regmap, chip_data); +} + +static const struct spi_device_id adxl380_spi_id[] = { + { "adxl380", (kernel_ulong_t)&adxl380_chip_info }, + { "adxl382", (kernel_ulong_t)&adxl382_chip_info }, + { } +}; +MODULE_DEVICE_TABLE(spi, adxl380_spi_id); + +static const struct of_device_id adxl380_of_match[] = { + { .compatible = "adi,adxl380", .data = &adxl380_chip_info }, + { .compatible = "adi,adxl382", .data = &adxl382_chip_info }, + { } +}; +MODULE_DEVICE_TABLE(of, adxl380_of_match); + +static struct spi_driver adxl380_spi_driver = { + .driver = { + .name = "adxl380_spi", + .of_match_table = adxl380_of_match, + }, + .probe = adxl380_spi_probe, + .id_table = adxl380_spi_id, +}; + +module_spi_driver(adxl380_spi_driver); + +MODULE_AUTHOR("Ramona Gradinariu <ramona.gradinariu@analog.com>"); +MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com>"); +MODULE_DESCRIPTION("Analog Devices ADXL380 3-axis accelerometer SPI driver"); +MODULE_LICENSE("GPL"); +MODULE_IMPORT_NS(IIO_ADXL380); -- 2.45.2 ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH v4 2/3] iio: accel: add ADXL380 driver 2024-07-01 8:30 ` [PATCH v4 2/3] iio: accel: add ADXL380 driver Antoniu Miclaus @ 2024-07-03 7:06 ` Alexandru Ardelean 2024-07-07 16:31 ` Jonathan Cameron 2024-07-08 10:22 ` Miclaus, Antoniu 0 siblings, 2 replies; 7+ messages in thread From: Alexandru Ardelean @ 2024-07-03 7:06 UTC (permalink / raw) To: Antoniu Miclaus Cc: Ramona Gradinariu, Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Jonathan Corbet, Jun Yan, Matti Vaittinen, Mario Limonciello, Mehdi Djait, linux-iio, devicetree, linux-kernel, linux-doc On Mon, Jul 1, 2024 at 11:47 AM Antoniu Miclaus <antoniu.miclaus@analog.com> wrote: > > The ADXL380/ADXL382 is a low noise density, low power, 3-axis > accelerometer with selectable measurement ranges. The ADXL380 supports > the +/-4 g, +/-8 g, and +/-16 g ranges, and the ADXL382 supports > +/-15 g, +/-30 g and +/-60 g ranges. > The ADXL380/ADXL382 offers industry leading noise, enabling precision > applications with minimal calibration. The low noise, and low power > ADXL380/ADXL382 enables accurate measurement in an environment with > high vibration, heart sounds and audio. > > In addition to its low power consumption, the ADXL380/ADXL382 has many > features to enable true system level performance. These include a > built-in micropower temperature sensor, single / double / triple tap > detection and a state machine to prevent a false triggering. In > addition, the ADXL380/ADXL382 has provisions for external control of > the sampling time and/or an external clock. > > Signed-off-by: Ramona Gradinariu <ramona.gradinariu@analog.com> > Signed-off-by: Antoniu Miclaus <antoniu.miclaus@analog.com> > --- > changes in v4: > - drop __aligned(IIO_DMA_MINALIGN); from tables and use it on fifo_buf > - drop brackets around odr >> 1 and odr & 1 > - wrap long line > - drop comma on null terminator > - fix odd indentation > - drop extra space before > > - add space before } on arrays where missing > MAINTAINERS | 4 + > drivers/iio/accel/Kconfig | 27 + > drivers/iio/accel/Makefile | 3 + > drivers/iio/accel/adxl380.c | 1908 +++++++++++++++++++++++++++++++ > drivers/iio/accel/adxl380.h | 26 + > drivers/iio/accel/adxl380_i2c.c | 64 ++ > drivers/iio/accel/adxl380_spi.c | 66 ++ > 7 files changed, 2098 insertions(+) > create mode 100644 drivers/iio/accel/adxl380.c > create mode 100644 drivers/iio/accel/adxl380.h > create mode 100644 drivers/iio/accel/adxl380_i2c.c > create mode 100644 drivers/iio/accel/adxl380_spi.c > > diff --git a/MAINTAINERS b/MAINTAINERS > index 1425182c85e2..67583f13da51 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -624,6 +624,10 @@ M: Antoniu Miclaus <antoniu.miclaus@analog.com> > S: Supported > W: https://ez.analog.com/linux-software-drivers > F: Documentation/devicetree/bindings/iio/accel/adi,adxl380.yaml > +F: drivers/iio/accel/adxl380.c > +F: drivers/iio/accel/adxl380.h > +F: drivers/iio/accel/adxl380_i2c.c > +F: drivers/iio/accel/adxl380_spi.c > > AF8133J THREE-AXIS MAGNETOMETER DRIVER > M: Ondřej Jirman <megi@xff.cz> > diff --git a/drivers/iio/accel/Kconfig b/drivers/iio/accel/Kconfig > index c2da5066e9a7..6572ab447e14 100644 > --- a/drivers/iio/accel/Kconfig > +++ b/drivers/iio/accel/Kconfig > @@ -177,6 +177,33 @@ config ADXL372_I2C > To compile this driver as a module, choose M here: the > module will be called adxl372_i2c. > > +config ADXL380 > + tristate > + select IIO_BUFFER > + select IIO_TRIGGERED_BUFFER > + > +config ADXL380_SPI > + tristate "Analog Devices ADXL380 3-Axis Accelerometer SPI Driver" > + depends on SPI > + select ADXL380 > + select REGMAP_SPI > + help > + Say yes here to add support for the Analog Devices ADXL380 triaxial > + acceleration sensor. > + To compile this driver as a module, choose M here: the > + module will be called adxl380_spi. > + > +config ADXL380_I2C > + tristate "Analog Devices ADXL380 3-Axis Accelerometer I2C Driver" > + depends on I2C > + select ADXL380 > + select REGMAP_I2C > + help > + Say yes here to add support for the Analog Devices ADXL380 triaxial > + acceleration sensor. > + To compile this driver as a module, choose M here: the > + module will be called adxl380_i2c. > + > config BMA180 > tristate "Bosch BMA023/BMA1x0/BMA250 3-Axis Accelerometer Driver" > depends on I2C && INPUT_BMA150=n > diff --git a/drivers/iio/accel/Makefile b/drivers/iio/accel/Makefile > index db90532ba24a..ca8569e25aba 100644 > --- a/drivers/iio/accel/Makefile > +++ b/drivers/iio/accel/Makefile > @@ -21,6 +21,9 @@ obj-$(CONFIG_ADXL367_SPI) += adxl367_spi.o > obj-$(CONFIG_ADXL372) += adxl372.o > obj-$(CONFIG_ADXL372_I2C) += adxl372_i2c.o > obj-$(CONFIG_ADXL372_SPI) += adxl372_spi.o > +obj-$(CONFIG_ADXL380) += adxl380.o > +obj-$(CONFIG_ADXL380_I2C) += adxl380_i2c.o > +obj-$(CONFIG_ADXL380_SPI) += adxl380_spi.o > obj-$(CONFIG_BMA180) += bma180.o > obj-$(CONFIG_BMA220) += bma220_spi.o > obj-$(CONFIG_BMA400) += bma400_core.o > diff --git a/drivers/iio/accel/adxl380.c b/drivers/iio/accel/adxl380.c > new file mode 100644 > index 000000000000..d37f4d85cf84 > --- /dev/null > +++ b/drivers/iio/accel/adxl380.c > @@ -0,0 +1,1908 @@ > +// SPDX-License-Identifier: GPL-2.0+ > +/* > + * ADXL380 3-Axis Digital Accelerometer core driver > + * > + * Copyright 2024 Analog Devices Inc. > + */ > + > +#include <linux/bitfield.h> > +#include <linux/interrupt.h> > +#include <linux/irq.h> > +#include <linux/module.h> > +#include <linux/property.h> > +#include <linux/regmap.h> > +#include <linux/units.h> > + > +#include <asm/unaligned.h> > + > +#include <linux/iio/buffer.h> > +#include <linux/iio/events.h> > +#include <linux/iio/iio.h> > +#include <linux/iio/kfifo_buf.h> > +#include <linux/iio/sysfs.h> > + > +#include <linux/regulator/consumer.h> > + > +#include "adxl380.h" > + > +#define ADXL380_ID_VAL 380 > +#define ADXL382_ID_VAL 382 > + > +#define ADXL380_DEVID_AD_REG 0x00 > +#define ADLX380_PART_ID_REG 0x02 > + > +#define ADXL380_X_DATA_H_REG 0x15 > +#define ADXL380_Y_DATA_H_REG 0x17 > +#define ADXL380_Z_DATA_H_REG 0x19 > +#define ADXL380_T_DATA_H_REG 0x1B > + > +#define ADXL380_MISC_0_REG 0x20 > +#define ADXL380_XL382_MSK BIT(7) > + > +#define ADXL380_MISC_1_REG 0x21 > + > +#define ADXL380_X_DSM_OFFSET_REG 0x4D > + > +#define ADXL380_ACT_INACT_CTL_REG 0x37 > +#define ADXL380_INACT_EN_MSK BIT(2) > +#define ADXL380_ACT_EN_MSK BIT(0) > + > +#define ADXL380_SNSR_AXIS_EN_REG 0x38 > +#define ADXL380_ACT_INACT_AXIS_EN_MSK GENMASK(2, 0) > + > +#define ADXL380_THRESH_ACT_H_REG 0x39 > +#define ADXL380_TIME_ACT_H_REG 0x3B > +#define ADXL380_THRESH_INACT_H_REG 0x3E > +#define ADXL380_TIME_INACT_H_REG 0x40 > +#define ADXL380_THRESH_MAX GENMASK(12, 0) > +#define ADXL380_TIME_MAX GENMASK(24, 0) > + > +#define ADXL380_FIFO_CONFIG_0_REG 0x30 > +#define ADXL380_FIFO_SAMPLES_8_MSK BIT(0) > +#define ADXL380_FIFO_MODE_MSK GENMASK(5, 4) > + > +#define ADXL380_FIFO_DISABLED 0 > +#define ADXL380_FIFO_NORMAL 1 > +#define ADXL380_FIFO_STREAMED 2 > +#define ADXL380_FIFO_TRIGGERED 3 > + > +#define ADXL380_FIFO_CONFIG_1_REG 0x31 > +#define ADXL380_FIFO_STATUS_0_REG 0x1E > + > +#define ADXL380_TAP_THRESH_REG 0x43 > +#define ADXL380_TAP_DUR_REG 0x44 > +#define ADXL380_TAP_LATENT_REG 0x45 > +#define ADXL380_TAP_WINDOW_REG 0x46 > +#define ADXL380_TAP_TIME_MAX GENMASK(7, 0) > + > +#define ADXL380_TAP_CFG_REG 0x47 > +#define ADXL380_TAP_AXIS_MSK GENMASK(1, 0) > + > +#define ADXL380_TRIG_CFG_REG 0x49 > +#define ADXL380_TRIG_CFG_DEC_2X_MSK BIT(7) > +#define ADXL380_TRIG_CFG_SINC_RATE_MSK BIT(6) > + > +#define ADXL380_FILTER_REG 0x50 > +#define ADXL380_FILTER_EQ_FILT_MSK BIT(6) > +#define ADXL380_FILTER_LPF_MODE_MSK GENMASK(5, 4) > +#define ADXL380_FILTER_HPF_PATH_MSK BIT(3) > +#define ADXL380_FILTER_HPF_CORNER_MSK GENMASK(2, 0) > + > +#define ADXL380_OP_MODE_REG 0x26 > +#define ADXL380_OP_MODE_RANGE_MSK GENMASK(7, 6) > +#define ADXL380_OP_MODE_MSK GENMASK(3, 0) > +#define ADXL380_OP_MODE_STANDBY 0 > +#define ADXL380_OP_MODE_HEART_SOUND 1 > +#define ADXL380_OP_MODE_ULP 2 > +#define ADXL380_OP_MODE_VLP 3 > +#define ADXL380_OP_MODE_LP 4 > +#define ADXL380_OP_MODE_LP_ULP 6 > +#define ADXL380_OP_MODE_LP_VLP 7 > +#define ADXL380_OP_MODE_RBW 8 > +#define ADXL380_OP_MODE_RBW_ULP 10 > +#define ADXL380_OP_MODE_RBW_VLP 11 > +#define ADXL380_OP_MODE_HP 12 > +#define ADXL380_OP_MODE_HP_ULP 14 > +#define ADXL380_OP_MODE_HP_VLP 15 > + > +#define ADXL380_OP_MODE_4G_RANGE 0 > +#define ADXL382_OP_MODE_15G_RANGE 0 > +#define ADXL380_OP_MODE_8G_RANGE 1 > +#define ADXL382_OP_MODE_30G_RANGE 1 > +#define ADXL380_OP_MODE_16G_RANGE 2 > +#define ADXL382_OP_MODE_60G_RANGE 2 > + > +#define ADXL380_DIG_EN_REG 0x27 > +#define ADXL380_CHAN_EN_MSK(chan) BIT(4 + (chan)) > +#define ADXL380_FIFO_EN_MSK BIT(3) > + > +#define ADXL380_INT0_MAP0_REG 0x2B > +#define ADXL380_INT1_MAP0_REG 0x2D > +#define ADXL380_INT_MAP0_INACT_INT0_MSK BIT(6) > +#define ADXL380_INT_MAP0_ACT_INT0_MSK BIT(5) > +#define ADXL380_INT_MAP0_FIFO_WM_INT0_MSK BIT(3) > + > +#define ADXL380_INT0_MAP1_REG 0x2C > +#define ADXL380_INT1_MAP1_REG 0x2E > +#define ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK BIT(1) > +#define ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK BIT(0) > + > +#define ADXL380_INT0_REG 0x5D > +#define ADXL380_INT0_POL_MSK BIT(7) > + > +#define ADXL380_RESET_REG 0x2A > +#define ADXL380_FIFO_DATA 0x1D > + > +#define ADXL380_DEVID_AD_VAL 0xAD > +#define ADXL380_RESET_CODE 0x52 > + > +#define ADXL380_STATUS_0_REG 0x11 > +#define ADXL380_STATUS_0_FIFO_FULL_MSK BIT(1) > +#define ADXL380_STATUS_0_FIFO_WM_MSK BIT(3) > + > +#define ADXL380_STATUS_1_INACT_MSK BIT(6) > +#define ADXL380_STATUS_1_ACT_MSK BIT(5) > +#define ADXL380_STATUS_1_DOUBLE_TAP_MSK BIT(1) > +#define ADXL380_STATUS_1_SINGLE_TAP_MSK BIT(0) > + > +#define ADXL380_FIFO_SAMPLES 315UL > + > +enum adxl380_channels { > + ADXL380_ACCEL_X, > + ADXL380_ACCEL_Y, > + ADXL380_ACCEL_Z, > + ADXL380_TEMP, > + ADXL380_CH_NUM, nitpick: If ADXL380_CH_NUM is the number of channels, then a trailing comma is not needed. Fine to also leave it. > +}; > + > +enum adxl380_axis { > + ADXL380_X_AXIS, > + ADXL380_Y_AXIS, > + ADXL380_Z_AXIS, > +}; > + > +enum adxl380_activity_type { > + ADXL380_ACTIVITY, > + ADXL380_INACTIVITY, > +}; > + > +enum adxl380_tap_type { > + ADXL380_SINGLE_TAP, > + ADXL380_DOUBLE_TAP, > +}; > + > +enum adxl380_tap_time_type { > + ADXL380_TAP_TIME_LATENT, > + ADXL380_TAP_TIME_WINDOW, > +}; > + > +static const int adxl380_range_scale_factor_tbl[] = { 1, 2, 4 }; > + > +const struct adxl380_chip_info adxl380_chip_info = { > + .name = "adxl380", > + .chip_id = ADXL380_ID_VAL, > + .scale_tbl = { > + [ADXL380_OP_MODE_4G_RANGE] = { 0, 1307226 }, > + [ADXL380_OP_MODE_8G_RANGE] = { 0, 2615434 }, > + [ADXL380_OP_MODE_16G_RANGE] = { 0, 5229886 }, > + }, > + .samp_freq_tbl = { 8000, 16000, 32000 }, > + /* > + * The datasheet defines an intercept of 470 LSB at 25 degC > + * and a sensitivity of 10.2 LSB/C. > + */ > + .temp_offset = 25 * 102 / 10 - 470, > + > +}; > +EXPORT_SYMBOL_NS_GPL(adxl380_chip_info, IIO_ADXL380); > + > +const struct adxl380_chip_info adxl382_chip_info = { > + .name = "adxl382", > + .chip_id = ADXL382_ID_VAL, > + .scale_tbl = { > + [ADXL382_OP_MODE_15G_RANGE] = { 0, 4903325 }, > + [ADXL382_OP_MODE_30G_RANGE] = { 0, 9806650 }, > + [ADXL382_OP_MODE_60G_RANGE] = { 0, 19613300 }, > + }, > + .samp_freq_tbl = { 16000, 32000, 64000 }, > + /* > + * The datasheet defines an intercept of 570 LSB at 25 degC > + * and a sensitivity of 10.2 LSB/C. > + */ > + .temp_offset = 25 * 102 / 10 - 570, > +}; > +EXPORT_SYMBOL_NS_GPL(adxl382_chip_info, IIO_ADXL380); > + > +static const unsigned int adxl380_th_reg_high_addr[2] = { > + [ADXL380_ACTIVITY] = ADXL380_THRESH_ACT_H_REG, > + [ADXL380_INACTIVITY] = ADXL380_THRESH_INACT_H_REG, > +}; > + > +static const unsigned int adxl380_time_reg_high_addr[2] = { > + [ADXL380_ACTIVITY] = ADXL380_TIME_ACT_H_REG, > + [ADXL380_INACTIVITY] = ADXL380_TIME_INACT_H_REG, > +}; > + > +static const unsigned int adxl380_tap_time_reg[2] = { > + [ADXL380_TAP_TIME_LATENT] = ADXL380_TAP_LATENT_REG, > + [ADXL380_TAP_TIME_WINDOW] = ADXL380_TAP_WINDOW_REG, > +}; > + > +struct adxl380_state { > + struct regmap *regmap; > + struct device *dev; > + const struct adxl380_chip_info *chip_info; > + /* > + * Synchronize access to members of driver state, and ensure atomicity > + * of consecutive regmap operations. > + */ > + struct mutex lock; > + enum adxl380_axis tap_axis_en; > + u8 range; > + u8 odr; > + u8 fifo_set_size; > + u8 transf_buf[3]; > + u16 watermark; > + u32 act_time_ms; > + u32 act_threshold; > + u32 inact_time_ms; > + u32 inact_threshold; > + u32 tap_latent_us; > + u32 tap_window_us; > + u32 tap_duration_us; > + u32 tap_threshold; > + int irq; > + int int_map[2]; > + int lpf_tbl[4]; > + int hpf_tbl[7][2]; > + > + __be16 fifo_buf[ADXL380_FIFO_SAMPLES] __aligned(IIO_DMA_MINALIGN); > +}; > + > +bool adxl380_readable_noinc_reg(struct device *dev, unsigned int reg) > +{ > + return reg == ADXL380_FIFO_DATA; > +} > +EXPORT_SYMBOL_NS_GPL(adxl380_readable_noinc_reg, IIO_ADXL380); > + > +static int adxl380_set_measure_en(struct adxl380_state *st, bool en) > +{ > + int ret; > + unsigned int act_inact_ctl; > + u8 op_mode = ADXL380_OP_MODE_STANDBY; > + > + if (en) { > + ret = regmap_read(st->regmap, ADXL380_ACT_INACT_CTL_REG, &act_inact_ctl); > + if (ret) > + return ret; > + > + /* Activity/ Inactivity detection available only in VLP/ULP mode */ > + if (FIELD_GET(ADXL380_ACT_EN_MSK, act_inact_ctl) || > + FIELD_GET(ADXL380_INACT_EN_MSK, act_inact_ctl)) > + op_mode = ADXL380_OP_MODE_VLP; > + else > + op_mode = ADXL380_OP_MODE_HP; > + } > + > + return regmap_update_bits(st->regmap, ADXL380_OP_MODE_REG, > + ADXL380_OP_MODE_MSK, > + FIELD_PREP(ADXL380_OP_MODE_MSK, op_mode)); > +} > + > +static void adxl380_scale_act_inact_thresholds(struct adxl380_state *st, > + u8 old_range, > + u8 new_range) > +{ > + st->act_threshold = mult_frac(st->act_threshold, > + adxl380_range_scale_factor_tbl[old_range], > + adxl380_range_scale_factor_tbl[new_range]); > + st->inact_threshold = mult_frac(st->inact_threshold, > + adxl380_range_scale_factor_tbl[old_range], > + adxl380_range_scale_factor_tbl[new_range]); > +} > + > +static int adxl380_write_act_inact_threshold(struct adxl380_state *st, > + enum adxl380_activity_type act, > + unsigned int th) > +{ > + int ret; > + u8 reg = adxl380_th_reg_high_addr[act]; > + > + if (th > ADXL380_THRESH_MAX) > + return -EINVAL; > + > + ret = regmap_write(st->regmap, reg + 1, th & GENMASK(7, 0)); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(st->regmap, reg, GENMASK(2, 0), th >> 8); > + if (ret) > + return ret; > + > + if (act == ADXL380_ACTIVITY) > + st->act_threshold = th; > + else > + st->inact_threshold = th; > + > + return 0; > +} > + > +static int adxl380_set_act_inact_threshold(struct iio_dev *indio_dev, > + enum adxl380_activity_type act, > + u16 th) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = adxl380_write_act_inact_threshold(st, act, th); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_set_tap_threshold_value(struct iio_dev *indio_dev, u8 th) > +{ > + int ret; > + struct adxl380_state *st = iio_priv(indio_dev); > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = regmap_write(st->regmap, ADXL380_TAP_THRESH_REG, th); > + if (ret) > + return ret; > + > + st->tap_threshold = th; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int _adxl380_write_tap_time_us(struct adxl380_state *st, > + enum adxl380_tap_time_type tap_time_type, > + u32 us) > +{ > + u8 reg = adxl380_tap_time_reg[tap_time_type]; > + unsigned int reg_val; > + int ret; > + > + /* scale factor for tap window is 1250us / LSB */ > + reg_val = DIV_ROUND_CLOSEST(us, 1250); > + if (reg_val > ADXL380_TAP_TIME_MAX) > + reg_val = ADXL380_TAP_TIME_MAX; > + > + ret = regmap_write(st->regmap, reg, reg_val); > + if (ret) > + return ret; > + > + if (tap_time_type == ADXL380_TAP_TIME_WINDOW) > + st->tap_window_us = us; > + else > + st->tap_latent_us = us; > + > + return 0; > +} > + > +static int adxl380_write_tap_time_us(struct adxl380_state *st, > + enum adxl380_tap_time_type tap_time_type, u32 us) > +{ > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = _adxl380_write_tap_time_us(st, tap_time_type, us); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_write_tap_dur_us(struct iio_dev *indio_dev, u32 us) > +{ > + int ret; > + unsigned int reg_val; > + struct adxl380_state *st = iio_priv(indio_dev); > + > + /* 625us per code is the scale factor of TAP_DUR register */ > + reg_val = DIV_ROUND_CLOSEST(us, 625); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = regmap_write(st->regmap, ADXL380_TAP_DUR_REG, reg_val); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_read_chn(struct adxl380_state *st, u8 addr) > +{ > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = regmap_bulk_read(st->regmap, addr, &st->transf_buf, 2); > + if (ret) > + return ret; > + > + return get_unaligned_be16(st->transf_buf); > +} > + > +static int adxl380_get_odr(struct adxl380_state *st, int *odr) > +{ > + int ret; > + unsigned int trig_cfg, odr_idx; > + > + ret = regmap_read(st->regmap, ADXL380_TRIG_CFG_REG, &trig_cfg); > + if (ret) > + return ret; > + > + odr_idx = (FIELD_GET(ADXL380_TRIG_CFG_SINC_RATE_MSK, trig_cfg) << 1) | > + (FIELD_GET(ADXL380_TRIG_CFG_DEC_2X_MSK, trig_cfg) & 1); > + > + *odr = st->chip_info->samp_freq_tbl[odr_idx]; > + > + return 0; > +} > + > +static const int adxl380_lpf_div[] = { > + 1, 4, 8, 16, > +}; > + > +static int adxl380_fill_lpf_tbl(struct adxl380_state *st) > +{ > + int ret, i; > + int odr; > + > + ret = adxl380_get_odr(st, &odr); > + if (ret) > + return ret; > + > + for (i = 0; i < ARRAY_SIZE(st->lpf_tbl); i++) > + st->lpf_tbl[i] = DIV_ROUND_CLOSEST(odr, adxl380_lpf_div[i]); > + > + return 0; > +} > + > +static const int adxl380_hpf_mul[] = { > + 0, 247000, 62084, 15545, 3862, 954, 238, > +}; > + > +static int adxl380_fill_hpf_tbl(struct adxl380_state *st) > +{ > + int i, ret, odr_hz; > + u32 multiplier; > + u64 div, rem, odr; > + > + ret = adxl380_get_odr(st, &odr_hz); > + if (ret) > + return ret; > + > + for (i = 0; i < ARRAY_SIZE(adxl380_hpf_mul); i++) { > + odr = mul_u64_u32_shr(odr_hz, MEGA, 0); > + multiplier = adxl380_hpf_mul[i]; > + div = div64_u64_rem(mul_u64_u32_shr(odr, multiplier, 0), > + TERA * 100, &rem); > + > + st->hpf_tbl[i][0] = div; > + st->hpf_tbl[i][1] = div_u64(rem, MEGA * 100); > + } > + > + return 0; > +} > + > +static int adxl380_set_odr(struct adxl380_state *st, u8 odr) > +{ > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(st->regmap, ADXL380_TRIG_CFG_REG, > + ADXL380_TRIG_CFG_DEC_2X_MSK, > + FIELD_PREP(ADXL380_TRIG_CFG_DEC_2X_MSK, odr & 1)); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(st->regmap, ADXL380_TRIG_CFG_REG, > + ADXL380_TRIG_CFG_SINC_RATE_MSK, > + FIELD_PREP(ADXL380_TRIG_CFG_SINC_RATE_MSK, odr >> 1)); > + if (ret) > + return ret; > + > + ret = adxl380_set_measure_en(st, true); > + if (ret) > + return ret; > + > + ret = adxl380_fill_lpf_tbl(st); > + if (ret) > + return ret; > + > + return adxl380_fill_hpf_tbl(st); > +} > + > +static int adxl380_find_match_1d_tbl(const int *array, unsigned int size, > + int val) I think this was copied from adxl372. But, I am wondering (at a later point in time), if it makes sense to use (or create) a common utility function for this. I haven't looked yet, if there is one. > +{ > + int i; > + > + for (i = 0; i < size; i++) { > + if (val == array[i]) > + return i; > + } > + > + return size - 1; > +} > + > +static int adxl380_find_match_2d_tbl(const int (*freq_tbl)[2], int n, int val, int val2) > +{ > + int i; > + > + for (i = 0; i < n; i++) { > + if (freq_tbl[i][0] == val && freq_tbl[i][1] == val2) > + return i; > + } > + > + return -EINVAL; > +} > + > +static int adxl380_get_lpf(struct adxl380_state *st, int *lpf) > +{ > + int ret; > + unsigned int trig_cfg, lpf_idx; > + > + guard(mutex)(&st->lock); > + > + ret = regmap_read(st->regmap, ADXL380_FILTER_REG, &trig_cfg); > + if (ret) > + return ret; > + > + lpf_idx = FIELD_GET(ADXL380_FILTER_LPF_MODE_MSK, trig_cfg); > + > + *lpf = st->lpf_tbl[lpf_idx]; > + > + return 0; > +} > + > +static int adxl380_set_lpf(struct adxl380_state *st, u8 lpf) > +{ > + int ret; > + u8 eq_bypass = 0; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + if (lpf) > + eq_bypass = 1; > + > + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, > + ADXL380_FILTER_EQ_FILT_MSK, > + FIELD_PREP(ADXL380_FILTER_EQ_FILT_MSK, eq_bypass)); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, > + ADXL380_FILTER_LPF_MODE_MSK, > + FIELD_PREP(ADXL380_FILTER_LPF_MODE_MSK, lpf)); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_get_hpf(struct adxl380_state *st, int *hpf_int, int *hpf_frac) > +{ > + int ret; > + unsigned int trig_cfg, hpf_idx; > + > + guard(mutex)(&st->lock); > + > + ret = regmap_read(st->regmap, ADXL380_FILTER_REG, &trig_cfg); > + if (ret) > + return ret; > + > + hpf_idx = FIELD_GET(ADXL380_FILTER_HPF_CORNER_MSK, trig_cfg); > + > + *hpf_int = st->hpf_tbl[hpf_idx][0]; > + *hpf_frac = st->hpf_tbl[hpf_idx][1]; > + > + return 0; > +} > + > +static int adxl380_set_hpf(struct adxl380_state *st, u8 hpf) > +{ > + int ret; > + u8 hpf_path = 0; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + if (hpf) > + hpf_path = 1; > + > + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, > + ADXL380_FILTER_HPF_PATH_MSK, > + FIELD_PREP(ADXL380_FILTER_HPF_PATH_MSK, hpf_path)); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, > + ADXL380_FILTER_HPF_CORNER_MSK, > + FIELD_PREP(ADXL380_FILTER_HPF_CORNER_MSK, hpf)); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int _adxl380_set_act_inact_time_ms(struct adxl380_state *st, > + enum adxl380_activity_type act, > + u32 ms) > +{ > + u8 reg = adxl380_time_reg_high_addr[act]; > + unsigned int reg_val; > + int ret; > + > + /* 500us per code is the scale factor of TIME_ACT / TIME_INACT registers */ > + reg_val = min(DIV_ROUND_CLOSEST(ms * 1000, 500), ADXL380_TIME_MAX); > + > + put_unaligned_be24(reg_val, &st->transf_buf[0]); > + > + ret = regmap_bulk_write(st->regmap, reg, st->transf_buf, sizeof(st->transf_buf)); > + if (ret) > + return ret; > + > + if (act == ADXL380_ACTIVITY) > + st->act_time_ms = ms; > + else > + st->inact_time_ms = ms; > + > + return 0; > +} > + > +static int adxl380_set_act_inact_time_ms(struct adxl380_state *st, > + enum adxl380_activity_type act, > + u32 ms) > +{ > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = _adxl380_set_act_inact_time_ms(st, act, ms); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_set_range(struct adxl380_state *st, u8 range) > +{ > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(st->regmap, ADXL380_OP_MODE_REG, > + ADXL380_OP_MODE_RANGE_MSK, > + FIELD_PREP(ADXL380_OP_MODE_RANGE_MSK, range)); > + > + if (ret) > + return ret; > + > + adxl380_scale_act_inact_thresholds(st, st->range, range); > + > + /* Activity thresholds depend on range */ > + ret = adxl380_write_act_inact_threshold(st, ADXL380_ACTIVITY, > + st->act_threshold); > + if (ret) > + return ret; > + > + ret = adxl380_write_act_inact_threshold(st, ADXL380_INACTIVITY, > + st->inact_threshold); > + if (ret) > + return ret; > + > + st->range = range; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_write_act_inact_en(struct adxl380_state *st, > + enum adxl380_activity_type type, > + bool en) > +{ > + if (type == ADXL380_ACTIVITY) > + return regmap_update_bits(st->regmap, ADXL380_ACT_INACT_CTL_REG, > + ADXL380_ACT_EN_MSK, > + FIELD_PREP(ADXL380_ACT_EN_MSK, en)); > + > + return regmap_update_bits(st->regmap, ADXL380_ACT_INACT_CTL_REG, > + ADXL380_INACT_EN_MSK, > + FIELD_PREP(ADXL380_INACT_EN_MSK, en)); > +} > + > +static int adxl380_read_act_inact_int(struct adxl380_state *st, > + enum adxl380_activity_type type, > + bool *en) > +{ > + int ret; > + unsigned int reg_val; > + > + guard(mutex)(&st->lock); > + > + ret = regmap_read(st->regmap, st->int_map[0], ®_val); > + if (ret) > + return ret; > + > + if (type == ADXL380_ACTIVITY) > + *en = FIELD_GET(ADXL380_INT_MAP0_ACT_INT0_MSK, reg_val); > + else > + *en = FIELD_GET(ADXL380_INT_MAP0_INACT_INT0_MSK, reg_val); > + > + return 0; > +} > + > +static int adxl380_write_act_inact_int(struct adxl380_state *st, > + enum adxl380_activity_type act, > + bool en) > +{ > + if (act == ADXL380_ACTIVITY) > + return regmap_update_bits(st->regmap, st->int_map[0], > + ADXL380_INT_MAP0_ACT_INT0_MSK, > + FIELD_PREP(ADXL380_INT_MAP0_ACT_INT0_MSK, en)); > + > + return regmap_update_bits(st->regmap, st->int_map[0], > + ADXL380_INT_MAP0_INACT_INT0_MSK, > + FIELD_PREP(ADXL380_INT_MAP0_INACT_INT0_MSK, en)); > +} > + > +static int adxl380_act_inact_config(struct adxl380_state *st, > + enum adxl380_activity_type type, > + bool en) > +{ > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = adxl380_write_act_inact_en(st, type, en); > + if (ret) > + return ret; > + > + ret = adxl380_write_act_inact_int(st, type, en); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_write_tap_axis(struct adxl380_state *st, > + enum adxl380_axis axis) > +{ > + int ret; > + > + ret = regmap_update_bits(st->regmap, ADXL380_TAP_CFG_REG, > + ADXL380_TAP_AXIS_MSK, > + FIELD_PREP(ADXL380_TAP_AXIS_MSK, axis)); > + > + if (ret) > + return ret; > + > + st->tap_axis_en = axis; > + > + return 0; > +} > + > +static int adxl380_read_tap_int(struct adxl380_state *st, enum adxl380_tap_type type, bool *en) > +{ > + int ret; > + unsigned int reg_val; > + > + ret = regmap_read(st->regmap, st->int_map[1], ®_val); > + if (ret) > + return ret; > + > + if (type == ADXL380_SINGLE_TAP) > + *en = FIELD_GET(ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK, reg_val); > + else > + *en = FIELD_GET(ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK, reg_val); > + > + return 0; > +} > + > +static int adxl380_write_tap_int(struct adxl380_state *st, enum adxl380_tap_type type, bool en) > +{ > + if (type == ADXL380_SINGLE_TAP) > + return regmap_update_bits(st->regmap, st->int_map[1], > + ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK, > + FIELD_PREP(ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK, en)); > + > + return regmap_update_bits(st->regmap, st->int_map[1], > + ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK, > + FIELD_PREP(ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK, en)); > +} > + > +static int adxl380_tap_config(struct adxl380_state *st, > + enum adxl380_axis axis, > + enum adxl380_tap_type type, > + bool en) > +{ > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = adxl380_write_tap_axis(st, axis); > + if (ret) > + return ret; > + > + ret = adxl380_write_tap_int(st, type, en); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_set_fifo_samples(struct adxl380_state *st) > +{ > + int ret; > + u16 fifo_samples = st->watermark * st->fifo_set_size; > + > + ret = regmap_update_bits(st->regmap, ADXL380_FIFO_CONFIG_0_REG, > + ADXL380_FIFO_SAMPLES_8_MSK, > + FIELD_PREP(ADXL380_FIFO_SAMPLES_8_MSK, > + (fifo_samples & BIT(8)))); > + if (ret) > + return ret; > + > + return regmap_write(st->regmap, ADXL380_FIFO_CONFIG_1_REG, > + fifo_samples & 0xFF); > +} > + > +static int adxl380_get_status(struct adxl380_state *st, u8 *status0, u8 *status1) > +{ > + int ret; > + > + /* STATUS0, STATUS1 are adjacent regs */ > + ret = regmap_bulk_read(st->regmap, ADXL380_STATUS_0_REG, > + &st->transf_buf, 2); > + if (ret) > + return ret; > + > + *status0 = st->transf_buf[0]; > + *status1 = st->transf_buf[1]; > + > + return 0; > +} > + > +static int adxl380_get_fifo_entries(struct adxl380_state *st, u16 *fifo_entries) > +{ > + int ret; > + > + ret = regmap_bulk_read(st->regmap, ADXL380_FIFO_STATUS_0_REG, > + &st->transf_buf, 2); > + if (ret) > + return ret; > + > + *fifo_entries = st->transf_buf[0] | ((BIT(0) & st->transf_buf[1]) << 8); > + > + return 0; > +} > + > +static void adxl380_push_event(struct iio_dev *indio_dev, s64 timestamp, > + u8 status1) > +{ > + if (FIELD_GET(ADXL380_STATUS_1_ACT_MSK, status1)) > + iio_push_event(indio_dev, > + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X_OR_Y_OR_Z, > + IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), > + timestamp); > + > + if (FIELD_GET(ADXL380_STATUS_1_INACT_MSK, status1)) > + iio_push_event(indio_dev, > + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X_OR_Y_OR_Z, > + IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING), > + timestamp); > + if (FIELD_GET(ADXL380_STATUS_1_SINGLE_TAP_MSK, status1)) > + iio_push_event(indio_dev, > + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X_OR_Y_OR_Z, > + IIO_EV_TYPE_GESTURE, IIO_EV_DIR_SINGLETAP), > + timestamp); > + > + if (FIELD_GET(ADXL380_STATUS_1_DOUBLE_TAP_MSK, status1)) > + iio_push_event(indio_dev, > + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X_OR_Y_OR_Z, > + IIO_EV_TYPE_GESTURE, IIO_EV_DIR_DOUBLETAP), > + timestamp); > +} > + > +static irqreturn_t adxl380_irq_handler(int irq, void *p) > +{ > + struct iio_dev *indio_dev = p; > + struct adxl380_state *st = iio_priv(indio_dev); > + u8 status0, status1; > + u16 fifo_entries; > + int i; > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_get_status(st, &status0, &status1); > + if (ret) > + return IRQ_HANDLED; > + > + adxl380_push_event(indio_dev, iio_get_time_ns(indio_dev), status1); > + > + if (!FIELD_GET(ADXL380_STATUS_0_FIFO_WM_MSK, status0)) > + return IRQ_HANDLED; > + > + ret = adxl380_get_fifo_entries(st, &fifo_entries); > + if (ret) > + return IRQ_HANDLED; > + > + for (i = 0; i < fifo_entries; i += st->fifo_set_size) { > + ret = regmap_noinc_read(st->regmap, ADXL380_FIFO_DATA, > + &st->fifo_buf[i], > + 2 * st->fifo_set_size); > + if (ret) > + return IRQ_HANDLED; > + iio_push_to_buffers(indio_dev, &st->fifo_buf[i]); > + } > + > + return IRQ_HANDLED; > +} > + > +static int adxl380_write_calibbias_value(struct adxl380_state *st, > + unsigned long chan_addr, > + s8 calibbias) > +{ > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = regmap_write(st->regmap, ADXL380_X_DSM_OFFSET_REG + chan_addr, calibbias); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_read_calibbias_value(struct adxl380_state *st, > + unsigned long chan_addr, > + int *calibbias) > +{ > + int ret; > + unsigned int reg_val; > + > + guard(mutex)(&st->lock); > + > + ret = regmap_read(st->regmap, ADXL380_X_DSM_OFFSET_REG + chan_addr, ®_val); > + if (ret) > + return ret; > + > + *calibbias = sign_extend32(reg_val, 7); > + > + return 0; > +} > + > +static ssize_t hwfifo_watermark_min_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + return sysfs_emit(buf, "1\n"); > +} > + > +static ssize_t hwfifo_watermark_max_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + return sysfs_emit(buf, "%lu\n", ADXL380_FIFO_SAMPLES); > +} > + > +static ssize_t adxl380_get_fifo_watermark(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct iio_dev *indio_dev = dev_to_iio_dev(dev); > + struct adxl380_state *st = iio_priv(indio_dev); > + > + return sysfs_emit(buf, "%d\n", st->watermark); > +} > + > +static ssize_t adxl380_get_fifo_enabled(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct iio_dev *indio_dev = dev_to_iio_dev(dev); > + struct adxl380_state *st = iio_priv(indio_dev); > + int ret; > + unsigned int reg_val; > + > + ret = regmap_read(st->regmap, ADXL380_DIG_EN_REG, ®_val); > + if (ret) > + return ret; > + > + return sysfs_emit(buf, "%lu\n", > + FIELD_GET(ADXL380_FIFO_EN_MSK, reg_val)); > +} > + > +static IIO_DEVICE_ATTR_RO(hwfifo_watermark_min, 0); > +static IIO_DEVICE_ATTR_RO(hwfifo_watermark_max, 0); > +static IIO_DEVICE_ATTR(hwfifo_watermark, 0444, > + adxl380_get_fifo_watermark, NULL, 0); > +static IIO_DEVICE_ATTR(hwfifo_enabled, 0444, > + adxl380_get_fifo_enabled, NULL, 0); > + > +static const struct iio_dev_attr *adxl380_fifo_attributes[] = { > + &iio_dev_attr_hwfifo_watermark_min, > + &iio_dev_attr_hwfifo_watermark_max, > + &iio_dev_attr_hwfifo_watermark, > + &iio_dev_attr_hwfifo_enabled, > + NULL > +}; > + > +static int adxl380_buffer_postenable(struct iio_dev *indio_dev) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + int i; > + int ret; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(st->regmap, > + st->int_map[0], > + ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, > + FIELD_PREP(ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, 1)); > + if (ret) > + return ret; > + > + for_each_clear_bit(i, indio_dev->active_scan_mask, ADXL380_CH_NUM) { Would this need to be?: for_each_set_bit(i, indio_dev->active_scan_mask, indio_dev->masklength) Or, is the logic intended to go over the cleared bits here? Depending on what's needed here, this could make use of "iio_for_each_active_channel()" later. > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, > + ADXL380_CHAN_EN_MSK(i), > + 0 << (4 + i)); > + if (ret) > + return ret; > + } > + > + st->fifo_set_size = bitmap_weight(indio_dev->active_scan_mask, > + indio_dev->masklength); Depending on Nuno's series (and if that gets accepted first), this might need to use the new iio_get_masklength() wrapper. That's not a reason against this going in first though. > + > + if ((st->watermark * st->fifo_set_size) > ADXL380_FIFO_SAMPLES) > + st->watermark = (ADXL380_FIFO_SAMPLES / st->fifo_set_size); > + > + ret = adxl380_set_fifo_samples(st); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, ADXL380_FIFO_EN_MSK, > + FIELD_PREP(ADXL380_FIFO_EN_MSK, 1)); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static int adxl380_buffer_predisable(struct iio_dev *indio_dev) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + int ret, i; > + > + guard(mutex)(&st->lock); > + > + ret = adxl380_set_measure_en(st, false); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(st->regmap, > + st->int_map[0], > + ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, > + FIELD_PREP(ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, 0)); > + if (ret) > + return ret; > + > + for (i = 0; i < indio_dev->num_channels; i++) { > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, > + ADXL380_CHAN_EN_MSK(i), > + 1 << (4 + i)); > + if (ret) > + return ret; > + } > + > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, ADXL380_FIFO_EN_MSK, > + FIELD_PREP(ADXL380_FIFO_EN_MSK, 0)); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +static const struct iio_buffer_setup_ops adxl380_buffer_ops = { > + .postenable = adxl380_buffer_postenable, > + .predisable = adxl380_buffer_predisable, > +}; > + > +static int adxl380_read_raw(struct iio_dev *indio_dev, > + struct iio_chan_spec const *chan, > + int *val, int *val2, long info) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + int ret; > + > + switch (info) { > + case IIO_CHAN_INFO_RAW: > + ret = iio_device_claim_direct_mode(indio_dev); > + if (ret) > + return ret; > + > + ret = adxl380_read_chn(st, chan->address); > + if (ret) > + return ret; > + > + iio_device_release_direct_mode(indio_dev); > + > + *val = sign_extend32(ret >> chan->scan_type.shift, > + chan->scan_type.realbits - 1); > + return IIO_VAL_INT; > + case IIO_CHAN_INFO_SCALE: > + switch (chan->type) { > + case IIO_ACCEL: > + scoped_guard(mutex, &st->lock) { > + *val = st->chip_info->scale_tbl[st->range][0]; > + *val2 = st->chip_info->scale_tbl[st->range][1]; > + } > + return IIO_VAL_INT_PLUS_NANO; > + case IIO_TEMP: > + /* 10.2 LSB / Degree Celsius */ > + *val = 10000; > + *val2 = 102; > + return IIO_VAL_FRACTIONAL; > + default: > + return -EINVAL; > + } > + case IIO_CHAN_INFO_OFFSET: > + switch (chan->type) { > + case IIO_TEMP: > + *val = st->chip_info->temp_offset; > + return IIO_VAL_INT; > + default: > + return -EINVAL; > + } > + case IIO_CHAN_INFO_CALIBBIAS: > + switch (chan->type) { > + case IIO_ACCEL: > + ret = adxl380_read_calibbias_value(st, chan->scan_index, val); > + if (ret) > + return ret; > + return IIO_VAL_INT; > + default: > + return -EINVAL; > + } > + case IIO_CHAN_INFO_SAMP_FREQ: > + ret = adxl380_get_odr(st, val); > + if (ret) > + return ret; > + return IIO_VAL_INT; > + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: > + ret = adxl380_get_lpf(st, val); > + if (ret) > + return ret; > + return IIO_VAL_INT; > + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: > + ret = adxl380_get_hpf(st, val, val2); > + if (ret) > + return ret; > + return IIO_VAL_INT_PLUS_MICRO; > + } > + > + return -EINVAL; > +} > + > +static int adxl380_read_avail(struct iio_dev *indio_dev, > + struct iio_chan_spec const *chan, > + const int **vals, int *type, int *length, > + long mask) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + > + if (chan->type != IIO_ACCEL) > + return -EINVAL; > + > + switch (mask) { > + case IIO_CHAN_INFO_SCALE: > + *vals = (const int *)st->chip_info->scale_tbl; > + *type = IIO_VAL_INT_PLUS_NANO; > + *length = ARRAY_SIZE(st->chip_info->scale_tbl) * 2; > + return IIO_AVAIL_LIST; > + case IIO_CHAN_INFO_SAMP_FREQ: > + *vals = (const int *)st->chip_info->samp_freq_tbl; > + *type = IIO_VAL_INT; > + *length = ARRAY_SIZE(st->chip_info->samp_freq_tbl); > + return IIO_AVAIL_LIST; > + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: > + *vals = (const int *)st->lpf_tbl; > + *type = IIO_VAL_INT; > + *length = ARRAY_SIZE(st->lpf_tbl); > + return IIO_AVAIL_LIST; > + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: > + *vals = (const int *)st->hpf_tbl; > + *type = IIO_VAL_INT_PLUS_MICRO; > + /* Values are stored in a 2D matrix */ > + *length = ARRAY_SIZE(st->hpf_tbl) * 2; > + return IIO_AVAIL_LIST; > + default: > + return -EINVAL; > + } > +} > + > +static int adxl380_write_raw(struct iio_dev *indio_dev, > + struct iio_chan_spec const *chan, > + int val, int val2, long info) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + int odr_index, lpf_index, hpf_index, range_index; > + > + switch (info) { > + case IIO_CHAN_INFO_SAMP_FREQ: > + odr_index = adxl380_find_match_1d_tbl(st->chip_info->samp_freq_tbl, > + ARRAY_SIZE(st->chip_info->samp_freq_tbl), > + val); > + return adxl380_set_odr(st, odr_index); > + case IIO_CHAN_INFO_CALIBBIAS: > + return adxl380_write_calibbias_value(st, chan->scan_index, val); > + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: > + lpf_index = adxl380_find_match_1d_tbl(st->lpf_tbl, > + ARRAY_SIZE(st->lpf_tbl), > + val); > + if (lpf_index < 0) > + return lpf_index; The way I see adxl380_find_match_1d_tbl(), it will never return negative. > + return adxl380_set_lpf(st, lpf_index); > + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: > + hpf_index = adxl380_find_match_2d_tbl(st->hpf_tbl, > + ARRAY_SIZE(st->hpf_tbl), > + val, val2); > + if (hpf_index < 0) > + return hpf_index; > + return adxl380_set_hpf(st, hpf_index); > + case IIO_CHAN_INFO_SCALE: > + range_index = adxl380_find_match_2d_tbl(st->chip_info->scale_tbl, > + ARRAY_SIZE(st->chip_info->scale_tbl), > + val, val2); > + if (range_index < 0) > + return range_index; > + return adxl380_set_range(st, range_index); > + default: > + return -EINVAL; > + } > +} > + > +static int adxl380_write_raw_get_fmt(struct iio_dev *indio_dev, > + struct iio_chan_spec const *chan, > + long info) > +{ > + switch (info) { > + case IIO_CHAN_INFO_SCALE: > + if (chan->type != IIO_ACCEL) > + return -EINVAL; > + > + return IIO_VAL_INT_PLUS_NANO; > + default: > + return IIO_VAL_INT_PLUS_MICRO; > + } > +} > + > +static int adxl380_read_event_config(struct iio_dev *indio_dev, > + const struct iio_chan_spec *chan, > + enum iio_event_type type, > + enum iio_event_direction dir) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + int ret; > + bool int_en; > + bool tap_axis_en = false; > + > + switch (chan->channel2) { > + case IIO_MOD_X: > + tap_axis_en = st->tap_axis_en == ADXL380_X_AXIS; > + break; > + case IIO_MOD_Y: > + tap_axis_en = st->tap_axis_en == ADXL380_Y_AXIS; > + break; > + case IIO_MOD_Z: > + tap_axis_en = st->tap_axis_en == ADXL380_Z_AXIS; > + break; > + default: > + return -EINVAL; > + } > + > + switch (dir) { > + case IIO_EV_DIR_RISING: > + ret = adxl380_read_act_inact_int(st, ADXL380_ACTIVITY, &int_en); > + if (ret) > + return ret; > + return int_en; > + case IIO_EV_DIR_FALLING: > + ret = adxl380_read_act_inact_int(st, ADXL380_INACTIVITY, &int_en); > + if (ret) > + return ret; > + return int_en; > + case IIO_EV_DIR_SINGLETAP: > + ret = adxl380_read_tap_int(st, ADXL380_SINGLE_TAP, &int_en); > + if (ret) > + return ret; > + return int_en && tap_axis_en; > + case IIO_EV_DIR_DOUBLETAP: > + ret = adxl380_read_tap_int(st, ADXL380_DOUBLE_TAP, &int_en); > + if (ret) > + return ret; > + return int_en && tap_axis_en; > + default: > + return -EINVAL; > + } > +} > + > +static int adxl380_write_event_config(struct iio_dev *indio_dev, > + const struct iio_chan_spec *chan, > + enum iio_event_type type, > + enum iio_event_direction dir, > + int state) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + enum adxl380_axis axis; > + > + switch (chan->channel2) { > + case IIO_MOD_X: > + axis = ADXL380_X_AXIS; > + break; > + case IIO_MOD_Y: > + axis = ADXL380_Y_AXIS; > + break; > + case IIO_MOD_Z: > + axis = ADXL380_Z_AXIS; > + break; > + default: > + return -EINVAL; > + } > + > + switch (dir) { > + case IIO_EV_DIR_RISING: > + return adxl380_act_inact_config(st, ADXL380_ACTIVITY, state); > + case IIO_EV_DIR_FALLING: > + return adxl380_act_inact_config(st, ADXL380_INACTIVITY, state); > + case IIO_EV_DIR_SINGLETAP: > + return adxl380_tap_config(st, axis, ADXL380_SINGLE_TAP, state); > + case IIO_EV_DIR_DOUBLETAP: > + return adxl380_tap_config(st, axis, ADXL380_DOUBLE_TAP, state); > + default: > + return -EINVAL; > + } > +} > + > +static int adxl380_read_event_value(struct iio_dev *indio_dev, > + const struct iio_chan_spec *chan, > + enum iio_event_type type, > + enum iio_event_direction dir, > + enum iio_event_info info, > + int *val, int *val2) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + > + guard(mutex)(&st->lock); > + > + switch (type) { > + case IIO_EV_TYPE_THRESH: > + switch (info) { > + case IIO_EV_INFO_VALUE: { > + switch (dir) { > + case IIO_EV_DIR_RISING: > + *val = st->act_threshold; > + return IIO_VAL_INT; > + case IIO_EV_DIR_FALLING: > + *val = st->inact_threshold; > + return IIO_VAL_INT; > + default: > + return -EINVAL; > + } > + } > + case IIO_EV_INFO_PERIOD: > + switch (dir) { > + case IIO_EV_DIR_RISING: > + *val = st->act_time_ms; > + *val2 = 1000; > + return IIO_VAL_FRACTIONAL; > + case IIO_EV_DIR_FALLING: > + *val = st->inact_time_ms; > + *val2 = 1000; > + return IIO_VAL_FRACTIONAL; > + default: > + return -EINVAL; > + } > + default: > + return -EINVAL; > + } > + case IIO_EV_TYPE_GESTURE: > + switch (info) { > + case IIO_EV_INFO_VALUE: > + *val = st->tap_threshold; > + return IIO_VAL_INT; > + case IIO_EV_INFO_RESET_TIMEOUT: > + *val = st->tap_window_us; > + *val2 = 1000000; > + return IIO_VAL_FRACTIONAL; > + case IIO_EV_INFO_TAP2_MIN_DELAY: > + *val = st->tap_latent_us; > + *val2 = 1000000; > + return IIO_VAL_FRACTIONAL; > + default: > + return -EINVAL; > + } > + default: > + return -EINVAL; > + } > +} > + > +static int adxl380_write_event_value(struct iio_dev *indio_dev, > + const struct iio_chan_spec *chan, > + enum iio_event_type type, enum iio_event_direction dir, > + enum iio_event_info info, int val, int val2) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + u32 val_ms, val_us; > + > + if (chan->type != IIO_ACCEL) > + return -EINVAL; > + > + switch (type) { > + case IIO_EV_TYPE_THRESH: > + switch (info) { > + case IIO_EV_INFO_VALUE: > + switch (dir) { > + case IIO_EV_DIR_RISING: > + return adxl380_set_act_inact_threshold(indio_dev, > + ADXL380_ACTIVITY, val); > + case IIO_EV_DIR_FALLING: > + return adxl380_set_act_inact_threshold(indio_dev, > + ADXL380_INACTIVITY, val); > + default: > + return -EINVAL; > + } > + case IIO_EV_INFO_PERIOD: > + val_ms = val * 1000 + DIV_ROUND_UP(val2, 1000); > + switch (dir) { > + case IIO_EV_DIR_RISING: > + return adxl380_set_act_inact_time_ms(st, > + ADXL380_ACTIVITY, val_ms); > + case IIO_EV_DIR_FALLING: > + return adxl380_set_act_inact_time_ms(st, > + ADXL380_INACTIVITY, val_ms); > + default: > + return -EINVAL; > + } > + > + default: > + return -EINVAL; > + } > + case IIO_EV_TYPE_GESTURE: > + switch (info) { > + case IIO_EV_INFO_VALUE: > + return adxl380_set_tap_threshold_value(indio_dev, val); > + case IIO_EV_INFO_RESET_TIMEOUT: > + val_us = val * 1000000 + val2; > + return adxl380_write_tap_time_us(st, > + ADXL380_TAP_TIME_WINDOW, > + val_us); > + case IIO_EV_INFO_TAP2_MIN_DELAY: > + val_us = val * 1000000 + val2; > + return adxl380_write_tap_time_us(st, > + ADXL380_TAP_TIME_LATENT, > + val_us); > + default: > + return -EINVAL; > + } > + default: > + return -EINVAL; > + } > +} > + > +static ssize_t in_accel_gesture_tap_maxtomin_time_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + int vals[2]; > + struct iio_dev *indio_dev = dev_to_iio_dev(dev); > + struct adxl380_state *st = iio_priv(indio_dev); > + > + guard(mutex)(&st->lock); > + > + vals[0] = st->tap_duration_us; > + vals[1] = MICRO; > + > + return iio_format_value(buf, IIO_VAL_FRACTIONAL, 2, vals); > +} > + > +static ssize_t in_accel_gesture_tap_maxtomin_time_store(struct device *dev, > + struct device_attribute *attr, > + const char *buf, size_t len) > +{ > + struct iio_dev *indio_dev = dev_to_iio_dev(dev); > + struct adxl380_state *st = iio_priv(indio_dev); > + int ret, val_int, val_fract_us; > + > + guard(mutex)(&st->lock); > + > + ret = iio_str_to_fixpoint(buf, 100000, &val_int, &val_fract_us); > + if (ret) > + return ret; > + > + /* maximum value is 255 * 625 us = 0.159375 seconds */ > + if (val_int || val_fract_us > 159375 || val_fract_us < 0) > + return -EINVAL; > + > + ret = adxl380_write_tap_dur_us(indio_dev, val_fract_us); > + if (ret) > + return ret; > + > + return len; > +} > + > +static IIO_DEVICE_ATTR_RW(in_accel_gesture_tap_maxtomin_time, 0); > + > +static struct attribute *adxl380_event_attributes[] = { > + &iio_dev_attr_in_accel_gesture_tap_maxtomin_time.dev_attr.attr, > + NULL > +}; > + > +static const struct attribute_group adxl380_event_attribute_group = { > + .attrs = adxl380_event_attributes, > +}; > + > +static int adxl380_reg_access(struct iio_dev *indio_dev, > + unsigned int reg, > + unsigned int writeval, > + unsigned int *readval) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + > + if (readval) > + return regmap_read(st->regmap, reg, readval); > + > + return regmap_write(st->regmap, reg, writeval); > +} > + > +static int adxl380_set_watermark(struct iio_dev *indio_dev, unsigned int val) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + > + st->watermark = min(val, ADXL380_FIFO_SAMPLES); > + > + return 0; > +} > + > +static const struct iio_info adxl380_info = { > + .read_raw = adxl380_read_raw, > + .read_avail = &adxl380_read_avail, > + .write_raw = adxl380_write_raw, > + .write_raw_get_fmt = adxl380_write_raw_get_fmt, > + .read_event_config = adxl380_read_event_config, > + .write_event_config = adxl380_write_event_config, > + .read_event_value = adxl380_read_event_value, > + .write_event_value = adxl380_write_event_value, > + .event_attrs = &adxl380_event_attribute_group, > + .debugfs_reg_access = &adxl380_reg_access, > + .hwfifo_set_watermark = adxl380_set_watermark, > +}; > + > +static const struct iio_event_spec adxl380_events[] = { > + { > + .type = IIO_EV_TYPE_THRESH, > + .dir = IIO_EV_DIR_RISING, > + .mask_shared_by_type = BIT(IIO_EV_INFO_ENABLE) | > + BIT(IIO_EV_INFO_VALUE) | > + BIT(IIO_EV_INFO_PERIOD), > + }, > + { > + .type = IIO_EV_TYPE_THRESH, > + .dir = IIO_EV_DIR_FALLING, > + .mask_shared_by_type = BIT(IIO_EV_INFO_ENABLE) | > + BIT(IIO_EV_INFO_VALUE) | > + BIT(IIO_EV_INFO_PERIOD), > + }, > + { > + .type = IIO_EV_TYPE_GESTURE, > + .dir = IIO_EV_DIR_SINGLETAP, > + .mask_separate = BIT(IIO_EV_INFO_ENABLE), > + .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) | > + BIT(IIO_EV_INFO_RESET_TIMEOUT), > + }, > + { > + .type = IIO_EV_TYPE_GESTURE, > + .dir = IIO_EV_DIR_DOUBLETAP, > + .mask_separate = BIT(IIO_EV_INFO_ENABLE), > + .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) | > + BIT(IIO_EV_INFO_RESET_TIMEOUT) | > + BIT(IIO_EV_INFO_TAP2_MIN_DELAY), > + }, > +}; > + > +#define ADXL380_ACCEL_CHANNEL(index, reg, axis) { \ > + .type = IIO_ACCEL, \ > + .address = reg, \ > + .modified = 1, \ > + .channel2 = IIO_MOD_##axis, \ > + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ > + BIT(IIO_CHAN_INFO_CALIBBIAS), \ > + .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ > + .info_mask_shared_by_all_available = \ > + BIT(IIO_CHAN_INFO_SAMP_FREQ), \ > + .info_mask_shared_by_type = \ > + BIT(IIO_CHAN_INFO_SCALE) | \ > + BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \ > + BIT(IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY), \ > + .info_mask_shared_by_type_available = \ > + BIT(IIO_CHAN_INFO_SCALE) | \ > + BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \ > + BIT(IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY), \ > + .scan_index = index, \ > + .scan_type = { \ > + .sign = 's', \ > + .realbits = 16, \ > + .storagebits = 16, \ > + .endianness = IIO_BE, \ > + }, \ > + .event_spec = adxl380_events, \ > + .num_event_specs = ARRAY_SIZE(adxl380_events) \ > +} > + > +static const struct iio_chan_spec adxl380_channels[] = { > + ADXL380_ACCEL_CHANNEL(0, ADXL380_X_DATA_H_REG, X), > + ADXL380_ACCEL_CHANNEL(1, ADXL380_Y_DATA_H_REG, Y), > + ADXL380_ACCEL_CHANNEL(2, ADXL380_Z_DATA_H_REG, Z), > + { > + .type = IIO_TEMP, > + .address = ADXL380_T_DATA_H_REG, > + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | > + BIT(IIO_CHAN_INFO_SCALE) | > + BIT(IIO_CHAN_INFO_OFFSET), > + .scan_index = 3, > + .scan_type = { > + .sign = 's', > + .realbits = 12, > + .storagebits = 16, > + .shift = 4, > + .endianness = IIO_BE, > + }, > + }, > +}; > + > +static int adxl380_config_irq(struct iio_dev *indio_dev) > +{ > + struct adxl380_state *st = iio_priv(indio_dev); > + unsigned long irq_flag; > + struct irq_data *desc; > + u32 irq_type; > + u8 polarity; > + int ret; > + > + desc = irq_get_irq_data(st->irq); > + if (!desc) > + return dev_err_probe(st->dev, -EINVAL, "Could not find IRQ %d\n", st->irq); > + > + irq_type = irqd_get_trigger_type(desc); > + if (irq_type == IRQ_TYPE_LEVEL_HIGH) { > + polarity = 0; > + irq_flag = IRQF_TRIGGER_HIGH | IRQF_ONESHOT; > + } else if (irq_type == IRQ_TYPE_LEVEL_LOW) { > + polarity = 1; > + irq_flag = IRQF_TRIGGER_LOW | IRQF_ONESHOT; > + } else { > + return dev_err_probe(st->dev, -EINVAL, > + "Invalid interrupt 0x%x. Only level interrupts supported\n", > + irq_type); > + } > + > + ret = regmap_update_bits(st->regmap, ADXL380_INT0_REG, > + ADXL380_INT0_POL_MSK, > + FIELD_PREP(ADXL380_INT0_POL_MSK, polarity)); > + if (ret) > + return ret; > + > + return devm_request_threaded_irq(st->dev, st->irq, NULL, > + adxl380_irq_handler, irq_flag, > + indio_dev->name, indio_dev); > +} > + > +static int adxl380_setup(struct iio_dev *indio_dev) > +{ > + unsigned int reg_val; > + u16 part_id, chip_id; > + int ret, i; > + struct adxl380_state *st = iio_priv(indio_dev); > + > + ret = regmap_read(st->regmap, ADXL380_DEVID_AD_REG, ®_val); > + if (ret) > + return ret; > + > + if (reg_val != ADXL380_DEVID_AD_VAL) > + dev_warn(st->dev, "Unknown chip id %x\n", reg_val); > + > + ret = regmap_bulk_read(st->regmap, ADLX380_PART_ID_REG, > + &st->transf_buf, 2); > + if (ret) > + return ret; > + > + part_id = get_unaligned_be16(st->transf_buf); > + part_id >>= 4; > + > + if (part_id != ADXL380_ID_VAL) > + dev_warn(st->dev, "Unknown part id %x\n", part_id); > + > + ret = regmap_read(st->regmap, ADXL380_MISC_0_REG, ®_val); > + if (ret) > + return ret; > + > + /* Bit to differentiate between ADXL380/382. */ > + if (reg_val & ADXL380_XL382_MSK) > + chip_id = ADXL382_ID_VAL; > + else > + chip_id = ADXL380_ID_VAL; > + > + if (chip_id != st->chip_info->chip_id) > + dev_warn(st->dev, "Unknown chip id %x\n", chip_id); > + > + ret = regmap_write(st->regmap, ADXL380_RESET_REG, ADXL380_RESET_CODE); > + if (ret) > + return ret; > + > + /* > + * A latency of approximately 0.5 ms is required after soft reset. > + * Stated in the register REG_RESET description. > + */ > + fsleep(500); > + > + for (i = 0; i < indio_dev->num_channels; i++) { > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, > + ADXL380_CHAN_EN_MSK(i), > + 1 << (4 + i)); > + if (ret) > + return ret; > + } > + > + ret = regmap_update_bits(st->regmap, ADXL380_FIFO_CONFIG_0_REG, > + ADXL380_FIFO_MODE_MSK, > + FIELD_PREP(ADXL380_FIFO_MODE_MSK, ADXL380_FIFO_STREAMED)); > + if (ret) > + return ret; > + > + /* Select all 3 axis for act/inact detection. */ > + ret = regmap_update_bits(st->regmap, ADXL380_SNSR_AXIS_EN_REG, > + ADXL380_ACT_INACT_AXIS_EN_MSK, > + FIELD_PREP(ADXL380_ACT_INACT_AXIS_EN_MSK, > + ADXL380_ACT_INACT_AXIS_EN_MSK)); > + if (ret) > + return ret; > + > + ret = adxl380_config_irq(indio_dev); > + if (ret) > + return ret; > + > + ret = adxl380_fill_lpf_tbl(st); > + if (ret) > + return ret; > + > + ret = adxl380_fill_hpf_tbl(st); > + if (ret) > + return ret; > + > + return adxl380_set_measure_en(st, true); > +} > + > +int adxl380_probe(struct device *dev, struct regmap *regmap, > + const struct adxl380_chip_info *chip_info) > +{ > + struct iio_dev *indio_dev; > + struct adxl380_state *st; > + int ret; > + > + indio_dev = devm_iio_device_alloc(dev, sizeof(*st)); > + if (!indio_dev) > + return -ENOMEM; > + > + st = iio_priv(indio_dev); > + > + st->dev = dev; > + st->regmap = regmap; > + st->chip_info = chip_info; > + > + mutex_init(&st->lock); > + > + indio_dev->channels = adxl380_channels; > + indio_dev->num_channels = ARRAY_SIZE(adxl380_channels); > + indio_dev->name = chip_info->name; > + indio_dev->info = &adxl380_info; > + indio_dev->modes = INDIO_DIRECT_MODE; > + > + ret = devm_regulator_get_enable(dev, "vddio"); > + if (ret) > + return dev_err_probe(st->dev, ret, > + "Failed to get vddio regulator\n"); > + > + ret = devm_regulator_get_enable(st->dev, "vsupply"); > + if (ret) > + return dev_err_probe(st->dev, ret, > + "Failed to get vsupply regulator\n"); > + > + st->irq = fwnode_irq_get_byname(dev_fwnode(dev), "INT0"); > + if (st->irq > 0) { > + st->int_map[0] = ADXL380_INT0_MAP0_REG; > + st->int_map[1] = ADXL380_INT0_MAP1_REG; > + } else { > + st->irq = fwnode_irq_get_byname(dev_fwnode(dev), "INT1"); > + if (st->irq > 0) > + return dev_err_probe(dev, -ENODEV, > + "no interrupt name specified"); > + st->int_map[0] = ADXL380_INT1_MAP0_REG; > + st->int_map[1] = ADXL380_INT1_MAP1_REG; > + } Would it make sense fo this interrupt-register setup to go into "adxl380_config_irq()"? > + > + ret = adxl380_setup(indio_dev); > + if (ret) > + return ret; > + > + ret = devm_iio_kfifo_buffer_setup_ext(st->dev, indio_dev, > + &adxl380_buffer_ops, > + adxl380_fifo_attributes); > + if (ret) > + return ret; > + > + return devm_iio_device_register(dev, indio_dev); > +} > +EXPORT_SYMBOL_NS_GPL(adxl380_probe, IIO_ADXL380); > + > +MODULE_AUTHOR("Ramona Gradinariu <ramona.gradinariu@analog.com>"); > +MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com>"); > +MODULE_DESCRIPTION("Analog Devices ADXL380 3-axis accelerometer driver"); > +MODULE_LICENSE("GPL"); > diff --git a/drivers/iio/accel/adxl380.h b/drivers/iio/accel/adxl380.h > new file mode 100644 > index 000000000000..a683625d897a > --- /dev/null > +++ b/drivers/iio/accel/adxl380.h > @@ -0,0 +1,26 @@ > +/* SPDX-License-Identifier: GPL-2.0+ */ > +/* > + * ADXL380 3-Axis Digital Accelerometer > + * > + * Copyright 2024 Analog Devices Inc. > + */ > + > +#ifndef _ADXL380_H_ > +#define _ADXL380_H_ > + > +struct adxl380_chip_info { > + const char *name; > + const int scale_tbl[3][2]; > + const int samp_freq_tbl[3]; > + const int temp_offset; > + const u16 chip_id; > +}; > + > +extern const struct adxl380_chip_info adxl380_chip_info; > +extern const struct adxl380_chip_info adxl382_chip_info; > + > +int adxl380_probe(struct device *dev, struct regmap *regmap, > + const struct adxl380_chip_info *chip_info); > +bool adxl380_readable_noinc_reg(struct device *dev, unsigned int reg); > + > +#endif /* _ADXL380_H_ */ > diff --git a/drivers/iio/accel/adxl380_i2c.c b/drivers/iio/accel/adxl380_i2c.c > new file mode 100644 > index 000000000000..1dc1e77be815 > --- /dev/null > +++ b/drivers/iio/accel/adxl380_i2c.c > @@ -0,0 +1,64 @@ > +// SPDX-License-Identifier: GPL-2.0+ > +/* > + * ADXL380 3-Axis Digital Accelerometer I2C driver > + * > + * Copyright 2024 Analog Devices Inc. > + */ > + > +#include <linux/i2c.h> > +#include <linux/mod_devicetable.h> > +#include <linux/module.h> > +#include <linux/regmap.h> > + > +#include "adxl380.h" > + > +static const struct regmap_config adxl380_regmap_config = { > + .reg_bits = 8, > + .val_bits = 8, > + .readable_noinc_reg = adxl380_readable_noinc_reg, > +}; > + > +static int adxl380_i2c_probe(struct i2c_client *client) > +{ > + struct regmap *regmap; > + const struct adxl380_chip_info *chip_data; > + > + chip_data = i2c_get_match_data(client); > + > + regmap = devm_regmap_init_i2c(client, &adxl380_regmap_config); > + if (IS_ERR(regmap)) > + return PTR_ERR(regmap); > + > + return adxl380_probe(&client->dev, regmap, chip_data); > +} > + > +static const struct i2c_device_id adxl380_i2c_id[] = { > + { "adxl380", (kernel_ulong_t)&adxl380_chip_info }, > + { "adxl382", (kernel_ulong_t)&adxl382_chip_info }, > + { } > +}; > +MODULE_DEVICE_TABLE(i2c, adxl380_i2c_id); > + > +static const struct of_device_id adxl380_of_match[] = { > + { .compatible = "adi,adxl380", .data = &adxl380_chip_info }, > + { .compatible = "adi,adxl382", .data = &adxl382_chip_info }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, adxl380_of_match); > + > +static struct i2c_driver adxl380_i2c_driver = { > + .driver = { > + .name = "adxl380_i2c", > + .of_match_table = adxl380_of_match, > + }, > + .probe = adxl380_i2c_probe, > + .id_table = adxl380_i2c_id, > +}; > + > +module_i2c_driver(adxl380_i2c_driver); > + > +MODULE_AUTHOR("Ramona Gradinariu <ramona.gradinariu@analog.com>"); > +MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com>"); > +MODULE_DESCRIPTION("Analog Devices ADXL380 3-axis accelerometer I2C driver"); > +MODULE_LICENSE("GPL"); > +MODULE_IMPORT_NS(IIO_ADXL380); > diff --git a/drivers/iio/accel/adxl380_spi.c b/drivers/iio/accel/adxl380_spi.c > new file mode 100644 > index 000000000000..e7b5778cb6cf > --- /dev/null > +++ b/drivers/iio/accel/adxl380_spi.c > @@ -0,0 +1,66 @@ > +// SPDX-License-Identifier: GPL-2.0+ > +/* > + * ADXL380 3-Axis Digital Accelerometer SPI driver > + * > + * Copyright 2024 Analog Devices Inc. > + */ > + > +#include <linux/mod_devicetable.h> > +#include <linux/module.h> > +#include <linux/regmap.h> > +#include <linux/spi/spi.h> > + > +#include "adxl380.h" > + > +static const struct regmap_config adxl380_spi_regmap_config = { > + .reg_bits = 7, > + .pad_bits = 1, > + .val_bits = 8, > + .read_flag_mask = BIT(0), > + .readable_noinc_reg = adxl380_readable_noinc_reg, > +}; > + > +static int adxl380_spi_probe(struct spi_device *spi) > +{ > + const struct adxl380_chip_info *chip_data; > + struct regmap *regmap; > + > + chip_data = spi_get_device_match_data(spi); > + > + regmap = devm_regmap_init_spi(spi, &adxl380_spi_regmap_config); > + if (IS_ERR(regmap)) > + return PTR_ERR(regmap); > + > + return adxl380_probe(&spi->dev, regmap, chip_data); > +} > + > +static const struct spi_device_id adxl380_spi_id[] = { > + { "adxl380", (kernel_ulong_t)&adxl380_chip_info }, > + { "adxl382", (kernel_ulong_t)&adxl382_chip_info }, > + { } > +}; > +MODULE_DEVICE_TABLE(spi, adxl380_spi_id); > + > +static const struct of_device_id adxl380_of_match[] = { > + { .compatible = "adi,adxl380", .data = &adxl380_chip_info }, > + { .compatible = "adi,adxl382", .data = &adxl382_chip_info }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, adxl380_of_match); > + > +static struct spi_driver adxl380_spi_driver = { > + .driver = { > + .name = "adxl380_spi", > + .of_match_table = adxl380_of_match, > + }, > + .probe = adxl380_spi_probe, > + .id_table = adxl380_spi_id, > +}; > + > +module_spi_driver(adxl380_spi_driver); > + > +MODULE_AUTHOR("Ramona Gradinariu <ramona.gradinariu@analog.com>"); > +MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com>"); > +MODULE_DESCRIPTION("Analog Devices ADXL380 3-axis accelerometer SPI driver"); > +MODULE_LICENSE("GPL"); > +MODULE_IMPORT_NS(IIO_ADXL380); > -- > 2.45.2 > > ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH v4 2/3] iio: accel: add ADXL380 driver 2024-07-03 7:06 ` Alexandru Ardelean @ 2024-07-07 16:31 ` Jonathan Cameron 2024-07-08 10:22 ` Miclaus, Antoniu 1 sibling, 0 replies; 7+ messages in thread From: Jonathan Cameron @ 2024-07-07 16:31 UTC (permalink / raw) To: Alexandru Ardelean Cc: Antoniu Miclaus, Ramona Gradinariu, Lars-Peter Clausen, Michael Hennerich, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Jonathan Corbet, Jun Yan, Matti Vaittinen, Mario Limonciello, Mehdi Djait, linux-iio, devicetree, linux-kernel, linux-doc *grumpy* Alexandru, crop out the irrelevant parts! I initially only spotted the comma one due to too much scrolling. Good to have your review though. Jonathan > > +#define ADXL380_FIFO_SAMPLES 315UL > > + > > +enum adxl380_channels { > > + ADXL380_ACCEL_X, > > + ADXL380_ACCEL_Y, > > + ADXL380_ACCEL_Z, > > + ADXL380_TEMP, > > + ADXL380_CH_NUM, > > nitpick: If ADXL380_CH_NUM is the number of channels, then a trailing > comma is not needed. > Fine to also leave it. > > +static int adxl380_buffer_postenable(struct iio_dev *indio_dev) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int i; > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, > > + st->int_map[0], > > + ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, > > + FIELD_PREP(ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, 1)); > > + if (ret) > > + return ret; > > + > > + for_each_clear_bit(i, indio_dev->active_scan_mask, ADXL380_CH_NUM) { > > Would this need to be?: > for_each_set_bit(i, indio_dev->active_scan_mask, indio_dev->masklength) > > Or, is the logic intended to go over the cleared bits here? > > Depending on what's needed here, this could make use of > "iio_for_each_active_channel()" later. > > > > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, > > + ADXL380_CHAN_EN_MSK(i), > > + 0 << (4 + i)); > > + if (ret) > > + return ret; > > + } > > + > > + st->fifo_set_size = bitmap_weight(indio_dev->active_scan_mask, > > + indio_dev->masklength); > > Depending on Nuno's series (and if that gets accepted first), this > might need to use the new iio_get_masklength() wrapper. > That's not a reason against this going in first though. There will be a bunch of races with that, so I'm not worried if drivers use it yet. We'll fix them all up along with the existing cases before taking the masklength private. I have applied Nuno's initial series and some drivers that will need converting today :) ... > > +static int adxl380_write_raw(struct iio_dev *indio_dev, > > + struct iio_chan_spec const *chan, > > + int val, int val2, long info) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int odr_index, lpf_index, hpf_index, range_index; > > + > > + switch (info) { > > + case IIO_CHAN_INFO_SAMP_FREQ: > > + odr_index = adxl380_find_match_1d_tbl(st->chip_info->samp_freq_tbl, > > + ARRAY_SIZE(st->chip_info->samp_freq_tbl), > > + val); > > + return adxl380_set_odr(st, odr_index); > > + case IIO_CHAN_INFO_CALIBBIAS: > > + return adxl380_write_calibbias_value(st, chan->scan_index, val); > > + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: > > + lpf_index = adxl380_find_match_1d_tbl(st->lpf_tbl, > > + ARRAY_SIZE(st->lpf_tbl), > > + val); > > + if (lpf_index < 0) > > + return lpf_index; > > The way I see adxl380_find_match_1d_tbl(), it will never return negative. > > > + return adxl380_set_lpf(st, lpf_index); > > + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: > > + hpf_index = adxl380_find_match_2d_tbl(st->hpf_tbl, > > + ARRAY_SIZE(st->hpf_tbl), > > + val, val2); > > + if (hpf_index < 0) > > + return hpf_index; > > + return adxl380_set_hpf(st, hpf_index); > > + case IIO_CHAN_INFO_SCALE: > > + range_index = adxl380_find_match_2d_tbl(st->chip_info->scale_tbl, > > + ARRAY_SIZE(st->chip_info->scale_tbl), > > + val, val2); > > + if (range_index < 0) > > + return range_index; > > + return adxl380_set_range(st, range_index); > > + default: > > + return -EINVAL; > > + } > > +} > > > +int adxl380_probe(struct device *dev, struct regmap *regmap, > > + const struct adxl380_chip_info *chip_info) > > +{ > > + struct iio_dev *indio_dev; > > + struct adxl380_state *st; > > + int ret; > > + > > + indio_dev = devm_iio_device_alloc(dev, sizeof(*st)); > > + if (!indio_dev) > > + return -ENOMEM; > > + > > + st = iio_priv(indio_dev); > > + > > + st->dev = dev; > > + st->regmap = regmap; > > + st->chip_info = chip_info; > > + > > + mutex_init(&st->lock); > > + > > + indio_dev->channels = adxl380_channels; > > + indio_dev->num_channels = ARRAY_SIZE(adxl380_channels); > > + indio_dev->name = chip_info->name; > > + indio_dev->info = &adxl380_info; > > + indio_dev->modes = INDIO_DIRECT_MODE; > > + > > + ret = devm_regulator_get_enable(dev, "vddio"); > > + if (ret) > > + return dev_err_probe(st->dev, ret, > > + "Failed to get vddio regulator\n"); > > + > > + ret = devm_regulator_get_enable(st->dev, "vsupply"); > > + if (ret) > > + return dev_err_probe(st->dev, ret, > > + "Failed to get vsupply regulator\n"); > > + > > + st->irq = fwnode_irq_get_byname(dev_fwnode(dev), "INT0"); > > + if (st->irq > 0) { > > + st->int_map[0] = ADXL380_INT0_MAP0_REG; > > + st->int_map[1] = ADXL380_INT0_MAP1_REG; > > + } else { > > + st->irq = fwnode_irq_get_byname(dev_fwnode(dev), "INT1"); > > + if (st->irq > 0) > > + return dev_err_probe(dev, -ENODEV, > > + "no interrupt name specified"); > > + st->int_map[0] = ADXL380_INT1_MAP0_REG; > > + st->int_map[1] = ADXL380_INT1_MAP1_REG; > > + } > > Would it make sense fo this interrupt-register setup to go into > "adxl380_config_irq()"? > > > + > > + ret = adxl380_setup(indio_dev); > > + if (ret) > > + return ret; > > + > > + ret = devm_iio_kfifo_buffer_setup_ext(st->dev, indio_dev, > > + &adxl380_buffer_ops, > > + adxl380_fifo_attributes); > > + if (ret) > > + return ret; > > + > > + return devm_iio_device_register(dev, indio_dev); > > +} ^ permalink raw reply [flat|nested] 7+ messages in thread
* RE: [PATCH v4 2/3] iio: accel: add ADXL380 driver 2024-07-03 7:06 ` Alexandru Ardelean 2024-07-07 16:31 ` Jonathan Cameron @ 2024-07-08 10:22 ` Miclaus, Antoniu 2024-07-08 16:09 ` Jonathan Cameron 1 sibling, 1 reply; 7+ messages in thread From: Miclaus, Antoniu @ 2024-07-08 10:22 UTC (permalink / raw) To: Alexandru-Aleodor Ardelean Cc: Gradinariu, Ramona, Lars-Peter Clausen, Hennerich, Michael, Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Jonathan Corbet, Jun Yan, Matti Vaittinen, Mario Limonciello, Mehdi Djait, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org > -----Original Message----- > From: Alexandru Ardelean <aardelean@baylibre.com> > Sent: Wednesday, July 3, 2024 10:06 AM > To: Miclaus, Antoniu <Antoniu.Miclaus@analog.com> > Cc: Gradinariu, Ramona <Ramona.Gradinariu@analog.com>; Lars-Peter > Clausen <lars@metafoo.de>; Hennerich, Michael > <Michael.Hennerich@analog.com>; Jonathan Cameron <jic23@kernel.org>; > Rob Herring <robh@kernel.org>; Krzysztof Kozlowski <krzk+dt@kernel.org>; > Conor Dooley <conor+dt@kernel.org>; Jonathan Corbet <corbet@lwn.net>; > Jun Yan <jerrysteve1101@gmail.com>; Matti Vaittinen > <mazziesaccount@gmail.com>; Mario Limonciello > <mario.limonciello@amd.com>; Mehdi Djait <mehdi.djait.k@gmail.com>; > linux-iio@vger.kernel.org; devicetree@vger.kernel.org; linux- > kernel@vger.kernel.org; linux-doc@vger.kernel.org > Subject: Re: [PATCH v4 2/3] iio: accel: add ADXL380 driver > > [External] > > On Mon, Jul 1, 2024 at 11:47 AM Antoniu Miclaus > <antoniu.miclaus@analog.com> wrote: > > > > The ADXL380/ADXL382 is a low noise density, low power, 3-axis > > accelerometer with selectable measurement ranges. The ADXL380 supports > > the +/-4 g, +/-8 g, and +/-16 g ranges, and the ADXL382 supports > > +/-15 g, +/-30 g and +/-60 g ranges. > > The ADXL380/ADXL382 offers industry leading noise, enabling precision > > applications with minimal calibration. The low noise, and low power > > ADXL380/ADXL382 enables accurate measurement in an environment with > > high vibration, heart sounds and audio. > > > > In addition to its low power consumption, the ADXL380/ADXL382 has many > > features to enable true system level performance. These include a > > built-in micropower temperature sensor, single / double / triple tap > > detection and a state machine to prevent a false triggering. In > > addition, the ADXL380/ADXL382 has provisions for external control of > > the sampling time and/or an external clock. > > > > Signed-off-by: Ramona Gradinariu <ramona.gradinariu@analog.com> > > Signed-off-by: Antoniu Miclaus <antoniu.miclaus@analog.com> > > --- > > changes in v4: > > - drop __aligned(IIO_DMA_MINALIGN); from tables and use it on fifo_buf > > - drop brackets around odr >> 1 and odr & 1 > > - wrap long line > > - drop comma on null terminator > > - fix odd indentation > > - drop extra space before > > > - add space before } on arrays where missing > > MAINTAINERS | 4 + > > drivers/iio/accel/Kconfig | 27 + > > drivers/iio/accel/Makefile | 3 + > > drivers/iio/accel/adxl380.c | 1908 > +++++++++++++++++++++++++++++++ > > drivers/iio/accel/adxl380.h | 26 + > > drivers/iio/accel/adxl380_i2c.c | 64 ++ > > drivers/iio/accel/adxl380_spi.c | 66 ++ > > 7 files changed, 2098 insertions(+) > > create mode 100644 drivers/iio/accel/adxl380.c > > create mode 100644 drivers/iio/accel/adxl380.h > > create mode 100644 drivers/iio/accel/adxl380_i2c.c > > create mode 100644 drivers/iio/accel/adxl380_spi.c > > > > diff --git a/MAINTAINERS b/MAINTAINERS > > index 1425182c85e2..67583f13da51 100644 > > --- a/MAINTAINERS > > +++ b/MAINTAINERS > > @@ -624,6 +624,10 @@ M: Antoniu Miclaus > <antoniu.miclaus@analog.com> > > S: Supported > > W: https://ez.analog.com/linux-software-drivers > > F: Documentation/devicetree/bindings/iio/accel/adi,adxl380.yaml > > +F: drivers/iio/accel/adxl380.c > > +F: drivers/iio/accel/adxl380.h > > +F: drivers/iio/accel/adxl380_i2c.c > > +F: drivers/iio/accel/adxl380_spi.c > > > > AF8133J THREE-AXIS MAGNETOMETER DRIVER > > M: Ondřej Jirman <megi@xff.cz> > > diff --git a/drivers/iio/accel/Kconfig b/drivers/iio/accel/Kconfig > > index c2da5066e9a7..6572ab447e14 100644 > > --- a/drivers/iio/accel/Kconfig > > +++ b/drivers/iio/accel/Kconfig > > @@ -177,6 +177,33 @@ config ADXL372_I2C > > To compile this driver as a module, choose M here: the > > module will be called adxl372_i2c. > > > > +config ADXL380 > > + tristate > > + select IIO_BUFFER > > + select IIO_TRIGGERED_BUFFER > > + > > +config ADXL380_SPI > > + tristate "Analog Devices ADXL380 3-Axis Accelerometer SPI Driver" > > + depends on SPI > > + select ADXL380 > > + select REGMAP_SPI > > + help > > + Say yes here to add support for the Analog Devices ADXL380 triaxial > > + acceleration sensor. > > + To compile this driver as a module, choose M here: the > > + module will be called adxl380_spi. > > + > > +config ADXL380_I2C > > + tristate "Analog Devices ADXL380 3-Axis Accelerometer I2C Driver" > > + depends on I2C > > + select ADXL380 > > + select REGMAP_I2C > > + help > > + Say yes here to add support for the Analog Devices ADXL380 triaxial > > + acceleration sensor. > > + To compile this driver as a module, choose M here: the > > + module will be called adxl380_i2c. > > + > > config BMA180 > > tristate "Bosch BMA023/BMA1x0/BMA250 3-Axis Accelerometer > Driver" > > depends on I2C && INPUT_BMA150=n > > diff --git a/drivers/iio/accel/Makefile b/drivers/iio/accel/Makefile > > index db90532ba24a..ca8569e25aba 100644 > > --- a/drivers/iio/accel/Makefile > > +++ b/drivers/iio/accel/Makefile > > @@ -21,6 +21,9 @@ obj-$(CONFIG_ADXL367_SPI) += adxl367_spi.o > > obj-$(CONFIG_ADXL372) += adxl372.o > > obj-$(CONFIG_ADXL372_I2C) += adxl372_i2c.o > > obj-$(CONFIG_ADXL372_SPI) += adxl372_spi.o > > +obj-$(CONFIG_ADXL380) += adxl380.o > > +obj-$(CONFIG_ADXL380_I2C) += adxl380_i2c.o > > +obj-$(CONFIG_ADXL380_SPI) += adxl380_spi.o > > obj-$(CONFIG_BMA180) += bma180.o > > obj-$(CONFIG_BMA220) += bma220_spi.o > > obj-$(CONFIG_BMA400) += bma400_core.o > > diff --git a/drivers/iio/accel/adxl380.c b/drivers/iio/accel/adxl380.c > > new file mode 100644 > > index 000000000000..d37f4d85cf84 > > --- /dev/null > > +++ b/drivers/iio/accel/adxl380.c > > @@ -0,0 +1,1908 @@ > > +// SPDX-License-Identifier: GPL-2.0+ > > +/* > > + * ADXL380 3-Axis Digital Accelerometer core driver > > + * > > + * Copyright 2024 Analog Devices Inc. > > + */ > > + > > +#include <linux/bitfield.h> > > +#include <linux/interrupt.h> > > +#include <linux/irq.h> > > +#include <linux/module.h> > > +#include <linux/property.h> > > +#include <linux/regmap.h> > > +#include <linux/units.h> > > + > > +#include <asm/unaligned.h> > > + > > +#include <linux/iio/buffer.h> > > +#include <linux/iio/events.h> > > +#include <linux/iio/iio.h> > > +#include <linux/iio/kfifo_buf.h> > > +#include <linux/iio/sysfs.h> > > + > > +#include <linux/regulator/consumer.h> > > + > > +#include "adxl380.h" > > + > > +#define ADXL380_ID_VAL 380 > > +#define ADXL382_ID_VAL 382 > > + > > +#define ADXL380_DEVID_AD_REG 0x00 > > +#define ADLX380_PART_ID_REG 0x02 > > + > > +#define ADXL380_X_DATA_H_REG 0x15 > > +#define ADXL380_Y_DATA_H_REG 0x17 > > +#define ADXL380_Z_DATA_H_REG 0x19 > > +#define ADXL380_T_DATA_H_REG 0x1B > > + > > +#define ADXL380_MISC_0_REG 0x20 > > +#define ADXL380_XL382_MSK BIT(7) > > + > > +#define ADXL380_MISC_1_REG 0x21 > > + > > +#define ADXL380_X_DSM_OFFSET_REG 0x4D > > + > > +#define ADXL380_ACT_INACT_CTL_REG 0x37 > > +#define ADXL380_INACT_EN_MSK BIT(2) > > +#define ADXL380_ACT_EN_MSK BIT(0) > > + > > +#define ADXL380_SNSR_AXIS_EN_REG 0x38 > > +#define ADXL380_ACT_INACT_AXIS_EN_MSK GENMASK(2, 0) > > + > > +#define ADXL380_THRESH_ACT_H_REG 0x39 > > +#define ADXL380_TIME_ACT_H_REG 0x3B > > +#define ADXL380_THRESH_INACT_H_REG 0x3E > > +#define ADXL380_TIME_INACT_H_REG 0x40 > > +#define ADXL380_THRESH_MAX GENMASK(12, 0) > > +#define ADXL380_TIME_MAX GENMASK(24, 0) > > + > > +#define ADXL380_FIFO_CONFIG_0_REG 0x30 > > +#define ADXL380_FIFO_SAMPLES_8_MSK BIT(0) > > +#define ADXL380_FIFO_MODE_MSK GENMASK(5, 4) > > + > > +#define ADXL380_FIFO_DISABLED 0 > > +#define ADXL380_FIFO_NORMAL 1 > > +#define ADXL380_FIFO_STREAMED 2 > > +#define ADXL380_FIFO_TRIGGERED 3 > > + > > +#define ADXL380_FIFO_CONFIG_1_REG 0x31 > > +#define ADXL380_FIFO_STATUS_0_REG 0x1E > > + > > +#define ADXL380_TAP_THRESH_REG 0x43 > > +#define ADXL380_TAP_DUR_REG 0x44 > > +#define ADXL380_TAP_LATENT_REG 0x45 > > +#define ADXL380_TAP_WINDOW_REG 0x46 > > +#define ADXL380_TAP_TIME_MAX GENMASK(7, 0) > > + > > +#define ADXL380_TAP_CFG_REG 0x47 > > +#define ADXL380_TAP_AXIS_MSK GENMASK(1, 0) > > + > > +#define ADXL380_TRIG_CFG_REG 0x49 > > +#define ADXL380_TRIG_CFG_DEC_2X_MSK BIT(7) > > +#define ADXL380_TRIG_CFG_SINC_RATE_MSK BIT(6) > > + > > +#define ADXL380_FILTER_REG 0x50 > > +#define ADXL380_FILTER_EQ_FILT_MSK BIT(6) > > +#define ADXL380_FILTER_LPF_MODE_MSK GENMASK(5, 4) > > +#define ADXL380_FILTER_HPF_PATH_MSK BIT(3) > > +#define ADXL380_FILTER_HPF_CORNER_MSK GENMASK(2, 0) > > + > > +#define ADXL380_OP_MODE_REG 0x26 > > +#define ADXL380_OP_MODE_RANGE_MSK GENMASK(7, 6) > > +#define ADXL380_OP_MODE_MSK GENMASK(3, 0) > > +#define ADXL380_OP_MODE_STANDBY 0 > > +#define ADXL380_OP_MODE_HEART_SOUND 1 > > +#define ADXL380_OP_MODE_ULP 2 > > +#define ADXL380_OP_MODE_VLP 3 > > +#define ADXL380_OP_MODE_LP 4 > > +#define ADXL380_OP_MODE_LP_ULP 6 > > +#define ADXL380_OP_MODE_LP_VLP 7 > > +#define ADXL380_OP_MODE_RBW 8 > > +#define ADXL380_OP_MODE_RBW_ULP 10 > > +#define ADXL380_OP_MODE_RBW_VLP 11 > > +#define ADXL380_OP_MODE_HP 12 > > +#define ADXL380_OP_MODE_HP_ULP 14 > > +#define ADXL380_OP_MODE_HP_VLP 15 > > + > > +#define ADXL380_OP_MODE_4G_RANGE 0 > > +#define ADXL382_OP_MODE_15G_RANGE 0 > > +#define ADXL380_OP_MODE_8G_RANGE 1 > > +#define ADXL382_OP_MODE_30G_RANGE 1 > > +#define ADXL380_OP_MODE_16G_RANGE 2 > > +#define ADXL382_OP_MODE_60G_RANGE 2 > > + > > +#define ADXL380_DIG_EN_REG 0x27 > > +#define ADXL380_CHAN_EN_MSK(chan) BIT(4 + (chan)) > > +#define ADXL380_FIFO_EN_MSK BIT(3) > > + > > +#define ADXL380_INT0_MAP0_REG 0x2B > > +#define ADXL380_INT1_MAP0_REG 0x2D > > +#define ADXL380_INT_MAP0_INACT_INT0_MSK BIT(6) > > +#define ADXL380_INT_MAP0_ACT_INT0_MSK BIT(5) > > +#define ADXL380_INT_MAP0_FIFO_WM_INT0_MSK BIT(3) > > + > > +#define ADXL380_INT0_MAP1_REG 0x2C > > +#define ADXL380_INT1_MAP1_REG 0x2E > > +#define ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK BIT(1) > > +#define ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK BIT(0) > > + > > +#define ADXL380_INT0_REG 0x5D > > +#define ADXL380_INT0_POL_MSK BIT(7) > > + > > +#define ADXL380_RESET_REG 0x2A > > +#define ADXL380_FIFO_DATA 0x1D > > + > > +#define ADXL380_DEVID_AD_VAL 0xAD > > +#define ADXL380_RESET_CODE 0x52 > > + > > +#define ADXL380_STATUS_0_REG 0x11 > > +#define ADXL380_STATUS_0_FIFO_FULL_MSK BIT(1) > > +#define ADXL380_STATUS_0_FIFO_WM_MSK BIT(3) > > + > > +#define ADXL380_STATUS_1_INACT_MSK BIT(6) > > +#define ADXL380_STATUS_1_ACT_MSK BIT(5) > > +#define ADXL380_STATUS_1_DOUBLE_TAP_MSK BIT(1) > > +#define ADXL380_STATUS_1_SINGLE_TAP_MSK BIT(0) > > + > > +#define ADXL380_FIFO_SAMPLES 315UL > > + > > +enum adxl380_channels { > > + ADXL380_ACCEL_X, > > + ADXL380_ACCEL_Y, > > + ADXL380_ACCEL_Z, > > + ADXL380_TEMP, > > + ADXL380_CH_NUM, > > nitpick: If ADXL380_CH_NUM is the number of channels, then a trailing > comma is not needed. > Fine to also leave it. > > > +}; > > + > > +enum adxl380_axis { > > + ADXL380_X_AXIS, > > + ADXL380_Y_AXIS, > > + ADXL380_Z_AXIS, > > +}; > > + > > +enum adxl380_activity_type { > > + ADXL380_ACTIVITY, > > + ADXL380_INACTIVITY, > > +}; > > + > > +enum adxl380_tap_type { > > + ADXL380_SINGLE_TAP, > > + ADXL380_DOUBLE_TAP, > > +}; > > + > > +enum adxl380_tap_time_type { > > + ADXL380_TAP_TIME_LATENT, > > + ADXL380_TAP_TIME_WINDOW, > > +}; > > + > > +static const int adxl380_range_scale_factor_tbl[] = { 1, 2, 4 }; > > + > > +const struct adxl380_chip_info adxl380_chip_info = { > > + .name = "adxl380", > > + .chip_id = ADXL380_ID_VAL, > > + .scale_tbl = { > > + [ADXL380_OP_MODE_4G_RANGE] = { 0, 1307226 }, > > + [ADXL380_OP_MODE_8G_RANGE] = { 0, 2615434 }, > > + [ADXL380_OP_MODE_16G_RANGE] = { 0, 5229886 }, > > + }, > > + .samp_freq_tbl = { 8000, 16000, 32000 }, > > + /* > > + * The datasheet defines an intercept of 470 LSB at 25 degC > > + * and a sensitivity of 10.2 LSB/C. > > + */ > > + .temp_offset = 25 * 102 / 10 - 470, > > + > > +}; > > +EXPORT_SYMBOL_NS_GPL(adxl380_chip_info, IIO_ADXL380); > > + > > +const struct adxl380_chip_info adxl382_chip_info = { > > + .name = "adxl382", > > + .chip_id = ADXL382_ID_VAL, > > + .scale_tbl = { > > + [ADXL382_OP_MODE_15G_RANGE] = { 0, 4903325 }, > > + [ADXL382_OP_MODE_30G_RANGE] = { 0, 9806650 }, > > + [ADXL382_OP_MODE_60G_RANGE] = { 0, 19613300 }, > > + }, > > + .samp_freq_tbl = { 16000, 32000, 64000 }, > > + /* > > + * The datasheet defines an intercept of 570 LSB at 25 degC > > + * and a sensitivity of 10.2 LSB/C. > > + */ > > + .temp_offset = 25 * 102 / 10 - 570, > > +}; > > +EXPORT_SYMBOL_NS_GPL(adxl382_chip_info, IIO_ADXL380); > > + > > +static const unsigned int adxl380_th_reg_high_addr[2] = { > > + [ADXL380_ACTIVITY] = ADXL380_THRESH_ACT_H_REG, > > + [ADXL380_INACTIVITY] = ADXL380_THRESH_INACT_H_REG, > > +}; > > + > > +static const unsigned int adxl380_time_reg_high_addr[2] = { > > + [ADXL380_ACTIVITY] = ADXL380_TIME_ACT_H_REG, > > + [ADXL380_INACTIVITY] = ADXL380_TIME_INACT_H_REG, > > +}; > > + > > +static const unsigned int adxl380_tap_time_reg[2] = { > > + [ADXL380_TAP_TIME_LATENT] = ADXL380_TAP_LATENT_REG, > > + [ADXL380_TAP_TIME_WINDOW] = ADXL380_TAP_WINDOW_REG, > > +}; > > + > > +struct adxl380_state { > > + struct regmap *regmap; > > + struct device *dev; > > + const struct adxl380_chip_info *chip_info; > > + /* > > + * Synchronize access to members of driver state, and ensure atomicity > > + * of consecutive regmap operations. > > + */ > > + struct mutex lock; > > + enum adxl380_axis tap_axis_en; > > + u8 range; > > + u8 odr; > > + u8 fifo_set_size; > > + u8 transf_buf[3]; > > + u16 watermark; > > + u32 act_time_ms; > > + u32 act_threshold; > > + u32 inact_time_ms; > > + u32 inact_threshold; > > + u32 tap_latent_us; > > + u32 tap_window_us; > > + u32 tap_duration_us; > > + u32 tap_threshold; > > + int irq; > > + int int_map[2]; > > + int lpf_tbl[4]; > > + int hpf_tbl[7][2]; > > + > > + __be16 fifo_buf[ADXL380_FIFO_SAMPLES] > __aligned(IIO_DMA_MINALIGN); > > +}; > > + > > +bool adxl380_readable_noinc_reg(struct device *dev, unsigned int reg) > > +{ > > + return reg == ADXL380_FIFO_DATA; > > +} > > +EXPORT_SYMBOL_NS_GPL(adxl380_readable_noinc_reg, IIO_ADXL380); > > + > > +static int adxl380_set_measure_en(struct adxl380_state *st, bool en) > > +{ > > + int ret; > > + unsigned int act_inact_ctl; > > + u8 op_mode = ADXL380_OP_MODE_STANDBY; > > + > > + if (en) { > > + ret = regmap_read(st->regmap, ADXL380_ACT_INACT_CTL_REG, > &act_inact_ctl); > > + if (ret) > > + return ret; > > + > > + /* Activity/ Inactivity detection available only in VLP/ULP mode */ > > + if (FIELD_GET(ADXL380_ACT_EN_MSK, act_inact_ctl) || > > + FIELD_GET(ADXL380_INACT_EN_MSK, act_inact_ctl)) > > + op_mode = ADXL380_OP_MODE_VLP; > > + else > > + op_mode = ADXL380_OP_MODE_HP; > > + } > > + > > + return regmap_update_bits(st->regmap, ADXL380_OP_MODE_REG, > > + ADXL380_OP_MODE_MSK, > > + FIELD_PREP(ADXL380_OP_MODE_MSK, op_mode)); > > +} > > + > > +static void adxl380_scale_act_inact_thresholds(struct adxl380_state *st, > > + u8 old_range, > > + u8 new_range) > > +{ > > + st->act_threshold = mult_frac(st->act_threshold, > > + adxl380_range_scale_factor_tbl[old_range], > > + adxl380_range_scale_factor_tbl[new_range]); > > + st->inact_threshold = mult_frac(st->inact_threshold, > > + adxl380_range_scale_factor_tbl[old_range], > > + adxl380_range_scale_factor_tbl[new_range]); > > +} > > + > > +static int adxl380_write_act_inact_threshold(struct adxl380_state *st, > > + enum adxl380_activity_type act, > > + unsigned int th) > > +{ > > + int ret; > > + u8 reg = adxl380_th_reg_high_addr[act]; > > + > > + if (th > ADXL380_THRESH_MAX) > > + return -EINVAL; > > + > > + ret = regmap_write(st->regmap, reg + 1, th & GENMASK(7, 0)); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, reg, GENMASK(2, 0), th >> 8); > > + if (ret) > > + return ret; > > + > > + if (act == ADXL380_ACTIVITY) > > + st->act_threshold = th; > > + else > > + st->inact_threshold = th; > > + > > + return 0; > > +} > > + > > +static int adxl380_set_act_inact_threshold(struct iio_dev *indio_dev, > > + enum adxl380_activity_type act, > > + u16 th) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_write_act_inact_threshold(st, act, th); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_set_tap_threshold_value(struct iio_dev *indio_dev, u8 > th) > > +{ > > + int ret; > > + struct adxl380_state *st = iio_priv(indio_dev); > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = regmap_write(st->regmap, ADXL380_TAP_THRESH_REG, th); > > + if (ret) > > + return ret; > > + > > + st->tap_threshold = th; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int _adxl380_write_tap_time_us(struct adxl380_state *st, > > + enum adxl380_tap_time_type tap_time_type, > > + u32 us) > > +{ > > + u8 reg = adxl380_tap_time_reg[tap_time_type]; > > + unsigned int reg_val; > > + int ret; > > + > > + /* scale factor for tap window is 1250us / LSB */ > > + reg_val = DIV_ROUND_CLOSEST(us, 1250); > > + if (reg_val > ADXL380_TAP_TIME_MAX) > > + reg_val = ADXL380_TAP_TIME_MAX; > > + > > + ret = regmap_write(st->regmap, reg, reg_val); > > + if (ret) > > + return ret; > > + > > + if (tap_time_type == ADXL380_TAP_TIME_WINDOW) > > + st->tap_window_us = us; > > + else > > + st->tap_latent_us = us; > > + > > + return 0; > > +} > > + > > +static int adxl380_write_tap_time_us(struct adxl380_state *st, > > + enum adxl380_tap_time_type tap_time_type, u32 us) > > +{ > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = _adxl380_write_tap_time_us(st, tap_time_type, us); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_write_tap_dur_us(struct iio_dev *indio_dev, u32 us) > > +{ > > + int ret; > > + unsigned int reg_val; > > + struct adxl380_state *st = iio_priv(indio_dev); > > + > > + /* 625us per code is the scale factor of TAP_DUR register */ > > + reg_val = DIV_ROUND_CLOSEST(us, 625); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = regmap_write(st->regmap, ADXL380_TAP_DUR_REG, reg_val); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_read_chn(struct adxl380_state *st, u8 addr) > > +{ > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = regmap_bulk_read(st->regmap, addr, &st->transf_buf, 2); > > + if (ret) > > + return ret; > > + > > + return get_unaligned_be16(st->transf_buf); > > +} > > + > > +static int adxl380_get_odr(struct adxl380_state *st, int *odr) > > +{ > > + int ret; > > + unsigned int trig_cfg, odr_idx; > > + > > + ret = regmap_read(st->regmap, ADXL380_TRIG_CFG_REG, &trig_cfg); > > + if (ret) > > + return ret; > > + > > + odr_idx = (FIELD_GET(ADXL380_TRIG_CFG_SINC_RATE_MSK, trig_cfg) > << 1) | > > + (FIELD_GET(ADXL380_TRIG_CFG_DEC_2X_MSK, trig_cfg) & 1); > > + > > + *odr = st->chip_info->samp_freq_tbl[odr_idx]; > > + > > + return 0; > > +} > > + > > +static const int adxl380_lpf_div[] = { > > + 1, 4, 8, 16, > > +}; > > + > > +static int adxl380_fill_lpf_tbl(struct adxl380_state *st) > > +{ > > + int ret, i; > > + int odr; > > + > > + ret = adxl380_get_odr(st, &odr); > > + if (ret) > > + return ret; > > + > > + for (i = 0; i < ARRAY_SIZE(st->lpf_tbl); i++) > > + st->lpf_tbl[i] = DIV_ROUND_CLOSEST(odr, adxl380_lpf_div[i]); > > + > > + return 0; > > +} > > + > > +static const int adxl380_hpf_mul[] = { > > + 0, 247000, 62084, 15545, 3862, 954, 238, > > +}; > > + > > +static int adxl380_fill_hpf_tbl(struct adxl380_state *st) > > +{ > > + int i, ret, odr_hz; > > + u32 multiplier; > > + u64 div, rem, odr; > > + > > + ret = adxl380_get_odr(st, &odr_hz); > > + if (ret) > > + return ret; > > + > > + for (i = 0; i < ARRAY_SIZE(adxl380_hpf_mul); i++) { > > + odr = mul_u64_u32_shr(odr_hz, MEGA, 0); > > + multiplier = adxl380_hpf_mul[i]; > > + div = div64_u64_rem(mul_u64_u32_shr(odr, multiplier, 0), > > + TERA * 100, &rem); > > + > > + st->hpf_tbl[i][0] = div; > > + st->hpf_tbl[i][1] = div_u64(rem, MEGA * 100); > > + } > > + > > + return 0; > > +} > > + > > +static int adxl380_set_odr(struct adxl380_state *st, u8 odr) > > +{ > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_TRIG_CFG_REG, > > + ADXL380_TRIG_CFG_DEC_2X_MSK, > > + FIELD_PREP(ADXL380_TRIG_CFG_DEC_2X_MSK, odr & 1)); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_TRIG_CFG_REG, > > + ADXL380_TRIG_CFG_SINC_RATE_MSK, > > + FIELD_PREP(ADXL380_TRIG_CFG_SINC_RATE_MSK, odr >> > 1)); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_set_measure_en(st, true); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_fill_lpf_tbl(st); > > + if (ret) > > + return ret; > > + > > + return adxl380_fill_hpf_tbl(st); > > +} > > + > > +static int adxl380_find_match_1d_tbl(const int *array, unsigned int size, > > + int val) > > I think this was copied from adxl372. > But, I am wondering (at a later point in time), if it makes sense to > use (or create) a common utility function for this. > I haven't looked yet, if there is one. > > > +{ > > + int i; > > + > > + for (i = 0; i < size; i++) { > > + if (val == array[i]) > > + return i; > > + } > > + > > + return size - 1; > > +} > > + > > +static int adxl380_find_match_2d_tbl(const int (*freq_tbl)[2], int n, int val, > int val2) > > +{ > > + int i; > > + > > + for (i = 0; i < n; i++) { > > + if (freq_tbl[i][0] == val && freq_tbl[i][1] == val2) > > + return i; > > + } > > + > > + return -EINVAL; > > +} > > + > > +static int adxl380_get_lpf(struct adxl380_state *st, int *lpf) > > +{ > > + int ret; > > + unsigned int trig_cfg, lpf_idx; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = regmap_read(st->regmap, ADXL380_FILTER_REG, &trig_cfg); > > + if (ret) > > + return ret; > > + > > + lpf_idx = FIELD_GET(ADXL380_FILTER_LPF_MODE_MSK, trig_cfg); > > + > > + *lpf = st->lpf_tbl[lpf_idx]; > > + > > + return 0; > > +} > > + > > +static int adxl380_set_lpf(struct adxl380_state *st, u8 lpf) > > +{ > > + int ret; > > + u8 eq_bypass = 0; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + if (lpf) > > + eq_bypass = 1; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, > > + ADXL380_FILTER_EQ_FILT_MSK, > > + FIELD_PREP(ADXL380_FILTER_EQ_FILT_MSK, eq_bypass)); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, > > + ADXL380_FILTER_LPF_MODE_MSK, > > + FIELD_PREP(ADXL380_FILTER_LPF_MODE_MSK, lpf)); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_get_hpf(struct adxl380_state *st, int *hpf_int, int > *hpf_frac) > > +{ > > + int ret; > > + unsigned int trig_cfg, hpf_idx; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = regmap_read(st->regmap, ADXL380_FILTER_REG, &trig_cfg); > > + if (ret) > > + return ret; > > + > > + hpf_idx = FIELD_GET(ADXL380_FILTER_HPF_CORNER_MSK, trig_cfg); > > + > > + *hpf_int = st->hpf_tbl[hpf_idx][0]; > > + *hpf_frac = st->hpf_tbl[hpf_idx][1]; > > + > > + return 0; > > +} > > + > > +static int adxl380_set_hpf(struct adxl380_state *st, u8 hpf) > > +{ > > + int ret; > > + u8 hpf_path = 0; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + if (hpf) > > + hpf_path = 1; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, > > + ADXL380_FILTER_HPF_PATH_MSK, > > + FIELD_PREP(ADXL380_FILTER_HPF_PATH_MSK, > hpf_path)); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_FILTER_REG, > > + ADXL380_FILTER_HPF_CORNER_MSK, > > + FIELD_PREP(ADXL380_FILTER_HPF_CORNER_MSK, hpf)); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int _adxl380_set_act_inact_time_ms(struct adxl380_state *st, > > + enum adxl380_activity_type act, > > + u32 ms) > > +{ > > + u8 reg = adxl380_time_reg_high_addr[act]; > > + unsigned int reg_val; > > + int ret; > > + > > + /* 500us per code is the scale factor of TIME_ACT / TIME_INACT > registers */ > > + reg_val = min(DIV_ROUND_CLOSEST(ms * 1000, 500), > ADXL380_TIME_MAX); > > + > > + put_unaligned_be24(reg_val, &st->transf_buf[0]); > > + > > + ret = regmap_bulk_write(st->regmap, reg, st->transf_buf, sizeof(st- > >transf_buf)); > > + if (ret) > > + return ret; > > + > > + if (act == ADXL380_ACTIVITY) > > + st->act_time_ms = ms; > > + else > > + st->inact_time_ms = ms; > > + > > + return 0; > > +} > > + > > +static int adxl380_set_act_inact_time_ms(struct adxl380_state *st, > > + enum adxl380_activity_type act, > > + u32 ms) > > +{ > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = _adxl380_set_act_inact_time_ms(st, act, ms); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_set_range(struct adxl380_state *st, u8 range) > > +{ > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_OP_MODE_REG, > > + ADXL380_OP_MODE_RANGE_MSK, > > + FIELD_PREP(ADXL380_OP_MODE_RANGE_MSK, range)); > > + > > + if (ret) > > + return ret; > > + > > + adxl380_scale_act_inact_thresholds(st, st->range, range); > > + > > + /* Activity thresholds depend on range */ > > + ret = adxl380_write_act_inact_threshold(st, ADXL380_ACTIVITY, > > + st->act_threshold); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_write_act_inact_threshold(st, ADXL380_INACTIVITY, > > + st->inact_threshold); > > + if (ret) > > + return ret; > > + > > + st->range = range; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_write_act_inact_en(struct adxl380_state *st, > > + enum adxl380_activity_type type, > > + bool en) > > +{ > > + if (type == ADXL380_ACTIVITY) > > + return regmap_update_bits(st->regmap, > ADXL380_ACT_INACT_CTL_REG, > > + ADXL380_ACT_EN_MSK, > > + FIELD_PREP(ADXL380_ACT_EN_MSK, en)); > > + > > + return regmap_update_bits(st->regmap, > ADXL380_ACT_INACT_CTL_REG, > > + ADXL380_INACT_EN_MSK, > > + FIELD_PREP(ADXL380_INACT_EN_MSK, en)); > > +} > > + > > +static int adxl380_read_act_inact_int(struct adxl380_state *st, > > + enum adxl380_activity_type type, > > + bool *en) > > +{ > > + int ret; > > + unsigned int reg_val; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = regmap_read(st->regmap, st->int_map[0], ®_val); > > + if (ret) > > + return ret; > > + > > + if (type == ADXL380_ACTIVITY) > > + *en = FIELD_GET(ADXL380_INT_MAP0_ACT_INT0_MSK, reg_val); > > + else > > + *en = FIELD_GET(ADXL380_INT_MAP0_INACT_INT0_MSK, reg_val); > > + > > + return 0; > > +} > > + > > +static int adxl380_write_act_inact_int(struct adxl380_state *st, > > + enum adxl380_activity_type act, > > + bool en) > > +{ > > + if (act == ADXL380_ACTIVITY) > > + return regmap_update_bits(st->regmap, st->int_map[0], > > + ADXL380_INT_MAP0_ACT_INT0_MSK, > > + FIELD_PREP(ADXL380_INT_MAP0_ACT_INT0_MSK, > en)); > > + > > + return regmap_update_bits(st->regmap, st->int_map[0], > > + ADXL380_INT_MAP0_INACT_INT0_MSK, > > + FIELD_PREP(ADXL380_INT_MAP0_INACT_INT0_MSK, > en)); > > +} > > + > > +static int adxl380_act_inact_config(struct adxl380_state *st, > > + enum adxl380_activity_type type, > > + bool en) > > +{ > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_write_act_inact_en(st, type, en); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_write_act_inact_int(st, type, en); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_write_tap_axis(struct adxl380_state *st, > > + enum adxl380_axis axis) > > +{ > > + int ret; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_TAP_CFG_REG, > > + ADXL380_TAP_AXIS_MSK, > > + FIELD_PREP(ADXL380_TAP_AXIS_MSK, axis)); > > + > > + if (ret) > > + return ret; > > + > > + st->tap_axis_en = axis; > > + > > + return 0; > > +} > > + > > +static int adxl380_read_tap_int(struct adxl380_state *st, enum > adxl380_tap_type type, bool *en) > > +{ > > + int ret; > > + unsigned int reg_val; > > + > > + ret = regmap_read(st->regmap, st->int_map[1], ®_val); > > + if (ret) > > + return ret; > > + > > + if (type == ADXL380_SINGLE_TAP) > > + *en = FIELD_GET(ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK, > reg_val); > > + else > > + *en = FIELD_GET(ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK, > reg_val); > > + > > + return 0; > > +} > > + > > +static int adxl380_write_tap_int(struct adxl380_state *st, enum > adxl380_tap_type type, bool en) > > +{ > > + if (type == ADXL380_SINGLE_TAP) > > + return regmap_update_bits(st->regmap, st->int_map[1], > > + ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK, > > + > FIELD_PREP(ADXL380_INT_MAP1_SINGLE_TAP_INT0_MSK, en)); > > + > > + return regmap_update_bits(st->regmap, st->int_map[1], > > + ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK, > > + > FIELD_PREP(ADXL380_INT_MAP1_DOUBLE_TAP_INT0_MSK, en)); > > +} > > + > > +static int adxl380_tap_config(struct adxl380_state *st, > > + enum adxl380_axis axis, > > + enum adxl380_tap_type type, > > + bool en) > > +{ > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_write_tap_axis(st, axis); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_write_tap_int(st, type, en); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_set_fifo_samples(struct adxl380_state *st) > > +{ > > + int ret; > > + u16 fifo_samples = st->watermark * st->fifo_set_size; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_FIFO_CONFIG_0_REG, > > + ADXL380_FIFO_SAMPLES_8_MSK, > > + FIELD_PREP(ADXL380_FIFO_SAMPLES_8_MSK, > > + (fifo_samples & BIT(8)))); > > + if (ret) > > + return ret; > > + > > + return regmap_write(st->regmap, ADXL380_FIFO_CONFIG_1_REG, > > + fifo_samples & 0xFF); > > +} > > + > > +static int adxl380_get_status(struct adxl380_state *st, u8 *status0, u8 > *status1) > > +{ > > + int ret; > > + > > + /* STATUS0, STATUS1 are adjacent regs */ > > + ret = regmap_bulk_read(st->regmap, ADXL380_STATUS_0_REG, > > + &st->transf_buf, 2); > > + if (ret) > > + return ret; > > + > > + *status0 = st->transf_buf[0]; > > + *status1 = st->transf_buf[1]; > > + > > + return 0; > > +} > > + > > +static int adxl380_get_fifo_entries(struct adxl380_state *st, u16 > *fifo_entries) > > +{ > > + int ret; > > + > > + ret = regmap_bulk_read(st->regmap, ADXL380_FIFO_STATUS_0_REG, > > + &st->transf_buf, 2); > > + if (ret) > > + return ret; > > + > > + *fifo_entries = st->transf_buf[0] | ((BIT(0) & st->transf_buf[1]) << 8); > > + > > + return 0; > > +} > > + > > +static void adxl380_push_event(struct iio_dev *indio_dev, s64 timestamp, > > + u8 status1) > > +{ > > + if (FIELD_GET(ADXL380_STATUS_1_ACT_MSK, status1)) > > + iio_push_event(indio_dev, > > + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, > IIO_MOD_X_OR_Y_OR_Z, > > + IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), > > + timestamp); > > + > > + if (FIELD_GET(ADXL380_STATUS_1_INACT_MSK, status1)) > > + iio_push_event(indio_dev, > > + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, > IIO_MOD_X_OR_Y_OR_Z, > > + IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING), > > + timestamp); > > + if (FIELD_GET(ADXL380_STATUS_1_SINGLE_TAP_MSK, status1)) > > + iio_push_event(indio_dev, > > + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, > IIO_MOD_X_OR_Y_OR_Z, > > + IIO_EV_TYPE_GESTURE, IIO_EV_DIR_SINGLETAP), > > + timestamp); > > + > > + if (FIELD_GET(ADXL380_STATUS_1_DOUBLE_TAP_MSK, status1)) > > + iio_push_event(indio_dev, > > + IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, > IIO_MOD_X_OR_Y_OR_Z, > > + IIO_EV_TYPE_GESTURE, IIO_EV_DIR_DOUBLETAP), > > + timestamp); > > +} > > + > > +static irqreturn_t adxl380_irq_handler(int irq, void *p) > > +{ > > + struct iio_dev *indio_dev = p; > > + struct adxl380_state *st = iio_priv(indio_dev); > > + u8 status0, status1; > > + u16 fifo_entries; > > + int i; > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_get_status(st, &status0, &status1); > > + if (ret) > > + return IRQ_HANDLED; > > + > > + adxl380_push_event(indio_dev, iio_get_time_ns(indio_dev), status1); > > + > > + if (!FIELD_GET(ADXL380_STATUS_0_FIFO_WM_MSK, status0)) > > + return IRQ_HANDLED; > > + > > + ret = adxl380_get_fifo_entries(st, &fifo_entries); > > + if (ret) > > + return IRQ_HANDLED; > > + > > + for (i = 0; i < fifo_entries; i += st->fifo_set_size) { > > + ret = regmap_noinc_read(st->regmap, ADXL380_FIFO_DATA, > > + &st->fifo_buf[i], > > + 2 * st->fifo_set_size); > > + if (ret) > > + return IRQ_HANDLED; > > + iio_push_to_buffers(indio_dev, &st->fifo_buf[i]); > > + } > > + > > + return IRQ_HANDLED; > > +} > > + > > +static int adxl380_write_calibbias_value(struct adxl380_state *st, > > + unsigned long chan_addr, > > + s8 calibbias) > > +{ > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = regmap_write(st->regmap, ADXL380_X_DSM_OFFSET_REG + > chan_addr, calibbias); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_read_calibbias_value(struct adxl380_state *st, > > + unsigned long chan_addr, > > + int *calibbias) > > +{ > > + int ret; > > + unsigned int reg_val; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = regmap_read(st->regmap, ADXL380_X_DSM_OFFSET_REG + > chan_addr, ®_val); > > + if (ret) > > + return ret; > > + > > + *calibbias = sign_extend32(reg_val, 7); > > + > > + return 0; > > +} > > + > > +static ssize_t hwfifo_watermark_min_show(struct device *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + return sysfs_emit(buf, "1\n"); > > +} > > + > > +static ssize_t hwfifo_watermark_max_show(struct device *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + return sysfs_emit(buf, "%lu\n", ADXL380_FIFO_SAMPLES); > > +} > > + > > +static ssize_t adxl380_get_fifo_watermark(struct device *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + struct iio_dev *indio_dev = dev_to_iio_dev(dev); > > + struct adxl380_state *st = iio_priv(indio_dev); > > + > > + return sysfs_emit(buf, "%d\n", st->watermark); > > +} > > + > > +static ssize_t adxl380_get_fifo_enabled(struct device *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + struct iio_dev *indio_dev = dev_to_iio_dev(dev); > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int ret; > > + unsigned int reg_val; > > + > > + ret = regmap_read(st->regmap, ADXL380_DIG_EN_REG, ®_val); > > + if (ret) > > + return ret; > > + > > + return sysfs_emit(buf, "%lu\n", > > + FIELD_GET(ADXL380_FIFO_EN_MSK, reg_val)); > > +} > > + > > +static IIO_DEVICE_ATTR_RO(hwfifo_watermark_min, 0); > > +static IIO_DEVICE_ATTR_RO(hwfifo_watermark_max, 0); > > +static IIO_DEVICE_ATTR(hwfifo_watermark, 0444, > > + adxl380_get_fifo_watermark, NULL, 0); > > +static IIO_DEVICE_ATTR(hwfifo_enabled, 0444, > > + adxl380_get_fifo_enabled, NULL, 0); > > + > > +static const struct iio_dev_attr *adxl380_fifo_attributes[] = { > > + &iio_dev_attr_hwfifo_watermark_min, > > + &iio_dev_attr_hwfifo_watermark_max, > > + &iio_dev_attr_hwfifo_watermark, > > + &iio_dev_attr_hwfifo_enabled, > > + NULL > > +}; > > + > > +static int adxl380_buffer_postenable(struct iio_dev *indio_dev) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int i; > > + int ret; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, > > + st->int_map[0], > > + ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, > > + FIELD_PREP(ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, > 1)); > > + if (ret) > > + return ret; > > + > > + for_each_clear_bit(i, indio_dev->active_scan_mask, > ADXL380_CH_NUM) { > > Would this need to be?: > for_each_set_bit(i, indio_dev->active_scan_mask, indio_dev->masklength) > > Or, is the logic intended to go over the cleared bits here? > > Depending on what's needed here, this could make use of > "iio_for_each_active_channel()" later. This logic is intended. By default all channels are enabled for single raw readings (see adxl380_setup() function). For the buffer readings channels that are not intended to be used are disabled. > > > > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, > > + ADXL380_CHAN_EN_MSK(i), > > + 0 << (4 + i)); > > + if (ret) > > + return ret; > > + } > > + > > + st->fifo_set_size = bitmap_weight(indio_dev->active_scan_mask, > > + indio_dev->masklength); > > Depending on Nuno's series (and if that gets accepted first), this > might need to use the new iio_get_masklength() wrapper. > That's not a reason against this going in first though. > > > + > > + if ((st->watermark * st->fifo_set_size) > ADXL380_FIFO_SAMPLES) > > + st->watermark = (ADXL380_FIFO_SAMPLES / st->fifo_set_size); > > + > > + ret = adxl380_set_fifo_samples(st); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, > ADXL380_FIFO_EN_MSK, > > + FIELD_PREP(ADXL380_FIFO_EN_MSK, 1)); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static int adxl380_buffer_predisable(struct iio_dev *indio_dev) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int ret, i; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = adxl380_set_measure_en(st, false); > > + if (ret) > > + return ret; > > + > > + ret = regmap_update_bits(st->regmap, > > + st->int_map[0], > > + ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, > > + FIELD_PREP(ADXL380_INT_MAP0_FIFO_WM_INT0_MSK, > 0)); > > + if (ret) > > + return ret; > > + > > + for (i = 0; i < indio_dev->num_channels; i++) { > > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, > > + ADXL380_CHAN_EN_MSK(i), > > + 1 << (4 + i)); > > + if (ret) > > + return ret; > > + } > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, > ADXL380_FIFO_EN_MSK, > > + FIELD_PREP(ADXL380_FIFO_EN_MSK, 0)); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +static const struct iio_buffer_setup_ops adxl380_buffer_ops = { > > + .postenable = adxl380_buffer_postenable, > > + .predisable = adxl380_buffer_predisable, > > +}; > > + > > +static int adxl380_read_raw(struct iio_dev *indio_dev, > > + struct iio_chan_spec const *chan, > > + int *val, int *val2, long info) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int ret; > > + > > + switch (info) { > > + case IIO_CHAN_INFO_RAW: > > + ret = iio_device_claim_direct_mode(indio_dev); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_read_chn(st, chan->address); > > + if (ret) > > + return ret; > > + > > + iio_device_release_direct_mode(indio_dev); > > + > > + *val = sign_extend32(ret >> chan->scan_type.shift, > > + chan->scan_type.realbits - 1); > > + return IIO_VAL_INT; > > + case IIO_CHAN_INFO_SCALE: > > + switch (chan->type) { > > + case IIO_ACCEL: > > + scoped_guard(mutex, &st->lock) { > > + *val = st->chip_info->scale_tbl[st->range][0]; > > + *val2 = st->chip_info->scale_tbl[st->range][1]; > > + } > > + return IIO_VAL_INT_PLUS_NANO; > > + case IIO_TEMP: > > + /* 10.2 LSB / Degree Celsius */ > > + *val = 10000; > > + *val2 = 102; > > + return IIO_VAL_FRACTIONAL; > > + default: > > + return -EINVAL; > > + } > > + case IIO_CHAN_INFO_OFFSET: > > + switch (chan->type) { > > + case IIO_TEMP: > > + *val = st->chip_info->temp_offset; > > + return IIO_VAL_INT; > > + default: > > + return -EINVAL; > > + } > > + case IIO_CHAN_INFO_CALIBBIAS: > > + switch (chan->type) { > > + case IIO_ACCEL: > > + ret = adxl380_read_calibbias_value(st, chan->scan_index, val); > > + if (ret) > > + return ret; > > + return IIO_VAL_INT; > > + default: > > + return -EINVAL; > > + } > > + case IIO_CHAN_INFO_SAMP_FREQ: > > + ret = adxl380_get_odr(st, val); > > + if (ret) > > + return ret; > > + return IIO_VAL_INT; > > + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: > > + ret = adxl380_get_lpf(st, val); > > + if (ret) > > + return ret; > > + return IIO_VAL_INT; > > + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: > > + ret = adxl380_get_hpf(st, val, val2); > > + if (ret) > > + return ret; > > + return IIO_VAL_INT_PLUS_MICRO; > > + } > > + > > + return -EINVAL; > > +} > > + > > +static int adxl380_read_avail(struct iio_dev *indio_dev, > > + struct iio_chan_spec const *chan, > > + const int **vals, int *type, int *length, > > + long mask) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + > > + if (chan->type != IIO_ACCEL) > > + return -EINVAL; > > + > > + switch (mask) { > > + case IIO_CHAN_INFO_SCALE: > > + *vals = (const int *)st->chip_info->scale_tbl; > > + *type = IIO_VAL_INT_PLUS_NANO; > > + *length = ARRAY_SIZE(st->chip_info->scale_tbl) * 2; > > + return IIO_AVAIL_LIST; > > + case IIO_CHAN_INFO_SAMP_FREQ: > > + *vals = (const int *)st->chip_info->samp_freq_tbl; > > + *type = IIO_VAL_INT; > > + *length = ARRAY_SIZE(st->chip_info->samp_freq_tbl); > > + return IIO_AVAIL_LIST; > > + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: > > + *vals = (const int *)st->lpf_tbl; > > + *type = IIO_VAL_INT; > > + *length = ARRAY_SIZE(st->lpf_tbl); > > + return IIO_AVAIL_LIST; > > + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: > > + *vals = (const int *)st->hpf_tbl; > > + *type = IIO_VAL_INT_PLUS_MICRO; > > + /* Values are stored in a 2D matrix */ > > + *length = ARRAY_SIZE(st->hpf_tbl) * 2; > > + return IIO_AVAIL_LIST; > > + default: > > + return -EINVAL; > > + } > > +} > > + > > +static int adxl380_write_raw(struct iio_dev *indio_dev, > > + struct iio_chan_spec const *chan, > > + int val, int val2, long info) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int odr_index, lpf_index, hpf_index, range_index; > > + > > + switch (info) { > > + case IIO_CHAN_INFO_SAMP_FREQ: > > + odr_index = adxl380_find_match_1d_tbl(st->chip_info- > >samp_freq_tbl, > > + ARRAY_SIZE(st->chip_info->samp_freq_tbl), > > + val); > > + return adxl380_set_odr(st, odr_index); > > + case IIO_CHAN_INFO_CALIBBIAS: > > + return adxl380_write_calibbias_value(st, chan->scan_index, val); > > + case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: > > + lpf_index = adxl380_find_match_1d_tbl(st->lpf_tbl, > > + ARRAY_SIZE(st->lpf_tbl), > > + val); > > + if (lpf_index < 0) > > + return lpf_index; > > The way I see adxl380_find_match_1d_tbl(), it will never return negative. > > > + return adxl380_set_lpf(st, lpf_index); > > + case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: > > + hpf_index = adxl380_find_match_2d_tbl(st->hpf_tbl, > > + ARRAY_SIZE(st->hpf_tbl), > > + val, val2); > > + if (hpf_index < 0) > > + return hpf_index; > > + return adxl380_set_hpf(st, hpf_index); > > + case IIO_CHAN_INFO_SCALE: > > + range_index = adxl380_find_match_2d_tbl(st->chip_info->scale_tbl, > > + ARRAY_SIZE(st->chip_info->scale_tbl), > > + val, val2); > > + if (range_index < 0) > > + return range_index; > > + return adxl380_set_range(st, range_index); > > + default: > > + return -EINVAL; > > + } > > +} > > + > > +static int adxl380_write_raw_get_fmt(struct iio_dev *indio_dev, > > + struct iio_chan_spec const *chan, > > + long info) > > +{ > > + switch (info) { > > + case IIO_CHAN_INFO_SCALE: > > + if (chan->type != IIO_ACCEL) > > + return -EINVAL; > > + > > + return IIO_VAL_INT_PLUS_NANO; > > + default: > > + return IIO_VAL_INT_PLUS_MICRO; > > + } > > +} > > + > > +static int adxl380_read_event_config(struct iio_dev *indio_dev, > > + const struct iio_chan_spec *chan, > > + enum iio_event_type type, > > + enum iio_event_direction dir) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int ret; > > + bool int_en; > > + bool tap_axis_en = false; > > + > > + switch (chan->channel2) { > > + case IIO_MOD_X: > > + tap_axis_en = st->tap_axis_en == ADXL380_X_AXIS; > > + break; > > + case IIO_MOD_Y: > > + tap_axis_en = st->tap_axis_en == ADXL380_Y_AXIS; > > + break; > > + case IIO_MOD_Z: > > + tap_axis_en = st->tap_axis_en == ADXL380_Z_AXIS; > > + break; > > + default: > > + return -EINVAL; > > + } > > + > > + switch (dir) { > > + case IIO_EV_DIR_RISING: > > + ret = adxl380_read_act_inact_int(st, ADXL380_ACTIVITY, &int_en); > > + if (ret) > > + return ret; > > + return int_en; > > + case IIO_EV_DIR_FALLING: > > + ret = adxl380_read_act_inact_int(st, ADXL380_INACTIVITY, > &int_en); > > + if (ret) > > + return ret; > > + return int_en; > > + case IIO_EV_DIR_SINGLETAP: > > + ret = adxl380_read_tap_int(st, ADXL380_SINGLE_TAP, &int_en); > > + if (ret) > > + return ret; > > + return int_en && tap_axis_en; > > + case IIO_EV_DIR_DOUBLETAP: > > + ret = adxl380_read_tap_int(st, ADXL380_DOUBLE_TAP, &int_en); > > + if (ret) > > + return ret; > > + return int_en && tap_axis_en; > > + default: > > + return -EINVAL; > > + } > > +} > > + > > +static int adxl380_write_event_config(struct iio_dev *indio_dev, > > + const struct iio_chan_spec *chan, > > + enum iio_event_type type, > > + enum iio_event_direction dir, > > + int state) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + enum adxl380_axis axis; > > + > > + switch (chan->channel2) { > > + case IIO_MOD_X: > > + axis = ADXL380_X_AXIS; > > + break; > > + case IIO_MOD_Y: > > + axis = ADXL380_Y_AXIS; > > + break; > > + case IIO_MOD_Z: > > + axis = ADXL380_Z_AXIS; > > + break; > > + default: > > + return -EINVAL; > > + } > > + > > + switch (dir) { > > + case IIO_EV_DIR_RISING: > > + return adxl380_act_inact_config(st, ADXL380_ACTIVITY, state); > > + case IIO_EV_DIR_FALLING: > > + return adxl380_act_inact_config(st, ADXL380_INACTIVITY, state); > > + case IIO_EV_DIR_SINGLETAP: > > + return adxl380_tap_config(st, axis, ADXL380_SINGLE_TAP, state); > > + case IIO_EV_DIR_DOUBLETAP: > > + return adxl380_tap_config(st, axis, ADXL380_DOUBLE_TAP, state); > > + default: > > + return -EINVAL; > > + } > > +} > > + > > +static int adxl380_read_event_value(struct iio_dev *indio_dev, > > + const struct iio_chan_spec *chan, > > + enum iio_event_type type, > > + enum iio_event_direction dir, > > + enum iio_event_info info, > > + int *val, int *val2) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + > > + guard(mutex)(&st->lock); > > + > > + switch (type) { > > + case IIO_EV_TYPE_THRESH: > > + switch (info) { > > + case IIO_EV_INFO_VALUE: { > > + switch (dir) { > > + case IIO_EV_DIR_RISING: > > + *val = st->act_threshold; > > + return IIO_VAL_INT; > > + case IIO_EV_DIR_FALLING: > > + *val = st->inact_threshold; > > + return IIO_VAL_INT; > > + default: > > + return -EINVAL; > > + } > > + } > > + case IIO_EV_INFO_PERIOD: > > + switch (dir) { > > + case IIO_EV_DIR_RISING: > > + *val = st->act_time_ms; > > + *val2 = 1000; > > + return IIO_VAL_FRACTIONAL; > > + case IIO_EV_DIR_FALLING: > > + *val = st->inact_time_ms; > > + *val2 = 1000; > > + return IIO_VAL_FRACTIONAL; > > + default: > > + return -EINVAL; > > + } > > + default: > > + return -EINVAL; > > + } > > + case IIO_EV_TYPE_GESTURE: > > + switch (info) { > > + case IIO_EV_INFO_VALUE: > > + *val = st->tap_threshold; > > + return IIO_VAL_INT; > > + case IIO_EV_INFO_RESET_TIMEOUT: > > + *val = st->tap_window_us; > > + *val2 = 1000000; > > + return IIO_VAL_FRACTIONAL; > > + case IIO_EV_INFO_TAP2_MIN_DELAY: > > + *val = st->tap_latent_us; > > + *val2 = 1000000; > > + return IIO_VAL_FRACTIONAL; > > + default: > > + return -EINVAL; > > + } > > + default: > > + return -EINVAL; > > + } > > +} > > + > > +static int adxl380_write_event_value(struct iio_dev *indio_dev, > > + const struct iio_chan_spec *chan, > > + enum iio_event_type type, enum iio_event_direction dir, > > + enum iio_event_info info, int val, int val2) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + u32 val_ms, val_us; > > + > > + if (chan->type != IIO_ACCEL) > > + return -EINVAL; > > + > > + switch (type) { > > + case IIO_EV_TYPE_THRESH: > > + switch (info) { > > + case IIO_EV_INFO_VALUE: > > + switch (dir) { > > + case IIO_EV_DIR_RISING: > > + return adxl380_set_act_inact_threshold(indio_dev, > > + ADXL380_ACTIVITY, val); > > + case IIO_EV_DIR_FALLING: > > + return adxl380_set_act_inact_threshold(indio_dev, > > + ADXL380_INACTIVITY, val); > > + default: > > + return -EINVAL; > > + } > > + case IIO_EV_INFO_PERIOD: > > + val_ms = val * 1000 + DIV_ROUND_UP(val2, 1000); > > + switch (dir) { > > + case IIO_EV_DIR_RISING: > > + return adxl380_set_act_inact_time_ms(st, > > + ADXL380_ACTIVITY, val_ms); > > + case IIO_EV_DIR_FALLING: > > + return adxl380_set_act_inact_time_ms(st, > > + ADXL380_INACTIVITY, val_ms); > > + default: > > + return -EINVAL; > > + } > > + > > + default: > > + return -EINVAL; > > + } > > + case IIO_EV_TYPE_GESTURE: > > + switch (info) { > > + case IIO_EV_INFO_VALUE: > > + return adxl380_set_tap_threshold_value(indio_dev, val); > > + case IIO_EV_INFO_RESET_TIMEOUT: > > + val_us = val * 1000000 + val2; > > + return adxl380_write_tap_time_us(st, > > + ADXL380_TAP_TIME_WINDOW, > > + val_us); > > + case IIO_EV_INFO_TAP2_MIN_DELAY: > > + val_us = val * 1000000 + val2; > > + return adxl380_write_tap_time_us(st, > > + ADXL380_TAP_TIME_LATENT, > > + val_us); > > + default: > > + return -EINVAL; > > + } > > + default: > > + return -EINVAL; > > + } > > +} > > + > > +static ssize_t in_accel_gesture_tap_maxtomin_time_show(struct device > *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + int vals[2]; > > + struct iio_dev *indio_dev = dev_to_iio_dev(dev); > > + struct adxl380_state *st = iio_priv(indio_dev); > > + > > + guard(mutex)(&st->lock); > > + > > + vals[0] = st->tap_duration_us; > > + vals[1] = MICRO; > > + > > + return iio_format_value(buf, IIO_VAL_FRACTIONAL, 2, vals); > > +} > > + > > +static ssize_t in_accel_gesture_tap_maxtomin_time_store(struct device > *dev, > > + struct device_attribute *attr, > > + const char *buf, size_t len) > > +{ > > + struct iio_dev *indio_dev = dev_to_iio_dev(dev); > > + struct adxl380_state *st = iio_priv(indio_dev); > > + int ret, val_int, val_fract_us; > > + > > + guard(mutex)(&st->lock); > > + > > + ret = iio_str_to_fixpoint(buf, 100000, &val_int, &val_fract_us); > > + if (ret) > > + return ret; > > + > > + /* maximum value is 255 * 625 us = 0.159375 seconds */ > > + if (val_int || val_fract_us > 159375 || val_fract_us < 0) > > + return -EINVAL; > > + > > + ret = adxl380_write_tap_dur_us(indio_dev, val_fract_us); > > + if (ret) > > + return ret; > > + > > + return len; > > +} > > + > > +static IIO_DEVICE_ATTR_RW(in_accel_gesture_tap_maxtomin_time, 0); > > + > > +static struct attribute *adxl380_event_attributes[] = { > > + &iio_dev_attr_in_accel_gesture_tap_maxtomin_time.dev_attr.attr, > > + NULL > > +}; > > + > > +static const struct attribute_group adxl380_event_attribute_group = { > > + .attrs = adxl380_event_attributes, > > +}; > > + > > +static int adxl380_reg_access(struct iio_dev *indio_dev, > > + unsigned int reg, > > + unsigned int writeval, > > + unsigned int *readval) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + > > + if (readval) > > + return regmap_read(st->regmap, reg, readval); > > + > > + return regmap_write(st->regmap, reg, writeval); > > +} > > + > > +static int adxl380_set_watermark(struct iio_dev *indio_dev, unsigned int > val) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + > > + st->watermark = min(val, ADXL380_FIFO_SAMPLES); > > + > > + return 0; > > +} > > + > > +static const struct iio_info adxl380_info = { > > + .read_raw = adxl380_read_raw, > > + .read_avail = &adxl380_read_avail, > > + .write_raw = adxl380_write_raw, > > + .write_raw_get_fmt = adxl380_write_raw_get_fmt, > > + .read_event_config = adxl380_read_event_config, > > + .write_event_config = adxl380_write_event_config, > > + .read_event_value = adxl380_read_event_value, > > + .write_event_value = adxl380_write_event_value, > > + .event_attrs = &adxl380_event_attribute_group, > > + .debugfs_reg_access = &adxl380_reg_access, > > + .hwfifo_set_watermark = adxl380_set_watermark, > > +}; > > + > > +static const struct iio_event_spec adxl380_events[] = { > > + { > > + .type = IIO_EV_TYPE_THRESH, > > + .dir = IIO_EV_DIR_RISING, > > + .mask_shared_by_type = BIT(IIO_EV_INFO_ENABLE) | > > + BIT(IIO_EV_INFO_VALUE) | > > + BIT(IIO_EV_INFO_PERIOD), > > + }, > > + { > > + .type = IIO_EV_TYPE_THRESH, > > + .dir = IIO_EV_DIR_FALLING, > > + .mask_shared_by_type = BIT(IIO_EV_INFO_ENABLE) | > > + BIT(IIO_EV_INFO_VALUE) | > > + BIT(IIO_EV_INFO_PERIOD), > > + }, > > + { > > + .type = IIO_EV_TYPE_GESTURE, > > + .dir = IIO_EV_DIR_SINGLETAP, > > + .mask_separate = BIT(IIO_EV_INFO_ENABLE), > > + .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) | > > + BIT(IIO_EV_INFO_RESET_TIMEOUT), > > + }, > > + { > > + .type = IIO_EV_TYPE_GESTURE, > > + .dir = IIO_EV_DIR_DOUBLETAP, > > + .mask_separate = BIT(IIO_EV_INFO_ENABLE), > > + .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) | > > + BIT(IIO_EV_INFO_RESET_TIMEOUT) | > > + BIT(IIO_EV_INFO_TAP2_MIN_DELAY), > > + }, > > +}; > > + > > +#define ADXL380_ACCEL_CHANNEL(index, reg, axis) { \ > > + .type = IIO_ACCEL, \ > > + .address = reg, \ > > + .modified = 1, \ > > + .channel2 = IIO_MOD_##axis, \ > > + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ > > + BIT(IIO_CHAN_INFO_CALIBBIAS), \ > > + .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ > > + .info_mask_shared_by_all_available = \ > > + BIT(IIO_CHAN_INFO_SAMP_FREQ), \ > > + .info_mask_shared_by_type = \ > > + BIT(IIO_CHAN_INFO_SCALE) | \ > > + BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \ > > + BIT(IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY), \ > > + .info_mask_shared_by_type_available = \ > > + BIT(IIO_CHAN_INFO_SCALE) | \ > > + BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \ > > + BIT(IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY), \ > > + .scan_index = index, \ > > + .scan_type = { \ > > + .sign = 's', \ > > + .realbits = 16, \ > > + .storagebits = 16, \ > > + .endianness = IIO_BE, \ > > + }, \ > > + .event_spec = adxl380_events, \ > > + .num_event_specs = ARRAY_SIZE(adxl380_events) \ > > +} > > + > > +static const struct iio_chan_spec adxl380_channels[] = { > > + ADXL380_ACCEL_CHANNEL(0, ADXL380_X_DATA_H_REG, X), > > + ADXL380_ACCEL_CHANNEL(1, ADXL380_Y_DATA_H_REG, Y), > > + ADXL380_ACCEL_CHANNEL(2, ADXL380_Z_DATA_H_REG, Z), > > + { > > + .type = IIO_TEMP, > > + .address = ADXL380_T_DATA_H_REG, > > + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | > > + BIT(IIO_CHAN_INFO_SCALE) | > > + BIT(IIO_CHAN_INFO_OFFSET), > > + .scan_index = 3, > > + .scan_type = { > > + .sign = 's', > > + .realbits = 12, > > + .storagebits = 16, > > + .shift = 4, > > + .endianness = IIO_BE, > > + }, > > + }, > > +}; > > + > > +static int adxl380_config_irq(struct iio_dev *indio_dev) > > +{ > > + struct adxl380_state *st = iio_priv(indio_dev); > > + unsigned long irq_flag; > > + struct irq_data *desc; > > + u32 irq_type; > > + u8 polarity; > > + int ret; > > + > > + desc = irq_get_irq_data(st->irq); > > + if (!desc) > > + return dev_err_probe(st->dev, -EINVAL, "Could not find IRQ %d\n", > st->irq); > > + > > + irq_type = irqd_get_trigger_type(desc); > > + if (irq_type == IRQ_TYPE_LEVEL_HIGH) { > > + polarity = 0; > > + irq_flag = IRQF_TRIGGER_HIGH | IRQF_ONESHOT; > > + } else if (irq_type == IRQ_TYPE_LEVEL_LOW) { > > + polarity = 1; > > + irq_flag = IRQF_TRIGGER_LOW | IRQF_ONESHOT; > > + } else { > > + return dev_err_probe(st->dev, -EINVAL, > > + "Invalid interrupt 0x%x. Only level interrupts > supported\n", > > + irq_type); > > + } > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_INT0_REG, > > + ADXL380_INT0_POL_MSK, > > + FIELD_PREP(ADXL380_INT0_POL_MSK, polarity)); > > + if (ret) > > + return ret; > > + > > + return devm_request_threaded_irq(st->dev, st->irq, NULL, > > + adxl380_irq_handler, irq_flag, > > + indio_dev->name, indio_dev); > > +} > > + > > +static int adxl380_setup(struct iio_dev *indio_dev) > > +{ > > + unsigned int reg_val; > > + u16 part_id, chip_id; > > + int ret, i; > > + struct adxl380_state *st = iio_priv(indio_dev); > > + > > + ret = regmap_read(st->regmap, ADXL380_DEVID_AD_REG, ®_val); > > + if (ret) > > + return ret; > > + > > + if (reg_val != ADXL380_DEVID_AD_VAL) > > + dev_warn(st->dev, "Unknown chip id %x\n", reg_val); > > + > > + ret = regmap_bulk_read(st->regmap, ADLX380_PART_ID_REG, > > + &st->transf_buf, 2); > > + if (ret) > > + return ret; > > + > > + part_id = get_unaligned_be16(st->transf_buf); > > + part_id >>= 4; > > + > > + if (part_id != ADXL380_ID_VAL) > > + dev_warn(st->dev, "Unknown part id %x\n", part_id); > > + > > + ret = regmap_read(st->regmap, ADXL380_MISC_0_REG, ®_val); > > + if (ret) > > + return ret; > > + > > + /* Bit to differentiate between ADXL380/382. */ > > + if (reg_val & ADXL380_XL382_MSK) > > + chip_id = ADXL382_ID_VAL; > > + else > > + chip_id = ADXL380_ID_VAL; > > + > > + if (chip_id != st->chip_info->chip_id) > > + dev_warn(st->dev, "Unknown chip id %x\n", chip_id); > > + > > + ret = regmap_write(st->regmap, ADXL380_RESET_REG, > ADXL380_RESET_CODE); > > + if (ret) > > + return ret; > > + > > + /* > > + * A latency of approximately 0.5 ms is required after soft reset. > > + * Stated in the register REG_RESET description. > > + */ > > + fsleep(500); > > + > > + for (i = 0; i < indio_dev->num_channels; i++) { > > + ret = regmap_update_bits(st->regmap, ADXL380_DIG_EN_REG, > > + ADXL380_CHAN_EN_MSK(i), > > + 1 << (4 + i)); > > + if (ret) > > + return ret; > > + } > > + > > + ret = regmap_update_bits(st->regmap, ADXL380_FIFO_CONFIG_0_REG, > > + ADXL380_FIFO_MODE_MSK, > > + FIELD_PREP(ADXL380_FIFO_MODE_MSK, > ADXL380_FIFO_STREAMED)); > > + if (ret) > > + return ret; > > + > > + /* Select all 3 axis for act/inact detection. */ > > + ret = regmap_update_bits(st->regmap, ADXL380_SNSR_AXIS_EN_REG, > > + ADXL380_ACT_INACT_AXIS_EN_MSK, > > + FIELD_PREP(ADXL380_ACT_INACT_AXIS_EN_MSK, > > + ADXL380_ACT_INACT_AXIS_EN_MSK)); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_config_irq(indio_dev); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_fill_lpf_tbl(st); > > + if (ret) > > + return ret; > > + > > + ret = adxl380_fill_hpf_tbl(st); > > + if (ret) > > + return ret; > > + > > + return adxl380_set_measure_en(st, true); > > +} > > + > > +int adxl380_probe(struct device *dev, struct regmap *regmap, > > + const struct adxl380_chip_info *chip_info) > > +{ > > + struct iio_dev *indio_dev; > > + struct adxl380_state *st; > > + int ret; > > + > > + indio_dev = devm_iio_device_alloc(dev, sizeof(*st)); > > + if (!indio_dev) > > + return -ENOMEM; > > + > > + st = iio_priv(indio_dev); > > + > > + st->dev = dev; > > + st->regmap = regmap; > > + st->chip_info = chip_info; > > + > > + mutex_init(&st->lock); > > + > > + indio_dev->channels = adxl380_channels; > > + indio_dev->num_channels = ARRAY_SIZE(adxl380_channels); > > + indio_dev->name = chip_info->name; > > + indio_dev->info = &adxl380_info; > > + indio_dev->modes = INDIO_DIRECT_MODE; > > + > > + ret = devm_regulator_get_enable(dev, "vddio"); > > + if (ret) > > + return dev_err_probe(st->dev, ret, > > + "Failed to get vddio regulator\n"); > > + > > + ret = devm_regulator_get_enable(st->dev, "vsupply"); > > + if (ret) > > + return dev_err_probe(st->dev, ret, > > + "Failed to get vsupply regulator\n"); > > + > > + st->irq = fwnode_irq_get_byname(dev_fwnode(dev), "INT0"); > > + if (st->irq > 0) { > > + st->int_map[0] = ADXL380_INT0_MAP0_REG; > > + st->int_map[1] = ADXL380_INT0_MAP1_REG; > > + } else { > > + st->irq = fwnode_irq_get_byname(dev_fwnode(dev), "INT1"); > > + if (st->irq > 0) > > + return dev_err_probe(dev, -ENODEV, > > + "no interrupt name specified"); > > + st->int_map[0] = ADXL380_INT1_MAP0_REG; > > + st->int_map[1] = ADXL380_INT1_MAP1_REG; > > + } > > Would it make sense fo this interrupt-register setup to go into > "adxl380_config_irq()"? > > > + > > + ret = adxl380_setup(indio_dev); > > + if (ret) > > + return ret; > > + > > + ret = devm_iio_kfifo_buffer_setup_ext(st->dev, indio_dev, > > + &adxl380_buffer_ops, > > + adxl380_fifo_attributes); > > + if (ret) > > + return ret; > > + > > + return devm_iio_device_register(dev, indio_dev); > > +} > > +EXPORT_SYMBOL_NS_GPL(adxl380_probe, IIO_ADXL380); > > + > > +MODULE_AUTHOR("Ramona Gradinariu > <ramona.gradinariu@analog.com>"); > > +MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com>"); > > +MODULE_DESCRIPTION("Analog Devices ADXL380 3-axis accelerometer > driver"); > > +MODULE_LICENSE("GPL"); > > diff --git a/drivers/iio/accel/adxl380.h b/drivers/iio/accel/adxl380.h > > new file mode 100644 > > index 000000000000..a683625d897a > > --- /dev/null > > +++ b/drivers/iio/accel/adxl380.h > > @@ -0,0 +1,26 @@ > > +/* SPDX-License-Identifier: GPL-2.0+ */ > > +/* > > + * ADXL380 3-Axis Digital Accelerometer > > + * > > + * Copyright 2024 Analog Devices Inc. > > + */ > > + > > +#ifndef _ADXL380_H_ > > +#define _ADXL380_H_ > > + > > +struct adxl380_chip_info { > > + const char *name; > > + const int scale_tbl[3][2]; > > + const int samp_freq_tbl[3]; > > + const int temp_offset; > > + const u16 chip_id; > > +}; > > + > > +extern const struct adxl380_chip_info adxl380_chip_info; > > +extern const struct adxl380_chip_info adxl382_chip_info; > > + > > +int adxl380_probe(struct device *dev, struct regmap *regmap, > > + const struct adxl380_chip_info *chip_info); > > +bool adxl380_readable_noinc_reg(struct device *dev, unsigned int reg); > > + > > +#endif /* _ADXL380_H_ */ > > diff --git a/drivers/iio/accel/adxl380_i2c.c b/drivers/iio/accel/adxl380_i2c.c > > new file mode 100644 > > index 000000000000..1dc1e77be815 > > --- /dev/null > > +++ b/drivers/iio/accel/adxl380_i2c.c > > @@ -0,0 +1,64 @@ > > +// SPDX-License-Identifier: GPL-2.0+ > > +/* > > + * ADXL380 3-Axis Digital Accelerometer I2C driver > > + * > > + * Copyright 2024 Analog Devices Inc. > > + */ > > + > > +#include <linux/i2c.h> > > +#include <linux/mod_devicetable.h> > > +#include <linux/module.h> > > +#include <linux/regmap.h> > > + > > +#include "adxl380.h" > > + > > +static const struct regmap_config adxl380_regmap_config = { > > + .reg_bits = 8, > > + .val_bits = 8, > > + .readable_noinc_reg = adxl380_readable_noinc_reg, > > +}; > > + > > +static int adxl380_i2c_probe(struct i2c_client *client) > > +{ > > + struct regmap *regmap; > > + const struct adxl380_chip_info *chip_data; > > + > > + chip_data = i2c_get_match_data(client); > > + > > + regmap = devm_regmap_init_i2c(client, &adxl380_regmap_config); > > + if (IS_ERR(regmap)) > > + return PTR_ERR(regmap); > > + > > + return adxl380_probe(&client->dev, regmap, chip_data); > > +} > > + > > +static const struct i2c_device_id adxl380_i2c_id[] = { > > + { "adxl380", (kernel_ulong_t)&adxl380_chip_info }, > > + { "adxl382", (kernel_ulong_t)&adxl382_chip_info }, > > + { } > > +}; > > +MODULE_DEVICE_TABLE(i2c, adxl380_i2c_id); > > + > > +static const struct of_device_id adxl380_of_match[] = { > > + { .compatible = "adi,adxl380", .data = &adxl380_chip_info }, > > + { .compatible = "adi,adxl382", .data = &adxl382_chip_info }, > > + { } > > +}; > > +MODULE_DEVICE_TABLE(of, adxl380_of_match); > > + > > +static struct i2c_driver adxl380_i2c_driver = { > > + .driver = { > > + .name = "adxl380_i2c", > > + .of_match_table = adxl380_of_match, > > + }, > > + .probe = adxl380_i2c_probe, > > + .id_table = adxl380_i2c_id, > > +}; > > + > > +module_i2c_driver(adxl380_i2c_driver); > > + > > +MODULE_AUTHOR("Ramona Gradinariu > <ramona.gradinariu@analog.com>"); > > +MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com>"); > > +MODULE_DESCRIPTION("Analog Devices ADXL380 3-axis accelerometer I2C > driver"); > > +MODULE_LICENSE("GPL"); > > +MODULE_IMPORT_NS(IIO_ADXL380); > > diff --git a/drivers/iio/accel/adxl380_spi.c b/drivers/iio/accel/adxl380_spi.c > > new file mode 100644 > > index 000000000000..e7b5778cb6cf > > --- /dev/null > > +++ b/drivers/iio/accel/adxl380_spi.c > > @@ -0,0 +1,66 @@ > > +// SPDX-License-Identifier: GPL-2.0+ > > +/* > > + * ADXL380 3-Axis Digital Accelerometer SPI driver > > + * > > + * Copyright 2024 Analog Devices Inc. > > + */ > > + > > +#include <linux/mod_devicetable.h> > > +#include <linux/module.h> > > +#include <linux/regmap.h> > > +#include <linux/spi/spi.h> > > + > > +#include "adxl380.h" > > + > > +static const struct regmap_config adxl380_spi_regmap_config = { > > + .reg_bits = 7, > > + .pad_bits = 1, > > + .val_bits = 8, > > + .read_flag_mask = BIT(0), > > + .readable_noinc_reg = adxl380_readable_noinc_reg, > > +}; > > + > > +static int adxl380_spi_probe(struct spi_device *spi) > > +{ > > + const struct adxl380_chip_info *chip_data; > > + struct regmap *regmap; > > + > > + chip_data = spi_get_device_match_data(spi); > > + > > + regmap = devm_regmap_init_spi(spi, &adxl380_spi_regmap_config); > > + if (IS_ERR(regmap)) > > + return PTR_ERR(regmap); > > + > > + return adxl380_probe(&spi->dev, regmap, chip_data); > > +} > > + > > +static const struct spi_device_id adxl380_spi_id[] = { > > + { "adxl380", (kernel_ulong_t)&adxl380_chip_info }, > > + { "adxl382", (kernel_ulong_t)&adxl382_chip_info }, > > + { } > > +}; > > +MODULE_DEVICE_TABLE(spi, adxl380_spi_id); > > + > > +static const struct of_device_id adxl380_of_match[] = { > > + { .compatible = "adi,adxl380", .data = &adxl380_chip_info }, > > + { .compatible = "adi,adxl382", .data = &adxl382_chip_info }, > > + { } > > +}; > > +MODULE_DEVICE_TABLE(of, adxl380_of_match); > > + > > +static struct spi_driver adxl380_spi_driver = { > > + .driver = { > > + .name = "adxl380_spi", > > + .of_match_table = adxl380_of_match, > > + }, > > + .probe = adxl380_spi_probe, > > + .id_table = adxl380_spi_id, > > +}; > > + > > +module_spi_driver(adxl380_spi_driver); > > + > > +MODULE_AUTHOR("Ramona Gradinariu > <ramona.gradinariu@analog.com>"); > > +MODULE_AUTHOR("Antoniu Miclaus <antoniu.miclaus@analog.com>"); > > +MODULE_DESCRIPTION("Analog Devices ADXL380 3-axis accelerometer SPI > driver"); > > +MODULE_LICENSE("GPL"); > > +MODULE_IMPORT_NS(IIO_ADXL380); > > -- > > 2.45.2 > > > > ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH v4 2/3] iio: accel: add ADXL380 driver 2024-07-08 10:22 ` Miclaus, Antoniu @ 2024-07-08 16:09 ` Jonathan Cameron 0 siblings, 0 replies; 7+ messages in thread From: Jonathan Cameron @ 2024-07-08 16:09 UTC (permalink / raw) To: Miclaus, Antoniu Cc: Alexandru-Aleodor Ardelean, Gradinariu, Ramona, Lars-Peter Clausen, Hennerich, Michael, Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Jonathan Corbet, Jun Yan, Matti Vaittinen, Mario Limonciello, Mehdi Djait, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org *Grumpier* Crop to relevant parts of email. ^ permalink raw reply [flat|nested] 7+ messages in thread
* [PATCH v4 3/3] docs: iio: add documentation for adxl380 driver 2024-07-01 8:30 [PATCH v4 1/3] dt-bindings: iio: accel: add ADXL380 Antoniu Miclaus 2024-07-01 8:30 ` [PATCH v4 2/3] iio: accel: add ADXL380 driver Antoniu Miclaus @ 2024-07-01 8:30 ` Antoniu Miclaus 1 sibling, 0 replies; 7+ messages in thread From: Antoniu Miclaus @ 2024-07-01 8:30 UTC (permalink / raw) To: Ramona Gradinariu, Antoniu Miclaus, Lars-Peter Clausen, Michael Hennerich, Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Jonathan Corbet, Matti Vaittinen, Jun Yan, Andy Shevchenko, Mehdi Djait, Mario Limonciello, linux-iio, devicetree, linux-kernel, linux-doc Add documentation for adxl380 driver which describes the driver device files and shows how the user may use the ABI for various scenarios (configuration, measurement, etc.). Signed-off-by: Ramona Gradinariu <ramona.gradinariu@analog.com> Signed-off-by: Antoniu Miclaus <antoniu.miclaus@analog.com> --- changes in v4: - drop marketing from description. Documentation/iio/adxl380.rst | 233 ++++++++++++++++++++++++++++++++++ Documentation/iio/index.rst | 1 + 2 files changed, 234 insertions(+) create mode 100644 Documentation/iio/adxl380.rst diff --git a/Documentation/iio/adxl380.rst b/Documentation/iio/adxl380.rst new file mode 100644 index 000000000000..376dee5fe1dd --- /dev/null +++ b/Documentation/iio/adxl380.rst @@ -0,0 +1,233 @@ +.. SPDX-License-Identifier: GPL-2.0 + +=============== +ADXL380 driver +=============== + +This driver supports Analog Device's ADXL380/382 on SPI/I2C bus. + +1. Supported devices +==================== + +* `ADXL380 <https://www.analog.com/ADXL380>`_ +* `ADXL382 <https://www.analog.com/ADXL382>`_ + +The ADXL380/ADXL382 is a low noise density, low power, 3-axis accelerometer with +selectable measurement ranges. The ADXL380 supports the ±4 g, ±8 g, and ±16 g +ranges, and the ADXL382 supports ±15 g, ±30 g, and ±60 g ranges. + +2. Device attributes +==================== + +Accelerometer measurements are always provided. + +Temperature data are also provided. This data can be used to monitor the +internal system temperature or to improve the temperature stability of the +device via calibration. + +Each IIO device, has a device folder under ``/sys/bus/iio/devices/iio:deviceX``, +where X is the IIO index of the device. Under these folders reside a set of +device files, depending on the characteristics and features of the hardware +device in questions. These files are consistently generalized and documented in +the IIO ABI documentation. + +The following tables show the adxl380 related device files, found in the +specific device folder path ``/sys/bus/iio/devices/iio:deviceX``. + ++---------------------------------------------------+----------------------------------------------------------+ +| 3-Axis Accelerometer related device files | Description | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_scale | Scale for the accelerometer channels. | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_filter_high_pass_3db_frequency | Low pass filter bandwidth. | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_filter_high_pass_3db_frequency_available | Available low pass filter bandwidth configurations. | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_filter_low_pass_3db_frequency | High pass filter bandwidth. | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_filter_low_pass_3db_frequency_available | Available high pass filter bandwidth configurations. | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_x_calibbias | Calibration offset for the X-axis accelerometer channel. | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_x_raw | Raw X-axis accelerometer channel value. | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_y_calibbias | y-axis acceleration offset correction | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_y_raw | Raw Y-axis accelerometer channel value. | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_z_calibbias | Calibration offset for the Z-axis accelerometer channel. | ++---------------------------------------------------+----------------------------------------------------------+ +| in_accel_z_raw | Raw Z-axis accelerometer channel value. | ++---------------------------------------------------+----------------------------------------------------------+ + ++----------------------------------+--------------------------------------------+ +| Temperature sensor related files | Description | ++----------------------------------+--------------------------------------------+ +| in_temp_raw | Raw temperature channel value. | ++----------------------------------+--------------------------------------------+ +| in_temp_offset | Offset for the temperature sensor channel. | ++----------------------------------+--------------------------------------------+ +| in_temp_scale | Scale for the temperature sensor channel. | ++----------------------------------+--------------------------------------------+ + ++------------------------------+----------------------------------------------+ +| Miscellaneous device files | Description | ++------------------------------+----------------------------------------------+ +| name | Name of the IIO device. | ++------------------------------+----------------------------------------------+ +| sampling_frequency | Currently selected sample rate. | ++------------------------------+----------------------------------------------+ +| sampling_frequency_available | Available sampling frequency configurations. | ++------------------------------+----------------------------------------------+ + +Channels processed values +------------------------- + +A channel value can be read from its _raw attribute. The value returned is the +raw value as reported by the devices. To get the processed value of the channel, +apply the following formula: + +.. code-block:: bash + + processed value = (_raw + _offset) * _scale + +Where _offset and _scale are device attributes. If no _offset attribute is +present, simply assume its value is 0. + +The adis16475 driver offers data for 2 types of channels, the table below shows +the measurement units for the processed value, which are defined by the IIO +framework: + ++-------------------------------------+---------------------------+ +| Channel type | Measurement unit | ++-------------------------------------+---------------------------+ +| Acceleration on X, Y, and Z axis | Meters per Second squared | ++-------------------------------------+---------------------------+ +| Temperature | Millidegrees Celsius | ++-------------------------------------+---------------------------+ + +Usage examples +-------------- + +Show device name: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> cat name + adxl382 + +Show accelerometer channels value: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> cat in_accel_x_raw + -1771 + root:/sys/bus/iio/devices/iio:device0> cat in_accel_y_raw + 282 + root:/sys/bus/iio/devices/iio:device0> cat in_accel_z_raw + -1523 + root:/sys/bus/iio/devices/iio:device0> cat in_accel_scale + 0.004903325 + +- X-axis acceleration = in_accel_x_raw * in_accel_scale = −8.683788575 m/s^2 +- Y-axis acceleration = in_accel_y_raw * in_accel_scale = 1.38273765 m/s^2 +- Z-axis acceleration = in_accel_z_raw * in_accel_scale = -7.467763975 m/s^2 + +Set calibration offset for accelerometer channels: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> cat in_accel_x_calibbias + 0 + + root:/sys/bus/iio/devices/iio:device0> echo 50 > in_accel_x_calibbias + root:/sys/bus/iio/devices/iio:device0> cat in_accel_x_calibbias + 50 + +Set sampling frequency: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> cat sampling_frequency + 16000 + root:/sys/bus/iio/devices/iio:device0> cat sampling_frequency_available + 16000 32000 64000 + + root:/sys/bus/iio/devices/iio:device0> echo 32000 > sampling_frequency + root:/sys/bus/iio/devices/iio:device0> cat sampling_frequency + 32000 + +Set low pass filter bandwidth for accelerometer channels: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> cat in_accel_filter_low_pass_3db_frequency + 32000 + root:/sys/bus/iio/devices/iio:device0> cat in_accel_filter_low_pass_3db_frequency_available + 32000 8000 4000 2000 + + root:/sys/bus/iio/devices/iio:device0> echo 2000 > in_accel_filter_low_pass_3db_frequency + root:/sys/bus/iio/devices/iio:device0> cat in_accel_filter_low_pass_3db_frequency + 2000 + +3. Device buffers +================= + +This driver supports IIO buffers. + +All devices support retrieving the raw acceleration and temperature measurements +using buffers. + +Usage examples +-------------- + +Select channels for buffer read: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> echo 1 > scan_elements/in_accel_x_en + root:/sys/bus/iio/devices/iio:device0> echo 1 > scan_elements/in_accel_y_en + root:/sys/bus/iio/devices/iio:device0> echo 1 > scan_elements/in_accel_z_en + root:/sys/bus/iio/devices/iio:device0> echo 1 > scan_elements/in_temp_en + +Set the number of samples to be stored in the buffer: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> echo 10 > buffer/length + +Enable buffer readings: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> echo 1 > buffer/enable + +Obtain buffered data: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> hexdump -C /dev/iio\:device0 + ... + 002bc300 f7 e7 00 a8 fb c5 24 80 f7 e7 01 04 fb d6 24 80 |......$.......$.| + 002bc310 f7 f9 00 ab fb dc 24 80 f7 c3 00 b8 fb e2 24 80 |......$.......$.| + 002bc320 f7 fb 00 bb fb d1 24 80 f7 b1 00 5f fb d1 24 80 |......$...._..$.| + 002bc330 f7 c4 00 c6 fb a6 24 80 f7 a6 00 68 fb f1 24 80 |......$....h..$.| + 002bc340 f7 b8 00 a3 fb e7 24 80 f7 9a 00 b1 fb af 24 80 |......$.......$.| + 002bc350 f7 b1 00 67 fb ee 24 80 f7 96 00 be fb 92 24 80 |...g..$.......$.| + 002bc360 f7 ab 00 7a fc 1b 24 80 f7 b6 00 ae fb 76 24 80 |...z..$......v$.| + 002bc370 f7 ce 00 a3 fc 02 24 80 f7 c0 00 be fb 8b 24 80 |......$.......$.| + 002bc380 f7 c3 00 93 fb d0 24 80 f7 ce 00 d8 fb c8 24 80 |......$.......$.| + 002bc390 f7 bd 00 c0 fb 82 24 80 f8 00 00 e8 fb db 24 80 |......$.......$.| + 002bc3a0 f7 d8 00 d3 fb b4 24 80 f8 0b 00 e5 fb c3 24 80 |......$.......$.| + 002bc3b0 f7 eb 00 c8 fb 92 24 80 f7 e7 00 ea fb cb 24 80 |......$.......$.| + 002bc3c0 f7 fd 00 cb fb 94 24 80 f7 e3 00 f2 fb b8 24 80 |......$.......$.| + ... + +See ``Documentation/iio/iio_devbuf.rst`` for more information about how buffered +data is structured. + +4. IIO Interfacing Tools +======================== + +See ``Documentation/iio/iio_tools.rst`` for the description of the available IIO +interfacing tools. diff --git a/Documentation/iio/index.rst b/Documentation/iio/index.rst index 4c13bfa2865c..1ce5b24d40aa 100644 --- a/Documentation/iio/index.rst +++ b/Documentation/iio/index.rst @@ -20,5 +20,6 @@ Industrial I/O Kernel Drivers ad7944 adis16475 adis16480 + adxl380 bno055 ep93xx_adc -- 2.45.2 ^ permalink raw reply related [flat|nested] 7+ messages in thread
end of thread, other threads:[~2024-07-08 16:09 UTC | newest] Thread overview: 7+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2024-07-01 8:30 [PATCH v4 1/3] dt-bindings: iio: accel: add ADXL380 Antoniu Miclaus 2024-07-01 8:30 ` [PATCH v4 2/3] iio: accel: add ADXL380 driver Antoniu Miclaus 2024-07-03 7:06 ` Alexandru Ardelean 2024-07-07 16:31 ` Jonathan Cameron 2024-07-08 10:22 ` Miclaus, Antoniu 2024-07-08 16:09 ` Jonathan Cameron 2024-07-01 8:30 ` [PATCH v4 3/3] docs: iio: add documentation for adxl380 driver Antoniu Miclaus
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.