iio: accel: adxl345: add activity event feature

Enable the sensor to detect activity and trigger interrupts accordingly.
Activity events are determined based on a threshold, which is initialized
to a sensible default during probe. This default value is adopted from the
legacy ADXL345 input driver to maintain consistent behavior.

The combination of activity detection, ODR configuration, and range
settings lays the groundwork for the activity/inactivity hysteresis
mechanism, which will be implemented in a subsequent patch. As such,
portions of this patch prepare switch-case structures to support those
upcoming changes.

Signed-off-by: Lothar Rubusch <l.rubusch@gmail.com>
Link: https://patch.msgid.link/20250727210014.27766-3-l.rubusch@gmail.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/accel/adxl345_core.c b/drivers/iio/accel/adxl345_core.c
index e293fc91797233682c393dc89bfba8f942b86a48..8ff1784403ba0cb60f5522597cb5218b1cd530b3 100644 (file)
--- a/drivers/iio/accel/adxl345_core.c
+++ b/drivers/iio/accel/adxl345_core.c
@@ -39,6 +39,11 @@
 #define ADXL345_TAP_X_EN               BIT(2)
 #define ADXL345_REG_TAP_SUPPRESS       BIT(3)
 
+#define ADXL345_ACT_Z_EN               BIT(4)
+#define ADXL345_ACT_Y_EN               BIT(5)
+#define ADXL345_ACT_X_EN               BIT(6)
+#define ADXL345_ACT_XYZ_EN             (ADXL345_ACT_Z_EN | ADXL345_ACT_Y_EN | ADXL345_ACT_X_EN)
+
 /* single/double tap */
 enum adxl345_tap_type {
        ADXL345_SINGLE_TAP,
@@ -62,6 +67,19 @@ static const unsigned int adxl345_tap_time_reg[] = {
        [ADXL345_TAP_TIME_DUR] = ADXL345_REG_DUR,
 };
 
+/* activity/inactivity */
+enum adxl345_activity_type {
+       ADXL345_ACTIVITY,
+};
+
+static const unsigned int adxl345_act_int_reg[] = {
+       [ADXL345_ACTIVITY] = ADXL345_INT_ACTIVITY,
+};
+
+static const unsigned int adxl345_act_thresh_reg[] = {
+       [ADXL345_ACTIVITY] = ADXL345_REG_THRESH_ACT,
+};
+
 enum adxl345_odr {
        ADXL345_ODR_0P10HZ = 0,
        ADXL345_ODR_0P20HZ,
@@ -142,6 +160,14 @@ struct adxl345_state {
 };
 
 static const struct iio_event_spec adxl345_events[] = {
+       {
+               /* activity */
+               .type = IIO_EV_TYPE_MAG,
+               .dir = IIO_EV_DIR_RISING,
+               .mask_shared_by_type =
+                       BIT(IIO_EV_INFO_ENABLE) |
+                       BIT(IIO_EV_INFO_VALUE),
+       },
        {
                /* single tap */
                .type = IIO_EV_TYPE_GESTURE,
@@ -235,6 +261,87 @@ static int adxl345_set_measure_en(struct adxl345_state *st, bool en)
                                  ADXL345_POWER_CTL_MEASURE, en);
 }
 
+/* activity / inactivity */
+
+static int adxl345_is_act_inact_en(struct adxl345_state *st,
+                                  enum adxl345_activity_type type)
+{
+       unsigned int axis_ctrl;
+       unsigned int regval;
+       bool en;
+       int ret;
+
+       ret = regmap_read(st->regmap, ADXL345_REG_ACT_INACT_CTRL, &axis_ctrl);
+       if (ret)
+               return ret;
+
+       /* Check if axis for activity are enabled */
+       switch (type) {
+       case ADXL345_ACTIVITY:
+               en = FIELD_GET(ADXL345_ACT_XYZ_EN, axis_ctrl);
+               if (!en)
+                       return false;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       /* Check if specific interrupt is enabled */
+       ret = regmap_read(st->regmap, ADXL345_REG_INT_ENABLE, &regval);
+       if (ret)
+               return ret;
+
+       return adxl345_act_int_reg[type] & regval;
+}
+
+static int adxl345_set_act_inact_en(struct adxl345_state *st,
+                                   enum adxl345_activity_type type,
+                                   bool cmd_en)
+{
+       unsigned int axis_ctrl;
+       unsigned int threshold;
+       int ret;
+
+       if (cmd_en) {
+               /* When turning on, check if threshold is valid */
+               ret = regmap_read(st->regmap,
+                                 adxl345_act_thresh_reg[type],
+                                 &threshold);
+               if (ret)
+                       return ret;
+
+               if (!threshold) /* Just ignore the command if threshold is 0 */
+                       return 0;
+       }
+
+       /* Start modifying configuration registers */
+       ret = adxl345_set_measure_en(st, false);
+       if (ret)
+               return ret;
+
+       /* Enable axis according to the command */
+       switch (type) {
+       case ADXL345_ACTIVITY:
+               axis_ctrl = ADXL345_ACT_XYZ_EN;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       ret = regmap_assign_bits(st->regmap, ADXL345_REG_ACT_INACT_CTRL,
+                                axis_ctrl, cmd_en);
+       if (ret)
+               return ret;
+
+       /* Enable the interrupt line, according to the command */
+       ret = regmap_assign_bits(st->regmap, ADXL345_REG_INT_ENABLE,
+                                adxl345_act_int_reg[type], cmd_en);
+       if (ret)
+               return ret;
+
+       return adxl345_set_measure_en(st, true);
+}
+
 /* tap */
 
 static int _adxl345_set_tap_int(struct adxl345_state *st,
@@ -621,6 +728,31 @@ static int adxl345_write_raw(struct iio_dev *indio_dev,
        return adxl345_set_measure_en(st, true);
 }
 
+static int adxl345_read_mag_config(struct adxl345_state *st,
+                                  enum iio_event_direction dir,
+                                  enum adxl345_activity_type type_act)
+{
+       switch (dir) {
+       case IIO_EV_DIR_RISING:
+               return !!adxl345_is_act_inact_en(st, type_act);
+       default:
+               return -EINVAL;
+       }
+}
+
+static int adxl345_write_mag_config(struct adxl345_state *st,
+                                   enum iio_event_direction dir,
+                                   enum adxl345_activity_type type_act,
+                                   bool state)
+{
+       switch (dir) {
+       case IIO_EV_DIR_RISING:
+               return adxl345_set_act_inact_en(st, type_act, state);
+       default:
+               return -EINVAL;
+       }
+}
+
 static int adxl345_read_event_config(struct iio_dev *indio_dev,
                                     const struct iio_chan_spec *chan,
                                     enum iio_event_type type,
@@ -631,6 +763,9 @@ static int adxl345_read_event_config(struct iio_dev *indio_dev,
        int ret;
 
        switch (type) {
+       case IIO_EV_TYPE_MAG:
+               return adxl345_read_mag_config(st, dir,
+                                              ADXL345_ACTIVITY);
        case IIO_EV_TYPE_GESTURE:
                switch (dir) {
                case IIO_EV_DIR_SINGLETAP:
@@ -662,6 +797,10 @@ static int adxl345_write_event_config(struct iio_dev *indio_dev,
        struct adxl345_state *st = iio_priv(indio_dev);
 
        switch (type) {
+       case IIO_EV_TYPE_MAG:
+               return adxl345_write_mag_config(st, dir,
+                                               ADXL345_ACTIVITY,
+                                               state);
        case IIO_EV_TYPE_GESTURE:
                switch (dir) {
                case IIO_EV_DIR_SINGLETAP:
@@ -676,6 +815,58 @@ static int adxl345_write_event_config(struct iio_dev *indio_dev,
        }
 }
 
+static int adxl345_read_mag_value(struct adxl345_state *st,
+                                 enum iio_event_direction dir,
+                                 enum iio_event_info info,
+                                 enum adxl345_activity_type type_act,
+                                 int *val, int *val2)
+{
+       unsigned int threshold;
+       int ret;
+
+       switch (info) {
+       case IIO_EV_INFO_VALUE:
+               switch (dir) {
+               case IIO_EV_DIR_RISING:
+                       ret = regmap_read(st->regmap,
+                                         adxl345_act_thresh_reg[type_act],
+                                         &threshold);
+                       if (ret)
+                               return ret;
+                       *val = 62500 * threshold;
+                       *val2 = MICRO;
+                       return IIO_VAL_FRACTIONAL;
+               default:
+                       return -EINVAL;
+               }
+       default:
+               return -EINVAL;
+       }
+}
+
+static int adxl345_write_mag_value(struct adxl345_state *st,
+                                  enum iio_event_direction dir,
+                                  enum iio_event_info info,
+                                  enum adxl345_activity_type type_act,
+                                  int val, int val2)
+{
+       switch (info) {
+       case IIO_EV_INFO_VALUE:
+               /* Scaling factor 62.5mg/LSB, i.e. ~16g corresponds to 0xff */
+               val = DIV_ROUND_CLOSEST(val * MICRO + val2, 62500);
+               switch (dir) {
+               case IIO_EV_DIR_RISING:
+                       return regmap_write(st->regmap,
+                                           adxl345_act_thresh_reg[type_act],
+                                           val);
+               default:
+                       return -EINVAL;
+               }
+       default:
+               return -EINVAL;
+       }
+}
+
 static int adxl345_read_event_value(struct iio_dev *indio_dev,
                                    const struct iio_chan_spec *chan,
                                    enum iio_event_type type,
@@ -688,6 +879,10 @@ static int adxl345_read_event_value(struct iio_dev *indio_dev,
        int ret;
 
        switch (type) {
+       case IIO_EV_TYPE_MAG:
+               return adxl345_read_mag_value(st, dir, info,
+                                             ADXL345_ACTIVITY,
+                                             val, val2);
        case IIO_EV_TYPE_GESTURE:
                switch (info) {
                case IIO_EV_INFO_VALUE:
@@ -738,6 +933,13 @@ static int adxl345_write_event_value(struct iio_dev *indio_dev,
                return ret;
 
        switch (type) {
+       case IIO_EV_TYPE_MAG:
+               ret = adxl345_write_mag_value(st, dir, info,
+                                             ADXL345_ACTIVITY,
+                                             val, val2);
+               if (ret)
+                       return ret;
+               break;
        case IIO_EV_TYPE_GESTURE:
                switch (info) {
                case IIO_EV_INFO_VALUE:
@@ -977,6 +1179,7 @@ static int adxl345_fifo_push(struct iio_dev *indio_dev,
 }
 
 static int adxl345_push_event(struct iio_dev *indio_dev, int int_stat,
+                             enum iio_modifier act_dir,
                              enum iio_modifier tap_dir)
 {
        s64 ts = iio_get_time_ns(indio_dev);
@@ -1004,6 +1207,16 @@ static int adxl345_push_event(struct iio_dev *indio_dev, int int_stat,
                        return ret;
        }
 
+       if (FIELD_GET(ADXL345_INT_ACTIVITY, int_stat)) {
+               ret = iio_push_event(indio_dev,
+                                    IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, act_dir,
+                                                       IIO_EV_TYPE_MAG,
+                                                       IIO_EV_DIR_RISING),
+                                    ts);
+               if (ret)
+                       return ret;
+       }
+
        if (FIELD_GET(ADXL345_INT_WATERMARK, int_stat)) {
                samples = adxl345_get_samples(st);
                if (samples < 0)
@@ -1031,6 +1244,7 @@ static irqreturn_t adxl345_irq_handler(int irq, void *p)
        struct adxl345_state *st = iio_priv(indio_dev);
        unsigned int regval;
        enum iio_modifier tap_dir = IIO_NO_MOD;
+       enum iio_modifier act_dir = IIO_NO_MOD;
        u32 axis_ctrl;
        int int_stat;
        int ret;
@@ -1039,7 +1253,8 @@ static irqreturn_t adxl345_irq_handler(int irq, void *p)
        if (ret)
                return IRQ_NONE;
 
-       if (FIELD_GET(ADXL345_REG_TAP_AXIS_MSK, axis_ctrl)) {
+       if (FIELD_GET(ADXL345_REG_TAP_AXIS_MSK, axis_ctrl) ||
+           FIELD_GET(ADXL345_ACT_XYZ_EN, axis_ctrl)) {
                ret = regmap_read(st->regmap, ADXL345_REG_ACT_TAP_STATUS, &regval);
                if (ret)
                        return IRQ_NONE;
@@ -1050,12 +1265,19 @@ static irqreturn_t adxl345_irq_handler(int irq, void *p)
                        tap_dir = IIO_MOD_Y;
                else if (FIELD_GET(ADXL345_TAP_X_EN, regval))
                        tap_dir = IIO_MOD_X;
+
+               if (FIELD_GET(ADXL345_ACT_Z_EN, regval))
+                       act_dir = IIO_MOD_Z;
+               else if (FIELD_GET(ADXL345_ACT_Y_EN, regval))
+                       act_dir = IIO_MOD_Y;
+               else if (FIELD_GET(ADXL345_ACT_X_EN, regval))
+                       act_dir = IIO_MOD_X;
        }
 
        if (regmap_read(st->regmap, ADXL345_REG_INT_SOURCE, &int_stat))
                return IRQ_NONE;
 
-       if (adxl345_push_event(indio_dev, int_stat, tap_dir))
+       if (adxl345_push_event(indio_dev, int_stat, act_dir, tap_dir))
                goto err;
 
        if (FIELD_GET(ADXL345_INT_OVERRUN, int_stat))
@@ -1223,6 +1445,20 @@ int adxl345_core_probe(struct device *dev, struct regmap *regmap,
                if (ret)
                        return ret;
 
+               /*
+                * Initialized with sensible default values to streamline
+                * sensor operation. These defaults are partly derived from
+                * the previous input driver for the ADXL345 and partly
+                * based on the recommendations provided in the datasheet.
+                */
+               ret = regmap_write(st->regmap, ADXL345_REG_ACT_INACT_CTRL, 0);
+               if (ret)
+                       return ret;
+
+               ret = regmap_write(st->regmap, ADXL345_REG_THRESH_ACT, 6);
+               if (ret)
+                       return ret;
+
                ret = regmap_write(st->regmap, ADXL345_REG_THRESH_TAP, tap_threshold);
                if (ret)
                        return ret;