drivers/iio/accel/fxls8962af-core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * NXP FXLS8962AF/FXLS8964AF Accelerometer Core Driver
   4  *
   5  * Copyright 2021 Connected Cars A/S
   6  *
   7  * Datasheet:
   8  * https://www.nxp.com/docs/en/data-sheet/FXLS8962AF.pdf
   9  * https://www.nxp.com/docs/en/data-sheet/FXLS8964AF.pdf
  10  *
  11  * Errata:
  12  * https://www.nxp.com/docs/en/errata/ES_FXLS8962AF.pdf
  13  */
  14
  15 #include <linux/bits.h>
  16 #include <linux/bitfield.h>
  17 #include <linux/i2c.h>
  18 #include <linux/module.h>
  19 #include <linux/of_irq.h>
  20 #include <linux/pm_runtime.h>
  21 #include <linux/regulator/consumer.h>
  22 #include <linux/regmap.h>
  23
  24 #include <linux/iio/buffer.h>
  25 #include <linux/iio/events.h>
  26 #include <linux/iio/iio.h>
  27 #include <linux/iio/kfifo_buf.h>
  28 #include <linux/iio/sysfs.h>
  29
  30 #include "fxls8962af.h"
  31
  32 #define FXLS8962AF_INT_STATUS                   0x00
  33 #define FXLS8962AF_INT_STATUS_SRC_BOOT          BIT(0)
  34 #define FXLS8962AF_INT_STATUS_SRC_SDCD_OT       BIT(4)
  35 #define FXLS8962AF_INT_STATUS_SRC_BUF           BIT(5)
  36 #define FXLS8962AF_INT_STATUS_SRC_DRDY          BIT(7)
  37 #define FXLS8962AF_TEMP_OUT                     0x01
  38 #define FXLS8962AF_VECM_LSB                     0x02
  39 #define FXLS8962AF_OUT_X_LSB                    0x04
  40 #define FXLS8962AF_OUT_Y_LSB                    0x06
  41 #define FXLS8962AF_OUT_Z_LSB                    0x08
  42 #define FXLS8962AF_BUF_STATUS                   0x0b
  43 #define FXLS8962AF_BUF_STATUS_BUF_CNT           GENMASK(5, 0)
  44 #define FXLS8962AF_BUF_STATUS_BUF_OVF           BIT(6)
  45 #define FXLS8962AF_BUF_STATUS_BUF_WMRK          BIT(7)
  46 #define FXLS8962AF_BUF_X_LSB                    0x0c
  47 #define FXLS8962AF_BUF_Y_LSB                    0x0e
  48 #define FXLS8962AF_BUF_Z_LSB                    0x10
  49
  50 #define FXLS8962AF_PROD_REV                     0x12
  51 #define FXLS8962AF_WHO_AM_I                     0x13
  52
  53 #define FXLS8962AF_SYS_MODE                     0x14
  54 #define FXLS8962AF_SENS_CONFIG1                 0x15
  55 #define FXLS8962AF_SENS_CONFIG1_ACTIVE          BIT(0)
  56 #define FXLS8962AF_SENS_CONFIG1_RST             BIT(7)
  57 #define FXLS8962AF_SC1_FSR_MASK                 GENMASK(2, 1)
  58 #define FXLS8962AF_SC1_FSR_PREP(x)              FIELD_PREP(FXLS8962AF_SC1_FSR_MASK, (x))
  59 #define FXLS8962AF_SC1_FSR_GET(x)               FIELD_GET(FXLS8962AF_SC1_FSR_MASK, (x))
  60
  61 #define FXLS8962AF_SENS_CONFIG2                 0x16
  62 #define FXLS8962AF_SENS_CONFIG3                 0x17
  63 #define FXLS8962AF_SC3_WAKE_ODR_MASK            GENMASK(7, 4)
  64 #define FXLS8962AF_SC3_WAKE_ODR_PREP(x)         FIELD_PREP(FXLS8962AF_SC3_WAKE_ODR_MASK, (x))
  65 #define FXLS8962AF_SC3_WAKE_ODR_GET(x)          FIELD_GET(FXLS8962AF_SC3_WAKE_ODR_MASK, (x))
  66 #define FXLS8962AF_SENS_CONFIG4                 0x18
  67 #define FXLS8962AF_SC4_INT_PP_OD_MASK           BIT(1)
  68 #define FXLS8962AF_SC4_INT_PP_OD_PREP(x)        FIELD_PREP(FXLS8962AF_SC4_INT_PP_OD_MASK, (x))
  69 #define FXLS8962AF_SC4_INT_POL_MASK             BIT(0)
  70 #define FXLS8962AF_SC4_INT_POL_PREP(x)          FIELD_PREP(FXLS8962AF_SC4_INT_POL_MASK, (x))
  71 #define FXLS8962AF_SENS_CONFIG5                 0x19
  72
  73 #define FXLS8962AF_WAKE_IDLE_LSB                0x1b
  74 #define FXLS8962AF_SLEEP_IDLE_LSB               0x1c
  75 #define FXLS8962AF_ASLP_COUNT_LSB               0x1e
  76
  77 #define FXLS8962AF_INT_EN                       0x20
  78 #define FXLS8962AF_INT_EN_SDCD_OT_EN            BIT(5)
  79 #define FXLS8962AF_INT_EN_BUF_EN                BIT(6)
  80 #define FXLS8962AF_INT_PIN_SEL                  0x21
  81 #define FXLS8962AF_INT_PIN_SEL_MASK             GENMASK(7, 0)
  82 #define FXLS8962AF_INT_PIN_SEL_INT1             0x00
  83 #define FXLS8962AF_INT_PIN_SEL_INT2             GENMASK(7, 0)
  84
  85 #define FXLS8962AF_OFF_X                        0x22
  86 #define FXLS8962AF_OFF_Y                        0x23
  87 #define FXLS8962AF_OFF_Z                        0x24
  88
  89 #define FXLS8962AF_BUF_CONFIG1                  0x26
  90 #define FXLS8962AF_BC1_BUF_MODE_MASK            GENMASK(6, 5)
  91 #define FXLS8962AF_BC1_BUF_MODE_PREP(x)         FIELD_PREP(FXLS8962AF_BC1_BUF_MODE_MASK, (x))
  92 #define FXLS8962AF_BUF_CONFIG2                  0x27
  93 #define FXLS8962AF_BUF_CONFIG2_BUF_WMRK         GENMASK(5, 0)
  94
  95 #define FXLS8962AF_ORIENT_STATUS                0x28
  96 #define FXLS8962AF_ORIENT_CONFIG                0x29
  97 #define FXLS8962AF_ORIENT_DBCOUNT               0x2a
  98 #define FXLS8962AF_ORIENT_BF_ZCOMP              0x2b
  99 #define FXLS8962AF_ORIENT_THS_REG               0x2c
 100
 101 #define FXLS8962AF_SDCD_INT_SRC1                0x2d
 102 #define FXLS8962AF_SDCD_INT_SRC1_X_OT           BIT(5)
 103 #define FXLS8962AF_SDCD_INT_SRC1_X_POL          BIT(4)
 104 #define FXLS8962AF_SDCD_INT_SRC1_Y_OT           BIT(3)
 105 #define FXLS8962AF_SDCD_INT_SRC1_Y_POL          BIT(2)
 106 #define FXLS8962AF_SDCD_INT_SRC1_Z_OT           BIT(1)
 107 #define FXLS8962AF_SDCD_INT_SRC1_Z_POL          BIT(0)
 108 #define FXLS8962AF_SDCD_INT_SRC2                0x2e
 109 #define FXLS8962AF_SDCD_CONFIG1                 0x2f
 110 #define FXLS8962AF_SDCD_CONFIG1_Z_OT_EN         BIT(3)
 111 #define FXLS8962AF_SDCD_CONFIG1_Y_OT_EN         BIT(4)
 112 #define FXLS8962AF_SDCD_CONFIG1_X_OT_EN         BIT(5)
 113 #define FXLS8962AF_SDCD_CONFIG1_OT_ELE          BIT(7)
 114 #define FXLS8962AF_SDCD_CONFIG2                 0x30
 115 #define FXLS8962AF_SDCD_CONFIG2_SDCD_EN         BIT(7)
 116 #define FXLS8962AF_SC2_REF_UPDM_AC              GENMASK(6, 5)
 117 #define FXLS8962AF_SDCD_OT_DBCNT                0x31
 118 #define FXLS8962AF_SDCD_WT_DBCNT                0x32
 119 #define FXLS8962AF_SDCD_LTHS_LSB                0x33
 120 #define FXLS8962AF_SDCD_UTHS_LSB                0x35
 121
 122 #define FXLS8962AF_SELF_TEST_CONFIG1            0x37
 123 #define FXLS8962AF_SELF_TEST_CONFIG2            0x38
 124
 125 #define FXLS8962AF_MAX_REG                      0x38
 126
 127 #define FXLS8962AF_DEVICE_ID                    0x62
 128 #define FXLS8964AF_DEVICE_ID                    0x84
 129
 130 /* Raw temp channel offset */
 131 #define FXLS8962AF_TEMP_CENTER_VAL              25
 132
 133 #define FXLS8962AF_AUTO_SUSPEND_DELAY_MS        2000
 134
 135 #define FXLS8962AF_FIFO_LENGTH                  32
 136 #define FXLS8962AF_SCALE_TABLE_LEN              4
 137 #define FXLS8962AF_SAMP_FREQ_TABLE_LEN          13
 138
 139 static const int fxls8962af_scale_table[FXLS8962AF_SCALE_TABLE_LEN][2] = {
 140         {0, IIO_G_TO_M_S_2(980000)},
 141         {0, IIO_G_TO_M_S_2(1950000)},
 142         {0, IIO_G_TO_M_S_2(3910000)},
 143         {0, IIO_G_TO_M_S_2(7810000)},
 144 };
 145
 146 static const int fxls8962af_samp_freq_table[FXLS8962AF_SAMP_FREQ_TABLE_LEN][2] = {
 147         {3200, 0}, {1600, 0}, {800, 0}, {400, 0}, {200, 0}, {100, 0},
 148         {50, 0}, {25, 0}, {12, 500000}, {6, 250000}, {3, 125000},
 149         {1, 563000}, {0, 781000},
 150 };
 151
 152 struct fxls8962af_chip_info {
 153         const char *name;
 154         const struct iio_chan_spec *channels;
 155         int num_channels;
 156         u8 chip_id;
 157 };
 158
 159 struct fxls8962af_data {
 160         struct regmap *regmap;
 161         const struct fxls8962af_chip_info *chip_info;
 162         struct {
 163                 __le16 channels[3];
 164                 s64 ts __aligned(8);
 165         } scan;
 166         int64_t timestamp, old_timestamp;       /* Only used in hw fifo mode. */
 167         struct iio_mount_matrix orientation;
 168         int irq;
 169         u8 watermark;
 170         u8 enable_event;
 171         u16 lower_thres;
 172         u16 upper_thres;
 173 };
 174
 175 const struct regmap_config fxls8962af_i2c_regmap_conf = {
 176         .reg_bits = 8,
 177         .val_bits = 8,
 178         .max_register = FXLS8962AF_MAX_REG,
 179 };
 180 EXPORT_SYMBOL_NS_GPL(fxls8962af_i2c_regmap_conf, IIO_FXLS8962AF);
 181
 182 const struct regmap_config fxls8962af_spi_regmap_conf = {
 183         .reg_bits = 8,
 184         .pad_bits = 8,
 185         .val_bits = 8,
 186         .max_register = FXLS8962AF_MAX_REG,
 187 };
 188 EXPORT_SYMBOL_NS_GPL(fxls8962af_spi_regmap_conf, IIO_FXLS8962AF);
 189
 190 enum {
 191         fxls8962af_idx_x,
 192         fxls8962af_idx_y,
 193         fxls8962af_idx_z,
 194         fxls8962af_idx_ts,
 195 };
 196
 197 enum fxls8962af_int_pin {
 198         FXLS8962AF_PIN_INT1,
 199         FXLS8962AF_PIN_INT2,
 200 };
 201
 202 static int fxls8962af_power_on(struct fxls8962af_data *data)
 203 {
 204         struct device *dev = regmap_get_device(data->regmap);
 205         int ret;
 206
 207         ret = pm_runtime_resume_and_get(dev);
 208         if (ret)
 209                 dev_err(dev, "failed to power on\n");
 210
 211         return ret;
 212 }
 213
 214 static int fxls8962af_power_off(struct fxls8962af_data *data)
 215 {
 216         struct device *dev = regmap_get_device(data->regmap);
 217         int ret;
 218
 219         pm_runtime_mark_last_busy(dev);
 220         ret = pm_runtime_put_autosuspend(dev);
 221         if (ret)
 222                 dev_err(dev, "failed to power off\n");
 223
 224         return ret;
 225 }
 226
 227 static int fxls8962af_standby(struct fxls8962af_data *data)
 228 {
 229         return regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG1,
 230                                   FXLS8962AF_SENS_CONFIG1_ACTIVE, 0);
 231 }
 232
 233 static int fxls8962af_active(struct fxls8962af_data *data)
 234 {
 235         return regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG1,
 236                                   FXLS8962AF_SENS_CONFIG1_ACTIVE, 1);
 237 }
 238
 239 static int fxls8962af_is_active(struct fxls8962af_data *data)
 240 {
 241         unsigned int reg;
 242         int ret;
 243
 244         ret = regmap_read(data->regmap, FXLS8962AF_SENS_CONFIG1, &reg);
 245         if (ret)
 246                 return ret;
 247
 248         return reg & FXLS8962AF_SENS_CONFIG1_ACTIVE;
 249 }
 250
 251 static int fxls8962af_get_out(struct fxls8962af_data *data,
 252                               struct iio_chan_spec const *chan, int *val)
 253 {
 254         struct device *dev = regmap_get_device(data->regmap);
 255         __le16 raw_val;
 256         int is_active;
 257         int ret;
 258
 259         is_active = fxls8962af_is_active(data);
 260         if (!is_active) {
 261                 ret = fxls8962af_power_on(data);
 262                 if (ret)
 263                         return ret;
 264         }
 265
 266         ret = regmap_bulk_read(data->regmap, chan->address,
 267                                &raw_val, sizeof(data->lower_thres));
 268
 269         if (!is_active)
 270                 fxls8962af_power_off(data);
 271
 272         if (ret) {
 273                 dev_err(dev, "failed to get out reg 0x%lx\n", chan->address);
 274                 return ret;
 275         }
 276
 277         *val = sign_extend32(le16_to_cpu(raw_val),
 278                              chan->scan_type.realbits - 1);
 279
 280         return IIO_VAL_INT;
 281 }
 282
 283 static int fxls8962af_read_avail(struct iio_dev *indio_dev,
 284                                  struct iio_chan_spec const *chan,
 285                                  const int **vals, int *type, int *length,
 286                                  long mask)
 287 {
 288         switch (mask) {
 289         case IIO_CHAN_INFO_SCALE:
 290                 *type = IIO_VAL_INT_PLUS_NANO;
 291                 *vals = (int *)fxls8962af_scale_table;
 292                 *length = ARRAY_SIZE(fxls8962af_scale_table) * 2;
 293                 return IIO_AVAIL_LIST;
 294         case IIO_CHAN_INFO_SAMP_FREQ:
 295                 *type = IIO_VAL_INT_PLUS_MICRO;
 296                 *vals = (int *)fxls8962af_samp_freq_table;
 297                 *length = ARRAY_SIZE(fxls8962af_samp_freq_table) * 2;
 298                 return IIO_AVAIL_LIST;
 299         default:
 300                 return -EINVAL;
 301         }
 302 }
 303
 304 static int fxls8962af_write_raw_get_fmt(struct iio_dev *indio_dev,
 305                                         struct iio_chan_spec const *chan,
 306                                         long mask)
 307 {
 308         switch (mask) {
 309         case IIO_CHAN_INFO_SCALE:
 310                 return IIO_VAL_INT_PLUS_NANO;
 311         case IIO_CHAN_INFO_SAMP_FREQ:
 312                 return IIO_VAL_INT_PLUS_MICRO;
 313         default:
 314                 return IIO_VAL_INT_PLUS_NANO;
 315         }
 316 }
 317
 318 static int fxls8962af_update_config(struct fxls8962af_data *data, u8 reg,
 319                                     u8 mask, u8 val)
 320 {
 321         int ret;
 322         int is_active;
 323
 324         is_active = fxls8962af_is_active(data);
 325         if (is_active) {
 326                 ret = fxls8962af_standby(data);
 327                 if (ret)
 328                         return ret;
 329         }
 330
 331         ret = regmap_update_bits(data->regmap, reg, mask, val);
 332         if (ret)
 333                 return ret;
 334
 335         if (is_active) {
 336                 ret = fxls8962af_active(data);
 337                 if (ret)
 338                         return ret;
 339         }
 340
 341         return 0;
 342 }
 343
 344 static int fxls8962af_set_full_scale(struct fxls8962af_data *data, u32 scale)
 345 {
 346         int i;
 347
 348         for (i = 0; i < ARRAY_SIZE(fxls8962af_scale_table); i++)
 349                 if (scale == fxls8962af_scale_table[i][1])
 350                         break;
 351
 352         if (i == ARRAY_SIZE(fxls8962af_scale_table))
 353                 return -EINVAL;
 354
 355         return fxls8962af_update_config(data, FXLS8962AF_SENS_CONFIG1,
 356                                         FXLS8962AF_SC1_FSR_MASK,
 357                                         FXLS8962AF_SC1_FSR_PREP(i));
 358 }
 359
 360 static unsigned int fxls8962af_read_full_scale(struct fxls8962af_data *data,
 361                                                int *val)
 362 {
 363         int ret;
 364         unsigned int reg;
 365         u8 range_idx;
 366
 367         ret = regmap_read(data->regmap, FXLS8962AF_SENS_CONFIG1, &reg);
 368         if (ret)
 369                 return ret;
 370
 371         range_idx = FXLS8962AF_SC1_FSR_GET(reg);
 372
 373         *val = fxls8962af_scale_table[range_idx][1];
 374
 375         return IIO_VAL_INT_PLUS_NANO;
 376 }
 377
 378 static int fxls8962af_set_samp_freq(struct fxls8962af_data *data, u32 val,
 379                                     u32 val2)
 380 {
 381         int i;
 382
 383         for (i = 0; i < ARRAY_SIZE(fxls8962af_samp_freq_table); i++)
 384                 if (val == fxls8962af_samp_freq_table[i][0] &&
 385                     val2 == fxls8962af_samp_freq_table[i][1])
 386                         break;
 387
 388         if (i == ARRAY_SIZE(fxls8962af_samp_freq_table))
 389                 return -EINVAL;
 390
 391         return fxls8962af_update_config(data, FXLS8962AF_SENS_CONFIG3,
 392                                         FXLS8962AF_SC3_WAKE_ODR_MASK,
 393                                         FXLS8962AF_SC3_WAKE_ODR_PREP(i));
 394 }
 395
 396 static unsigned int fxls8962af_read_samp_freq(struct fxls8962af_data *data,
 397                                               int *val, int *val2)
 398 {
 399         int ret;
 400         unsigned int reg;
 401         u8 range_idx;
 402
 403         ret = regmap_read(data->regmap, FXLS8962AF_SENS_CONFIG3, &reg);
 404         if (ret)
 405                 return ret;
 406
 407         range_idx = FXLS8962AF_SC3_WAKE_ODR_GET(reg);
 408
 409         *val = fxls8962af_samp_freq_table[range_idx][0];
 410         *val2 = fxls8962af_samp_freq_table[range_idx][1];
 411
 412         return IIO_VAL_INT_PLUS_MICRO;
 413 }
 414
 415 static int fxls8962af_read_raw(struct iio_dev *indio_dev,
 416                                struct iio_chan_spec const *chan,
 417                                int *val, int *val2, long mask)
 418 {
 419         struct fxls8962af_data *data = iio_priv(indio_dev);
 420
 421         switch (mask) {
 422         case IIO_CHAN_INFO_RAW:
 423                 switch (chan->type) {
 424                 case IIO_TEMP:
 425                 case IIO_ACCEL:
 426                         return fxls8962af_get_out(data, chan, val);
 427                 default:
 428                         return -EINVAL;
 429                 }
 430         case IIO_CHAN_INFO_OFFSET:
 431                 if (chan->type != IIO_TEMP)
 432                         return -EINVAL;
 433
 434                 *val = FXLS8962AF_TEMP_CENTER_VAL;
 435                 return IIO_VAL_INT;
 436         case IIO_CHAN_INFO_SCALE:
 437                 *val = 0;
 438                 return fxls8962af_read_full_scale(data, val2);
 439         case IIO_CHAN_INFO_SAMP_FREQ:
 440                 return fxls8962af_read_samp_freq(data, val, val2);
 441         default:
 442                 return -EINVAL;
 443         }
 444 }
 445
 446 static int fxls8962af_write_raw(struct iio_dev *indio_dev,
 447                                 struct iio_chan_spec const *chan,
 448                                 int val, int val2, long mask)
 449 {
 450         struct fxls8962af_data *data = iio_priv(indio_dev);
 451         int ret;
 452
 453         switch (mask) {
 454         case IIO_CHAN_INFO_SCALE:
 455                 if (val != 0)
 456                         return -EINVAL;
 457
 458                 ret = iio_device_claim_direct_mode(indio_dev);
 459                 if (ret)
 460                         return ret;
 461
 462                 ret = fxls8962af_set_full_scale(data, val2);
 463
 464                 iio_device_release_direct_mode(indio_dev);
 465                 return ret;
 466         case IIO_CHAN_INFO_SAMP_FREQ:
 467                 ret = iio_device_claim_direct_mode(indio_dev);
 468                 if (ret)
 469                         return ret;
 470
 471                 ret = fxls8962af_set_samp_freq(data, val, val2);
 472
 473                 iio_device_release_direct_mode(indio_dev);
 474                 return ret;
 475         default:
 476                 return -EINVAL;
 477         }
 478 }
 479
 480 static int fxls8962af_event_setup(struct fxls8962af_data *data, int state)
 481 {
 482         /* Enable wakeup interrupt */
 483         int mask = FXLS8962AF_INT_EN_SDCD_OT_EN;
 484         int value = state ? mask : 0;
 485
 486         return regmap_update_bits(data->regmap, FXLS8962AF_INT_EN, mask, value);
 487 }
 488
 489 static int fxls8962af_set_watermark(struct iio_dev *indio_dev, unsigned val)
 490 {
 491         struct fxls8962af_data *data = iio_priv(indio_dev);
 492
 493         if (val > FXLS8962AF_FIFO_LENGTH)
 494                 val = FXLS8962AF_FIFO_LENGTH;
 495
 496         data->watermark = val;
 497
 498         return 0;
 499 }
 500
 501 static int __fxls8962af_set_thresholds(struct fxls8962af_data *data,
 502                                        const struct iio_chan_spec *chan,
 503                                        enum iio_event_direction dir,
 504                                        int val)
 505 {
 506         switch (dir) {
 507         case IIO_EV_DIR_FALLING:
 508                 data->lower_thres = val;
 509                 return regmap_bulk_write(data->regmap, FXLS8962AF_SDCD_LTHS_LSB,
 510                                 &data->lower_thres, sizeof(data->lower_thres));
 511         case IIO_EV_DIR_RISING:
 512                 data->upper_thres = val;
 513                 return regmap_bulk_write(data->regmap, FXLS8962AF_SDCD_UTHS_LSB,
 514                                 &data->upper_thres, sizeof(data->upper_thres));
 515         default:
 516                 return -EINVAL;
 517         }
 518 }
 519
 520 static int fxls8962af_read_event(struct iio_dev *indio_dev,
 521                                  const struct iio_chan_spec *chan,
 522                                  enum iio_event_type type,
 523                                  enum iio_event_direction dir,
 524                                  enum iio_event_info info,
 525                                  int *val, int *val2)
 526 {
 527         struct fxls8962af_data *data = iio_priv(indio_dev);
 528         int ret;
 529
 530         if (type != IIO_EV_TYPE_THRESH)
 531                 return -EINVAL;
 532
 533         switch (dir) {
 534         case IIO_EV_DIR_FALLING:
 535                 ret = regmap_bulk_read(data->regmap, FXLS8962AF_SDCD_LTHS_LSB,
 536                                        &data->lower_thres, sizeof(data->lower_thres));
 537                 if (ret)
 538                         return ret;
 539
 540                 *val = sign_extend32(data->lower_thres, chan->scan_type.realbits - 1);
 541                 return IIO_VAL_INT;
 542         case IIO_EV_DIR_RISING:
 543                 ret = regmap_bulk_read(data->regmap, FXLS8962AF_SDCD_UTHS_LSB,
 544                                        &data->upper_thres, sizeof(data->upper_thres));
 545                 if (ret)
 546                         return ret;
 547
 548                 *val = sign_extend32(data->upper_thres, chan->scan_type.realbits - 1);
 549                 return IIO_VAL_INT;
 550         default:
 551                 return -EINVAL;
 552         }
 553 }
 554
 555 static int fxls8962af_write_event(struct iio_dev *indio_dev,
 556                                   const struct iio_chan_spec *chan,
 557                                   enum iio_event_type type,
 558                                   enum iio_event_direction dir,
 559                                   enum iio_event_info info,
 560                                   int val, int val2)
 561 {
 562         struct fxls8962af_data *data = iio_priv(indio_dev);
 563         int ret, val_masked;
 564
 565         if (type != IIO_EV_TYPE_THRESH)
 566                 return -EINVAL;
 567
 568         if (val < -2048 || val > 2047)
 569                 return -EINVAL;
 570
 571         if (data->enable_event)
 572                 return -EBUSY;
 573
 574         val_masked = val & GENMASK(11, 0);
 575         if (fxls8962af_is_active(data)) {
 576                 ret = fxls8962af_standby(data);
 577                 if (ret)
 578                         return ret;
 579
 580                 ret = __fxls8962af_set_thresholds(data, chan, dir, val_masked);
 581                 if (ret)
 582                         return ret;
 583
 584                 return fxls8962af_active(data);
 585         } else {
 586                 return __fxls8962af_set_thresholds(data, chan, dir, val_masked);
 587         }
 588 }
 589
 590 static int
 591 fxls8962af_read_event_config(struct iio_dev *indio_dev,
 592                              const struct iio_chan_spec *chan,
 593                              enum iio_event_type type,
 594                              enum iio_event_direction dir)
 595 {
 596         struct fxls8962af_data *data = iio_priv(indio_dev);
 597
 598         if (type != IIO_EV_TYPE_THRESH)
 599                 return -EINVAL;
 600
 601         switch (chan->channel2) {
 602         case IIO_MOD_X:
 603                 return !!(FXLS8962AF_SDCD_CONFIG1_X_OT_EN & data->enable_event);
 604         case IIO_MOD_Y:
 605                 return !!(FXLS8962AF_SDCD_CONFIG1_Y_OT_EN & data->enable_event);
 606         case IIO_MOD_Z:
 607                 return !!(FXLS8962AF_SDCD_CONFIG1_Z_OT_EN & data->enable_event);
 608         default:
 609                 return -EINVAL;
 610         }
 611 }
 612
 613 static int
 614 fxls8962af_write_event_config(struct iio_dev *indio_dev,
 615                               const struct iio_chan_spec *chan,
 616                               enum iio_event_type type,
 617                               enum iio_event_direction dir, int state)
 618 {
 619         struct fxls8962af_data *data = iio_priv(indio_dev);
 620         u8 enable_event, enable_bits;
 621         int ret, value;
 622
 623         if (type != IIO_EV_TYPE_THRESH)
 624                 return -EINVAL;
 625
 626         switch (chan->channel2) {
 627         case IIO_MOD_X:
 628                 enable_bits = FXLS8962AF_SDCD_CONFIG1_X_OT_EN;
 629                 break;
 630         case IIO_MOD_Y:
 631                 enable_bits = FXLS8962AF_SDCD_CONFIG1_Y_OT_EN;
 632                 break;
 633         case IIO_MOD_Z:
 634                 enable_bits = FXLS8962AF_SDCD_CONFIG1_Z_OT_EN;
 635                 break;
 636         default:
 637                 return -EINVAL;
 638         }
 639
 640         if (state)
 641                 enable_event = data->enable_event | enable_bits;
 642         else
 643                 enable_event = data->enable_event & ~enable_bits;
 644
 645         if (data->enable_event == enable_event)
 646                 return 0;
 647
 648         ret = fxls8962af_standby(data);
 649         if (ret)
 650                 return ret;
 651
 652         /* Enable events */
 653         value = enable_event | FXLS8962AF_SDCD_CONFIG1_OT_ELE;
 654         ret = regmap_write(data->regmap, FXLS8962AF_SDCD_CONFIG1, value);
 655         if (ret)
 656                 return ret;
 657
 658         /*
 659          * Enable update of SDCD_REF_X/Y/Z values with the current decimated and
 660          * trimmed X/Y/Z acceleration input data. This allows for acceleration
 661          * slope detection with Data(n) to Data(n–1) always used as the input
 662          * to the window comparator.
 663          */
 664         value = enable_event ?
 665                 FXLS8962AF_SDCD_CONFIG2_SDCD_EN | FXLS8962AF_SC2_REF_UPDM_AC :
 666                 0x00;
 667         ret = regmap_write(data->regmap, FXLS8962AF_SDCD_CONFIG2, value);
 668         if (ret)
 669                 return ret;
 670
 671         ret = fxls8962af_event_setup(data, state);
 672         if (ret)
 673                 return ret;
 674
 675         data->enable_event = enable_event;
 676
 677         if (data->enable_event) {
 678                 fxls8962af_active(data);
 679                 ret = fxls8962af_power_on(data);
 680         } else {
 681                 ret = iio_device_claim_direct_mode(indio_dev);
 682                 if (ret)
 683                         return ret;
 684
 685                 /* Not in buffered mode so disable power */
 686                 ret = fxls8962af_power_off(data);
 687
 688                 iio_device_release_direct_mode(indio_dev);
 689         }
 690
 691         return ret;
 692 }
 693
 694 static const struct iio_event_spec fxls8962af_event[] = {
 695         {
 696                 .type = IIO_EV_TYPE_THRESH,
 697                 .dir = IIO_EV_DIR_EITHER,
 698                 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
 699         },
 700         {
 701                 .type = IIO_EV_TYPE_THRESH,
 702                 .dir = IIO_EV_DIR_FALLING,
 703                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
 704         },
 705         {
 706                 .type = IIO_EV_TYPE_THRESH,
 707                 .dir = IIO_EV_DIR_RISING,
 708                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
 709         },
 710 };
 711
 712 #define FXLS8962AF_CHANNEL(axis, reg, idx) { \
 713         .type = IIO_ACCEL, \
 714         .address = reg, \
 715         .modified = 1, \
 716         .channel2 = IIO_MOD_##axis, \
 717         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 718         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
 719                                     BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 720         .info_mask_shared_by_type_available = BIT(IIO_CHAN_INFO_SCALE) | \
 721                                               BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 722         .scan_index = idx, \
 723         .scan_type = { \
 724                 .sign = 's', \
 725                 .realbits = 12, \
 726                 .storagebits = 16, \
 727                 .endianness = IIO_LE, \
 728         }, \
 729         .event_spec = fxls8962af_event, \
 730         .num_event_specs = ARRAY_SIZE(fxls8962af_event), \
 731 }
 732
 733 #define FXLS8962AF_TEMP_CHANNEL { \
 734         .type = IIO_TEMP, \
 735         .address = FXLS8962AF_TEMP_OUT, \
 736         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
 737                               BIT(IIO_CHAN_INFO_OFFSET),\
 738         .scan_index = -1, \
 739         .scan_type = { \
 740                 .realbits = 8, \
 741                 .storagebits = 8, \
 742         }, \
 743 }
 744
 745 static const struct iio_chan_spec fxls8962af_channels[] = {
 746         FXLS8962AF_CHANNEL(X, FXLS8962AF_OUT_X_LSB, fxls8962af_idx_x),
 747         FXLS8962AF_CHANNEL(Y, FXLS8962AF_OUT_Y_LSB, fxls8962af_idx_y),
 748         FXLS8962AF_CHANNEL(Z, FXLS8962AF_OUT_Z_LSB, fxls8962af_idx_z),
 749         IIO_CHAN_SOFT_TIMESTAMP(fxls8962af_idx_ts),
 750         FXLS8962AF_TEMP_CHANNEL,
 751 };
 752
 753 static const struct fxls8962af_chip_info fxls_chip_info_table[] = {
 754         [fxls8962af] = {
 755                 .chip_id = FXLS8962AF_DEVICE_ID,
 756                 .name = "fxls8962af",
 757                 .channels = fxls8962af_channels,
 758                 .num_channels = ARRAY_SIZE(fxls8962af_channels),
 759         },
 760         [fxls8964af] = {
 761                 .chip_id = FXLS8964AF_DEVICE_ID,
 762                 .name = "fxls8964af",
 763                 .channels = fxls8962af_channels,
 764                 .num_channels = ARRAY_SIZE(fxls8962af_channels),
 765         },
 766 };
 767
 768 static const struct iio_info fxls8962af_info = {
 769         .read_raw = &fxls8962af_read_raw,
 770         .write_raw = &fxls8962af_write_raw,
 771         .write_raw_get_fmt = fxls8962af_write_raw_get_fmt,
 772         .read_event_value = fxls8962af_read_event,
 773         .write_event_value = fxls8962af_write_event,
 774         .read_event_config = fxls8962af_read_event_config,
 775         .write_event_config = fxls8962af_write_event_config,
 776         .read_avail = fxls8962af_read_avail,
 777         .hwfifo_set_watermark = fxls8962af_set_watermark,
 778 };
 779
 780 static int fxls8962af_reset(struct fxls8962af_data *data)
 781 {
 782         struct device *dev = regmap_get_device(data->regmap);
 783         unsigned int reg;
 784         int ret;
 785
 786         ret = regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG1,
 787                                  FXLS8962AF_SENS_CONFIG1_RST,
 788                                  FXLS8962AF_SENS_CONFIG1_RST);
 789         if (ret)
 790                 return ret;
 791
 792         /* TBOOT1, TBOOT2, specifies we have to wait between 1 - 17.7ms */
 793         ret = regmap_read_poll_timeout(data->regmap, FXLS8962AF_INT_STATUS, reg,
 794                                        (reg & FXLS8962AF_INT_STATUS_SRC_BOOT),
 795                                        1000, 18000);
 796         if (ret == -ETIMEDOUT)
 797                 dev_err(dev, "reset timeout, int_status = 0x%x\n", reg);
 798
 799         return ret;
 800 }
 801
 802 static int __fxls8962af_fifo_set_mode(struct fxls8962af_data *data, bool onoff)
 803 {
 804         int ret;
 805
 806         /* Enable watermark at max fifo size */
 807         ret = regmap_update_bits(data->regmap, FXLS8962AF_BUF_CONFIG2,
 808                                  FXLS8962AF_BUF_CONFIG2_BUF_WMRK,
 809                                  data->watermark);
 810         if (ret)
 811                 return ret;
 812
 813         return regmap_update_bits(data->regmap, FXLS8962AF_BUF_CONFIG1,
 814                                   FXLS8962AF_BC1_BUF_MODE_MASK,
 815                                   FXLS8962AF_BC1_BUF_MODE_PREP(onoff));
 816 }
 817
 818 static int fxls8962af_buffer_preenable(struct iio_dev *indio_dev)
 819 {
 820         return fxls8962af_power_on(iio_priv(indio_dev));
 821 }
 822
 823 static int fxls8962af_buffer_postenable(struct iio_dev *indio_dev)
 824 {
 825         struct fxls8962af_data *data = iio_priv(indio_dev);
 826         int ret;
 827
 828         fxls8962af_standby(data);
 829
 830         /* Enable buffer interrupt */
 831         ret = regmap_update_bits(data->regmap, FXLS8962AF_INT_EN,
 832                                  FXLS8962AF_INT_EN_BUF_EN,
 833                                  FXLS8962AF_INT_EN_BUF_EN);
 834         if (ret)
 835                 return ret;
 836
 837         ret = __fxls8962af_fifo_set_mode(data, true);
 838
 839         fxls8962af_active(data);
 840
 841         return ret;
 842 }
 843
 844 static int fxls8962af_buffer_predisable(struct iio_dev *indio_dev)
 845 {
 846         struct fxls8962af_data *data = iio_priv(indio_dev);
 847         int ret;
 848
 849         fxls8962af_standby(data);
 850
 851         /* Disable buffer interrupt */
 852         ret = regmap_update_bits(data->regmap, FXLS8962AF_INT_EN,
 853                                  FXLS8962AF_INT_EN_BUF_EN, 0);
 854         if (ret)
 855                 return ret;
 856
 857         ret = __fxls8962af_fifo_set_mode(data, false);
 858
 859         if (data->enable_event)
 860                 fxls8962af_active(data);
 861
 862         return ret;
 863 }
 864
 865 static int fxls8962af_buffer_postdisable(struct iio_dev *indio_dev)
 866 {
 867         struct fxls8962af_data *data = iio_priv(indio_dev);
 868
 869         if (!data->enable_event)
 870                 fxls8962af_power_off(data);
 871
 872         return 0;
 873 }
 874
 875 static const struct iio_buffer_setup_ops fxls8962af_buffer_ops = {
 876         .preenable = fxls8962af_buffer_preenable,
 877         .postenable = fxls8962af_buffer_postenable,
 878         .predisable = fxls8962af_buffer_predisable,
 879         .postdisable = fxls8962af_buffer_postdisable,
 880 };
 881
 882 static int fxls8962af_i2c_raw_read_errata3(struct fxls8962af_data *data,
 883                                            u16 *buffer, int samples,
 884                                            int sample_length)
 885 {
 886         int i, ret;
 887
 888         for (i = 0; i < samples; i++) {
 889                 ret = regmap_raw_read(data->regmap, FXLS8962AF_BUF_X_LSB,
 890                                       &buffer[i * 3], sample_length);
 891                 if (ret)
 892                         return ret;
 893         }
 894
 895         return 0;
 896 }
 897
 898 static int fxls8962af_fifo_transfer(struct fxls8962af_data *data,
 899                                     u16 *buffer, int samples)
 900 {
 901         struct device *dev = regmap_get_device(data->regmap);
 902         int sample_length = 3 * sizeof(*buffer);
 903         int total_length = samples * sample_length;
 904         int ret;
 905
 906         if (i2c_verify_client(dev) &&
 907             data->chip_info->chip_id == FXLS8962AF_DEVICE_ID)
 908                 /*
 909                  * Due to errata bug (only applicable on fxls8962af):
 910                  * E3: FIFO burst read operation error using I2C interface
 911                  * We have to avoid burst reads on I2C..
 912                  */
 913                 ret = fxls8962af_i2c_raw_read_errata3(data, buffer, samples,
 914                                                       sample_length);
 915         else
 916                 ret = regmap_raw_read(data->regmap, FXLS8962AF_BUF_X_LSB, buffer,
 917                                       total_length);
 918
 919         if (ret)
 920                 dev_err(dev, "Error transferring data from fifo: %d\n", ret);
 921
 922         return ret;
 923 }
 924
 925 static int fxls8962af_fifo_flush(struct iio_dev *indio_dev)
 926 {
 927         struct fxls8962af_data *data = iio_priv(indio_dev);
 928         struct device *dev = regmap_get_device(data->regmap);
 929         u16 buffer[FXLS8962AF_FIFO_LENGTH * 3];
 930         uint64_t sample_period;
 931         unsigned int reg;
 932         int64_t tstamp;
 933         int ret, i;
 934         u8 count;
 935
 936         ret = regmap_read(data->regmap, FXLS8962AF_BUF_STATUS, &reg);
 937         if (ret)
 938                 return ret;
 939
 940         if (reg & FXLS8962AF_BUF_STATUS_BUF_OVF) {
 941                 dev_err(dev, "Buffer overflow");
 942                 return -EOVERFLOW;
 943         }
 944
 945         count = reg & FXLS8962AF_BUF_STATUS_BUF_CNT;
 946         if (!count)
 947                 return 0;
 948
 949         data->old_timestamp = data->timestamp;
 950         data->timestamp = iio_get_time_ns(indio_dev);
 951
 952         /*
 953          * Approximate timestamps for each of the sample based on the sampling,
 954          * frequency, timestamp for last sample and number of samples.
 955          */
 956         sample_period = (data->timestamp - data->old_timestamp);
 957         do_div(sample_period, count);
 958         tstamp = data->timestamp - (count - 1) * sample_period;
 959
 960         ret = fxls8962af_fifo_transfer(data, buffer, count);
 961         if (ret)
 962                 return ret;
 963
 964         /* Demux hw FIFO into kfifo. */
 965         for (i = 0; i < count; i++) {
 966                 int j, bit;
 967
 968                 j = 0;
 969                 for_each_set_bit(bit, indio_dev->active_scan_mask,
 970                                  indio_dev->masklength) {
 971                         memcpy(&data->scan.channels[j++], &buffer[i * 3 + bit],
 972                                sizeof(data->scan.channels[0]));
 973                 }
 974
 975                 iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 976                                                    tstamp);
 977
 978                 tstamp += sample_period;
 979         }
 980
 981         return count;
 982 }
 983
 984 static int fxls8962af_event_interrupt(struct iio_dev *indio_dev)
 985 {
 986         struct fxls8962af_data *data = iio_priv(indio_dev);
 987         s64 ts = iio_get_time_ns(indio_dev);
 988         unsigned int reg;
 989         u64 ev_code;
 990         int ret;
 991
 992         ret = regmap_read(data->regmap, FXLS8962AF_SDCD_INT_SRC1, &reg);
 993         if (ret)
 994                 return ret;
 995
 996         if (reg & FXLS8962AF_SDCD_INT_SRC1_X_OT) {
 997                 ev_code = reg & FXLS8962AF_SDCD_INT_SRC1_X_POL ?
 998                         IIO_EV_DIR_RISING : IIO_EV_DIR_FALLING;
 999                 iio_push_event(indio_dev,
1000                                 IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X,
1001                                         IIO_EV_TYPE_THRESH, ev_code), ts);
1002         }
1003
1004         if (reg & FXLS8962AF_SDCD_INT_SRC1_Y_OT) {
1005                 ev_code = reg & FXLS8962AF_SDCD_INT_SRC1_Y_POL ?
1006                         IIO_EV_DIR_RISING : IIO_EV_DIR_FALLING;
1007                 iio_push_event(indio_dev,
1008                                 IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X,
1009                                         IIO_EV_TYPE_THRESH, ev_code), ts);
1010         }
1011
1012         if (reg & FXLS8962AF_SDCD_INT_SRC1_Z_OT) {
1013                 ev_code = reg & FXLS8962AF_SDCD_INT_SRC1_Z_POL ?
1014                         IIO_EV_DIR_RISING : IIO_EV_DIR_FALLING;
1015                 iio_push_event(indio_dev,
1016                                 IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X,
1017                                         IIO_EV_TYPE_THRESH, ev_code), ts);
1018         }
1019
1020         return 0;
1021 }
1022
1023 static irqreturn_t fxls8962af_interrupt(int irq, void *p)
1024 {
1025         struct iio_dev *indio_dev = p;
1026         struct fxls8962af_data *data = iio_priv(indio_dev);
1027         unsigned int reg;
1028         int ret;
1029
1030         ret = regmap_read(data->regmap, FXLS8962AF_INT_STATUS, &reg);
1031         if (ret)
1032                 return IRQ_NONE;
1033
1034         if (reg & FXLS8962AF_INT_STATUS_SRC_BUF) {
1035                 ret = fxls8962af_fifo_flush(indio_dev);
1036                 if (ret < 0)
1037                         return IRQ_NONE;
1038
1039                 return IRQ_HANDLED;
1040         }
1041
1042         if (reg & FXLS8962AF_INT_STATUS_SRC_SDCD_OT) {
1043                 ret = fxls8962af_event_interrupt(indio_dev);
1044                 if (ret < 0)
1045                         return IRQ_NONE;
1046
1047                 return IRQ_HANDLED;
1048         }
1049
1050         return IRQ_NONE;
1051 }
1052
1053 static void fxls8962af_pm_disable(void *dev_ptr)
1054 {
1055         struct device *dev = dev_ptr;
1056         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1057
1058         pm_runtime_disable(dev);
1059         pm_runtime_set_suspended(dev);
1060         pm_runtime_put_noidle(dev);
1061
1062         fxls8962af_standby(iio_priv(indio_dev));
1063 }
1064
1065 static void fxls8962af_get_irq(struct device_node *of_node,
1066                                enum fxls8962af_int_pin *pin)
1067 {
1068         int irq;
1069
1070         irq = of_irq_get_byname(of_node, "INT2");
1071         if (irq > 0) {
1072                 *pin = FXLS8962AF_PIN_INT2;
1073                 return;
1074         }
1075
1076         *pin = FXLS8962AF_PIN_INT1;
1077 }
1078
1079 static int fxls8962af_irq_setup(struct iio_dev *indio_dev, int irq)
1080 {
1081         struct fxls8962af_data *data = iio_priv(indio_dev);
1082         struct device *dev = regmap_get_device(data->regmap);
1083         unsigned long irq_type;
1084         bool irq_active_high;
1085         enum fxls8962af_int_pin int_pin;
1086         u8 int_pin_sel;
1087         int ret;
1088
1089         fxls8962af_get_irq(dev->of_node, &int_pin);
1090         switch (int_pin) {
1091         case FXLS8962AF_PIN_INT1:
1092                 int_pin_sel = FXLS8962AF_INT_PIN_SEL_INT1;
1093                 break;
1094         case FXLS8962AF_PIN_INT2:
1095                 int_pin_sel = FXLS8962AF_INT_PIN_SEL_INT2;
1096                 break;
1097         default:
1098                 dev_err(dev, "unsupported int pin selected\n");
1099                 return -EINVAL;
1100         }
1101
1102         ret = regmap_update_bits(data->regmap, FXLS8962AF_INT_PIN_SEL,
1103                                  FXLS8962AF_INT_PIN_SEL_MASK, int_pin_sel);
1104         if (ret)
1105                 return ret;
1106
1107         irq_type = irqd_get_trigger_type(irq_get_irq_data(irq));
1108
1109         switch (irq_type) {
1110         case IRQF_TRIGGER_HIGH:
1111         case IRQF_TRIGGER_RISING:
1112                 irq_active_high = true;
1113                 break;
1114         case IRQF_TRIGGER_LOW:
1115         case IRQF_TRIGGER_FALLING:
1116                 irq_active_high = false;
1117                 break;
1118         default:
1119                 dev_info(dev, "mode %lx unsupported\n", irq_type);
1120                 return -EINVAL;
1121         }
1122
1123         ret = regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG4,
1124                                  FXLS8962AF_SC4_INT_POL_MASK,
1125                                  FXLS8962AF_SC4_INT_POL_PREP(irq_active_high));
1126         if (ret)
1127                 return ret;
1128
1129         if (device_property_read_bool(dev, "drive-open-drain")) {
1130                 ret = regmap_update_bits(data->regmap, FXLS8962AF_SENS_CONFIG4,
1131                                          FXLS8962AF_SC4_INT_PP_OD_MASK,
1132                                          FXLS8962AF_SC4_INT_PP_OD_PREP(1));
1133                 if (ret)
1134                         return ret;
1135
1136                 irq_type |= IRQF_SHARED;
1137         }
1138
1139         return devm_request_threaded_irq(dev,
1140                                          irq,
1141                                          NULL, fxls8962af_interrupt,
1142                                          irq_type | IRQF_ONESHOT,
1143                                          indio_dev->name, indio_dev);
1144 }
1145
1146 int fxls8962af_core_probe(struct device *dev, struct regmap *regmap, int irq)
1147 {
1148         struct fxls8962af_data *data;
1149         struct iio_dev *indio_dev;
1150         unsigned int reg;
1151         int ret, i;
1152
1153         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
1154         if (!indio_dev)
1155                 return -ENOMEM;
1156
1157         data = iio_priv(indio_dev);
1158         dev_set_drvdata(dev, indio_dev);
1159         data->regmap = regmap;
1160         data->irq = irq;
1161
1162         ret = iio_read_mount_matrix(dev, &data->orientation);
1163         if (ret)
1164                 return ret;
1165
1166         ret = devm_regulator_get_enable(dev, "vdd");
1167         if (ret)
1168                 return dev_err_probe(dev, ret,
1169                                      "Failed to get vdd regulator\n");
1170
1171         ret = regmap_read(data->regmap, FXLS8962AF_WHO_AM_I, &reg);
1172         if (ret)
1173                 return ret;
1174
1175         for (i = 0; i < ARRAY_SIZE(fxls_chip_info_table); i++) {
1176                 if (fxls_chip_info_table[i].chip_id == reg) {
1177                         data->chip_info = &fxls_chip_info_table[i];
1178                         break;
1179                 }
1180         }
1181         if (i == ARRAY_SIZE(fxls_chip_info_table)) {
1182                 dev_err(dev, "failed to match device in table\n");
1183                 return -ENXIO;
1184         }
1185
1186         indio_dev->channels = data->chip_info->channels;
1187         indio_dev->num_channels = data->chip_info->num_channels;
1188         indio_dev->name = data->chip_info->name;
1189         indio_dev->info = &fxls8962af_info;
1190         indio_dev->modes = INDIO_DIRECT_MODE;
1191
1192         ret = fxls8962af_reset(data);
1193         if (ret)
1194                 return ret;
1195
1196         if (irq) {
1197                 ret = fxls8962af_irq_setup(indio_dev, irq);
1198                 if (ret)
1199                         return ret;
1200
1201                 ret = devm_iio_kfifo_buffer_setup(dev, indio_dev,
1202                                                   &fxls8962af_buffer_ops);
1203                 if (ret)
1204                         return ret;
1205         }
1206
1207         ret = pm_runtime_set_active(dev);
1208         if (ret)
1209                 return ret;
1210
1211         pm_runtime_enable(dev);
1212         pm_runtime_set_autosuspend_delay(dev, FXLS8962AF_AUTO_SUSPEND_DELAY_MS);
1213         pm_runtime_use_autosuspend(dev);
1214
1215         ret = devm_add_action_or_reset(dev, fxls8962af_pm_disable, dev);
1216         if (ret)
1217                 return ret;
1218
1219         if (device_property_read_bool(dev, "wakeup-source"))
1220                 device_init_wakeup(dev, true);
1221
1222         return devm_iio_device_register(dev, indio_dev);
1223 }
1224 EXPORT_SYMBOL_NS_GPL(fxls8962af_core_probe, IIO_FXLS8962AF);
1225
1226 static int fxls8962af_runtime_suspend(struct device *dev)
1227 {
1228         struct fxls8962af_data *data = iio_priv(dev_get_drvdata(dev));
1229         int ret;
1230
1231         ret = fxls8962af_standby(data);
1232         if (ret) {
1233                 dev_err(dev, "powering off device failed\n");
1234                 return ret;
1235         }
1236
1237         return 0;
1238 }
1239
1240 static int fxls8962af_runtime_resume(struct device *dev)
1241 {
1242         struct fxls8962af_data *data = iio_priv(dev_get_drvdata(dev));
1243
1244         return fxls8962af_active(data);
1245 }
1246
1247 static int fxls8962af_suspend(struct device *dev)
1248 {
1249         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1250         struct fxls8962af_data *data = iio_priv(indio_dev);
1251
1252         if (device_may_wakeup(dev) && data->enable_event) {
1253                 enable_irq_wake(data->irq);
1254
1255                 /*
1256                  * Disable buffer, as the buffer is so small the device will wake
1257                  * almost immediately.
1258                  */
1259                 if (iio_buffer_enabled(indio_dev))
1260                         fxls8962af_buffer_predisable(indio_dev);
1261         } else {
1262                 fxls8962af_runtime_suspend(dev);
1263         }
1264
1265         return 0;
1266 }
1267
1268 static int fxls8962af_resume(struct device *dev)
1269 {
1270         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1271         struct fxls8962af_data *data = iio_priv(indio_dev);
1272
1273         if (device_may_wakeup(dev) && data->enable_event) {
1274                 disable_irq_wake(data->irq);
1275
1276                 if (iio_buffer_enabled(indio_dev))
1277                         fxls8962af_buffer_postenable(indio_dev);
1278         } else {
1279                 fxls8962af_runtime_resume(dev);
1280         }
1281
1282         return 0;
1283 }
1284
1285 EXPORT_NS_GPL_DEV_PM_OPS(fxls8962af_pm_ops, IIO_FXLS8962AF) = {
1286         SYSTEM_SLEEP_PM_OPS(fxls8962af_suspend, fxls8962af_resume)
1287         RUNTIME_PM_OPS(fxls8962af_runtime_suspend, fxls8962af_runtime_resume, NULL)
1288 };
1289
1290 MODULE_AUTHOR("Sean Nyekjaer <sean@geanix.com>");
1291 MODULE_DESCRIPTION("NXP FXLS8962AF/FXLS8964AF accelerometer driver");
1292 MODULE_LICENSE("GPL v2");