drivers/iio/proximity/sx9500.c

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