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_postenable(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         mutex_lock(&data->mutex);
 708
 709         for (i = 0; i < SX9500_NUM_CHANNELS; i++)
 710                 if (test_bit(i, indio_dev->active_scan_mask)) {
 711                         ret = sx9500_dec_chan_users(data, i);
 712                         if (ret)
 713                                 break;
 714                 }
 715
 716         if (ret)
 717                 for (i = i - 1; i >= 0; i--)
 718                         if (test_bit(i, indio_dev->active_scan_mask))
 719                                 sx9500_inc_chan_users(data, i);
 720
 721         mutex_unlock(&data->mutex);
 722
 723         return ret;
 724 }
 725
 726 static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = {
 727         .postenable = sx9500_buffer_postenable,
 728         .predisable = sx9500_buffer_predisable,
 729 };
 730
 731 struct sx9500_reg_default {
 732         u8 reg;
 733         u8 def;
 734 };
 735
 736 static const struct sx9500_reg_default sx9500_default_regs[] = {
 737         {
 738                 .reg = SX9500_REG_PROX_CTRL1,
 739                 /* Shield enabled, small range. */
 740                 .def = 0x43,
 741         },
 742         {
 743                 .reg = SX9500_REG_PROX_CTRL2,
 744                 /* x8 gain, 167kHz frequency, finest resolution. */
 745                 .def = 0x77,
 746         },
 747         {
 748                 .reg = SX9500_REG_PROX_CTRL3,
 749                 /* Doze enabled, 2x scan period doze, no raw filter. */
 750                 .def = 0x40,
 751         },
 752         {
 753                 .reg = SX9500_REG_PROX_CTRL4,
 754                 /* Average threshold. */
 755                 .def = 0x30,
 756         },
 757         {
 758                 .reg = SX9500_REG_PROX_CTRL5,
 759                 /*
 760                  * Debouncer off, lowest average negative filter,
 761                  * highest average positive filter.
 762                  */
 763                 .def = 0x0f,
 764         },
 765         {
 766                 .reg = SX9500_REG_PROX_CTRL6,
 767                 /* Proximity detection threshold: 280 */
 768                 .def = 0x0e,
 769         },
 770         {
 771                 .reg = SX9500_REG_PROX_CTRL7,
 772                 /*
 773                  * No automatic compensation, compensate each pin
 774                  * independently, proximity hysteresis: 32, close
 775                  * debouncer off, far debouncer off.
 776                  */
 777                 .def = 0x00,
 778         },
 779         {
 780                 .reg = SX9500_REG_PROX_CTRL8,
 781                 /* No stuck timeout, no periodic compensation. */
 782                 .def = 0x00,
 783         },
 784         {
 785                 .reg = SX9500_REG_PROX_CTRL0,
 786                 /* Scan period: 30ms, all sensors disabled. */
 787                 .def = 0x00,
 788         },
 789 };
 790
 791 /* Activate all channels and perform an initial compensation. */
 792 static int sx9500_init_compensation(struct iio_dev *indio_dev)
 793 {
 794         struct sx9500_data *data = iio_priv(indio_dev);
 795         int i, ret;
 796         unsigned int val;
 797
 798         ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
 799                                  SX9500_CHAN_MASK, SX9500_CHAN_MASK);
 800         if (ret < 0)
 801                 return ret;
 802
 803         for (i = 10; i >= 0; i--) {
 804                 usleep_range(10000, 20000);
 805                 ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
 806                 if (ret < 0)
 807                         goto out;
 808                 if (!(val & SX9500_COMPSTAT_MASK))
 809                         break;
 810         }
 811
 812         if (i < 0) {
 813                 dev_err(&data->client->dev, "initial compensation timed out");
 814                 ret = -ETIMEDOUT;
 815         }
 816
 817 out:
 818         regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
 819                            SX9500_CHAN_MASK, 0);
 820         return ret;
 821 }
 822
 823 static int sx9500_init_device(struct iio_dev *indio_dev)
 824 {
 825         struct sx9500_data *data = iio_priv(indio_dev);
 826         int ret, i;
 827         unsigned int val;
 828
 829         if (data->gpiod_rst) {
 830                 gpiod_set_value_cansleep(data->gpiod_rst, 0);
 831                 usleep_range(1000, 2000);
 832                 gpiod_set_value_cansleep(data->gpiod_rst, 1);
 833                 usleep_range(1000, 2000);
 834         }
 835
 836         ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0);
 837         if (ret < 0)
 838                 return ret;
 839
 840         ret = regmap_write(data->regmap, SX9500_REG_RESET,
 841                            SX9500_SOFT_RESET);
 842         if (ret < 0)
 843                 return ret;
 844
 845         ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
 846         if (ret < 0)
 847                 return ret;
 848
 849         for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) {
 850                 ret = regmap_write(data->regmap,
 851                                    sx9500_default_regs[i].reg,
 852                                    sx9500_default_regs[i].def);
 853                 if (ret < 0)
 854                         return ret;
 855         }
 856
 857         return sx9500_init_compensation(indio_dev);
 858 }
 859
 860 static const struct acpi_gpio_params reset_gpios = { 0, 0, false };
 861 static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false };
 862
 863 static const struct acpi_gpio_mapping acpi_sx9500_gpios[] = {
 864         { "reset-gpios", &reset_gpios, 1 },
 865         /*
 866          * Some platforms have a bug in ACPI GPIO description making IRQ
 867          * GPIO to be output only. Ask the GPIO core to ignore this limit.
 868          */
 869         { "interrupt-gpios", &interrupt_gpios, 1, ACPI_GPIO_QUIRK_NO_IO_RESTRICTION },
 870         { },
 871 };
 872
 873 static void sx9500_gpio_probe(struct i2c_client *client,
 874                               struct sx9500_data *data)
 875 {
 876         struct gpio_desc *gpiod_int;
 877         struct device *dev;
 878         int ret;
 879
 880         if (!client)
 881                 return;
 882
 883         dev = &client->dev;
 884
 885         ret = devm_acpi_dev_add_driver_gpios(dev, acpi_sx9500_gpios);
 886         if (ret)
 887                 dev_dbg(dev, "Unable to add GPIO mapping table\n");
 888
 889         if (client->irq <= 0) {
 890                 gpiod_int = devm_gpiod_get(dev, "interrupt", GPIOD_IN);
 891                 if (IS_ERR(gpiod_int))
 892                         dev_err(dev, "gpio get irq failed\n");
 893                 else
 894                         client->irq = gpiod_to_irq(gpiod_int);
 895         }
 896
 897         data->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
 898         if (IS_ERR(data->gpiod_rst)) {
 899                 dev_warn(dev, "gpio get reset pin failed\n");
 900                 data->gpiod_rst = NULL;
 901         }
 902 }
 903
 904 static int sx9500_probe(struct i2c_client *client)
 905 {
 906         int ret;
 907         struct iio_dev *indio_dev;
 908         struct sx9500_data *data;
 909
 910         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 911         if (indio_dev == NULL)
 912                 return -ENOMEM;
 913
 914         data = iio_priv(indio_dev);
 915         data->client = client;
 916         mutex_init(&data->mutex);
 917         init_completion(&data->completion);
 918         data->trigger_enabled = false;
 919
 920         data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config);
 921         if (IS_ERR(data->regmap))
 922                 return PTR_ERR(data->regmap);
 923
 924         indio_dev->name = SX9500_DRIVER_NAME;
 925         indio_dev->channels = sx9500_channels;
 926         indio_dev->num_channels = ARRAY_SIZE(sx9500_channels);
 927         indio_dev->info = &sx9500_info;
 928         indio_dev->modes = INDIO_DIRECT_MODE;
 929         i2c_set_clientdata(client, indio_dev);
 930
 931         sx9500_gpio_probe(client, data);
 932
 933         ret = sx9500_init_device(indio_dev);
 934         if (ret < 0)
 935                 return ret;
 936
 937         if (client->irq <= 0)
 938                 dev_warn(&client->dev, "no valid irq found\n");
 939         else {
 940                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 941                                 sx9500_irq_handler, sx9500_irq_thread_handler,
 942                                 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 943                                 SX9500_IRQ_NAME, indio_dev);
 944                 if (ret < 0)
 945                         return ret;
 946
 947                 data->trig = devm_iio_trigger_alloc(&client->dev,
 948                                 "%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
 949                 if (!data->trig)
 950                         return -ENOMEM;
 951
 952                 data->trig->ops = &sx9500_trigger_ops;
 953                 iio_trigger_set_drvdata(data->trig, indio_dev);
 954
 955                 ret = iio_trigger_register(data->trig);
 956                 if (ret)
 957                         return ret;
 958         }
 959
 960         ret = iio_triggered_buffer_setup(indio_dev, NULL,
 961                                          sx9500_trigger_handler,
 962                                          &sx9500_buffer_setup_ops);
 963         if (ret < 0)
 964                 goto out_trigger_unregister;
 965
 966         ret = iio_device_register(indio_dev);
 967         if (ret < 0)
 968                 goto out_buffer_cleanup;
 969
 970         return 0;
 971
 972 out_buffer_cleanup:
 973         iio_triggered_buffer_cleanup(indio_dev);
 974 out_trigger_unregister:
 975         if (client->irq > 0)
 976                 iio_trigger_unregister(data->trig);
 977
 978         return ret;
 979 }
 980
 981 static void sx9500_remove(struct i2c_client *client)
 982 {
 983         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 984         struct sx9500_data *data = iio_priv(indio_dev);
 985
 986         iio_device_unregister(indio_dev);
 987         iio_triggered_buffer_cleanup(indio_dev);
 988         if (client->irq > 0)
 989                 iio_trigger_unregister(data->trig);
 990         kfree(data->buffer);
 991 }
 992
 993 static int sx9500_suspend(struct device *dev)
 994 {
 995         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 996         struct sx9500_data *data = iio_priv(indio_dev);
 997         int ret;
 998
 999         mutex_lock(&data->mutex);
1000         ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0,
1001                           &data->suspend_ctrl0);
1002         if (ret < 0)
1003                 goto out;
1004
1005         /*
1006          * Scan period doesn't matter because when all the sensors are
1007          * deactivated the device is in sleep mode.
1008          */
1009         ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 0);
1010
1011 out:
1012         mutex_unlock(&data->mutex);
1013         return ret;
1014 }
1015
1016 static int sx9500_resume(struct device *dev)
1017 {
1018         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1019         struct sx9500_data *data = iio_priv(indio_dev);
1020         int ret;
1021
1022         mutex_lock(&data->mutex);
1023         ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0,
1024                            data->suspend_ctrl0);
1025         mutex_unlock(&data->mutex);
1026
1027         return ret;
1028 }
1029
1030 static DEFINE_SIMPLE_DEV_PM_OPS(sx9500_pm_ops, sx9500_suspend, sx9500_resume);
1031
1032 static const struct acpi_device_id sx9500_acpi_match[] = {
1033         {"SSX9500", 0},
1034         {"SASX9500", 0},
1035         { },
1036 };
1037 MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match);
1038
1039 static const struct of_device_id sx9500_of_match[] = {
1040         { .compatible = "semtech,sx9500", },
1041         { }
1042 };
1043 MODULE_DEVICE_TABLE(of, sx9500_of_match);
1044
1045 static const struct i2c_device_id sx9500_id[] = {
1046         {"sx9500", 0},
1047         { },
1048 };
1049 MODULE_DEVICE_TABLE(i2c, sx9500_id);
1050
1051 static struct i2c_driver sx9500_driver = {
1052         .driver = {
1053                 .name   = SX9500_DRIVER_NAME,
1054                 .acpi_match_table = sx9500_acpi_match,
1055                 .of_match_table = sx9500_of_match,
1056                 .pm = pm_sleep_ptr(&sx9500_pm_ops),
1057         },
1058         .probe_new      = sx9500_probe,
1059         .remove         = sx9500_remove,
1060         .id_table       = sx9500_id,
1061 };
1062 module_i2c_driver(sx9500_driver);
1063
1064 MODULE_AUTHOR("Vlad Dogaru <[email protected]>");
1065 MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor");
1066 MODULE_LICENSE("GPL v2");