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