drivers/iio/proximity/sx9500.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2014 Intel Corporation
   4  *
   5  * Driver for Semtech's SX9500 capacitive proximity/button solution.
   6  * Datasheet available at
   7  * <http://www.semtech.com/images/datasheet/sx9500.pdf>.
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/slab.h>
  12 #include <linux/module.h>
  13 #include <linux/i2c.h>
  14 #include <linux/irq.h>
  15 #include <linux/acpi.h>
  16 #include <linux/gpio/consumer.h>
  17 #include <linux/regmap.h>
  18 #include <linux/pm.h>
  19 #include <linux/delay.h>
  20
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/buffer.h>
  23 #include <linux/iio/sysfs.h>
  24 #include <linux/iio/events.h>
  25 #include <linux/iio/trigger.h>
  26 #include <linux/iio/triggered_buffer.h>
  27 #include <linux/iio/trigger_consumer.h>
  28
  29 #define SX9500_DRIVER_NAME              "sx9500"
  30 #define SX9500_IRQ_NAME                 "sx9500_event"
  31
  32 /* Register definitions. */
  33 #define SX9500_REG_IRQ_SRC              0x00
  34 #define SX9500_REG_STAT                 0x01
  35 #define SX9500_REG_IRQ_MSK              0x03
  36
  37 #define SX9500_REG_PROX_CTRL0           0x06
  38 #define SX9500_REG_PROX_CTRL1           0x07
  39 #define SX9500_REG_PROX_CTRL2           0x08
  40 #define SX9500_REG_PROX_CTRL3           0x09
  41 #define SX9500_REG_PROX_CTRL4           0x0a
  42 #define SX9500_REG_PROX_CTRL5           0x0b
  43 #define SX9500_REG_PROX_CTRL6           0x0c
  44 #define SX9500_REG_PROX_CTRL7           0x0d
  45 #define SX9500_REG_PROX_CTRL8           0x0e
  46
  47 #define SX9500_REG_SENSOR_SEL           0x20
  48 #define SX9500_REG_USE_MSB              0x21
  49 #define SX9500_REG_USE_LSB              0x22
  50 #define SX9500_REG_AVG_MSB              0x23
  51 #define SX9500_REG_AVG_LSB              0x24
  52 #define SX9500_REG_DIFF_MSB             0x25
  53 #define SX9500_REG_DIFF_LSB             0x26
  54 #define SX9500_REG_OFFSET_MSB           0x27
  55 #define SX9500_REG_OFFSET_LSB           0x28
  56
  57 #define SX9500_REG_RESET                0x7f
  58
  59 /* Write this to REG_RESET to do a soft reset. */
  60 #define SX9500_SOFT_RESET               0xde
  61
  62 #define SX9500_SCAN_PERIOD_MASK         GENMASK(6, 4)
  63 #define SX9500_SCAN_PERIOD_SHIFT        4
  64
  65 /*
  66  * These serve for identifying IRQ source in the IRQ_SRC register, and
  67  * also for masking the IRQs in the IRQ_MSK register.
  68  */
  69 #define SX9500_CLOSE_IRQ                BIT(6)
  70 #define SX9500_FAR_IRQ                  BIT(5)
  71 #define SX9500_CONVDONE_IRQ             BIT(3)
  72
  73 #define SX9500_PROXSTAT_SHIFT           4
  74 #define SX9500_COMPSTAT_MASK            GENMASK(3, 0)
  75
  76 #define SX9500_NUM_CHANNELS             4
  77 #define SX9500_CHAN_MASK                GENMASK(SX9500_NUM_CHANNELS - 1, 0)
  78
  79 struct sx9500_data {
  80         struct mutex mutex;
  81         struct i2c_client *client;
  82         struct iio_trigger *trig;
  83         struct regmap *regmap;
  84         struct gpio_desc *gpiod_rst;
  85         /*
  86          * Last reading of the proximity status for each channel.  We
  87          * only send an event to user space when this changes.
  88          */
  89         bool prox_stat[SX9500_NUM_CHANNELS];
  90         bool event_enabled[SX9500_NUM_CHANNELS];
  91         bool trigger_enabled;
  92         u16 *buffer;
  93         /* Remember enabled channels and sample rate during suspend. */
  94         unsigned int suspend_ctrl0;
  95         struct completion completion;
  96         int data_rdy_users, close_far_users;
  97         int channel_users[SX9500_NUM_CHANNELS];
  98 };
  99
 100 static const struct iio_event_spec sx9500_events[] = {
 101         {
 102                 .type = IIO_EV_TYPE_THRESH,
 103                 .dir = IIO_EV_DIR_EITHER,
 104                 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
 105         },
 106 };
 107
 108 #define SX9500_CHANNEL(idx)                                     \
 109         {                                                       \
 110                 .type = IIO_PROXIMITY,                          \
 111                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
 112                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 113                 .indexed = 1,                                   \
 114                 .channel = idx,                                 \
 115                 .event_spec = sx9500_events,                    \
 116                 .num_event_specs = ARRAY_SIZE(sx9500_events),   \
 117                 .scan_index = idx,                              \
 118                 .scan_type = {                                  \
 119                         .sign = 'u',                            \
 120                         .realbits = 16,                         \
 121                         .storagebits = 16,                      \
 122                         .shift = 0,                             \
 123                 },                                              \
 124         }
 125
 126 static const struct iio_chan_spec sx9500_channels[] = {
 127         SX9500_CHANNEL(0),
 128         SX9500_CHANNEL(1),
 129         SX9500_CHANNEL(2),
 130         SX9500_CHANNEL(3),
 131         IIO_CHAN_SOFT_TIMESTAMP(4),
 132 };
 133
 134 static const struct {
 135         int val;
 136         int val2;
 137 } sx9500_samp_freq_table[] = {
 138         {33, 333333},
 139         {16, 666666},
 140         {11, 111111},
 141         {8, 333333},
 142         {6, 666666},
 143         {5, 0},
 144         {3, 333333},
 145         {2, 500000},
 146 };
 147
 148 static const unsigned int sx9500_scan_period_table[] = {
 149         30, 60, 90, 120, 150, 200, 300, 400,
 150 };
 151
 152 static const struct regmap_range sx9500_writable_reg_ranges[] = {
 153         regmap_reg_range(SX9500_REG_IRQ_MSK, SX9500_REG_IRQ_MSK),
 154         regmap_reg_range(SX9500_REG_PROX_CTRL0, SX9500_REG_PROX_CTRL8),
 155         regmap_reg_range(SX9500_REG_SENSOR_SEL, SX9500_REG_SENSOR_SEL),
 156         regmap_reg_range(SX9500_REG_OFFSET_MSB, SX9500_REG_OFFSET_LSB),
 157         regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
 158 };
 159
 160 static const struct regmap_access_table sx9500_writeable_regs = {
 161         .yes_ranges = sx9500_writable_reg_ranges,
 162         .n_yes_ranges = ARRAY_SIZE(sx9500_writable_reg_ranges),
 163 };
 164
 165 /*
 166  * All allocated registers are readable, so we just list unallocated
 167  * ones.
 168  */
 169 static const struct regmap_range sx9500_non_readable_reg_ranges[] = {
 170         regmap_reg_range(SX9500_REG_STAT + 1, SX9500_REG_STAT + 1),
 171         regmap_reg_range(SX9500_REG_IRQ_MSK + 1, SX9500_REG_PROX_CTRL0 - 1),
 172         regmap_reg_range(SX9500_REG_PROX_CTRL8 + 1, SX9500_REG_SENSOR_SEL - 1),
 173         regmap_reg_range(SX9500_REG_OFFSET_LSB + 1, SX9500_REG_RESET - 1),
 174 };
 175
 176 static const struct regmap_access_table sx9500_readable_regs = {
 177         .no_ranges = sx9500_non_readable_reg_ranges,
 178         .n_no_ranges = ARRAY_SIZE(sx9500_non_readable_reg_ranges),
 179 };
 180
 181 static const struct regmap_range sx9500_volatile_reg_ranges[] = {
 182         regmap_reg_range(SX9500_REG_IRQ_SRC, SX9500_REG_STAT),
 183         regmap_reg_range(SX9500_REG_USE_MSB, SX9500_REG_OFFSET_LSB),
 184         regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
 185 };
 186
 187 static const struct regmap_access_table sx9500_volatile_regs = {
 188         .yes_ranges = sx9500_volatile_reg_ranges,
 189         .n_yes_ranges = ARRAY_SIZE(sx9500_volatile_reg_ranges),
 190 };
 191
 192 static const struct regmap_config sx9500_regmap_config = {
 193         .reg_bits = 8,
 194         .val_bits = 8,
 195
 196         .max_register = SX9500_REG_RESET,
 197         .cache_type = REGCACHE_RBTREE,
 198
 199         .wr_table = &sx9500_writeable_regs,
 200         .rd_table = &sx9500_readable_regs,
 201         .volatile_table = &sx9500_volatile_regs,
 202 };
 203
 204 static int sx9500_inc_users(struct sx9500_data *data, int *counter,
 205                             unsigned int reg, unsigned int bitmask)
 206 {
 207         (*counter)++;
 208         if (*counter != 1)
 209                 /* Bit is already active, nothing to do. */
 210                 return 0;
 211
 212         return regmap_update_bits(data->regmap, reg, bitmask, bitmask);
 213 }
 214
 215 static int sx9500_dec_users(struct sx9500_data *data, int *counter,
 216                             unsigned int reg, unsigned int bitmask)
 217 {
 218         (*counter)--;
 219         if (*counter != 0)
 220                 /* There are more users, do not deactivate. */
 221                 return 0;
 222
 223         return regmap_update_bits(data->regmap, reg, bitmask, 0);
 224 }
 225
 226 static int sx9500_inc_chan_users(struct sx9500_data *data, int chan)
 227 {
 228         return sx9500_inc_users(data, &data->channel_users[chan],
 229                                 SX9500_REG_PROX_CTRL0, BIT(chan));
 230 }
 231
 232 static int sx9500_dec_chan_users(struct sx9500_data *data, int chan)
 233 {
 234         return sx9500_dec_users(data, &data->channel_users[chan],
 235                                 SX9500_REG_PROX_CTRL0, BIT(chan));
 236 }
 237
 238 static int sx9500_inc_data_rdy_users(struct sx9500_data *data)
 239 {
 240         return sx9500_inc_users(data, &data->data_rdy_users,
 241                                 SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ);
 242 }
 243
 244 static int sx9500_dec_data_rdy_users(struct sx9500_data *data)
 245 {
 246         return sx9500_dec_users(data, &data->data_rdy_users,
 247                                 SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ);
 248 }
 249
 250 static int sx9500_inc_close_far_users(struct sx9500_data *data)
 251 {
 252         return sx9500_inc_users(data, &data->close_far_users,
 253                                 SX9500_REG_IRQ_MSK,
 254                                 SX9500_CLOSE_IRQ | SX9500_FAR_IRQ);
 255 }
 256
 257 static int sx9500_dec_close_far_users(struct sx9500_data *data)
 258 {
 259         return sx9500_dec_users(data, &data->close_far_users,
 260                                 SX9500_REG_IRQ_MSK,
 261                                 SX9500_CLOSE_IRQ | SX9500_FAR_IRQ);
 262 }
 263
 264 static int sx9500_read_prox_data(struct sx9500_data *data,
 265                                  const struct iio_chan_spec *chan,
 266                                  int *val)
 267 {
 268         int ret;
 269         __be16 regval;
 270
 271         ret = regmap_write(data->regmap, SX9500_REG_SENSOR_SEL, chan->channel);
 272         if (ret < 0)
 273                 return ret;
 274
 275         ret = regmap_bulk_read(data->regmap, SX9500_REG_USE_MSB, &regval, 2);
 276         if (ret < 0)
 277                 return ret;
 278
 279         *val = be16_to_cpu(regval);
 280
 281         return IIO_VAL_INT;
 282 }
 283
 284 /*
 285  * If we have no interrupt support, we have to wait for a scan period
 286  * after enabling a channel to get a result.
 287  */
 288 static int sx9500_wait_for_sample(struct sx9500_data *data)
 289 {
 290         int ret;
 291         unsigned int val;
 292
 293         ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, &val);
 294         if (ret < 0)
 295                 return ret;
 296
 297         val = (val & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT;
 298
 299         msleep(sx9500_scan_period_table[val]);
 300
 301         return 0;
 302 }
 303
 304 static int sx9500_read_proximity(struct sx9500_data *data,
 305                                  const struct iio_chan_spec *chan,
 306                                  int *val)
 307 {
 308         int ret;
 309
 310         mutex_lock(&data->mutex);
 311
 312         ret = sx9500_inc_chan_users(data, chan->channel);
 313         if (ret < 0)
 314                 goto out;
 315
 316         ret = sx9500_inc_data_rdy_users(data);
 317         if (ret < 0)
 318                 goto out_dec_chan;
 319
 320         mutex_unlock(&data->mutex);
 321
 322         if (data->client->irq > 0)
 323                 ret = wait_for_completion_interruptible(&data->completion);
 324         else
 325                 ret = sx9500_wait_for_sample(data);
 326
 327         mutex_lock(&data->mutex);
 328
 329         if (ret < 0)
 330                 goto out_dec_data_rdy;
 331
 332         ret = sx9500_read_prox_data(data, chan, val);
 333         if (ret < 0)
 334                 goto out_dec_data_rdy;
 335
 336         ret = sx9500_dec_data_rdy_users(data);
 337         if (ret < 0)
 338                 goto out_dec_chan;
 339
 340         ret = sx9500_dec_chan_users(data, chan->channel);
 341         if (ret < 0)
 342                 goto out;
 343
 344         ret = IIO_VAL_INT;
 345
 346         goto out;
 347
 348 out_dec_data_rdy:
 349         sx9500_dec_data_rdy_users(data);
 350 out_dec_chan:
 351         sx9500_dec_chan_users(data, chan->channel);
 352 out:
 353         mutex_unlock(&data->mutex);
 354         reinit_completion(&data->completion);
 355
 356         return ret;
 357 }
 358
 359 static int sx9500_read_samp_freq(struct sx9500_data *data,
 360                                  int *val, int *val2)
 361 {
 362         int ret;
 363         unsigned int regval;
 364
 365         mutex_lock(&data->mutex);
 366         ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, &regval);
 367         mutex_unlock(&data->mutex);
 368
 369         if (ret < 0)
 370                 return ret;
 371
 372         regval = (regval & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT;
 373         *val = sx9500_samp_freq_table[regval].val;
 374         *val2 = sx9500_samp_freq_table[regval].val2;
 375
 376         return IIO_VAL_INT_PLUS_MICRO;
 377 }
 378
 379 static int sx9500_read_raw(struct iio_dev *indio_dev,
 380                            const struct iio_chan_spec *chan,
 381                            int *val, int *val2, long mask)
 382 {
 383         struct sx9500_data *data = iio_priv(indio_dev);
 384         int ret;
 385
 386         switch (chan->type) {
 387         case IIO_PROXIMITY:
 388                 switch (mask) {
 389                 case IIO_CHAN_INFO_RAW:
 390                         ret = iio_device_claim_direct_mode(indio_dev);
 391                         if (ret)
 392                                 return ret;
 393                         ret = sx9500_read_proximity(data, chan, val);
 394                         iio_device_release_direct_mode(indio_dev);
 395                         return ret;
 396                 case IIO_CHAN_INFO_SAMP_FREQ:
 397                         return sx9500_read_samp_freq(data, val, val2);
 398                 default:
 399                         return -EINVAL;
 400                 }
 401         default:
 402                 return -EINVAL;
 403         }
 404 }
 405
 406 static int sx9500_set_samp_freq(struct sx9500_data *data,
 407                                 int val, int val2)
 408 {
 409         int i, ret;
 410
 411         for (i = 0; i < ARRAY_SIZE(sx9500_samp_freq_table); i++)
 412                 if (val == sx9500_samp_freq_table[i].val &&
 413                     val2 == sx9500_samp_freq_table[i].val2)
 414                         break;
 415
 416         if (i == ARRAY_SIZE(sx9500_samp_freq_table))
 417                 return -EINVAL;
 418
 419         mutex_lock(&data->mutex);
 420
 421         ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
 422                                  SX9500_SCAN_PERIOD_MASK,
 423                                  i << SX9500_SCAN_PERIOD_SHIFT);
 424
 425         mutex_unlock(&data->mutex);
 426
 427         return ret;
 428 }
 429
 430 static int sx9500_write_raw(struct iio_dev *indio_dev,
 431                             const struct iio_chan_spec *chan,
 432                             int val, int val2, long mask)
 433 {
 434         struct sx9500_data *data = iio_priv(indio_dev);
 435
 436         switch (chan->type) {
 437         case IIO_PROXIMITY:
 438                 switch (mask) {
 439                 case IIO_CHAN_INFO_SAMP_FREQ:
 440                         return sx9500_set_samp_freq(data, val, val2);
 441                 default:
 442                         return -EINVAL;
 443                 }
 444         default:
 445                 return -EINVAL;
 446         }
 447 }
 448
 449 static irqreturn_t sx9500_irq_handler(int irq, void *private)
 450 {
 451         struct iio_dev *indio_dev = private;
 452         struct sx9500_data *data = iio_priv(indio_dev);
 453
 454         if (data->trigger_enabled)
 455                 iio_trigger_poll(data->trig);
 456
 457         /*
 458          * Even if no event is enabled, we need to wake the thread to
 459          * clear the interrupt state by reading SX9500_REG_IRQ_SRC.  It
 460          * is not possible to do that here because regmap_read takes a
 461          * mutex.
 462          */
 463         return IRQ_WAKE_THREAD;
 464 }
 465
 466 static void sx9500_push_events(struct iio_dev *indio_dev)
 467 {
 468         int ret;
 469         unsigned int val, chan;
 470         struct sx9500_data *data = iio_priv(indio_dev);
 471
 472         ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
 473         if (ret < 0) {
 474                 dev_err(&data->client->dev, "i2c transfer error in irq\n");
 475                 return;
 476         }
 477
 478         val >>= SX9500_PROXSTAT_SHIFT;
 479         for (chan = 0; chan < SX9500_NUM_CHANNELS; chan++) {
 480                 int dir;
 481                 u64 ev;
 482                 bool new_prox = val & BIT(chan);
 483
 484                 if (!data->event_enabled[chan])
 485                         continue;
 486                 if (new_prox == data->prox_stat[chan])
 487                         /* No change on this channel. */
 488                         continue;
 489
 490                 dir = new_prox ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
 491                 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan,
 492                                           IIO_EV_TYPE_THRESH, dir);
 493                 iio_push_event(indio_dev, ev, iio_get_time_ns(indio_dev));
 494                 data->prox_stat[chan] = new_prox;
 495         }
 496 }
 497
 498 static irqreturn_t sx9500_irq_thread_handler(int irq, void *private)
 499 {
 500         struct iio_dev *indio_dev = private;
 501         struct sx9500_data *data = iio_priv(indio_dev);
 502         int ret;
 503         unsigned int val;
 504
 505         mutex_lock(&data->mutex);
 506
 507         ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
 508         if (ret < 0) {
 509                 dev_err(&data->client->dev, "i2c transfer error in irq\n");
 510                 goto out;
 511         }
 512
 513         if (val & (SX9500_CLOSE_IRQ | SX9500_FAR_IRQ))
 514                 sx9500_push_events(indio_dev);
 515
 516         if (val & SX9500_CONVDONE_IRQ)
 517                 complete(&data->completion);
 518
 519 out:
 520         mutex_unlock(&data->mutex);
 521
 522         return IRQ_HANDLED;
 523 }
 524
 525 static int sx9500_read_event_config(struct iio_dev *indio_dev,
 526                                     const struct iio_chan_spec *chan,
 527                                     enum iio_event_type type,
 528                                     enum iio_event_direction dir)
 529 {
 530         struct sx9500_data *data = iio_priv(indio_dev);
 531
 532         if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
 533             dir != IIO_EV_DIR_EITHER)
 534                 return -EINVAL;
 535
 536         return data->event_enabled[chan->channel];
 537 }
 538
 539 static int sx9500_write_event_config(struct iio_dev *indio_dev,
 540                                      const struct iio_chan_spec *chan,
 541                                      enum iio_event_type type,
 542                                      enum iio_event_direction dir,
 543                                      int state)
 544 {
 545         struct sx9500_data *data = iio_priv(indio_dev);
 546         int ret;
 547
 548         if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
 549             dir != IIO_EV_DIR_EITHER)
 550                 return -EINVAL;
 551
 552         mutex_lock(&data->mutex);
 553
 554         if (state == 1) {
 555                 ret = sx9500_inc_chan_users(data, chan->channel);
 556                 if (ret < 0)
 557                         goto out_unlock;
 558                 ret = sx9500_inc_close_far_users(data);
 559                 if (ret < 0)
 560                         goto out_undo_chan;
 561         } else {
 562                 ret = sx9500_dec_chan_users(data, chan->channel);
 563                 if (ret < 0)
 564                         goto out_unlock;
 565                 ret = sx9500_dec_close_far_users(data);
 566                 if (ret < 0)
 567                         goto out_undo_chan;
 568         }
 569
 570         data->event_enabled[chan->channel] = state;
 571         goto out_unlock;
 572
 573 out_undo_chan:
 574         if (state == 1)
 575                 sx9500_dec_chan_users(data, chan->channel);
 576         else
 577                 sx9500_inc_chan_users(data, chan->channel);
 578 out_unlock:
 579         mutex_unlock(&data->mutex);
 580         return ret;
 581 }
 582
 583 static int sx9500_update_scan_mode(struct iio_dev *indio_dev,
 584                                    const unsigned long *scan_mask)
 585 {
 586         struct sx9500_data *data = iio_priv(indio_dev);
 587
 588         mutex_lock(&data->mutex);
 589         kfree(data->buffer);
 590         data->buffer = kzalloc(indio_dev->scan_bytes, GFP_KERNEL);
 591         mutex_unlock(&data->mutex);
 592
 593         if (data->buffer == NULL)
 594                 return -ENOMEM;
 595
 596         return 0;
 597 }
 598
 599 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
 600         "2.500000 3.333333 5 6.666666 8.333333 11.111111 16.666666 33.333333");
 601
 602 static struct attribute *sx9500_attributes[] = {
 603         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 604         NULL,
 605 };
 606
 607 static const struct attribute_group sx9500_attribute_group = {
 608         .attrs = sx9500_attributes,
 609 };
 610
 611 static const struct iio_info sx9500_info = {
 612         .attrs = &sx9500_attribute_group,
 613         .read_raw = &sx9500_read_raw,
 614         .write_raw = &sx9500_write_raw,
 615         .read_event_config = &sx9500_read_event_config,
 616         .write_event_config = &sx9500_write_event_config,
 617         .update_scan_mode = &sx9500_update_scan_mode,
 618 };
 619
 620 static int sx9500_set_trigger_state(struct iio_trigger *trig,
 621                                     bool state)
 622 {
 623         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 624         struct sx9500_data *data = iio_priv(indio_dev);
 625         int ret;
 626
 627         mutex_lock(&data->mutex);
 628
 629         if (state)
 630                 ret = sx9500_inc_data_rdy_users(data);
 631         else
 632                 ret = sx9500_dec_data_rdy_users(data);
 633         if (ret < 0)
 634                 goto out;
 635
 636         data->trigger_enabled = state;
 637
 638 out:
 639         mutex_unlock(&data->mutex);
 640
 641         return ret;
 642 }
 643
 644 static const struct iio_trigger_ops sx9500_trigger_ops = {
 645         .set_trigger_state = sx9500_set_trigger_state,
 646 };
 647
 648 static irqreturn_t sx9500_trigger_handler(int irq, void *private)
 649 {
 650         struct iio_poll_func *pf = private;
 651         struct iio_dev *indio_dev = pf->indio_dev;
 652         struct sx9500_data *data = iio_priv(indio_dev);
 653         int val, bit, ret, i = 0;
 654
 655         mutex_lock(&data->mutex);
 656
 657         for_each_set_bit(bit, indio_dev->active_scan_mask,
 658                          indio_dev->masklength) {
 659                 ret = sx9500_read_prox_data(data, &indio_dev->channels[bit],
 660                                             &val);
 661                 if (ret < 0)
 662                         goto out;
 663
 664                 data->buffer[i++] = val;
 665         }
 666
 667         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 668                                            iio_get_time_ns(indio_dev));
 669
 670 out:
 671         mutex_unlock(&data->mutex);
 672
 673         iio_trigger_notify_done(indio_dev->trig);
 674
 675         return IRQ_HANDLED;
 676 }
 677
 678 static int sx9500_buffer_preenable(struct iio_dev *indio_dev)
 679 {
 680         struct sx9500_data *data = iio_priv(indio_dev);
 681         int ret = 0, i;
 682
 683         mutex_lock(&data->mutex);
 684
 685         for (i = 0; i < SX9500_NUM_CHANNELS; i++)
 686                 if (test_bit(i, indio_dev->active_scan_mask)) {
 687                         ret = sx9500_inc_chan_users(data, i);
 688                         if (ret)
 689                                 break;
 690                 }
 691
 692         if (ret)
 693                 for (i = i - 1; i >= 0; i--)
 694                         if (test_bit(i, indio_dev->active_scan_mask))
 695                                 sx9500_dec_chan_users(data, i);
 696
 697         mutex_unlock(&data->mutex);
 698
 699         return ret;
 700 }
 701
 702 static int sx9500_buffer_predisable(struct iio_dev *indio_dev)
 703 {
 704         struct sx9500_data *data = iio_priv(indio_dev);
 705         int ret = 0, i;
 706
 707         iio_triggered_buffer_predisable(indio_dev);
 708
 709         mutex_lock(&data->mutex);
 710
 711         for (i = 0; i < SX9500_NUM_CHANNELS; i++)
 712                 if (test_bit(i, indio_dev->active_scan_mask)) {
 713                         ret = sx9500_dec_chan_users(data, i);
 714                         if (ret)
 715                                 break;
 716                 }
 717
 718         if (ret)
 719                 for (i = i - 1; i >= 0; i--)
 720                         if (test_bit(i, indio_dev->active_scan_mask))
 721                                 sx9500_inc_chan_users(data, i);
 722
 723         mutex_unlock(&data->mutex);
 724
 725         return ret;
 726 }
 727
 728 static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = {
 729         .preenable = sx9500_buffer_preenable,
 730         .postenable = iio_triggered_buffer_postenable,
 731         .predisable = sx9500_buffer_predisable,
 732 };
 733
 734 struct sx9500_reg_default {
 735         u8 reg;
 736         u8 def;
 737 };
 738
 739 static const struct sx9500_reg_default sx9500_default_regs[] = {
 740         {
 741                 .reg = SX9500_REG_PROX_CTRL1,
 742                 /* Shield enabled, small range. */
 743                 .def = 0x43,
 744         },
 745         {
 746                 .reg = SX9500_REG_PROX_CTRL2,
 747                 /* x8 gain, 167kHz frequency, finest resolution. */
 748                 .def = 0x77,
 749         },
 750         {
 751                 .reg = SX9500_REG_PROX_CTRL3,
 752                 /* Doze enabled, 2x scan period doze, no raw filter. */
 753                 .def = 0x40,
 754         },
 755         {
 756                 .reg = SX9500_REG_PROX_CTRL4,
 757                 /* Average threshold. */
 758                 .def = 0x30,
 759         },
 760         {
 761                 .reg = SX9500_REG_PROX_CTRL5,
 762                 /*
 763                  * Debouncer off, lowest average negative filter,
 764                  * highest average postive filter.
 765                  */
 766                 .def = 0x0f,
 767         },
 768         {
 769                 .reg = SX9500_REG_PROX_CTRL6,
 770                 /* Proximity detection threshold: 280 */
 771                 .def = 0x0e,
 772         },
 773         {
 774                 .reg = SX9500_REG_PROX_CTRL7,
 775                 /*
 776                  * No automatic compensation, compensate each pin
 777                  * independently, proximity hysteresis: 32, close
 778                  * debouncer off, far debouncer off.
 779                  */
 780                 .def = 0x00,
 781         },
 782         {
 783                 .reg = SX9500_REG_PROX_CTRL8,
 784                 /* No stuck timeout, no periodic compensation. */
 785                 .def = 0x00,
 786         },
 787         {
 788                 .reg = SX9500_REG_PROX_CTRL0,
 789                 /* Scan period: 30ms, all sensors disabled. */
 790                 .def = 0x00,
 791         },
 792 };
 793
 794 /* Activate all channels and perform an initial compensation. */
 795 static int sx9500_init_compensation(struct iio_dev *indio_dev)
 796 {
 797         struct sx9500_data *data = iio_priv(indio_dev);
 798         int i, ret;
 799         unsigned int val;
 800
 801         ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
 802                                  SX9500_CHAN_MASK, SX9500_CHAN_MASK);
 803         if (ret < 0)
 804                 return ret;
 805
 806         for (i = 10; i >= 0; i--) {
 807                 usleep_range(10000, 20000);
 808                 ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
 809                 if (ret < 0)
 810                         goto out;
 811                 if (!(val & SX9500_COMPSTAT_MASK))
 812                         break;
 813         }
 814
 815         if (i < 0) {
 816                 dev_err(&data->client->dev, "initial compensation timed out");
 817                 ret = -ETIMEDOUT;
 818         }
 819
 820 out:
 821         regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
 822                            SX9500_CHAN_MASK, 0);
 823         return ret;
 824 }
 825
 826 static int sx9500_init_device(struct iio_dev *indio_dev)
 827 {
 828         struct sx9500_data *data = iio_priv(indio_dev);
 829         int ret, i;
 830         unsigned int val;
 831
 832         if (data->gpiod_rst) {
 833                 gpiod_set_value_cansleep(data->gpiod_rst, 0);
 834                 usleep_range(1000, 2000);
 835                 gpiod_set_value_cansleep(data->gpiod_rst, 1);
 836                 usleep_range(1000, 2000);
 837         }
 838
 839         ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0);
 840         if (ret < 0)
 841                 return ret;
 842
 843         ret = regmap_write(data->regmap, SX9500_REG_RESET,
 844                            SX9500_SOFT_RESET);
 845         if (ret < 0)
 846                 return ret;
 847
 848         ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
 849         if (ret < 0)
 850                 return ret;
 851
 852         for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) {
 853                 ret = regmap_write(data->regmap,
 854                                    sx9500_default_regs[i].reg,
 855                                    sx9500_default_regs[i].def);
 856                 if (ret < 0)
 857                         return ret;
 858         }
 859
 860         return sx9500_init_compensation(indio_dev);
 861 }
 862
 863 static const struct acpi_gpio_params reset_gpios = { 0, 0, false };
 864 static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false };
 865
 866 static const struct acpi_gpio_mapping acpi_sx9500_gpios[] = {
 867         { "reset-gpios", &reset_gpios, 1 },
 868         /*
 869          * Some platforms have a bug in ACPI GPIO description making IRQ
 870          * GPIO to be output only. Ask the GPIO core to ignore this limit.
 871          */
 872         { "interrupt-gpios", &interrupt_gpios, 1, ACPI_GPIO_QUIRK_NO_IO_RESTRICTION },
 873         { },
 874 };
 875
 876 static void sx9500_gpio_probe(struct i2c_client *client,
 877                               struct sx9500_data *data)
 878 {
 879         struct gpio_desc *gpiod_int;
 880         struct device *dev;
 881         int ret;
 882
 883         if (!client)
 884                 return;
 885
 886         dev = &client->dev;
 887
 888         ret = devm_acpi_dev_add_driver_gpios(dev, acpi_sx9500_gpios);
 889         if (ret)
 890                 dev_dbg(dev, "Unable to add GPIO mapping table\n");
 891
 892         if (client->irq <= 0) {
 893                 gpiod_int = devm_gpiod_get(dev, "interrupt", GPIOD_IN);
 894                 if (IS_ERR(gpiod_int))
 895                         dev_err(dev, "gpio get irq failed\n");
 896                 else
 897                         client->irq = gpiod_to_irq(gpiod_int);
 898         }
 899
 900         data->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
 901         if (IS_ERR(data->gpiod_rst)) {
 902                 dev_warn(dev, "gpio get reset pin failed\n");
 903                 data->gpiod_rst = NULL;
 904         }
 905 }
 906
 907 static int sx9500_probe(struct i2c_client *client,
 908                         const struct i2c_device_id *id)
 909 {
 910         int ret;
 911         struct iio_dev *indio_dev;
 912         struct sx9500_data *data;
 913
 914         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 915         if (indio_dev == NULL)
 916                 return -ENOMEM;
 917
 918         data = iio_priv(indio_dev);
 919         data->client = client;
 920         mutex_init(&data->mutex);
 921         init_completion(&data->completion);
 922         data->trigger_enabled = false;
 923
 924         data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config);
 925         if (IS_ERR(data->regmap))
 926                 return PTR_ERR(data->regmap);
 927
 928         indio_dev->dev.parent = &client->dev;
 929         indio_dev->name = SX9500_DRIVER_NAME;
 930         indio_dev->channels = sx9500_channels;
 931         indio_dev->num_channels = ARRAY_SIZE(sx9500_channels);
 932         indio_dev->info = &sx9500_info;
 933         indio_dev->modes = INDIO_DIRECT_MODE;
 934         i2c_set_clientdata(client, indio_dev);
 935
 936         sx9500_gpio_probe(client, data);
 937
 938         ret = sx9500_init_device(indio_dev);
 939         if (ret < 0)
 940                 return ret;
 941
 942         if (client->irq <= 0)
 943                 dev_warn(&client->dev, "no valid irq found\n");
 944         else {
 945                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 946                                 sx9500_irq_handler, sx9500_irq_thread_handler,
 947                                 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 948                                 SX9500_IRQ_NAME, indio_dev);
 949                 if (ret < 0)
 950                         return ret;
 951
 952                 data->trig = devm_iio_trigger_alloc(&client->dev,
 953                                 "%s-dev%d", 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 = &sx9500_trigger_ops;
 959                 iio_trigger_set_drvdata(data->trig, indio_dev);
 960
 961                 ret = iio_trigger_register(data->trig);
 962                 if (ret)
 963                         return ret;
 964         }
 965
 966         ret = iio_triggered_buffer_setup(indio_dev, NULL,
 967                                          sx9500_trigger_handler,
 968                                          &sx9500_buffer_setup_ops);
 969         if (ret < 0)
 970                 goto out_trigger_unregister;
 971
 972         ret = iio_device_register(indio_dev);
 973         if (ret < 0)
 974                 goto out_buffer_cleanup;
 975
 976         return 0;
 977
 978 out_buffer_cleanup:
 979         iio_triggered_buffer_cleanup(indio_dev);
 980 out_trigger_unregister:
 981         if (client->irq > 0)
 982                 iio_trigger_unregister(data->trig);
 983
 984         return ret;
 985 }
 986
 987 static int sx9500_remove(struct i2c_client *client)
 988 {
 989         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 990         struct sx9500_data *data = iio_priv(indio_dev);
 991
 992         iio_device_unregister(indio_dev);
 993         iio_triggered_buffer_cleanup(indio_dev);
 994         if (client->irq > 0)
 995                 iio_trigger_unregister(data->trig);
 996         kfree(data->buffer);
 997
 998         return 0;
 999 }
1000
1001 #ifdef CONFIG_PM_SLEEP
1002 static int sx9500_suspend(struct device *dev)
1003 {
1004         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1005         struct sx9500_data *data = iio_priv(indio_dev);
1006         int ret;
1007
1008         mutex_lock(&data->mutex);
1009         ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0,
1010                           &data->suspend_ctrl0);
1011         if (ret < 0)
1012                 goto out;
1013
1014         /*
1015          * Scan period doesn't matter because when all the sensors are
1016          * deactivated the device is in sleep mode.
1017          */
1018         ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 0);
1019
1020 out:
1021         mutex_unlock(&data->mutex);
1022         return ret;
1023 }
1024
1025 static int sx9500_resume(struct device *dev)
1026 {
1027         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1028         struct sx9500_data *data = iio_priv(indio_dev);
1029         int ret;
1030
1031         mutex_lock(&data->mutex);
1032         ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0,
1033                            data->suspend_ctrl0);
1034         mutex_unlock(&data->mutex);
1035
1036         return ret;
1037 }
1038 #endif /* CONFIG_PM_SLEEP */
1039
1040 static const struct dev_pm_ops sx9500_pm_ops = {
1041         SET_SYSTEM_SLEEP_PM_OPS(sx9500_suspend, sx9500_resume)
1042 };
1043
1044 static const struct acpi_device_id sx9500_acpi_match[] = {
1045         {"SSX9500", 0},
1046         {"SASX9500", 0},
1047         { },
1048 };
1049 MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match);
1050
1051 static const struct of_device_id sx9500_of_match[] = {
1052         { .compatible = "semtech,sx9500", },
1053         { }
1054 };
1055 MODULE_DEVICE_TABLE(of, sx9500_of_match);
1056
1057 static const struct i2c_device_id sx9500_id[] = {
1058         {"sx9500", 0},
1059         { },
1060 };
1061 MODULE_DEVICE_TABLE(i2c, sx9500_id);
1062
1063 static struct i2c_driver sx9500_driver = {
1064         .driver = {
1065                 .name   = SX9500_DRIVER_NAME,
1066                 .acpi_match_table = ACPI_PTR(sx9500_acpi_match),
1067                 .of_match_table = of_match_ptr(sx9500_of_match),
1068                 .pm = &sx9500_pm_ops,
1069         },
1070         .probe          = sx9500_probe,
1071         .remove         = sx9500_remove,
1072         .id_table       = sx9500_id,
1073 };
1074 module_i2c_driver(sx9500_driver);
1075
1076 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
1077 MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor");
1078 MODULE_LICENSE("GPL v2");