drivers/iio/proximity/sx9310.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2018 Google LLC.
   4  *
   5  * Driver for Semtech's SX9310/SX9311 capacitive proximity/button solution.
   6  * Based on SX9500 driver and Semtech driver using the input framework
   7  * <https://my.syncplicity.com/share/teouwsim8niiaud/
   8  *          linux-driver-SX9310_NoSmartHSensing>.
   9  * Reworked in April 2019 by Evan Green <evgreen@chromium.org>
  10  * and in January 2020 by Daniel Campello <campello@chromium.org>.
  11  */
  12
  13 #include <linux/acpi.h>
  14 #include <linux/bitfield.h>
  15 #include <linux/delay.h>
  16 #include <linux/i2c.h>
  17 #include <linux/irq.h>
  18 #include <linux/kernel.h>
  19 #include <linux/log2.h>
  20 #include <linux/mod_devicetable.h>
  21 #include <linux/module.h>
  22 #include <linux/pm.h>
  23 #include <linux/regmap.h>
  24 #include <linux/regulator/consumer.h>
  25 #include <linux/slab.h>
  26
  27 #include <linux/iio/buffer.h>
  28 #include <linux/iio/events.h>
  29 #include <linux/iio/iio.h>
  30 #include <linux/iio/sysfs.h>
  31 #include <linux/iio/trigger.h>
  32 #include <linux/iio/triggered_buffer.h>
  33 #include <linux/iio/trigger_consumer.h>
  34
  35 /* Register definitions. */
  36 #define SX9310_REG_IRQ_SRC                              0x00
  37 #define SX9310_REG_STAT0                                0x01
  38 #define SX9310_REG_STAT1                                0x02
  39 #define SX9310_REG_STAT1_COMPSTAT_MASK                  GENMASK(3, 0)
  40 #define SX9310_REG_IRQ_MSK                              0x03
  41 #define   SX9310_CONVDONE_IRQ                           BIT(3)
  42 #define   SX9310_FAR_IRQ                                BIT(5)
  43 #define   SX9310_CLOSE_IRQ                              BIT(6)
  44 #define SX9310_REG_IRQ_FUNC                             0x04
  45
  46 #define SX9310_REG_PROX_CTRL0                           0x10
  47 #define   SX9310_REG_PROX_CTRL0_SENSOREN_MASK           GENMASK(3, 0)
  48 #define   SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK         GENMASK(7, 4)
  49 #define   SX9310_REG_PROX_CTRL0_SCANPERIOD_15MS         0x01
  50 #define SX9310_REG_PROX_CTRL1                           0x11
  51 #define SX9310_REG_PROX_CTRL2                           0x12
  52 #define   SX9310_REG_PROX_CTRL2_COMBMODE_MASK           GENMASK(7, 6)
  53 #define   SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1_CS2_CS3 (0x03 << 6)
  54 #define   SX9310_REG_PROX_CTRL2_COMBMODE_CS1_CS2        (0x02 << 6)
  55 #define   SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1        (0x01 << 6)
  56 #define   SX9310_REG_PROX_CTRL2_COMBMODE_CS3            (0x00 << 6)
  57 #define   SX9310_REG_PROX_CTRL2_SHIELDEN_MASK           GENMASK(3, 2)
  58 #define   SX9310_REG_PROX_CTRL2_SHIELDEN_DYNAMIC        (0x01 << 2)
  59 #define   SX9310_REG_PROX_CTRL2_SHIELDEN_GROUND         (0x02 << 2)
  60 #define SX9310_REG_PROX_CTRL3                           0x13
  61 #define   SX9310_REG_PROX_CTRL3_GAIN0_MASK              GENMASK(3, 2)
  62 #define   SX9310_REG_PROX_CTRL3_GAIN0_X8                (0x03 << 2)
  63 #define   SX9310_REG_PROX_CTRL3_GAIN12_MASK             GENMASK(1, 0)
  64 #define   SX9310_REG_PROX_CTRL3_GAIN12_X4               0x02
  65 #define SX9310_REG_PROX_CTRL4                           0x14
  66 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_MASK         GENMASK(2, 0)
  67 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST       0x07
  68 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_FINE    0x06
  69 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_FINE         0x05
  70 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM       0x04
  71 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM_COARSE 0x03
  72 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_COARSE       0x02
  73 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_COARSE  0x01
  74 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_COARSEST     0x00
  75 #define SX9310_REG_PROX_CTRL5                           0x15
  76 #define   SX9310_REG_PROX_CTRL5_RANGE_SMALL             (0x03 << 6)
  77 #define   SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK        GENMASK(3, 2)
  78 #define   SX9310_REG_PROX_CTRL5_STARTUPSENS_CS1         (0x01 << 2)
  79 #define   SX9310_REG_PROX_CTRL5_RAWFILT_MASK            GENMASK(1, 0)
  80 #define   SX9310_REG_PROX_CTRL5_RAWFILT_SHIFT           0
  81 #define   SX9310_REG_PROX_CTRL5_RAWFILT_1P25            0x02
  82 #define SX9310_REG_PROX_CTRL6                           0x16
  83 #define   SX9310_REG_PROX_CTRL6_AVGTHRESH_DEFAULT       0x20
  84 #define SX9310_REG_PROX_CTRL7                           0x17
  85 #define   SX9310_REG_PROX_CTRL7_AVGNEGFILT_2            (0x01 << 3)
  86 #define   SX9310_REG_PROX_CTRL7_AVGPOSFILT_MASK         GENMASK(2, 0)
  87 #define   SX9310_REG_PROX_CTRL7_AVGPOSFILT_SHIFT        0
  88 #define   SX9310_REG_PROX_CTRL7_AVGPOSFILT_512          0x05
  89 #define SX9310_REG_PROX_CTRL8                           0x18
  90 #define   SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK          GENMASK(7, 3)
  91 #define SX9310_REG_PROX_CTRL9                           0x19
  92 #define   SX9310_REG_PROX_CTRL8_9_PTHRESH_28            (0x08 << 3)
  93 #define   SX9310_REG_PROX_CTRL8_9_PTHRESH_96            (0x11 << 3)
  94 #define   SX9310_REG_PROX_CTRL8_9_BODYTHRESH_900        0x03
  95 #define   SX9310_REG_PROX_CTRL8_9_BODYTHRESH_1500       0x05
  96 #define SX9310_REG_PROX_CTRL10                          0x1a
  97 #define   SX9310_REG_PROX_CTRL10_HYST_MASK              GENMASK(5, 4)
  98 #define   SX9310_REG_PROX_CTRL10_HYST_6PCT              (0x01 << 4)
  99 #define   SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK    GENMASK(3, 2)
 100 #define   SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK      GENMASK(1, 0)
 101 #define   SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_2         0x01
 102 #define SX9310_REG_PROX_CTRL11                          0x1b
 103 #define SX9310_REG_PROX_CTRL12                          0x1c
 104 #define SX9310_REG_PROX_CTRL13                          0x1d
 105 #define SX9310_REG_PROX_CTRL14                          0x1e
 106 #define SX9310_REG_PROX_CTRL15                          0x1f
 107 #define SX9310_REG_PROX_CTRL16                          0x20
 108 #define SX9310_REG_PROX_CTRL17                          0x21
 109 #define SX9310_REG_PROX_CTRL18                          0x22
 110 #define SX9310_REG_PROX_CTRL19                          0x23
 111 #define SX9310_REG_SAR_CTRL0                            0x2a
 112 #define   SX9310_REG_SAR_CTRL0_SARDEB_4_SAMPLES         (0x02 << 5)
 113 #define   SX9310_REG_SAR_CTRL0_SARHYST_8                (0x02 << 3)
 114 #define SX9310_REG_SAR_CTRL1                            0x2b
 115 /* Each increment of the slope register is 0.0078125. */
 116 #define   SX9310_REG_SAR_CTRL1_SLOPE(_hnslope)          (_hnslope / 78125)
 117 #define SX9310_REG_SAR_CTRL2                            0x2c
 118 #define   SX9310_REG_SAR_CTRL2_SAROFFSET_DEFAULT        0x3c
 119
 120 #define SX9310_REG_SENSOR_SEL                           0x30
 121 #define SX9310_REG_USE_MSB                              0x31
 122 #define SX9310_REG_USE_LSB                              0x32
 123 #define SX9310_REG_AVG_MSB                              0x33
 124 #define SX9310_REG_AVG_LSB                              0x34
 125 #define SX9310_REG_DIFF_MSB                             0x35
 126 #define SX9310_REG_DIFF_LSB                             0x36
 127 #define SX9310_REG_OFFSET_MSB                           0x37
 128 #define SX9310_REG_OFFSET_LSB                           0x38
 129 #define SX9310_REG_SAR_MSB                              0x39
 130 #define SX9310_REG_SAR_LSB                              0x3a
 131 #define SX9310_REG_I2C_ADDR                             0x40
 132 #define SX9310_REG_PAUSE                                0x41
 133 #define SX9310_REG_WHOAMI                               0x42
 134 #define   SX9310_WHOAMI_VALUE                           0x01
 135 #define   SX9311_WHOAMI_VALUE                           0x02
 136 #define SX9310_REG_RESET                                0x7f
 137 #define   SX9310_SOFT_RESET                             0xde
 138
 139
 140 /* 4 hardware channels, as defined in STAT0: COMB, CS2, CS1 and CS0. */
 141 #define SX9310_NUM_CHANNELS                             4
 142 static_assert(SX9310_NUM_CHANNELS < BITS_PER_LONG);
 143
 144 struct sx9310_data {
 145         /* Serialize access to registers and channel configuration */
 146         struct mutex mutex;
 147         struct i2c_client *client;
 148         struct iio_trigger *trig;
 149         struct regmap *regmap;
 150         struct regulator_bulk_data supplies[2];
 151         /*
 152          * Last reading of the proximity status for each channel.
 153          * We only send an event to user space when this changes.
 154          */
 155         unsigned long chan_prox_stat;
 156         bool trigger_enabled;
 157         /* Ensure correct alignment of timestamp when present. */
 158         struct {
 159                 __be16 channels[SX9310_NUM_CHANNELS];
 160                 s64 ts __aligned(8);
 161         } buffer;
 162         /* Remember enabled channels and sample rate during suspend. */
 163         unsigned int suspend_ctrl0;
 164         struct completion completion;
 165         unsigned long chan_read;
 166         unsigned long chan_event;
 167         unsigned int whoami;
 168 };
 169
 170 static const struct iio_event_spec sx9310_events[] = {
 171         {
 172                 .type = IIO_EV_TYPE_THRESH,
 173                 .dir = IIO_EV_DIR_RISING,
 174                 .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD),
 175         },
 176         {
 177                 .type = IIO_EV_TYPE_THRESH,
 178                 .dir = IIO_EV_DIR_FALLING,
 179                 .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD),
 180         },
 181         {
 182                 .type = IIO_EV_TYPE_THRESH,
 183                 .dir = IIO_EV_DIR_EITHER,
 184                 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
 185                                  BIT(IIO_EV_INFO_HYSTERESIS) |
 186                                  BIT(IIO_EV_INFO_VALUE),
 187         },
 188 };
 189
 190 #define SX9310_NAMED_CHANNEL(idx, name)                                  \
 191         {                                                                \
 192                 .type = IIO_PROXIMITY,                                   \
 193                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |           \
 194                                       BIT(IIO_CHAN_INFO_HARDWAREGAIN),   \
 195                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 196                 .info_mask_separate_available =                          \
 197                         BIT(IIO_CHAN_INFO_HARDWAREGAIN),                 \
 198                 .indexed = 1,                                            \
 199                 .channel = idx,                                          \
 200                 .extend_name = name,                                     \
 201                 .address = SX9310_REG_DIFF_MSB,                          \
 202                 .event_spec = sx9310_events,                             \
 203                 .num_event_specs = ARRAY_SIZE(sx9310_events),            \
 204                 .scan_index = idx,                                       \
 205                 .scan_type = {                                           \
 206                         .sign = 's',                                     \
 207                         .realbits = 12,                                  \
 208                         .storagebits = 16,                               \
 209                         .endianness = IIO_BE,                            \
 210                 },                                                       \
 211         }
 212 #define SX9310_CHANNEL(idx) SX9310_NAMED_CHANNEL(idx, NULL)
 213
 214 static const struct iio_chan_spec sx9310_channels[] = {
 215         SX9310_CHANNEL(0),                      /* CS0 */
 216         SX9310_CHANNEL(1),                      /* CS1 */
 217         SX9310_CHANNEL(2),                      /* CS2 */
 218         SX9310_NAMED_CHANNEL(3, "comb"),        /* COMB */
 219
 220         IIO_CHAN_SOFT_TIMESTAMP(4),
 221 };
 222
 223 /*
 224  * Each entry contains the integer part (val) and the fractional part, in micro
 225  * seconds. It conforms to the IIO output IIO_VAL_INT_PLUS_MICRO.
 226  */
 227 static const struct {
 228         int val;
 229         int val2;
 230 } sx9310_samp_freq_table[] = {
 231         { 500, 0 }, /* 0000: Min (no idle time) */
 232         { 66, 666666 }, /* 0001: 15 ms */
 233         { 33, 333333 }, /* 0010: 30 ms (Typ.) */
 234         { 22, 222222 }, /* 0011: 45 ms */
 235         { 16, 666666 }, /* 0100: 60 ms */
 236         { 11, 111111 }, /* 0101: 90 ms */
 237         { 8, 333333 }, /* 0110: 120 ms */
 238         { 5, 0 }, /* 0111: 200 ms */
 239         { 2, 500000 }, /* 1000: 400 ms */
 240         { 1, 666666 }, /* 1001: 600 ms */
 241         { 1, 250000 }, /* 1010: 800 ms */
 242         { 1, 0 }, /* 1011: 1 s */
 243         { 0, 500000 }, /* 1100: 2 s */
 244         { 0, 333333 }, /* 1101: 3 s */
 245         { 0, 250000 }, /* 1110: 4 s */
 246         { 0, 200000 }, /* 1111: 5 s */
 247 };
 248 static const unsigned int sx9310_scan_period_table[] = {
 249         2,   15,  30,  45,   60,   90,   120,  200,
 250         400, 600, 800, 1000, 2000, 3000, 4000, 5000,
 251 };
 252
 253 static ssize_t sx9310_show_samp_freq_avail(struct device *dev,
 254                                            struct device_attribute *attr,
 255                                            char *buf)
 256 {
 257         size_t len = 0;
 258         int i;
 259
 260         for (i = 0; i < ARRAY_SIZE(sx9310_samp_freq_table); i++)
 261                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%d ",
 262                                  sx9310_samp_freq_table[i].val,
 263                                  sx9310_samp_freq_table[i].val2);
 264         buf[len - 1] = '\n';
 265         return len;
 266 }
 267 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(sx9310_show_samp_freq_avail);
 268
 269 static const struct regmap_range sx9310_writable_reg_ranges[] = {
 270         regmap_reg_range(SX9310_REG_IRQ_MSK, SX9310_REG_IRQ_FUNC),
 271         regmap_reg_range(SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL19),
 272         regmap_reg_range(SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL2),
 273         regmap_reg_range(SX9310_REG_SENSOR_SEL, SX9310_REG_SENSOR_SEL),
 274         regmap_reg_range(SX9310_REG_OFFSET_MSB, SX9310_REG_OFFSET_LSB),
 275         regmap_reg_range(SX9310_REG_PAUSE, SX9310_REG_PAUSE),
 276         regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET),
 277 };
 278
 279 static const struct regmap_access_table sx9310_writeable_regs = {
 280         .yes_ranges = sx9310_writable_reg_ranges,
 281         .n_yes_ranges = ARRAY_SIZE(sx9310_writable_reg_ranges),
 282 };
 283
 284 static const struct regmap_range sx9310_readable_reg_ranges[] = {
 285         regmap_reg_range(SX9310_REG_IRQ_SRC, SX9310_REG_IRQ_FUNC),
 286         regmap_reg_range(SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL19),
 287         regmap_reg_range(SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL2),
 288         regmap_reg_range(SX9310_REG_SENSOR_SEL, SX9310_REG_SAR_LSB),
 289         regmap_reg_range(SX9310_REG_I2C_ADDR, SX9310_REG_WHOAMI),
 290         regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET),
 291 };
 292
 293 static const struct regmap_access_table sx9310_readable_regs = {
 294         .yes_ranges = sx9310_readable_reg_ranges,
 295         .n_yes_ranges = ARRAY_SIZE(sx9310_readable_reg_ranges),
 296 };
 297
 298 static const struct regmap_range sx9310_volatile_reg_ranges[] = {
 299         regmap_reg_range(SX9310_REG_IRQ_SRC, SX9310_REG_STAT1),
 300         regmap_reg_range(SX9310_REG_USE_MSB, SX9310_REG_DIFF_LSB),
 301         regmap_reg_range(SX9310_REG_SAR_MSB, SX9310_REG_SAR_LSB),
 302         regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET),
 303 };
 304
 305 static const struct regmap_access_table sx9310_volatile_regs = {
 306         .yes_ranges = sx9310_volatile_reg_ranges,
 307         .n_yes_ranges = ARRAY_SIZE(sx9310_volatile_reg_ranges),
 308 };
 309
 310 static const struct regmap_config sx9310_regmap_config = {
 311         .reg_bits = 8,
 312         .val_bits = 8,
 313
 314         .max_register = SX9310_REG_RESET,
 315         .cache_type = REGCACHE_RBTREE,
 316
 317         .wr_table = &sx9310_writeable_regs,
 318         .rd_table = &sx9310_readable_regs,
 319         .volatile_table = &sx9310_volatile_regs,
 320 };
 321
 322 static int sx9310_update_chan_en(struct sx9310_data *data,
 323                                  unsigned long chan_read,
 324                                  unsigned long chan_event)
 325 {
 326         int ret;
 327         unsigned long channels = chan_read | chan_event;
 328
 329         if ((data->chan_read | data->chan_event) != channels) {
 330                 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL0,
 331                                          SX9310_REG_PROX_CTRL0_SENSOREN_MASK,
 332                                          channels);
 333                 if (ret)
 334                         return ret;
 335         }
 336         data->chan_read = chan_read;
 337         data->chan_event = chan_event;
 338         return 0;
 339 }
 340
 341 static int sx9310_get_read_channel(struct sx9310_data *data, int channel)
 342 {
 343         return sx9310_update_chan_en(data, data->chan_read | BIT(channel),
 344                                      data->chan_event);
 345 }
 346
 347 static int sx9310_put_read_channel(struct sx9310_data *data, int channel)
 348 {
 349         return sx9310_update_chan_en(data, data->chan_read & ~BIT(channel),
 350                                      data->chan_event);
 351 }
 352
 353 static int sx9310_get_event_channel(struct sx9310_data *data, int channel)
 354 {
 355         return sx9310_update_chan_en(data, data->chan_read,
 356                                      data->chan_event | BIT(channel));
 357 }
 358
 359 static int sx9310_put_event_channel(struct sx9310_data *data, int channel)
 360 {
 361         return sx9310_update_chan_en(data, data->chan_read,
 362                                      data->chan_event & ~BIT(channel));
 363 }
 364
 365 static int sx9310_enable_irq(struct sx9310_data *data, unsigned int irq)
 366 {
 367         if (!data->client->irq)
 368                 return 0;
 369         return regmap_update_bits(data->regmap, SX9310_REG_IRQ_MSK, irq, irq);
 370 }
 371
 372 static int sx9310_disable_irq(struct sx9310_data *data, unsigned int irq)
 373 {
 374         if (!data->client->irq)
 375                 return 0;
 376         return regmap_update_bits(data->regmap, SX9310_REG_IRQ_MSK, irq, 0);
 377 }
 378
 379 static int sx9310_read_prox_data(struct sx9310_data *data,
 380                                  const struct iio_chan_spec *chan, __be16 *val)
 381 {
 382         int ret;
 383
 384         ret = regmap_write(data->regmap, SX9310_REG_SENSOR_SEL, chan->channel);
 385         if (ret)
 386                 return ret;
 387
 388         return regmap_bulk_read(data->regmap, chan->address, val, sizeof(*val));
 389 }
 390
 391 /*
 392  * If we have no interrupt support, we have to wait for a scan period
 393  * after enabling a channel to get a result.
 394  */
 395 static int sx9310_wait_for_sample(struct sx9310_data *data)
 396 {
 397         int ret;
 398         unsigned int val;
 399
 400         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &val);
 401         if (ret)
 402                 return ret;
 403
 404         val = FIELD_GET(SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, val);
 405
 406         msleep(sx9310_scan_period_table[val]);
 407
 408         return 0;
 409 }
 410
 411 static int sx9310_read_proximity(struct sx9310_data *data,
 412                                  const struct iio_chan_spec *chan, int *val)
 413 {
 414         int ret;
 415         __be16 rawval;
 416
 417         mutex_lock(&data->mutex);
 418
 419         ret = sx9310_get_read_channel(data, chan->channel);
 420         if (ret)
 421                 goto out;
 422
 423         ret = sx9310_enable_irq(data, SX9310_CONVDONE_IRQ);
 424         if (ret)
 425                 goto out_put_channel;
 426
 427         mutex_unlock(&data->mutex);
 428
 429         if (data->client->irq) {
 430                 ret = wait_for_completion_interruptible(&data->completion);
 431                 reinit_completion(&data->completion);
 432         } else {
 433                 ret = sx9310_wait_for_sample(data);
 434         }
 435
 436         mutex_lock(&data->mutex);
 437
 438         if (ret)
 439                 goto out_disable_irq;
 440
 441         ret = sx9310_read_prox_data(data, chan, &rawval);
 442         if (ret)
 443                 goto out_disable_irq;
 444
 445         *val = sign_extend32(be16_to_cpu(rawval),
 446                              chan->address == SX9310_REG_DIFF_MSB ? 11 : 15);
 447
 448         ret = sx9310_disable_irq(data, SX9310_CONVDONE_IRQ);
 449         if (ret)
 450                 goto out_put_channel;
 451
 452         ret = sx9310_put_read_channel(data, chan->channel);
 453         if (ret)
 454                 goto out;
 455
 456         mutex_unlock(&data->mutex);
 457
 458         return IIO_VAL_INT;
 459
 460 out_disable_irq:
 461         sx9310_disable_irq(data, SX9310_CONVDONE_IRQ);
 462 out_put_channel:
 463         sx9310_put_read_channel(data, chan->channel);
 464 out:
 465         mutex_unlock(&data->mutex);
 466
 467         return ret;
 468 }
 469
 470 static int sx9310_read_gain(struct sx9310_data *data,
 471                             const struct iio_chan_spec *chan, int *val)
 472 {
 473         unsigned int regval, gain;
 474         int ret;
 475
 476         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL3, &regval);
 477         if (ret)
 478                 return ret;
 479
 480         switch (chan->channel) {
 481         case 0:
 482         case 3:
 483                 gain = FIELD_GET(SX9310_REG_PROX_CTRL3_GAIN0_MASK, regval);
 484                 break;
 485         case 1:
 486         case 2:
 487                 gain = FIELD_GET(SX9310_REG_PROX_CTRL3_GAIN12_MASK, regval);
 488                 break;
 489         default:
 490                 return -EINVAL;
 491         }
 492
 493         *val = 1 << gain;
 494
 495         return IIO_VAL_INT;
 496 }
 497
 498 static int sx9310_read_samp_freq(struct sx9310_data *data, int *val, int *val2)
 499 {
 500         unsigned int regval;
 501         int ret;
 502
 503         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &regval);
 504         if (ret)
 505                 return ret;
 506
 507         regval = FIELD_GET(SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, regval);
 508         *val = sx9310_samp_freq_table[regval].val;
 509         *val2 = sx9310_samp_freq_table[regval].val2;
 510
 511         return IIO_VAL_INT_PLUS_MICRO;
 512 }
 513
 514 static int sx9310_read_raw(struct iio_dev *indio_dev,
 515                            const struct iio_chan_spec *chan, int *val,
 516                            int *val2, long mask)
 517 {
 518         struct sx9310_data *data = iio_priv(indio_dev);
 519         int ret;
 520
 521         if (chan->type != IIO_PROXIMITY)
 522                 return -EINVAL;
 523
 524         switch (mask) {
 525         case IIO_CHAN_INFO_RAW:
 526                 ret = iio_device_claim_direct_mode(indio_dev);
 527                 if (ret)
 528                         return ret;
 529
 530                 ret = sx9310_read_proximity(data, chan, val);
 531                 iio_device_release_direct_mode(indio_dev);
 532                 return ret;
 533         case IIO_CHAN_INFO_HARDWAREGAIN:
 534                 ret = iio_device_claim_direct_mode(indio_dev);
 535                 if (ret)
 536                         return ret;
 537
 538                 ret = sx9310_read_gain(data, chan, val);
 539                 iio_device_release_direct_mode(indio_dev);
 540                 return ret;
 541         case IIO_CHAN_INFO_SAMP_FREQ:
 542                 return sx9310_read_samp_freq(data, val, val2);
 543         default:
 544                 return -EINVAL;
 545         }
 546 }
 547
 548 static const int sx9310_gain_vals[] = { 1, 2, 4, 8 };
 549
 550 static int sx9310_read_avail(struct iio_dev *indio_dev,
 551                              struct iio_chan_spec const *chan,
 552                              const int **vals, int *type, int *length,
 553                              long mask)
 554 {
 555         if (chan->type != IIO_PROXIMITY)
 556                 return -EINVAL;
 557
 558         switch (mask) {
 559         case IIO_CHAN_INFO_HARDWAREGAIN:
 560                 *type = IIO_VAL_INT;
 561                 *length = ARRAY_SIZE(sx9310_gain_vals);
 562                 *vals = sx9310_gain_vals;
 563                 return IIO_AVAIL_LIST;
 564         }
 565
 566         return -EINVAL;
 567 }
 568
 569 static const unsigned int sx9310_pthresh_codes[] = {
 570         2, 4, 6, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 72, 80, 88, 96, 112,
 571         128, 144, 160, 192, 224, 256, 320, 384, 512, 640, 768, 1024, 1536
 572 };
 573
 574 static int sx9310_get_thresh_reg(unsigned int channel)
 575 {
 576         switch (channel) {
 577         case 0:
 578         case 3:
 579                 return SX9310_REG_PROX_CTRL8;
 580         case 1:
 581         case 2:
 582                 return SX9310_REG_PROX_CTRL9;
 583         }
 584
 585         return -EINVAL;
 586 }
 587
 588 static int sx9310_read_thresh(struct sx9310_data *data,
 589                               const struct iio_chan_spec *chan, int *val)
 590 {
 591         unsigned int reg;
 592         unsigned int regval;
 593         int ret;
 594
 595         reg = ret = sx9310_get_thresh_reg(chan->channel);
 596         if (ret < 0)
 597                 return ret;
 598
 599         ret = regmap_read(data->regmap, reg, &regval);
 600         if (ret)
 601                 return ret;
 602
 603         regval = FIELD_GET(SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK, regval);
 604         if (regval >= ARRAY_SIZE(sx9310_pthresh_codes))
 605                 return -EINVAL;
 606
 607         *val = sx9310_pthresh_codes[regval];
 608         return IIO_VAL_INT;
 609 }
 610
 611 static int sx9310_read_hysteresis(struct sx9310_data *data,
 612                                   const struct iio_chan_spec *chan, int *val)
 613 {
 614         unsigned int regval, pthresh;
 615         int ret;
 616
 617         ret = sx9310_read_thresh(data, chan, &pthresh);
 618         if (ret < 0)
 619                 return ret;
 620
 621         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL10, &regval);
 622         if (ret)
 623                 return ret;
 624
 625         regval = FIELD_GET(SX9310_REG_PROX_CTRL10_HYST_MASK, regval);
 626         if (!regval)
 627                 regval = 5;
 628
 629         /* regval is at most 5 */
 630         *val = pthresh >> (5 - regval);
 631
 632         return IIO_VAL_INT;
 633 }
 634
 635 static int sx9310_read_far_debounce(struct sx9310_data *data, int *val)
 636 {
 637         unsigned int regval;
 638         int ret;
 639
 640         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL10, &regval);
 641         if (ret)
 642                 return ret;
 643
 644         regval = FIELD_GET(SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK, regval);
 645         if (regval)
 646                 *val = 1 << regval;
 647         else
 648                 *val = 0;
 649
 650         return IIO_VAL_INT;
 651 }
 652
 653 static int sx9310_read_close_debounce(struct sx9310_data *data, int *val)
 654 {
 655         unsigned int regval;
 656         int ret;
 657
 658         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL10, &regval);
 659         if (ret)
 660                 return ret;
 661
 662         regval = FIELD_GET(SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK, regval);
 663         if (regval)
 664                 *val = 1 << regval;
 665         else
 666                 *val = 0;
 667
 668         return IIO_VAL_INT;
 669 }
 670
 671 static int sx9310_read_event_val(struct iio_dev *indio_dev,
 672                                  const struct iio_chan_spec *chan,
 673                                  enum iio_event_type type,
 674                                  enum iio_event_direction dir,
 675                                  enum iio_event_info info, int *val, int *val2)
 676 {
 677         struct sx9310_data *data = iio_priv(indio_dev);
 678
 679         if (chan->type != IIO_PROXIMITY)
 680                 return -EINVAL;
 681
 682         switch (info) {
 683         case IIO_EV_INFO_VALUE:
 684                 return sx9310_read_thresh(data, chan, val);
 685         case IIO_EV_INFO_PERIOD:
 686                 switch (dir) {
 687                 case IIO_EV_DIR_RISING:
 688                         return sx9310_read_far_debounce(data, val);
 689                 case IIO_EV_DIR_FALLING:
 690                         return sx9310_read_close_debounce(data, val);
 691                 default:
 692                         return -EINVAL;
 693                 }
 694         case IIO_EV_INFO_HYSTERESIS:
 695                 return sx9310_read_hysteresis(data, chan, val);
 696         default:
 697                 return -EINVAL;
 698         }
 699 }
 700
 701 static int sx9310_write_thresh(struct sx9310_data *data,
 702                                const struct iio_chan_spec *chan, int val)
 703 {
 704         unsigned int reg;
 705         unsigned int regval;
 706         int ret, i;
 707
 708         reg = ret = sx9310_get_thresh_reg(chan->channel);
 709         if (ret < 0)
 710                 return ret;
 711
 712         for (i = 0; i < ARRAY_SIZE(sx9310_pthresh_codes); i++) {
 713                 if (sx9310_pthresh_codes[i] == val) {
 714                         regval = i;
 715                         break;
 716                 }
 717         }
 718
 719         if (i == ARRAY_SIZE(sx9310_pthresh_codes))
 720                 return -EINVAL;
 721
 722         regval = FIELD_PREP(SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK, regval);
 723         mutex_lock(&data->mutex);
 724         ret = regmap_update_bits(data->regmap, reg,
 725                                  SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK, regval);
 726         mutex_unlock(&data->mutex);
 727
 728         return ret;
 729 }
 730
 731 static int sx9310_write_hysteresis(struct sx9310_data *data,
 732                                    const struct iio_chan_spec *chan, int _val)
 733 {
 734         unsigned int hyst, val = _val;
 735         int ret, pthresh;
 736
 737         ret = sx9310_read_thresh(data, chan, &pthresh);
 738         if (ret < 0)
 739                 return ret;
 740
 741         if (val == 0)
 742                 hyst = 0;
 743         else if (val == pthresh >> 2)
 744                 hyst = 3;
 745         else if (val == pthresh >> 3)
 746                 hyst = 2;
 747         else if (val == pthresh >> 4)
 748                 hyst = 1;
 749         else
 750                 return -EINVAL;
 751
 752         hyst = FIELD_PREP(SX9310_REG_PROX_CTRL10_HYST_MASK, hyst);
 753         mutex_lock(&data->mutex);
 754         ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL10,
 755                                  SX9310_REG_PROX_CTRL10_HYST_MASK, hyst);
 756         mutex_unlock(&data->mutex);
 757
 758         return ret;
 759 }
 760
 761 static int sx9310_write_far_debounce(struct sx9310_data *data, int val)
 762 {
 763         int ret;
 764         unsigned int regval;
 765
 766         if (val > 0)
 767                 val = ilog2(val);
 768         if (!FIELD_FIT(SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK, val))
 769                 return -EINVAL;
 770
 771         regval = FIELD_PREP(SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK, val);
 772
 773         mutex_lock(&data->mutex);
 774         ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL10,
 775                                  SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK,
 776                                  regval);
 777         mutex_unlock(&data->mutex);
 778
 779         return ret;
 780 }
 781
 782 static int sx9310_write_close_debounce(struct sx9310_data *data, int val)
 783 {
 784         int ret;
 785         unsigned int regval;
 786
 787         if (val > 0)
 788                 val = ilog2(val);
 789         if (!FIELD_FIT(SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK, val))
 790                 return -EINVAL;
 791
 792         regval = FIELD_PREP(SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK, val);
 793
 794         mutex_lock(&data->mutex);
 795         ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL10,
 796                                  SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK,
 797                                  regval);
 798         mutex_unlock(&data->mutex);
 799
 800         return ret;
 801 }
 802
 803 static int sx9310_write_event_val(struct iio_dev *indio_dev,
 804                                   const struct iio_chan_spec *chan,
 805                                   enum iio_event_type type,
 806                                   enum iio_event_direction dir,
 807                                   enum iio_event_info info, int val, int val2)
 808 {
 809         struct sx9310_data *data = iio_priv(indio_dev);
 810
 811         if (chan->type != IIO_PROXIMITY)
 812                 return -EINVAL;
 813
 814         switch (info) {
 815         case IIO_EV_INFO_VALUE:
 816                 return sx9310_write_thresh(data, chan, val);
 817         case IIO_EV_INFO_PERIOD:
 818                 switch (dir) {
 819                 case IIO_EV_DIR_RISING:
 820                         return sx9310_write_far_debounce(data, val);
 821                 case IIO_EV_DIR_FALLING:
 822                         return sx9310_write_close_debounce(data, val);
 823                 default:
 824                         return -EINVAL;
 825                 }
 826         case IIO_EV_INFO_HYSTERESIS:
 827                 return sx9310_write_hysteresis(data, chan, val);
 828         default:
 829                 return -EINVAL;
 830         }
 831 }
 832
 833 static int sx9310_set_samp_freq(struct sx9310_data *data, int val, int val2)
 834 {
 835         int i, ret;
 836
 837         for (i = 0; i < ARRAY_SIZE(sx9310_samp_freq_table); i++)
 838                 if (val == sx9310_samp_freq_table[i].val &&
 839                     val2 == sx9310_samp_freq_table[i].val2)
 840                         break;
 841
 842         if (i == ARRAY_SIZE(sx9310_samp_freq_table))
 843                 return -EINVAL;
 844
 845         mutex_lock(&data->mutex);
 846
 847         ret = regmap_update_bits(
 848                 data->regmap, SX9310_REG_PROX_CTRL0,
 849                 SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK,
 850                 FIELD_PREP(SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, i));
 851
 852         mutex_unlock(&data->mutex);
 853
 854         return ret;
 855 }
 856
 857 static int sx9310_write_gain(struct sx9310_data *data,
 858                             const struct iio_chan_spec *chan, int val)
 859 {
 860         unsigned int gain, mask;
 861         int ret;
 862
 863         gain = ilog2(val);
 864
 865         switch (chan->channel) {
 866         case 0:
 867         case 3:
 868                 mask = SX9310_REG_PROX_CTRL3_GAIN0_MASK;
 869                 gain = FIELD_PREP(SX9310_REG_PROX_CTRL3_GAIN0_MASK, gain);
 870                 break;
 871         case 1:
 872         case 2:
 873                 mask = SX9310_REG_PROX_CTRL3_GAIN12_MASK;
 874                 gain = FIELD_PREP(SX9310_REG_PROX_CTRL3_GAIN12_MASK, gain);
 875                 break;
 876         default:
 877                 return -EINVAL;
 878         }
 879
 880         mutex_lock(&data->mutex);
 881         ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL3, mask,
 882                                  gain);
 883         mutex_unlock(&data->mutex);
 884
 885         return ret;
 886 }
 887
 888 static int sx9310_write_raw(struct iio_dev *indio_dev,
 889                             const struct iio_chan_spec *chan, int val, int val2,
 890                             long mask)
 891 {
 892         struct sx9310_data *data = iio_priv(indio_dev);
 893
 894         if (chan->type != IIO_PROXIMITY)
 895                 return -EINVAL;
 896
 897         switch (mask) {
 898         case IIO_CHAN_INFO_SAMP_FREQ:
 899                 return sx9310_set_samp_freq(data, val, val2);
 900         case IIO_CHAN_INFO_HARDWAREGAIN:
 901                 return sx9310_write_gain(data, chan, val);
 902         }
 903
 904         return -EINVAL;
 905 }
 906
 907 static irqreturn_t sx9310_irq_handler(int irq, void *private)
 908 {
 909         struct iio_dev *indio_dev = private;
 910         struct sx9310_data *data = iio_priv(indio_dev);
 911
 912         if (data->trigger_enabled)
 913                 iio_trigger_poll(data->trig);
 914
 915         /*
 916          * Even if no event is enabled, we need to wake the thread to clear the
 917          * interrupt state by reading SX9310_REG_IRQ_SRC.
 918          * It is not possible to do that here because regmap_read takes a mutex.
 919          */
 920         return IRQ_WAKE_THREAD;
 921 }
 922
 923 static void sx9310_push_events(struct iio_dev *indio_dev)
 924 {
 925         int ret;
 926         unsigned int val, chan;
 927         struct sx9310_data *data = iio_priv(indio_dev);
 928         s64 timestamp = iio_get_time_ns(indio_dev);
 929         unsigned long prox_changed;
 930
 931         /* Read proximity state on all channels */
 932         ret = regmap_read(data->regmap, SX9310_REG_STAT0, &val);
 933         if (ret) {
 934                 dev_err(&data->client->dev, "i2c transfer error in irq\n");
 935                 return;
 936         }
 937
 938         /*
 939          * Only iterate over channels with changes on proximity status that have
 940          * events enabled.
 941          */
 942         prox_changed = (data->chan_prox_stat ^ val) & data->chan_event;
 943
 944         for_each_set_bit(chan, &prox_changed, SX9310_NUM_CHANNELS) {
 945                 int dir;
 946                 u64 ev;
 947
 948                 dir = (val & BIT(chan)) ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
 949                 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan,
 950                                           IIO_EV_TYPE_THRESH, dir);
 951
 952                 iio_push_event(indio_dev, ev, timestamp);
 953         }
 954         data->chan_prox_stat = val;
 955 }
 956
 957 static irqreturn_t sx9310_irq_thread_handler(int irq, void *private)
 958 {
 959         struct iio_dev *indio_dev = private;
 960         struct sx9310_data *data = iio_priv(indio_dev);
 961         int ret;
 962         unsigned int val;
 963
 964         mutex_lock(&data->mutex);
 965
 966         ret = regmap_read(data->regmap, SX9310_REG_IRQ_SRC, &val);
 967         if (ret) {
 968                 dev_err(&data->client->dev, "i2c transfer error in irq\n");
 969                 goto out;
 970         }
 971
 972         if (val & (SX9310_FAR_IRQ | SX9310_CLOSE_IRQ))
 973                 sx9310_push_events(indio_dev);
 974
 975         if (val & SX9310_CONVDONE_IRQ)
 976                 complete(&data->completion);
 977
 978 out:
 979         mutex_unlock(&data->mutex);
 980
 981         return IRQ_HANDLED;
 982 }
 983
 984 static int sx9310_read_event_config(struct iio_dev *indio_dev,
 985                                     const struct iio_chan_spec *chan,
 986                                     enum iio_event_type type,
 987                                     enum iio_event_direction dir)
 988 {
 989         struct sx9310_data *data = iio_priv(indio_dev);
 990
 991         return !!(data->chan_event & BIT(chan->channel));
 992 }
 993
 994 static int sx9310_write_event_config(struct iio_dev *indio_dev,
 995                                      const struct iio_chan_spec *chan,
 996                                      enum iio_event_type type,
 997                                      enum iio_event_direction dir, int state)
 998 {
 999         struct sx9310_data *data = iio_priv(indio_dev);
1000         unsigned int eventirq = SX9310_FAR_IRQ | SX9310_CLOSE_IRQ;
1001         int ret;
1002
1003         /* If the state hasn't changed, there's nothing to do. */
1004         if (!!(data->chan_event & BIT(chan->channel)) == state)
1005                 return 0;
1006
1007         mutex_lock(&data->mutex);
1008         if (state) {
1009                 ret = sx9310_get_event_channel(data, chan->channel);
1010                 if (ret)
1011                         goto out_unlock;
1012                 if (!(data->chan_event & ~BIT(chan->channel))) {
1013                         ret = sx9310_enable_irq(data, eventirq);
1014                         if (ret)
1015                                 sx9310_put_event_channel(data, chan->channel);
1016                 }
1017         } else {
1018                 ret = sx9310_put_event_channel(data, chan->channel);
1019                 if (ret)
1020                         goto out_unlock;
1021                 if (!data->chan_event) {
1022                         ret = sx9310_disable_irq(data, eventirq);
1023                         if (ret)
1024                                 sx9310_get_event_channel(data, chan->channel);
1025                 }
1026         }
1027
1028 out_unlock:
1029         mutex_unlock(&data->mutex);
1030         return ret;
1031 }
1032
1033 static struct attribute *sx9310_attributes[] = {
1034         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
1035         NULL
1036 };
1037
1038 static const struct attribute_group sx9310_attribute_group = {
1039         .attrs = sx9310_attributes,
1040 };
1041
1042 static const struct iio_info sx9310_info = {
1043         .attrs = &sx9310_attribute_group,
1044         .read_raw = sx9310_read_raw,
1045         .read_avail = sx9310_read_avail,
1046         .read_event_value = sx9310_read_event_val,
1047         .write_event_value = sx9310_write_event_val,
1048         .write_raw = sx9310_write_raw,
1049         .read_event_config = sx9310_read_event_config,
1050         .write_event_config = sx9310_write_event_config,
1051 };
1052
1053 static int sx9310_set_trigger_state(struct iio_trigger *trig, bool state)
1054 {
1055         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1056         struct sx9310_data *data = iio_priv(indio_dev);
1057         int ret = 0;
1058
1059         mutex_lock(&data->mutex);
1060
1061         if (state)
1062                 ret = sx9310_enable_irq(data, SX9310_CONVDONE_IRQ);
1063         else if (!data->chan_read)
1064                 ret = sx9310_disable_irq(data, SX9310_CONVDONE_IRQ);
1065         if (ret)
1066                 goto out;
1067
1068         data->trigger_enabled = state;
1069
1070 out:
1071         mutex_unlock(&data->mutex);
1072
1073         return ret;
1074 }
1075
1076 static const struct iio_trigger_ops sx9310_trigger_ops = {
1077         .set_trigger_state = sx9310_set_trigger_state,
1078 };
1079
1080 static irqreturn_t sx9310_trigger_handler(int irq, void *private)
1081 {
1082         struct iio_poll_func *pf = private;
1083         struct iio_dev *indio_dev = pf->indio_dev;
1084         struct sx9310_data *data = iio_priv(indio_dev);
1085         __be16 val;
1086         int bit, ret, i = 0;
1087
1088         mutex_lock(&data->mutex);
1089
1090         for_each_set_bit(bit, indio_dev->active_scan_mask,
1091                          indio_dev->masklength) {
1092                 ret = sx9310_read_prox_data(data, &indio_dev->channels[bit],
1093                                             &val);
1094                 if (ret)
1095                         goto out;
1096
1097                 data->buffer.channels[i++] = val;
1098         }
1099
1100         iio_push_to_buffers_with_timestamp(indio_dev, &data->buffer,
1101                                            pf->timestamp);
1102
1103 out:
1104         mutex_unlock(&data->mutex);
1105
1106         iio_trigger_notify_done(indio_dev->trig);
1107
1108         return IRQ_HANDLED;
1109 }
1110
1111 static int sx9310_buffer_preenable(struct iio_dev *indio_dev)
1112 {
1113         struct sx9310_data *data = iio_priv(indio_dev);
1114         unsigned long channels = 0;
1115         int bit, ret;
1116
1117         mutex_lock(&data->mutex);
1118         for_each_set_bit(bit, indio_dev->active_scan_mask,
1119                          indio_dev->masklength)
1120                 __set_bit(indio_dev->channels[bit].channel, &channels);
1121
1122         ret = sx9310_update_chan_en(data, channels, data->chan_event);
1123         mutex_unlock(&data->mutex);
1124         return ret;
1125 }
1126
1127 static int sx9310_buffer_postdisable(struct iio_dev *indio_dev)
1128 {
1129         struct sx9310_data *data = iio_priv(indio_dev);
1130         int ret;
1131
1132         mutex_lock(&data->mutex);
1133         ret = sx9310_update_chan_en(data, 0, data->chan_event);
1134         mutex_unlock(&data->mutex);
1135         return ret;
1136 }
1137
1138 static const struct iio_buffer_setup_ops sx9310_buffer_setup_ops = {
1139         .preenable = sx9310_buffer_preenable,
1140         .postdisable = sx9310_buffer_postdisable,
1141 };
1142
1143 struct sx9310_reg_default {
1144         u8 reg;
1145         u8 def;
1146 };
1147
1148 static const struct sx9310_reg_default sx9310_default_regs[] = {
1149         { SX9310_REG_IRQ_MSK, 0x00 },
1150         { SX9310_REG_IRQ_FUNC, 0x00 },
1151         /*
1152          * The lower 4 bits should not be set as it enable sensors measurements.
1153          * Turning the detection on before the configuration values are set to
1154          * good values can cause the device to return erroneous readings.
1155          */
1156         { SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL0_SCANPERIOD_15MS },
1157         { SX9310_REG_PROX_CTRL1, 0x00 },
1158         { SX9310_REG_PROX_CTRL2, SX9310_REG_PROX_CTRL2_COMBMODE_CS1_CS2 |
1159                                  SX9310_REG_PROX_CTRL2_SHIELDEN_DYNAMIC },
1160         { SX9310_REG_PROX_CTRL3, SX9310_REG_PROX_CTRL3_GAIN0_X8 |
1161                                  SX9310_REG_PROX_CTRL3_GAIN12_X4 },
1162         { SX9310_REG_PROX_CTRL4, SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST },
1163         { SX9310_REG_PROX_CTRL5, SX9310_REG_PROX_CTRL5_RANGE_SMALL |
1164                                  SX9310_REG_PROX_CTRL5_STARTUPSENS_CS1 |
1165                                  SX9310_REG_PROX_CTRL5_RAWFILT_1P25 },
1166         { SX9310_REG_PROX_CTRL6, SX9310_REG_PROX_CTRL6_AVGTHRESH_DEFAULT },
1167         { SX9310_REG_PROX_CTRL7, SX9310_REG_PROX_CTRL7_AVGNEGFILT_2 |
1168                                  SX9310_REG_PROX_CTRL7_AVGPOSFILT_512 },
1169         { SX9310_REG_PROX_CTRL8, SX9310_REG_PROX_CTRL8_9_PTHRESH_96 |
1170                                  SX9310_REG_PROX_CTRL8_9_BODYTHRESH_1500 },
1171         { SX9310_REG_PROX_CTRL9, SX9310_REG_PROX_CTRL8_9_PTHRESH_28 |
1172                                  SX9310_REG_PROX_CTRL8_9_BODYTHRESH_900 },
1173         { SX9310_REG_PROX_CTRL10, SX9310_REG_PROX_CTRL10_HYST_6PCT |
1174                                   SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_2 },
1175         { SX9310_REG_PROX_CTRL11, 0x00 },
1176         { SX9310_REG_PROX_CTRL12, 0x00 },
1177         { SX9310_REG_PROX_CTRL13, 0x00 },
1178         { SX9310_REG_PROX_CTRL14, 0x00 },
1179         { SX9310_REG_PROX_CTRL15, 0x00 },
1180         { SX9310_REG_PROX_CTRL16, 0x00 },
1181         { SX9310_REG_PROX_CTRL17, 0x00 },
1182         { SX9310_REG_PROX_CTRL18, 0x00 },
1183         { SX9310_REG_PROX_CTRL19, 0x00 },
1184         { SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL0_SARDEB_4_SAMPLES |
1185                                 SX9310_REG_SAR_CTRL0_SARHYST_8 },
1186         { SX9310_REG_SAR_CTRL1, SX9310_REG_SAR_CTRL1_SLOPE(10781250) },
1187         { SX9310_REG_SAR_CTRL2, SX9310_REG_SAR_CTRL2_SAROFFSET_DEFAULT },
1188 };
1189
1190 /* Activate all channels and perform an initial compensation. */
1191 static int sx9310_init_compensation(struct iio_dev *indio_dev)
1192 {
1193         struct sx9310_data *data = iio_priv(indio_dev);
1194         int ret;
1195         unsigned int val;
1196         unsigned int ctrl0;
1197
1198         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &ctrl0);
1199         if (ret)
1200                 return ret;
1201
1202         /* run the compensation phase on all channels */
1203         ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0,
1204                            ctrl0 | SX9310_REG_PROX_CTRL0_SENSOREN_MASK);
1205         if (ret)
1206                 return ret;
1207
1208         ret = regmap_read_poll_timeout(data->regmap, SX9310_REG_STAT1, val,
1209                                        !(val & SX9310_REG_STAT1_COMPSTAT_MASK),
1210                                        20000, 2000000);
1211         if (ret) {
1212                 if (ret == -ETIMEDOUT)
1213                         dev_err(&data->client->dev,
1214                                 "initial compensation timed out: 0x%02x\n",
1215                                 val);
1216                 return ret;
1217         }
1218
1219         regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, ctrl0);
1220         return ret;
1221 }
1222
1223 static const struct sx9310_reg_default *
1224 sx9310_get_default_reg(struct sx9310_data *data, int idx,
1225                        struct sx9310_reg_default *reg_def)
1226 {
1227         const struct device_node *np = data->client->dev.of_node;
1228         u32 combined[SX9310_NUM_CHANNELS];
1229         u32 start = 0, raw = 0, pos = 0;
1230         unsigned long comb_mask = 0;
1231         int ret, i, count;
1232         const char *res;
1233
1234         memcpy(reg_def, &sx9310_default_regs[idx], sizeof(*reg_def));
1235         if (!np)
1236                 return reg_def;
1237
1238         switch (reg_def->reg) {
1239         case SX9310_REG_PROX_CTRL2:
1240                 if (of_property_read_bool(np, "semtech,cs0-ground")) {
1241                         reg_def->def &= ~SX9310_REG_PROX_CTRL2_SHIELDEN_MASK;
1242                         reg_def->def |= SX9310_REG_PROX_CTRL2_SHIELDEN_GROUND;
1243                 }
1244
1245                 count = of_property_count_elems_of_size(np, "semtech,combined-sensors",
1246                                                         sizeof(u32));
1247                 if (count > 0 && count <= ARRAY_SIZE(combined)) {
1248                         ret = of_property_read_u32_array(np, "semtech,combined-sensors",
1249                                                          combined, count);
1250                         if (ret)
1251                                 break;
1252                 } else {
1253                         /*
1254                          * Either the property does not exist in the DT or the
1255                          * number of entries is incorrect.
1256                          */
1257                         break;
1258                 }
1259                 for (i = 0; i < count; i++) {
1260                         if (combined[i] >= SX9310_NUM_CHANNELS) {
1261                                 /* Invalid sensor (invalid DT). */
1262                                 break;
1263                         }
1264                         comb_mask |= BIT(combined[i]);
1265                 }
1266                 if (i < count)
1267                         break;
1268
1269                 reg_def->def &= ~SX9310_REG_PROX_CTRL2_COMBMODE_MASK;
1270                 if (comb_mask == (BIT(3) | BIT(2) | BIT(1) | BIT(0)))
1271                         reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1_CS2_CS3;
1272                 else if (comb_mask == (BIT(1) | BIT(2)))
1273                         reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS1_CS2;
1274                 else if (comb_mask == (BIT(0) | BIT(1)))
1275                         reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1;
1276                 else if (comb_mask == BIT(3))
1277                         reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS3;
1278
1279                 break;
1280         case SX9310_REG_PROX_CTRL4:
1281                 ret = of_property_read_string(np, "semtech,resolution", &res);
1282                 if (ret)
1283                         break;
1284
1285                 reg_def->def &= ~SX9310_REG_PROX_CTRL4_RESOLUTION_MASK;
1286                 if (!strcmp(res, "coarsest"))
1287                         reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_COARSEST;
1288                 else if (!strcmp(res, "very-coarse"))
1289                         reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_COARSE;
1290                 else if (!strcmp(res, "coarse"))
1291                         reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_COARSE;
1292                 else if (!strcmp(res, "medium-coarse"))
1293                         reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM_COARSE;
1294                 else if (!strcmp(res, "medium"))
1295                         reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM;
1296                 else if (!strcmp(res, "fine"))
1297                         reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_FINE;
1298                 else if (!strcmp(res, "very-fine"))
1299                         reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_FINE;
1300                 else if (!strcmp(res, "finest"))
1301                         reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST;
1302
1303                 break;
1304         case SX9310_REG_PROX_CTRL5:
1305                 ret = of_property_read_u32(np, "semtech,startup-sensor", &start);
1306                 if (ret) {
1307                         start = FIELD_GET(SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK,
1308                                           reg_def->def);
1309                 }
1310
1311                 reg_def->def &= ~SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK;
1312                 reg_def->def |= FIELD_PREP(SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK,
1313                                            start);
1314
1315                 ret = of_property_read_u32(np, "semtech,proxraw-strength", &raw);
1316                 if (ret) {
1317                         raw = FIELD_GET(SX9310_REG_PROX_CTRL5_RAWFILT_MASK,
1318                                         reg_def->def);
1319                 } else {
1320                         raw = ilog2(raw);
1321                 }
1322
1323                 reg_def->def &= ~SX9310_REG_PROX_CTRL5_RAWFILT_MASK;
1324                 reg_def->def |= FIELD_PREP(SX9310_REG_PROX_CTRL5_RAWFILT_MASK,
1325                                            raw);
1326                 break;
1327         case SX9310_REG_PROX_CTRL7:
1328                 ret = of_property_read_u32(np, "semtech,avg-pos-strength", &pos);
1329                 if (ret)
1330                         break;
1331
1332                 /* Powers of 2, except for a gap between 16 and 64 */
1333                 pos = clamp(ilog2(pos), 3, 11) - (pos >= 32 ? 4 : 3);
1334                 reg_def->def &= ~SX9310_REG_PROX_CTRL7_AVGPOSFILT_MASK;
1335                 reg_def->def |= FIELD_PREP(SX9310_REG_PROX_CTRL7_AVGPOSFILT_MASK,
1336                                            pos);
1337                 break;
1338         }
1339
1340         return reg_def;
1341 }
1342
1343 static int sx9310_init_device(struct iio_dev *indio_dev)
1344 {
1345         struct sx9310_data *data = iio_priv(indio_dev);
1346         struct sx9310_reg_default tmp;
1347         const struct sx9310_reg_default *initval;
1348         int ret;
1349         unsigned int i, val;
1350
1351         ret = regmap_write(data->regmap, SX9310_REG_RESET, SX9310_SOFT_RESET);
1352         if (ret)
1353                 return ret;
1354
1355         usleep_range(1000, 2000); /* power-up time is ~1ms. */
1356
1357         /* Clear reset interrupt state by reading SX9310_REG_IRQ_SRC. */
1358         ret = regmap_read(data->regmap, SX9310_REG_IRQ_SRC, &val);
1359         if (ret)
1360                 return ret;
1361
1362         /* Program some sane defaults. */
1363         for (i = 0; i < ARRAY_SIZE(sx9310_default_regs); i++) {
1364                 initval = sx9310_get_default_reg(data, i, &tmp);
1365                 ret = regmap_write(data->regmap, initval->reg, initval->def);
1366                 if (ret)
1367                         return ret;
1368         }
1369
1370         return sx9310_init_compensation(indio_dev);
1371 }
1372
1373 static int sx9310_set_indio_dev_name(struct device *dev,
1374                                      struct iio_dev *indio_dev,
1375                                      unsigned int whoami)
1376 {
1377         unsigned int long ddata;
1378
1379         ddata = (uintptr_t)device_get_match_data(dev);
1380         if (ddata != whoami) {
1381                 dev_err(dev, "WHOAMI does not match device data: %u\n", whoami);
1382                 return -ENODEV;
1383         }
1384
1385         switch (whoami) {
1386         case SX9310_WHOAMI_VALUE:
1387                 indio_dev->name = "sx9310";
1388                 break;
1389         case SX9311_WHOAMI_VALUE:
1390                 indio_dev->name = "sx9311";
1391                 break;
1392         default:
1393                 dev_err(dev, "unexpected WHOAMI response: %u\n", whoami);
1394                 return -ENODEV;
1395         }
1396
1397         return 0;
1398 }
1399
1400 static void sx9310_regulator_disable(void *_data)
1401 {
1402         struct sx9310_data *data = _data;
1403
1404         regulator_bulk_disable(ARRAY_SIZE(data->supplies), data->supplies);
1405 }
1406
1407 static int sx9310_probe(struct i2c_client *client)
1408 {
1409         int ret;
1410         struct device *dev = &client->dev;
1411         struct iio_dev *indio_dev;
1412         struct sx9310_data *data;
1413
1414         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
1415         if (!indio_dev)
1416                 return -ENOMEM;
1417
1418         data = iio_priv(indio_dev);
1419         data->client = client;
1420         data->supplies[0].supply = "vdd";
1421         data->supplies[1].supply = "svdd";
1422         mutex_init(&data->mutex);
1423         init_completion(&data->completion);
1424
1425         data->regmap = devm_regmap_init_i2c(client, &sx9310_regmap_config);
1426         if (IS_ERR(data->regmap))
1427                 return PTR_ERR(data->regmap);
1428
1429         ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies),
1430                                       data->supplies);
1431         if (ret)
1432                 return ret;
1433
1434         ret = regulator_bulk_enable(ARRAY_SIZE(data->supplies), data->supplies);
1435         if (ret)
1436                 return ret;
1437         /* Must wait for Tpor time after initial power up */
1438         usleep_range(1000, 1100);
1439
1440         ret = devm_add_action_or_reset(dev, sx9310_regulator_disable, data);
1441         if (ret)
1442                 return ret;
1443
1444         ret = regmap_read(data->regmap, SX9310_REG_WHOAMI, &data->whoami);
1445         if (ret) {
1446                 dev_err(dev, "error in reading WHOAMI register: %d", ret);
1447                 return ret;
1448         }
1449
1450         ret = sx9310_set_indio_dev_name(dev, indio_dev, data->whoami);
1451         if (ret)
1452                 return ret;
1453
1454         ACPI_COMPANION_SET(&indio_dev->dev, ACPI_COMPANION(dev));
1455         indio_dev->channels = sx9310_channels;
1456         indio_dev->num_channels = ARRAY_SIZE(sx9310_channels);
1457         indio_dev->info = &sx9310_info;
1458         indio_dev->modes = INDIO_DIRECT_MODE;
1459         i2c_set_clientdata(client, indio_dev);
1460
1461         ret = sx9310_init_device(indio_dev);
1462         if (ret)
1463                 return ret;
1464
1465         if (client->irq) {
1466                 ret = devm_request_threaded_irq(dev, client->irq,
1467                                                 sx9310_irq_handler,
1468                                                 sx9310_irq_thread_handler,
1469                                                 IRQF_ONESHOT,
1470                                                 "sx9310_event", indio_dev);
1471                 if (ret)
1472                         return ret;
1473
1474                 data->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
1475                                                     indio_dev->name,
1476                                                     iio_device_id(indio_dev));
1477                 if (!data->trig)
1478                         return -ENOMEM;
1479
1480                 data->trig->ops = &sx9310_trigger_ops;
1481                 iio_trigger_set_drvdata(data->trig, indio_dev);
1482
1483                 ret = devm_iio_trigger_register(dev, data->trig);
1484                 if (ret)
1485                         return ret;
1486         }
1487
1488         ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
1489                                               iio_pollfunc_store_time,
1490                                               sx9310_trigger_handler,
1491                                               &sx9310_buffer_setup_ops);
1492         if (ret)
1493                 return ret;
1494
1495         return devm_iio_device_register(dev, indio_dev);
1496 }
1497
1498 static int __maybe_unused sx9310_suspend(struct device *dev)
1499 {
1500         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1501         struct sx9310_data *data = iio_priv(indio_dev);
1502         u8 ctrl0;
1503         int ret;
1504
1505         disable_irq_nosync(data->client->irq);
1506
1507         mutex_lock(&data->mutex);
1508         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0,
1509                           &data->suspend_ctrl0);
1510         if (ret)
1511                 goto out;
1512
1513         ctrl0 = data->suspend_ctrl0 & ~SX9310_REG_PROX_CTRL0_SENSOREN_MASK;
1514         ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, ctrl0);
1515         if (ret)
1516                 goto out;
1517
1518         ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 0);
1519
1520 out:
1521         mutex_unlock(&data->mutex);
1522         return ret;
1523 }
1524
1525 static int __maybe_unused sx9310_resume(struct device *dev)
1526 {
1527         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1528         struct sx9310_data *data = iio_priv(indio_dev);
1529         int ret;
1530
1531         mutex_lock(&data->mutex);
1532         ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 1);
1533         if (ret)
1534                 goto out;
1535
1536         ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0,
1537                            data->suspend_ctrl0);
1538
1539 out:
1540         mutex_unlock(&data->mutex);
1541         if (ret)
1542                 return ret;
1543
1544         enable_irq(data->client->irq);
1545         return 0;
1546 }
1547
1548 static const struct dev_pm_ops sx9310_pm_ops = {
1549         SET_SYSTEM_SLEEP_PM_OPS(sx9310_suspend, sx9310_resume)
1550 };
1551
1552 static const struct acpi_device_id sx9310_acpi_match[] = {
1553         { "STH9310", SX9310_WHOAMI_VALUE },
1554         { "STH9311", SX9311_WHOAMI_VALUE },
1555         {}
1556 };
1557 MODULE_DEVICE_TABLE(acpi, sx9310_acpi_match);
1558
1559 static const struct of_device_id sx9310_of_match[] = {
1560         { .compatible = "semtech,sx9310", (void *)SX9310_WHOAMI_VALUE },
1561         { .compatible = "semtech,sx9311", (void *)SX9311_WHOAMI_VALUE },
1562         {}
1563 };
1564 MODULE_DEVICE_TABLE(of, sx9310_of_match);
1565
1566 static const struct i2c_device_id sx9310_id[] = {
1567         { "sx9310", SX9310_WHOAMI_VALUE },
1568         { "sx9311", SX9311_WHOAMI_VALUE },
1569         {}
1570 };
1571 MODULE_DEVICE_TABLE(i2c, sx9310_id);
1572
1573 static struct i2c_driver sx9310_driver = {
1574         .driver = {
1575                 .name   = "sx9310",
1576                 .acpi_match_table = sx9310_acpi_match,
1577                 .of_match_table = sx9310_of_match,
1578                 .pm = &sx9310_pm_ops,
1579
1580                 /*
1581                  * Lots of i2c transfers in probe + over 200 ms waiting in
1582                  * sx9310_init_compensation() mean a slow probe; prefer async
1583                  * so we don't delay boot if we're builtin to the kernel.
1584                  */
1585                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1586         },
1587         .probe_new      = sx9310_probe,
1588         .id_table       = sx9310_id,
1589 };
1590 module_i2c_driver(sx9310_driver);
1591
1592 MODULE_AUTHOR("Gwendal Grignou <gwendal@chromium.org>");
1593 MODULE_AUTHOR("Daniel Campello <campello@chromium.org>");
1594 MODULE_DESCRIPTION("Driver for Semtech SX9310/SX9311 proximity sensor");
1595 MODULE_LICENSE("GPL v2");