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 April 2019 by Evan Green <evgreen@chromium.org>
  10  * and January 2020 by Daniel Campello <campello@chromium.org>
  11  */
  12
  13 #include <linux/acpi.h>
  14 #include <linux/delay.h>
  15 #include <linux/i2c.h>
  16 #include <linux/irq.h>
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/of.h>
  20 #include <linux/pm.h>
  21 #include <linux/regmap.h>
  22 #include <linux/slab.h>
  23
  24 #include <linux/iio/buffer.h>
  25 #include <linux/iio/events.h>
  26 #include <linux/iio/iio.h>
  27 #include <linux/iio/sysfs.h>
  28 #include <linux/iio/trigger.h>
  29 #include <linux/iio/triggered_buffer.h>
  30 #include <linux/iio/trigger_consumer.h>
  31
  32 /* Register definitions. */
  33 #define SX9310_REG_IRQ_SRC                              0x00
  34 #define SX9310_REG_STAT0                                0x01
  35 #define SX9310_REG_STAT1                                0x02
  36 #define SX9310_REG_IRQ_MSK                              0x03
  37 #define   SX9310_CONVDONE_IRQ                           BIT(3)
  38 #define   SX9310_FAR_IRQ                                BIT(5)
  39 #define   SX9310_CLOSE_IRQ                              BIT(6)
  40 #define   SX9310_EVENT_IRQ                              (SX9310_FAR_IRQ | \
  41                                                          SX9310_CLOSE_IRQ)
  42 #define SX9310_REG_IRQ_FUNC                             0x04
  43
  44 #define SX9310_REG_PROX_CTRL0                           0x10
  45 #define   SX9310_REG_PROX_CTRL0_PROXSTAT2               0x10
  46 #define   SX9310_REG_PROX_CTRL0_EN_MASK                 0x0F
  47 #define SX9310_REG_PROX_CTRL1                           0x11
  48 #define SX9310_REG_PROX_CTRL2                           0x12
  49 #define   SX9310_REG_PROX_CTRL2_COMBMODE_ALL            0x80
  50 #define   SX9310_REG_PROX_CTRL2_SHIELDEN_DYNAMIC        0x04
  51 #define SX9310_REG_PROX_CTRL3                           0x13
  52 #define   SX9310_REG_PROX_CTRL3_GAIN0_X8                0x0c
  53 #define   SX9310_REG_PROX_CTRL3_GAIN12_X4               0x02
  54 #define SX9310_REG_PROX_CTRL4                           0x14
  55 #define   SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST       0x07
  56 #define SX9310_REG_PROX_CTRL5                           0x15
  57 #define   SX9310_REG_PROX_CTRL5_RANGE_SMALL             0xc0
  58 #define   SX9310_REG_PROX_CTRL5_STARTUPSENS_CS1         0x04
  59 #define   SX9310_REG_PROX_CTRL5_RAWFILT_1P25            0x02
  60 #define SX9310_REG_PROX_CTRL6                           0x16
  61 #define   SX9310_REG_PROX_CTRL6_COMP_COMMON             0x20
  62 #define SX9310_REG_PROX_CTRL7                           0x17
  63 #define   SX9310_REG_PROX_CTRL7_AVGNEGFILT_2            0x08
  64 #define   SX9310_REG_PROX_CTRL7_AVGPOSFILT_512          0x05
  65 #define SX9310_REG_PROX_CTRL8                           0x18
  66 #define SX9310_REG_PROX_CTRL9                           0x19
  67 #define   SX9310_REG_PROX_CTRL8_9_PTHRESH12_28          0x40
  68 #define   SX9310_REG_PROX_CTRL8_9_PTHRESH_96            0x88
  69 #define   SX9310_REG_PROX_CTRL8_9_BODYTHRESH_900        0x03
  70 #define   SX9310_REG_PROX_CTRL8_9_BODYTHRESH_1500       0x05
  71 #define SX9310_REG_PROX_CTRL10                          0x1a
  72 #define   SX9310_REG_PROX_CTRL10_HYST_6PCT              0x10
  73 #define   SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_8       0x12
  74 #define   SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_8         0x03
  75 #define SX9310_REG_PROX_CTRL11                          0x1b
  76 #define SX9310_REG_PROX_CTRL12                          0x1c
  77 #define SX9310_REG_PROX_CTRL13                          0x1d
  78 #define SX9310_REG_PROX_CTRL14                          0x1e
  79 #define SX9310_REG_PROX_CTRL15                          0x1f
  80 #define SX9310_REG_PROX_CTRL16                          0x20
  81 #define SX9310_REG_PROX_CTRL17                          0x21
  82 #define SX9310_REG_PROX_CTRL18                          0x22
  83 #define SX9310_REG_PROX_CTRL19                          0x23
  84 #define SX9310_REG_SAR_CTRL0                            0x2a
  85 #define   SX9310_REG_SAR_CTRL0_SARDEB_4_SAMPLES         0x40
  86 #define   SX9310_REG_SAR_CTRL0_SARHYST_8                0x10
  87 #define SX9310_REG_SAR_CTRL1                            0x2b
  88 /* Each increment of the slope register is 0.0078125. */
  89 #define   SX9310_REG_SAR_CTRL1_SLOPE(_hnslope)          (_hnslope / 78125)
  90 #define SX9310_REG_SAR_CTRL2                            0x2c
  91 #define   SX9310_REG_SAR_CTRL2_SAROFFSET_DEFAULT        0x3c
  92
  93 #define SX9310_REG_SENSOR_SEL                           0x30
  94
  95 #define SX9310_REG_USE_MSB                              0x31
  96 #define SX9310_REG_USE_LSB                              0x32
  97
  98 #define SX9310_REG_AVG_MSB                              0x33
  99 #define SX9310_REG_AVG_LSB                              0x34
 100
 101 #define SX9310_REG_DIFF_MSB                             0x35
 102 #define SX9310_REG_DIFF_LSB                             0x36
 103
 104 #define SX9310_REG_OFFSET_MSB                           0x37
 105 #define SX9310_REG_OFFSET_LSB                           0x38
 106
 107 #define SX9310_REG_SAR_MSB                              0x39
 108 #define SX9310_REG_SAR_LSB                              0x3a
 109
 110 #define SX9310_REG_I2CADDR                              0x40
 111 #define SX9310_REG_PAUSE                                0x41
 112 #define SX9310_REG_WHOAMI                               0x42
 113 #define   SX9310_WHOAMI_VALUE                           0x01
 114 #define   SX9311_WHOAMI_VALUE                           0x02
 115
 116 #define SX9310_REG_RESET                                0x7f
 117 #define   SX9310_SOFT_RESET                             0xde
 118
 119 #define SX9310_SCAN_PERIOD_MASK                         GENMASK(7, 4)
 120 #define SX9310_SCAN_PERIOD_SHIFT                        4
 121
 122 #define SX9310_COMPSTAT_MASK                            GENMASK(3, 0)
 123
 124 /* 4 hardware channels, as defined in STAT0: COMB, CS2, CS1 and CS0. */
 125 #define SX9310_NUM_CHANNELS                             4
 126 #define SX9310_CHAN_ENABLED_MASK                        GENMASK(3, 0)
 127
 128 struct sx9310_data {
 129         /* Serialize access to registers and channel configuration */
 130         struct mutex mutex;
 131         struct i2c_client *client;
 132         struct iio_trigger *trig;
 133         struct regmap *regmap;
 134         /*
 135          * Last reading of the proximity status for each channel.
 136          * We only send an event to user space when this changes.
 137          */
 138         bool prox_stat[SX9310_NUM_CHANNELS];
 139         bool trigger_enabled;
 140         __be16 buffer[SX9310_NUM_CHANNELS +
 141                       4]; /* 64-bit data + 64-bit timestamp */
 142         /* Remember enabled channels and sample rate during suspend. */
 143         unsigned int suspend_ctrl0;
 144         struct completion completion;
 145         unsigned int chan_read, chan_event;
 146         int channel_users[SX9310_NUM_CHANNELS];
 147         int whoami;
 148 };
 149
 150 static const struct iio_event_spec sx9310_events[] = {
 151         {
 152                 .type = IIO_EV_TYPE_THRESH,
 153                 .dir = IIO_EV_DIR_EITHER,
 154                 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
 155         },
 156 };
 157
 158 #define SX9310_NAMED_CHANNEL(idx, name)                                  \
 159         {                                                                \
 160                 .type = IIO_PROXIMITY,                                   \
 161                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),            \
 162                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 163                 .indexed = 1,                                            \
 164                 .channel = idx,                                          \
 165                 .extend_name = name,                                     \
 166                 .address = SX9310_REG_DIFF_MSB,                          \
 167                 .event_spec = sx9310_events,                             \
 168                 .num_event_specs = ARRAY_SIZE(sx9310_events),            \
 169                 .scan_index = idx,                                       \
 170                 .scan_type = {                                           \
 171                         .sign = 's',                                     \
 172                         .realbits = 12,                                  \
 173                         .storagebits = 16,                               \
 174                         .endianness = IIO_BE,                            \
 175                 },                                                       \
 176         }
 177 #define SX9310_CHANNEL(idx) SX9310_NAMED_CHANNEL(idx, NULL)
 178
 179 static const struct iio_chan_spec sx9310_channels[] = {
 180         SX9310_CHANNEL(0),                      /* CS0 */
 181         SX9310_CHANNEL(1),                      /* CS1 */
 182         SX9310_CHANNEL(2),                      /* CS2 */
 183         SX9310_NAMED_CHANNEL(3, "comb"),        /* COMB */
 184
 185         IIO_CHAN_SOFT_TIMESTAMP(4),
 186 };
 187
 188 /*
 189  * Each entry contains the integer part (val) and the fractional part, in micro
 190  * seconds. It conforms to the IIO output IIO_VAL_INT_PLUS_MICRO.
 191  */
 192 static const struct {
 193         int val;
 194         int val2;
 195 } sx9310_samp_freq_table[] = {
 196         { 500, 0 }, /* 0000: Min (no idle time) */
 197         { 66, 666666 }, /* 0001: 15 ms */
 198         { 33, 333333 }, /* 0010: 30 ms (Typ.) */
 199         { 22, 222222 }, /* 0011: 45 ms */
 200         { 16, 666666 }, /* 0100: 60 ms */
 201         { 11, 111111 }, /* 0101: 90 ms */
 202         { 8, 333333 }, /* 0110: 120 ms */
 203         { 5, 0 }, /* 0111: 200 ms */
 204         { 2, 500000 }, /* 1000: 400 ms */
 205         { 1, 666666 }, /* 1001: 600 ms */
 206         { 1, 250000 }, /* 1010: 800 ms */
 207         { 1, 0 }, /* 1011: 1 s */
 208         { 0, 500000 }, /* 1100: 2 s */
 209         { 0, 333333 }, /* 1101: 3 s */
 210         { 0, 250000 }, /* 1110: 4 s */
 211         { 0, 200000 }, /* 1111: 5 s */
 212 };
 213 static const unsigned int sx9310_scan_period_table[] = {
 214         2,   15,  30,  45,   60,   90,   120,  200,
 215         400, 600, 800, 1000, 2000, 3000, 4000, 5000,
 216 };
 217
 218 static ssize_t sx9310_show_samp_freq_avail(struct device *dev,
 219                                            struct device_attribute *attr,
 220                                            char *buf)
 221 {
 222         size_t len = 0;
 223         int i;
 224
 225         for (i = 0; i < ARRAY_SIZE(sx9310_samp_freq_table); i++)
 226                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%d ",
 227                                  sx9310_samp_freq_table[i].val,
 228                                  sx9310_samp_freq_table[i].val2);
 229         buf[len - 1] = '\n';
 230         return len;
 231 }
 232 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(sx9310_show_samp_freq_avail);
 233
 234 static const struct regmap_range sx9310_writable_reg_ranges[] = {
 235         regmap_reg_range(SX9310_REG_IRQ_MSK, SX9310_REG_IRQ_FUNC),
 236         regmap_reg_range(SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL19),
 237         regmap_reg_range(SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL2),
 238         regmap_reg_range(SX9310_REG_SENSOR_SEL, SX9310_REG_SENSOR_SEL),
 239         regmap_reg_range(SX9310_REG_OFFSET_MSB, SX9310_REG_OFFSET_LSB),
 240         regmap_reg_range(SX9310_REG_PAUSE, SX9310_REG_PAUSE),
 241         regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET),
 242 };
 243
 244 static const struct regmap_access_table sx9310_writeable_regs = {
 245         .yes_ranges = sx9310_writable_reg_ranges,
 246         .n_yes_ranges = ARRAY_SIZE(sx9310_writable_reg_ranges),
 247 };
 248
 249 static const struct regmap_range sx9310_readable_reg_ranges[] = {
 250         regmap_reg_range(SX9310_REG_IRQ_SRC, SX9310_REG_IRQ_FUNC),
 251         regmap_reg_range(SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL19),
 252         regmap_reg_range(SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL2),
 253         regmap_reg_range(SX9310_REG_SENSOR_SEL, SX9310_REG_SAR_LSB),
 254         regmap_reg_range(SX9310_REG_I2CADDR, SX9310_REG_WHOAMI),
 255         regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET),
 256 };
 257
 258 static const struct regmap_access_table sx9310_readable_regs = {
 259         .yes_ranges = sx9310_readable_reg_ranges,
 260         .n_yes_ranges = ARRAY_SIZE(sx9310_readable_reg_ranges),
 261 };
 262
 263 static const struct regmap_range sx9310_volatile_reg_ranges[] = {
 264         regmap_reg_range(SX9310_REG_IRQ_SRC, SX9310_REG_STAT1),
 265         regmap_reg_range(SX9310_REG_USE_MSB, SX9310_REG_DIFF_LSB),
 266         regmap_reg_range(SX9310_REG_SAR_MSB, SX9310_REG_SAR_LSB),
 267         regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET),
 268 };
 269
 270 static const struct regmap_access_table sx9310_volatile_regs = {
 271         .yes_ranges = sx9310_volatile_reg_ranges,
 272         .n_yes_ranges = ARRAY_SIZE(sx9310_volatile_reg_ranges),
 273 };
 274
 275 static const struct regmap_config sx9310_regmap_config = {
 276         .reg_bits = 8,
 277         .val_bits = 8,
 278
 279         .max_register = SX9310_REG_RESET,
 280         .cache_type = REGCACHE_RBTREE,
 281
 282         .wr_table = &sx9310_writeable_regs,
 283         .rd_table = &sx9310_readable_regs,
 284         .volatile_table = &sx9310_volatile_regs,
 285 };
 286
 287 static int sx9310_update_chan_en(struct sx9310_data *data,
 288                                  unsigned int chan_read,
 289                                  unsigned int chan_event)
 290 {
 291         int ret;
 292
 293         if ((data->chan_read | data->chan_event) != (chan_read | chan_event)) {
 294                 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL0,
 295                                          SX9310_CHAN_ENABLED_MASK,
 296                                          chan_read | chan_event);
 297                 if (ret)
 298                         return ret;
 299         }
 300         data->chan_read = chan_read;
 301         data->chan_event = chan_event;
 302         return 0;
 303 }
 304
 305 static int sx9310_get_read_channel(struct sx9310_data *data, int channel)
 306 {
 307         return sx9310_update_chan_en(data, data->chan_read | BIT(channel),
 308                                      data->chan_event);
 309 }
 310
 311 static int sx9310_put_read_channel(struct sx9310_data *data, int channel)
 312 {
 313         return sx9310_update_chan_en(data, data->chan_read & ~BIT(channel),
 314                                      data->chan_event);
 315 }
 316
 317 static int sx9310_get_event_channel(struct sx9310_data *data, int channel)
 318 {
 319         return sx9310_update_chan_en(data, data->chan_read,
 320                                      data->chan_event | BIT(channel));
 321 }
 322
 323 static int sx9310_put_event_channel(struct sx9310_data *data, int channel)
 324 {
 325         return sx9310_update_chan_en(data, data->chan_read,
 326                                      data->chan_event & ~BIT(channel));
 327 }
 328
 329 static int sx9310_enable_irq(struct sx9310_data *data, unsigned int irq)
 330 {
 331         return regmap_update_bits(data->regmap, SX9310_REG_IRQ_MSK, irq, irq);
 332 }
 333
 334 static int sx9310_disable_irq(struct sx9310_data *data, unsigned int irq)
 335 {
 336         return regmap_update_bits(data->regmap, SX9310_REG_IRQ_MSK, irq, 0);
 337 }
 338
 339 static int sx9310_read_prox_data(struct sx9310_data *data,
 340                                  const struct iio_chan_spec *chan, __be16 *val)
 341 {
 342         int ret;
 343
 344         ret = regmap_write(data->regmap, SX9310_REG_SENSOR_SEL, chan->channel);
 345         if (ret < 0)
 346                 return ret;
 347
 348         return regmap_bulk_read(data->regmap, chan->address, val, 2);
 349 }
 350
 351 /*
 352  * If we have no interrupt support, we have to wait for a scan period
 353  * after enabling a channel to get a result.
 354  */
 355 static int sx9310_wait_for_sample(struct sx9310_data *data)
 356 {
 357         int ret;
 358         unsigned int val;
 359
 360         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &val);
 361         if (ret < 0)
 362                 return ret;
 363
 364         val = (val & SX9310_SCAN_PERIOD_MASK) >> SX9310_SCAN_PERIOD_SHIFT;
 365
 366         msleep(sx9310_scan_period_table[val]);
 367
 368         return 0;
 369 }
 370
 371 static int sx9310_read_proximity(struct sx9310_data *data,
 372                                  const struct iio_chan_spec *chan, int *val)
 373 {
 374         int ret = 0;
 375         __be16 rawval;
 376
 377         mutex_lock(&data->mutex);
 378
 379         ret = sx9310_get_read_channel(data, chan->channel);
 380         if (ret < 0)
 381                 goto out;
 382
 383         ret = sx9310_enable_irq(data, SX9310_CONVDONE_IRQ);
 384         if (ret < 0)
 385                 goto out_put_channel;
 386
 387         mutex_unlock(&data->mutex);
 388
 389         if (data->client->irq > 0) {
 390                 ret = wait_for_completion_interruptible(&data->completion);
 391                 reinit_completion(&data->completion);
 392         } else {
 393                 ret = sx9310_wait_for_sample(data);
 394         }
 395
 396         mutex_lock(&data->mutex);
 397
 398         if (ret < 0)
 399                 goto out_disable_irq;
 400
 401         ret = sx9310_read_prox_data(data, chan, &rawval);
 402         if (ret < 0)
 403                 goto out_disable_irq;
 404
 405         *val = sign_extend32(be16_to_cpu(rawval),
 406                              (chan->address == SX9310_REG_DIFF_MSB ? 11 : 15));
 407
 408         ret = sx9310_disable_irq(data, SX9310_CONVDONE_IRQ);
 409         if (ret < 0)
 410                 goto out_put_channel;
 411
 412         ret = sx9310_put_read_channel(data, chan->channel);
 413         if (ret < 0)
 414                 goto out;
 415
 416         mutex_unlock(&data->mutex);
 417
 418         return IIO_VAL_INT;
 419
 420 out_disable_irq:
 421         sx9310_disable_irq(data, SX9310_CONVDONE_IRQ);
 422 out_put_channel:
 423         sx9310_put_read_channel(data, chan->channel);
 424 out:
 425         mutex_unlock(&data->mutex);
 426
 427         return ret;
 428 }
 429
 430 static int sx9310_read_samp_freq(struct sx9310_data *data, int *val, int *val2)
 431 {
 432         unsigned int regval;
 433         int ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &regval);
 434
 435         if (ret < 0)
 436                 return ret;
 437
 438         regval = (regval & SX9310_SCAN_PERIOD_MASK) >> SX9310_SCAN_PERIOD_SHIFT;
 439         *val = sx9310_samp_freq_table[regval].val;
 440         *val2 = sx9310_samp_freq_table[regval].val2;
 441
 442         return IIO_VAL_INT_PLUS_MICRO;
 443 }
 444
 445 static int sx9310_read_raw(struct iio_dev *indio_dev,
 446                            const struct iio_chan_spec *chan, int *val,
 447                            int *val2, long mask)
 448 {
 449         struct sx9310_data *data = iio_priv(indio_dev);
 450         int ret;
 451
 452         if (chan->type != IIO_PROXIMITY)
 453                 return -EINVAL;
 454
 455         switch (mask) {
 456         case IIO_CHAN_INFO_RAW:
 457                 ret = iio_device_claim_direct_mode(indio_dev);
 458                 if (ret)
 459                         return ret;
 460
 461                 ret = sx9310_read_proximity(data, chan, val);
 462                 iio_device_release_direct_mode(indio_dev);
 463                 return ret;
 464         case IIO_CHAN_INFO_SAMP_FREQ:
 465                 return sx9310_read_samp_freq(data, val, val2);
 466         default:
 467                 return -EINVAL;
 468         }
 469 }
 470
 471 static int sx9310_set_samp_freq(struct sx9310_data *data, int val, int val2)
 472 {
 473         int i, ret;
 474
 475         for (i = 0; i < ARRAY_SIZE(sx9310_samp_freq_table); i++)
 476                 if (val == sx9310_samp_freq_table[i].val &&
 477                     val2 == sx9310_samp_freq_table[i].val2)
 478                         break;
 479
 480         if (i == ARRAY_SIZE(sx9310_samp_freq_table))
 481                 return -EINVAL;
 482
 483         mutex_lock(&data->mutex);
 484
 485         ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL0,
 486                                  SX9310_SCAN_PERIOD_MASK,
 487                                  i << SX9310_SCAN_PERIOD_SHIFT);
 488
 489         mutex_unlock(&data->mutex);
 490
 491         return ret;
 492 }
 493
 494 static int sx9310_write_raw(struct iio_dev *indio_dev,
 495                             const struct iio_chan_spec *chan, int val, int val2,
 496                             long mask)
 497 {
 498         struct sx9310_data *data = iio_priv(indio_dev);
 499
 500         if (chan->type != IIO_PROXIMITY)
 501                 return -EINVAL;
 502
 503         if (mask != IIO_CHAN_INFO_SAMP_FREQ)
 504                 return -EINVAL;
 505
 506         return sx9310_set_samp_freq(data, val, val2);
 507 }
 508
 509 static irqreturn_t sx9310_irq_handler(int irq, void *private)
 510 {
 511         struct iio_dev *indio_dev = private;
 512         struct sx9310_data *data = iio_priv(indio_dev);
 513
 514         if (data->trigger_enabled)
 515                 iio_trigger_poll(data->trig);
 516
 517         /*
 518          * Even if no event is enabled, we need to wake the thread to
 519          * clear the interrupt state by reading SX9310_REG_IRQ_SRC.  It
 520          * is not possible to do that here because regmap_read takes a
 521          * mutex.
 522          */
 523         return IRQ_WAKE_THREAD;
 524 }
 525
 526 static void sx9310_push_events(struct iio_dev *indio_dev)
 527 {
 528         int ret;
 529         unsigned int val, chan;
 530         struct sx9310_data *data = iio_priv(indio_dev);
 531         s64 timestamp = iio_get_time_ns(indio_dev);
 532
 533         /* Read proximity state on all channels */
 534         ret = regmap_read(data->regmap, SX9310_REG_STAT0, &val);
 535         if (ret < 0) {
 536                 dev_err(&data->client->dev, "i2c transfer error in irq\n");
 537                 return;
 538         }
 539
 540         for (chan = 0; chan < SX9310_NUM_CHANNELS; chan++) {
 541                 int dir;
 542                 u64 ev;
 543                 bool new_prox = val & BIT(chan);
 544
 545                 if (!(data->chan_event & BIT(chan)))
 546                         continue;
 547                 if (new_prox == data->prox_stat[chan])
 548                         /* No change on this channel. */
 549                         continue;
 550
 551                 dir = new_prox ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
 552                 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan,
 553                                           IIO_EV_TYPE_THRESH, dir);
 554
 555                 iio_push_event(indio_dev, ev, timestamp);
 556                 data->prox_stat[chan] = new_prox;
 557         }
 558 }
 559
 560 static irqreturn_t sx9310_irq_thread_handler(int irq, void *private)
 561 {
 562         struct iio_dev *indio_dev = private;
 563         struct sx9310_data *data = iio_priv(indio_dev);
 564         int ret;
 565         unsigned int val;
 566
 567         mutex_lock(&data->mutex);
 568
 569         ret = regmap_read(data->regmap, SX9310_REG_IRQ_SRC, &val);
 570         if (ret < 0) {
 571                 dev_err(&data->client->dev, "i2c transfer error in irq\n");
 572                 goto out;
 573         }
 574
 575         if (val & SX9310_EVENT_IRQ)
 576                 sx9310_push_events(indio_dev);
 577
 578         if (val & SX9310_CONVDONE_IRQ)
 579                 complete(&data->completion);
 580
 581 out:
 582         mutex_unlock(&data->mutex);
 583
 584         return IRQ_HANDLED;
 585 }
 586
 587 static int sx9310_read_event_config(struct iio_dev *indio_dev,
 588                                     const struct iio_chan_spec *chan,
 589                                     enum iio_event_type type,
 590                                     enum iio_event_direction dir)
 591 {
 592         struct sx9310_data *data = iio_priv(indio_dev);
 593
 594         return !!(data->chan_event & BIT(chan->channel));
 595 }
 596
 597 static int sx9310_write_event_config(struct iio_dev *indio_dev,
 598                                      const struct iio_chan_spec *chan,
 599                                      enum iio_event_type type,
 600                                      enum iio_event_direction dir, int state)
 601 {
 602         struct sx9310_data *data = iio_priv(indio_dev);
 603         int ret;
 604
 605         /* If the state hasn't changed, there's nothing to do. */
 606         if (!!(data->chan_event & BIT(chan->channel)) == state)
 607                 return 0;
 608
 609         mutex_lock(&data->mutex);
 610         if (state) {
 611                 ret = sx9310_get_event_channel(data, chan->channel);
 612                 if (ret < 0)
 613                         goto out_unlock;
 614                 if (!(data->chan_event & ~BIT(chan->channel))) {
 615                         ret = sx9310_enable_irq(data, SX9310_EVENT_IRQ);
 616                         if (ret < 0)
 617                                 sx9310_put_event_channel(data, chan->channel);
 618                 }
 619         } else {
 620                 ret = sx9310_put_event_channel(data, chan->channel);
 621                 if (ret < 0)
 622                         goto out_unlock;
 623                 if (!data->chan_event) {
 624                         ret = sx9310_disable_irq(data, SX9310_EVENT_IRQ);
 625                         if (ret < 0)
 626                                 sx9310_get_event_channel(data, chan->channel);
 627                 }
 628         }
 629
 630 out_unlock:
 631         mutex_unlock(&data->mutex);
 632         return ret;
 633 }
 634
 635 static struct attribute *sx9310_attributes[] = {
 636         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 637         NULL,
 638 };
 639
 640 static const struct attribute_group sx9310_attribute_group = {
 641         .attrs = sx9310_attributes,
 642 };
 643
 644 static const struct iio_info sx9310_info = {
 645         .attrs = &sx9310_attribute_group,
 646         .read_raw = sx9310_read_raw,
 647         .write_raw = sx9310_write_raw,
 648         .read_event_config = sx9310_read_event_config,
 649         .write_event_config = sx9310_write_event_config,
 650 };
 651
 652 static int sx9310_set_trigger_state(struct iio_trigger *trig, bool state)
 653 {
 654         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 655         struct sx9310_data *data = iio_priv(indio_dev);
 656         int ret = 0;
 657
 658         mutex_lock(&data->mutex);
 659
 660         if (state)
 661                 ret = sx9310_enable_irq(data, SX9310_CONVDONE_IRQ);
 662         else if (!data->chan_read)
 663                 ret = sx9310_disable_irq(data, SX9310_CONVDONE_IRQ);
 664         if (ret < 0)
 665                 goto out;
 666
 667         data->trigger_enabled = state;
 668
 669 out:
 670         mutex_unlock(&data->mutex);
 671
 672         return ret;
 673 }
 674
 675 static const struct iio_trigger_ops sx9310_trigger_ops = {
 676         .set_trigger_state = sx9310_set_trigger_state,
 677 };
 678
 679 static irqreturn_t sx9310_trigger_handler(int irq, void *private)
 680 {
 681         struct iio_poll_func *pf = private;
 682         struct iio_dev *indio_dev = pf->indio_dev;
 683         struct sx9310_data *data = iio_priv(indio_dev);
 684         __be16 val;
 685         int bit, ret, i = 0;
 686
 687         mutex_lock(&data->mutex);
 688
 689         for_each_set_bit(bit, indio_dev->active_scan_mask,
 690                          indio_dev->masklength) {
 691                 ret = sx9310_read_prox_data(data, &indio_dev->channels[bit],
 692                                             &val);
 693                 if (ret < 0)
 694                         goto out;
 695
 696                 data->buffer[i++] = val;
 697         }
 698
 699         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 700                                            pf->timestamp);
 701
 702 out:
 703         mutex_unlock(&data->mutex);
 704
 705         iio_trigger_notify_done(indio_dev->trig);
 706
 707         return IRQ_HANDLED;
 708 }
 709
 710 static int sx9310_buffer_preenable(struct iio_dev *indio_dev)
 711 {
 712         struct sx9310_data *data = iio_priv(indio_dev);
 713         unsigned int channels = 0;
 714         int bit, ret;
 715
 716         mutex_lock(&data->mutex);
 717         for_each_set_bit(bit, indio_dev->active_scan_mask,
 718                          indio_dev->masklength)
 719                 channels |= BIT(indio_dev->channels[bit].channel);
 720
 721         ret = sx9310_update_chan_en(data, channels, data->chan_event);
 722         mutex_unlock(&data->mutex);
 723         return ret;
 724 }
 725
 726 static int sx9310_buffer_postdisable(struct iio_dev *indio_dev)
 727 {
 728         struct sx9310_data *data = iio_priv(indio_dev);
 729         int ret;
 730
 731         mutex_lock(&data->mutex);
 732         ret = sx9310_update_chan_en(data, 0, data->chan_event);
 733         mutex_unlock(&data->mutex);
 734         return ret;
 735 }
 736
 737 static const struct iio_buffer_setup_ops sx9310_buffer_setup_ops = {
 738         .preenable = sx9310_buffer_preenable,
 739         .postdisable = sx9310_buffer_postdisable,
 740 };
 741
 742 struct sx9310_reg_default {
 743         u8 reg;
 744         u8 def;
 745 };
 746
 747 #define SX_INIT(_reg, _def)                     \
 748         {                                       \
 749                 .reg = SX9310_REG_##_reg,       \
 750                 .def = _def,                    \
 751         }
 752
 753 static const struct sx9310_reg_default sx9310_default_regs[] = {
 754         SX_INIT(IRQ_MSK, 0x00),
 755         SX_INIT(IRQ_FUNC, 0x00),
 756         /*
 757          * The lower 4 bits should not be set as it enable sensors measurements.
 758          * Turning the detection on before the configuration values are set to
 759          * good values can cause the device to return erroneous readings.
 760          */
 761         SX_INIT(PROX_CTRL0, SX9310_REG_PROX_CTRL0_PROXSTAT2),
 762         SX_INIT(PROX_CTRL1, 0x00),
 763         SX_INIT(PROX_CTRL2, SX9310_REG_PROX_CTRL2_COMBMODE_ALL |
 764                             SX9310_REG_PROX_CTRL2_SHIELDEN_DYNAMIC),
 765         SX_INIT(PROX_CTRL3, SX9310_REG_PROX_CTRL3_GAIN0_X8 |
 766                             SX9310_REG_PROX_CTRL3_GAIN12_X4),
 767         SX_INIT(PROX_CTRL4, SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST),
 768         SX_INIT(PROX_CTRL5, SX9310_REG_PROX_CTRL5_RANGE_SMALL |
 769                             SX9310_REG_PROX_CTRL5_STARTUPSENS_CS1 |
 770                             SX9310_REG_PROX_CTRL5_RAWFILT_1P25),
 771         SX_INIT(PROX_CTRL6, SX9310_REG_PROX_CTRL6_COMP_COMMON),
 772         SX_INIT(PROX_CTRL7, SX9310_REG_PROX_CTRL7_AVGNEGFILT_2 |
 773                             SX9310_REG_PROX_CTRL7_AVGPOSFILT_512),
 774         SX_INIT(PROX_CTRL8, SX9310_REG_PROX_CTRL8_9_PTHRESH_96 |
 775                             SX9310_REG_PROX_CTRL8_9_BODYTHRESH_1500),
 776         SX_INIT(PROX_CTRL9, SX9310_REG_PROX_CTRL8_9_PTHRESH12_28 |
 777                             SX9310_REG_PROX_CTRL8_9_BODYTHRESH_900),
 778         SX_INIT(PROX_CTRL10, SX9310_REG_PROX_CTRL10_HYST_6PCT |
 779                              SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_8 |
 780                              SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_8),
 781         SX_INIT(PROX_CTRL11, 0x00),
 782         SX_INIT(PROX_CTRL12, 0x00),
 783         SX_INIT(PROX_CTRL13, 0x00),
 784         SX_INIT(PROX_CTRL14, 0x00),
 785         SX_INIT(PROX_CTRL15, 0x00),
 786         SX_INIT(PROX_CTRL16, 0x00),
 787         SX_INIT(PROX_CTRL17, 0x00),
 788         SX_INIT(PROX_CTRL18, 0x00),
 789         SX_INIT(PROX_CTRL19, 0x00),
 790         SX_INIT(SAR_CTRL0, SX9310_REG_SAR_CTRL0_SARDEB_4_SAMPLES |
 791                            SX9310_REG_SAR_CTRL0_SARHYST_8),
 792         SX_INIT(SAR_CTRL1, SX9310_REG_SAR_CTRL1_SLOPE(10781250)),
 793         SX_INIT(SAR_CTRL2, SX9310_REG_SAR_CTRL2_SAROFFSET_DEFAULT),
 794 };
 795
 796 /* Activate all channels and perform an initial compensation. */
 797 static int sx9310_init_compensation(struct iio_dev *indio_dev)
 798 {
 799         struct sx9310_data *data = iio_priv(indio_dev);
 800         int i, ret;
 801         unsigned int val;
 802         unsigned int ctrl0;
 803
 804         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &ctrl0);
 805         if (ret < 0)
 806                 return ret;
 807
 808         /* run the compensation phase on all channels */
 809         ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0,
 810                            ctrl0 | SX9310_REG_PROX_CTRL0_EN_MASK);
 811         if (ret < 0)
 812                 return ret;
 813
 814         for (i = 100; i >= 0; i--) {
 815                 msleep(20);
 816                 ret = regmap_read(data->regmap, SX9310_REG_STAT1, &val);
 817                 if (ret < 0)
 818                         goto out;
 819                 if (!(val & SX9310_COMPSTAT_MASK))
 820                         break;
 821         }
 822
 823         if (i < 0) {
 824                 dev_err(&data->client->dev,
 825                         "initial compensation timed out: 0x%02x", val);
 826                 ret = -ETIMEDOUT;
 827         }
 828
 829 out:
 830         regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, ctrl0);
 831         return ret;
 832 }
 833
 834 static int sx9310_init_device(struct iio_dev *indio_dev)
 835 {
 836         struct sx9310_data *data = iio_priv(indio_dev);
 837         const struct sx9310_reg_default *initval;
 838         int ret;
 839         unsigned int i, val;
 840
 841         ret = regmap_write(data->regmap, SX9310_REG_RESET, SX9310_SOFT_RESET);
 842         if (ret < 0)
 843                 return ret;
 844
 845         usleep_range(1000, 2000); /* power-up time is ~1ms. */
 846
 847         /* Clear reset interrupt state by reading SX9310_REG_IRQ_SRC. */
 848         ret = regmap_read(data->regmap, SX9310_REG_IRQ_SRC, &val);
 849         if (ret < 0)
 850                 return ret;
 851
 852         /* Program some sane defaults. */
 853         for (i = 0; i < ARRAY_SIZE(sx9310_default_regs); i++) {
 854                 initval = &sx9310_default_regs[i];
 855                 ret = regmap_write(data->regmap, initval->reg, initval->def);
 856                 if (ret < 0)
 857                         return ret;
 858         }
 859
 860         return sx9310_init_compensation(indio_dev);
 861 }
 862
 863 static int sx9310_set_indio_dev_name(struct device *dev,
 864                                      struct iio_dev *indio_dev,
 865                                      const struct i2c_device_id *id, int whoami)
 866 {
 867         const struct acpi_device_id *acpi_id;
 868
 869         /* id will be NULL when enumerated via ACPI */
 870         if (id) {
 871                 if (id->driver_data != whoami)
 872                         dev_err(dev, "WHOAMI does not match i2c_device_id: %s",
 873                                 id->name);
 874         } else if (ACPI_HANDLE(dev)) {
 875                 acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev);
 876                 if (!acpi_id)
 877                         return -ENODEV;
 878                 if (acpi_id->driver_data != whoami)
 879                         dev_err(dev, "WHOAMI does not match acpi_device_id: %s",
 880                                 acpi_id->id);
 881         } else
 882                 return -ENODEV;
 883
 884         switch (whoami) {
 885         case SX9310_WHOAMI_VALUE:
 886                 indio_dev->name = "sx9310";
 887                 break;
 888         case SX9311_WHOAMI_VALUE:
 889                 indio_dev->name = "sx9311";
 890                 break;
 891         default:
 892                 dev_err(dev, "unexpected WHOAMI response: %u", whoami);
 893                 return -ENODEV;
 894         }
 895
 896         return 0;
 897 }
 898
 899 static int sx9310_probe(struct i2c_client *client,
 900                         const struct i2c_device_id *id)
 901 {
 902         int ret;
 903         struct iio_dev *indio_dev;
 904         struct sx9310_data *data;
 905
 906         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 907         if (indio_dev == NULL)
 908                 return -ENOMEM;
 909
 910         data = iio_priv(indio_dev);
 911         data->client = client;
 912         mutex_init(&data->mutex);
 913         init_completion(&data->completion);
 914
 915         data->regmap = devm_regmap_init_i2c(client, &sx9310_regmap_config);
 916         if (IS_ERR(data->regmap))
 917                 return PTR_ERR(data->regmap);
 918
 919         ret = regmap_read(data->regmap, SX9310_REG_WHOAMI, &data->whoami);
 920         if (ret < 0) {
 921                 dev_err(&client->dev, "error in reading WHOAMI register: %d",
 922                         ret);
 923                 return ret;
 924         }
 925
 926         ret = sx9310_set_indio_dev_name(&client->dev, indio_dev, id,
 927                                         data->whoami);
 928         if (ret < 0)
 929                 return ret;
 930
 931         ACPI_COMPANION_SET(&indio_dev->dev, ACPI_COMPANION(&client->dev));
 932         indio_dev->channels = sx9310_channels;
 933         indio_dev->num_channels = ARRAY_SIZE(sx9310_channels);
 934         indio_dev->info = &sx9310_info;
 935         indio_dev->modes = INDIO_DIRECT_MODE;
 936         i2c_set_clientdata(client, indio_dev);
 937
 938         ret = sx9310_init_device(indio_dev);
 939         if (ret < 0)
 940                 return ret;
 941
 942         if (client->irq) {
 943                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 944                                                 sx9310_irq_handler,
 945                                                 sx9310_irq_thread_handler,
 946                                                 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 947                                                 "sx9310_event", indio_dev);
 948                 if (ret < 0)
 949                         return ret;
 950
 951                 data->trig =
 952                         devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
 953                                                indio_dev->name, indio_dev->id);
 954                 if (!data->trig)
 955                         return -ENOMEM;
 956
 957                 data->trig->dev.parent = &client->dev;
 958                 data->trig->ops = &sx9310_trigger_ops;
 959                 iio_trigger_set_drvdata(data->trig, indio_dev);
 960
 961                 ret = devm_iio_trigger_register(&client->dev, data->trig);
 962                 if (ret)
 963                         return ret;
 964         }
 965
 966         ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev,
 967                                               iio_pollfunc_store_time,
 968                                               sx9310_trigger_handler,
 969                                               &sx9310_buffer_setup_ops);
 970         if (ret < 0)
 971                 return ret;
 972
 973         return devm_iio_device_register(&client->dev, indio_dev);
 974 }
 975
 976 static int __maybe_unused sx9310_suspend(struct device *dev)
 977 {
 978         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 979         struct sx9310_data *data = iio_priv(indio_dev);
 980         u8 ctrl0;
 981         int ret;
 982
 983         disable_irq_nosync(data->client->irq);
 984
 985         mutex_lock(&data->mutex);
 986         ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0,
 987                           &data->suspend_ctrl0);
 988
 989         if (ret)
 990                 goto out;
 991
 992         ctrl0 = data->suspend_ctrl0 & ~SX9310_REG_PROX_CTRL0_EN_MASK;
 993         ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, ctrl0);
 994         if (ret)
 995                 goto out;
 996
 997         ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 0);
 998
 999 out:
1000         mutex_unlock(&data->mutex);
1001         return ret;
1002 }
1003
1004 static int __maybe_unused sx9310_resume(struct device *dev)
1005 {
1006         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1007         struct sx9310_data *data = iio_priv(indio_dev);
1008         int ret;
1009
1010         mutex_lock(&data->mutex);
1011         ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 1);
1012         if (ret)
1013                 goto out;
1014
1015         ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0,
1016                            data->suspend_ctrl0);
1017
1018 out:
1019         mutex_unlock(&data->mutex);
1020
1021         enable_irq(data->client->irq);
1022
1023         return ret;
1024 }
1025
1026 static const struct dev_pm_ops sx9310_pm_ops = {
1027         SET_SYSTEM_SLEEP_PM_OPS(sx9310_suspend, sx9310_resume)
1028 };
1029
1030 static const struct acpi_device_id sx9310_acpi_match[] = {
1031         { "STH9310", SX9310_WHOAMI_VALUE },
1032         { "STH9311", SX9311_WHOAMI_VALUE },
1033         {},
1034 };
1035 MODULE_DEVICE_TABLE(acpi, sx9310_acpi_match);
1036
1037 static const struct of_device_id sx9310_of_match[] = {
1038         { .compatible = "semtech,sx9310" },
1039         { .compatible = "semtech,sx9311" },
1040         {},
1041 };
1042 MODULE_DEVICE_TABLE(of, sx9310_of_match);
1043
1044 static const struct i2c_device_id sx9310_id[] = {
1045         { "sx9310", SX9310_WHOAMI_VALUE },
1046         { "sx9311", SX9311_WHOAMI_VALUE },
1047         {},
1048 };
1049 MODULE_DEVICE_TABLE(i2c, sx9310_id);
1050
1051 static struct i2c_driver sx9310_driver = {
1052         .driver = {
1053                 .name   = "sx9310",
1054                 .acpi_match_table = ACPI_PTR(sx9310_acpi_match),
1055                 .of_match_table = of_match_ptr(sx9310_of_match),
1056                 .pm = &sx9310_pm_ops,
1057         },
1058         .probe          = sx9310_probe,
1059         .id_table       = sx9310_id,
1060 };
1061 module_i2c_driver(sx9310_driver);
1062
1063 MODULE_AUTHOR("Gwendal Grignou <gwendal@chromium.org>");
1064 MODULE_AUTHOR("Daniel Campello <campello@chromium.org>");
1065 MODULE_DESCRIPTION("Driver for Semtech SX9310/SX9311 proximity sensor");
1066 MODULE_LICENSE("GPL v2");