drivers/iio/light/vcnl4000.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * vcnl4000.c - Support for Vishay VCNL4000/4010/4020/4040/4200 combined ambient
   4  * light and proximity sensor
   5  *
   6  * Copyright 2012 Peter Meerwald <pmeerw@pmeerw.net>
   7  * Copyright 2019 Pursim SPC
   8  * Copyright 2020 Mathieu Othacehe <m.othacehe@gmail.com>
   9  *
  10  * IIO driver for:
  11  *   VCNL4000/10/20 (7-bit I2C slave address 0x13)
  12  *   VCNL4040 (7-bit I2C slave address 0x60)
  13  *   VCNL4200 (7-bit I2C slave address 0x51)
  14  *
  15  * TODO:
  16  *   allow to adjust IR current
  17  *   interrupts (VCNL4040, VCNL4200)
  18  */
  19
  20 #include <linux/bitfield.h>
  21 #include <linux/module.h>
  22 #include <linux/i2c.h>
  23 #include <linux/err.h>
  24 #include <linux/delay.h>
  25 #include <linux/pm_runtime.h>
  26 #include <linux/interrupt.h>
  27
  28 #include <linux/iio/buffer.h>
  29 #include <linux/iio/events.h>
  30 #include <linux/iio/iio.h>
  31 #include <linux/iio/sysfs.h>
  32 #include <linux/iio/trigger.h>
  33 #include <linux/iio/trigger_consumer.h>
  34 #include <linux/iio/triggered_buffer.h>
  35
  36 #define VCNL4000_DRV_NAME "vcnl4000"
  37 #define VCNL4000_PROD_ID        0x01
  38 #define VCNL4010_PROD_ID        0x02 /* for VCNL4020, VCNL4010 */
  39 #define VCNL4040_PROD_ID        0x86
  40 #define VCNL4200_PROD_ID        0x58
  41
  42 #define VCNL4000_COMMAND        0x80 /* Command register */
  43 #define VCNL4000_PROD_REV       0x81 /* Product ID and Revision ID */
  44 #define VCNL4010_PROX_RATE      0x82 /* Proximity rate */
  45 #define VCNL4000_LED_CURRENT    0x83 /* IR LED current for proximity mode */
  46 #define VCNL4000_AL_PARAM       0x84 /* Ambient light parameter register */
  47 #define VCNL4010_ALS_PARAM      0x84 /* ALS rate */
  48 #define VCNL4000_AL_RESULT_HI   0x85 /* Ambient light result register, MSB */
  49 #define VCNL4000_AL_RESULT_LO   0x86 /* Ambient light result register, LSB */
  50 #define VCNL4000_PS_RESULT_HI   0x87 /* Proximity result register, MSB */
  51 #define VCNL4000_PS_RESULT_LO   0x88 /* Proximity result register, LSB */
  52 #define VCNL4000_PS_MEAS_FREQ   0x89 /* Proximity test signal frequency */
  53 #define VCNL4010_INT_CTRL       0x89 /* Interrupt control */
  54 #define VCNL4000_PS_MOD_ADJ     0x8a /* Proximity modulator timing adjustment */
  55 #define VCNL4010_LOW_THR_HI     0x8a /* Low threshold, MSB */
  56 #define VCNL4010_LOW_THR_LO     0x8b /* Low threshold, LSB */
  57 #define VCNL4010_HIGH_THR_HI    0x8c /* High threshold, MSB */
  58 #define VCNL4010_HIGH_THR_LO    0x8d /* High threshold, LSB */
  59 #define VCNL4010_ISR            0x8e /* Interrupt status */
  60
  61 #define VCNL4200_AL_CONF        0x00 /* Ambient light configuration */
  62 #define VCNL4200_PS_CONF1       0x03 /* Proximity configuration */
  63 #define VCNL4040_PS_THDL_LM     0x06 /* Proximity threshold low */
  64 #define VCNL4040_PS_THDH_LM     0x07 /* Proximity threshold high */
  65 #define VCNL4200_PS_DATA        0x08 /* Proximity data */
  66 #define VCNL4200_AL_DATA        0x09 /* Ambient light data */
  67 #define VCNL4040_INT_FLAGS      0x0b /* Interrupt register */
  68 #define VCNL4200_DEV_ID         0x0e /* Device ID, slave address and version */
  69
  70 #define VCNL4040_DEV_ID         0x0c /* Device ID and version */
  71
  72 /* Bit masks for COMMAND register */
  73 #define VCNL4000_AL_RDY         BIT(6) /* ALS data ready? */
  74 #define VCNL4000_PS_RDY         BIT(5) /* proximity data ready? */
  75 #define VCNL4000_AL_OD          BIT(4) /* start on-demand ALS measurement */
  76 #define VCNL4000_PS_OD          BIT(3) /* start on-demand proximity measurement */
  77 #define VCNL4000_ALS_EN         BIT(2) /* start ALS measurement */
  78 #define VCNL4000_PROX_EN        BIT(1) /* start proximity measurement */
  79 #define VCNL4000_SELF_TIMED_EN  BIT(0) /* start self-timed measurement */
  80
  81 #define VCNL4040_ALS_CONF_ALS_SHUTDOWN  BIT(0)
  82 #define VCNL4040_PS_CONF1_PS_SHUTDOWN   BIT(0)
  83 #define VCNL4040_PS_CONF2_PS_IT GENMASK(3, 1) /* Proximity integration time */
  84 #define VCNL4040_PS_CONF2_PS_INT        GENMASK(9, 8) /* Proximity interrupt mode */
  85 #define VCNL4040_PS_IF_AWAY             BIT(8) /* Proximity event cross low threshold */
  86 #define VCNL4040_PS_IF_CLOSE            BIT(9) /* Proximity event cross high threshold */
  87
  88 /* Bit masks for interrupt registers. */
  89 #define VCNL4010_INT_THR_SEL    BIT(0) /* Select threshold interrupt source */
  90 #define VCNL4010_INT_THR_EN     BIT(1) /* Threshold interrupt type */
  91 #define VCNL4010_INT_ALS_EN     BIT(2) /* Enable on ALS data ready */
  92 #define VCNL4010_INT_PROX_EN    BIT(3) /* Enable on proximity data ready */
  93
  94 #define VCNL4010_INT_THR_HIGH   0 /* High threshold exceeded */
  95 #define VCNL4010_INT_THR_LOW    1 /* Low threshold exceeded */
  96 #define VCNL4010_INT_ALS        2 /* ALS data ready */
  97 #define VCNL4010_INT_PROXIMITY  3 /* Proximity data ready */
  98
  99 #define VCNL4010_INT_THR \
 100         (BIT(VCNL4010_INT_THR_LOW) | BIT(VCNL4010_INT_THR_HIGH))
 101 #define VCNL4010_INT_DRDY \
 102         (BIT(VCNL4010_INT_PROXIMITY) | BIT(VCNL4010_INT_ALS))
 103
 104 static const int vcnl4010_prox_sampling_frequency[][2] = {
 105         {1, 950000},
 106         {3, 906250},
 107         {7, 812500},
 108         {16, 625000},
 109         {31, 250000},
 110         {62, 500000},
 111         {125, 0},
 112         {250, 0},
 113 };
 114
 115 static const int vcnl4040_ps_it_times[][2] = {
 116         {0, 100},
 117         {0, 150},
 118         {0, 200},
 119         {0, 250},
 120         {0, 300},
 121         {0, 350},
 122         {0, 400},
 123         {0, 800},
 124 };
 125
 126 #define VCNL4000_SLEEP_DELAY_MS 2000 /* before we enter pm_runtime_suspend */
 127
 128 enum vcnl4000_device_ids {
 129         VCNL4000,
 130         VCNL4010,
 131         VCNL4040,
 132         VCNL4200,
 133 };
 134
 135 struct vcnl4200_channel {
 136         u8 reg;
 137         ktime_t last_measurement;
 138         ktime_t sampling_rate;
 139         struct mutex lock;
 140 };
 141
 142 struct vcnl4000_data {
 143         struct i2c_client *client;
 144         enum vcnl4000_device_ids id;
 145         int rev;
 146         int al_scale;
 147         u8 ps_int;              /* proximity interrupt mode */
 148         const struct vcnl4000_chip_spec *chip_spec;
 149         struct mutex vcnl4000_lock;
 150         struct vcnl4200_channel vcnl4200_al;
 151         struct vcnl4200_channel vcnl4200_ps;
 152         uint32_t near_level;
 153 };
 154
 155 struct vcnl4000_chip_spec {
 156         const char *prod;
 157         struct iio_chan_spec const *channels;
 158         const int num_channels;
 159         const struct iio_info *info;
 160         const struct iio_buffer_setup_ops *buffer_setup_ops;
 161         int (*init)(struct vcnl4000_data *data);
 162         int (*measure_light)(struct vcnl4000_data *data, int *val);
 163         int (*measure_proximity)(struct vcnl4000_data *data, int *val);
 164         int (*set_power_state)(struct vcnl4000_data *data, bool on);
 165         irqreturn_t (*irq_thread)(int irq, void *priv);
 166         irqreturn_t (*trig_buffer_func)(int irq, void *priv);
 167 };
 168
 169 static const struct i2c_device_id vcnl4000_id[] = {
 170         { "vcnl4000", VCNL4000 },
 171         { "vcnl4010", VCNL4010 },
 172         { "vcnl4020", VCNL4010 },
 173         { "vcnl4040", VCNL4040 },
 174         { "vcnl4200", VCNL4200 },
 175         { }
 176 };
 177 MODULE_DEVICE_TABLE(i2c, vcnl4000_id);
 178
 179 static int vcnl4000_set_power_state(struct vcnl4000_data *data, bool on)
 180 {
 181         /* no suspend op */
 182         return 0;
 183 }
 184
 185 static int vcnl4000_init(struct vcnl4000_data *data)
 186 {
 187         int ret, prod_id;
 188
 189         ret = i2c_smbus_read_byte_data(data->client, VCNL4000_PROD_REV);
 190         if (ret < 0)
 191                 return ret;
 192
 193         prod_id = ret >> 4;
 194         switch (prod_id) {
 195         case VCNL4000_PROD_ID:
 196                 if (data->id != VCNL4000)
 197                         dev_warn(&data->client->dev,
 198                                         "wrong device id, use vcnl4000");
 199                 break;
 200         case VCNL4010_PROD_ID:
 201                 if (data->id != VCNL4010)
 202                         dev_warn(&data->client->dev,
 203                                         "wrong device id, use vcnl4010/4020");
 204                 break;
 205         default:
 206                 return -ENODEV;
 207         }
 208
 209         data->rev = ret & 0xf;
 210         data->al_scale = 250000;
 211         mutex_init(&data->vcnl4000_lock);
 212
 213         return data->chip_spec->set_power_state(data, true);
 214 };
 215
 216 static ssize_t vcnl4000_write_als_enable(struct vcnl4000_data *data, bool en)
 217 {
 218         int ret;
 219
 220         mutex_lock(&data->vcnl4000_lock);
 221
 222         ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
 223         if (ret < 0)
 224                 goto out;
 225
 226         if (en)
 227                 ret &= ~VCNL4040_ALS_CONF_ALS_SHUTDOWN;
 228         else
 229                 ret |= VCNL4040_ALS_CONF_ALS_SHUTDOWN;
 230
 231         ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF, ret);
 232
 233 out:
 234         mutex_unlock(&data->vcnl4000_lock);
 235
 236         return ret;
 237 }
 238
 239 static ssize_t vcnl4000_write_ps_enable(struct vcnl4000_data *data, bool en)
 240 {
 241         int ret;
 242
 243         mutex_lock(&data->vcnl4000_lock);
 244
 245         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 246         if (ret < 0)
 247                 goto out;
 248
 249         if (en)
 250                 ret &= ~VCNL4040_PS_CONF1_PS_SHUTDOWN;
 251         else
 252                 ret |= VCNL4040_PS_CONF1_PS_SHUTDOWN;
 253
 254         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, ret);
 255
 256 out:
 257         mutex_unlock(&data->vcnl4000_lock);
 258
 259         return ret;
 260 }
 261
 262 static int vcnl4200_set_power_state(struct vcnl4000_data *data, bool on)
 263 {
 264         int ret;
 265
 266         /* Do not power down if interrupts are enabled */
 267         if (!on && data->ps_int)
 268                 return 0;
 269
 270         ret = vcnl4000_write_als_enable(data, on);
 271         if (ret < 0)
 272                 return ret;
 273
 274         ret = vcnl4000_write_ps_enable(data, on);
 275         if (ret < 0)
 276                 return ret;
 277
 278         if (on) {
 279                 /* Wait at least one integration cycle before fetching data */
 280                 data->vcnl4200_al.last_measurement = ktime_get();
 281                 data->vcnl4200_ps.last_measurement = ktime_get();
 282         }
 283
 284         return 0;
 285 }
 286
 287 static int vcnl4200_init(struct vcnl4000_data *data)
 288 {
 289         int ret, id;
 290
 291         ret = i2c_smbus_read_word_data(data->client, VCNL4200_DEV_ID);
 292         if (ret < 0)
 293                 return ret;
 294
 295         id = ret & 0xff;
 296
 297         if (id != VCNL4200_PROD_ID) {
 298                 ret = i2c_smbus_read_word_data(data->client, VCNL4040_DEV_ID);
 299                 if (ret < 0)
 300                         return ret;
 301
 302                 id = ret & 0xff;
 303
 304                 if (id != VCNL4040_PROD_ID)
 305                         return -ENODEV;
 306         }
 307
 308         dev_dbg(&data->client->dev, "device id 0x%x", id);
 309
 310         data->rev = (ret >> 8) & 0xf;
 311         data->ps_int = 0;
 312
 313         data->vcnl4200_al.reg = VCNL4200_AL_DATA;
 314         data->vcnl4200_ps.reg = VCNL4200_PS_DATA;
 315         switch (id) {
 316         case VCNL4200_PROD_ID:
 317                 /* Default wait time is 50ms, add 20% tolerance. */
 318                 data->vcnl4200_al.sampling_rate = ktime_set(0, 60000 * 1000);
 319                 /* Default wait time is 4.8ms, add 20% tolerance. */
 320                 data->vcnl4200_ps.sampling_rate = ktime_set(0, 5760 * 1000);
 321                 data->al_scale = 24000;
 322                 break;
 323         case VCNL4040_PROD_ID:
 324                 /* Default wait time is 80ms, add 20% tolerance. */
 325                 data->vcnl4200_al.sampling_rate = ktime_set(0, 96000 * 1000);
 326                 /* Default wait time is 5ms, add 20% tolerance. */
 327                 data->vcnl4200_ps.sampling_rate = ktime_set(0, 6000 * 1000);
 328                 data->al_scale = 120000;
 329                 break;
 330         }
 331         mutex_init(&data->vcnl4200_al.lock);
 332         mutex_init(&data->vcnl4200_ps.lock);
 333
 334         ret = data->chip_spec->set_power_state(data, true);
 335         if (ret < 0)
 336                 return ret;
 337
 338         return 0;
 339 };
 340
 341 static int vcnl4000_read_data(struct vcnl4000_data *data, u8 data_reg, int *val)
 342 {
 343         s32 ret;
 344
 345         ret = i2c_smbus_read_word_swapped(data->client, data_reg);
 346         if (ret < 0)
 347                 return ret;
 348
 349         *val = ret;
 350         return 0;
 351 }
 352
 353 static int vcnl4000_write_data(struct vcnl4000_data *data, u8 data_reg, int val)
 354 {
 355         if (val > U16_MAX)
 356                 return -ERANGE;
 357
 358         return i2c_smbus_write_word_swapped(data->client, data_reg, val);
 359 }
 360
 361
 362 static int vcnl4000_measure(struct vcnl4000_data *data, u8 req_mask,
 363                                 u8 rdy_mask, u8 data_reg, int *val)
 364 {
 365         int tries = 20;
 366         int ret;
 367
 368         mutex_lock(&data->vcnl4000_lock);
 369
 370         ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND,
 371                                         req_mask);
 372         if (ret < 0)
 373                 goto fail;
 374
 375         /* wait for data to become ready */
 376         while (tries--) {
 377                 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND);
 378                 if (ret < 0)
 379                         goto fail;
 380                 if (ret & rdy_mask)
 381                         break;
 382                 msleep(20); /* measurement takes up to 100 ms */
 383         }
 384
 385         if (tries < 0) {
 386                 dev_err(&data->client->dev,
 387                         "vcnl4000_measure() failed, data not ready\n");
 388                 ret = -EIO;
 389                 goto fail;
 390         }
 391
 392         ret = vcnl4000_read_data(data, data_reg, val);
 393         if (ret < 0)
 394                 goto fail;
 395
 396         mutex_unlock(&data->vcnl4000_lock);
 397
 398         return 0;
 399
 400 fail:
 401         mutex_unlock(&data->vcnl4000_lock);
 402         return ret;
 403 }
 404
 405 static int vcnl4200_measure(struct vcnl4000_data *data,
 406                 struct vcnl4200_channel *chan, int *val)
 407 {
 408         int ret;
 409         s64 delta;
 410         ktime_t next_measurement;
 411
 412         mutex_lock(&chan->lock);
 413
 414         next_measurement = ktime_add(chan->last_measurement,
 415                         chan->sampling_rate);
 416         delta = ktime_us_delta(next_measurement, ktime_get());
 417         if (delta > 0)
 418                 usleep_range(delta, delta + 500);
 419         chan->last_measurement = ktime_get();
 420
 421         mutex_unlock(&chan->lock);
 422
 423         ret = i2c_smbus_read_word_data(data->client, chan->reg);
 424         if (ret < 0)
 425                 return ret;
 426
 427         *val = ret;
 428
 429         return 0;
 430 }
 431
 432 static int vcnl4000_measure_light(struct vcnl4000_data *data, int *val)
 433 {
 434         return vcnl4000_measure(data,
 435                         VCNL4000_AL_OD, VCNL4000_AL_RDY,
 436                         VCNL4000_AL_RESULT_HI, val);
 437 }
 438
 439 static int vcnl4200_measure_light(struct vcnl4000_data *data, int *val)
 440 {
 441         return vcnl4200_measure(data, &data->vcnl4200_al, val);
 442 }
 443
 444 static int vcnl4000_measure_proximity(struct vcnl4000_data *data, int *val)
 445 {
 446         return vcnl4000_measure(data,
 447                         VCNL4000_PS_OD, VCNL4000_PS_RDY,
 448                         VCNL4000_PS_RESULT_HI, val);
 449 }
 450
 451 static int vcnl4200_measure_proximity(struct vcnl4000_data *data, int *val)
 452 {
 453         return vcnl4200_measure(data, &data->vcnl4200_ps, val);
 454 }
 455
 456 static int vcnl4010_read_proxy_samp_freq(struct vcnl4000_data *data, int *val,
 457                                          int *val2)
 458 {
 459         int ret;
 460
 461         ret = i2c_smbus_read_byte_data(data->client, VCNL4010_PROX_RATE);
 462         if (ret < 0)
 463                 return ret;
 464
 465         if (ret >= ARRAY_SIZE(vcnl4010_prox_sampling_frequency))
 466                 return -EINVAL;
 467
 468         *val = vcnl4010_prox_sampling_frequency[ret][0];
 469         *val2 = vcnl4010_prox_sampling_frequency[ret][1];
 470
 471         return 0;
 472 }
 473
 474 static bool vcnl4010_is_in_periodic_mode(struct vcnl4000_data *data)
 475 {
 476         int ret;
 477
 478         ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND);
 479         if (ret < 0)
 480                 return false;
 481
 482         return !!(ret & VCNL4000_SELF_TIMED_EN);
 483 }
 484
 485 static int vcnl4000_set_pm_runtime_state(struct vcnl4000_data *data, bool on)
 486 {
 487         struct device *dev = &data->client->dev;
 488         int ret;
 489
 490         if (on) {
 491                 ret = pm_runtime_resume_and_get(dev);
 492         } else {
 493                 pm_runtime_mark_last_busy(dev);
 494                 ret = pm_runtime_put_autosuspend(dev);
 495         }
 496
 497         return ret;
 498 }
 499
 500 static int vcnl4040_read_ps_it(struct vcnl4000_data *data, int *val, int *val2)
 501 {
 502         int ret;
 503
 504         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 505         if (ret < 0)
 506                 return ret;
 507
 508         ret = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret);
 509
 510         if (ret >= ARRAY_SIZE(vcnl4040_ps_it_times))
 511                 return -EINVAL;
 512
 513         *val = vcnl4040_ps_it_times[ret][0];
 514         *val2 = vcnl4040_ps_it_times[ret][1];
 515
 516         return 0;
 517 }
 518
 519 static ssize_t vcnl4040_write_ps_it(struct vcnl4000_data *data, int val)
 520 {
 521         unsigned int i;
 522         int ret, index = -1;
 523         u16 regval;
 524
 525         for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_it_times); i++) {
 526                 if (val == vcnl4040_ps_it_times[i][1]) {
 527                         index = i;
 528                         break;
 529                 }
 530         }
 531
 532         if (index < 0)
 533                 return -EINVAL;
 534
 535         mutex_lock(&data->vcnl4000_lock);
 536
 537         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 538         if (ret < 0)
 539                 goto out;
 540
 541         regval = (ret & ~VCNL4040_PS_CONF2_PS_IT) |
 542             FIELD_PREP(VCNL4040_PS_CONF2_PS_IT, index);
 543         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1,
 544                                         regval);
 545
 546 out:
 547         mutex_unlock(&data->vcnl4000_lock);
 548         return ret;
 549 }
 550
 551 static int vcnl4000_read_raw(struct iio_dev *indio_dev,
 552                                 struct iio_chan_spec const *chan,
 553                                 int *val, int *val2, long mask)
 554 {
 555         int ret;
 556         struct vcnl4000_data *data = iio_priv(indio_dev);
 557
 558         switch (mask) {
 559         case IIO_CHAN_INFO_RAW:
 560                 ret = vcnl4000_set_pm_runtime_state(data, true);
 561                 if  (ret < 0)
 562                         return ret;
 563
 564                 switch (chan->type) {
 565                 case IIO_LIGHT:
 566                         ret = data->chip_spec->measure_light(data, val);
 567                         if (!ret)
 568                                 ret = IIO_VAL_INT;
 569                         break;
 570                 case IIO_PROXIMITY:
 571                         ret = data->chip_spec->measure_proximity(data, val);
 572                         if (!ret)
 573                                 ret = IIO_VAL_INT;
 574                         break;
 575                 default:
 576                         ret = -EINVAL;
 577                 }
 578                 vcnl4000_set_pm_runtime_state(data, false);
 579                 return ret;
 580         case IIO_CHAN_INFO_SCALE:
 581                 if (chan->type != IIO_LIGHT)
 582                         return -EINVAL;
 583
 584                 *val = 0;
 585                 *val2 = data->al_scale;
 586                 return IIO_VAL_INT_PLUS_MICRO;
 587         case IIO_CHAN_INFO_INT_TIME:
 588                 if (chan->type != IIO_PROXIMITY)
 589                         return -EINVAL;
 590                 ret = vcnl4040_read_ps_it(data, val, val2);
 591                 if (ret < 0)
 592                         return ret;
 593                 return IIO_VAL_INT_PLUS_MICRO;
 594         default:
 595                 return -EINVAL;
 596         }
 597 }
 598
 599 static int vcnl4040_write_raw(struct iio_dev *indio_dev,
 600                               struct iio_chan_spec const *chan,
 601                               int val, int val2, long mask)
 602 {
 603         struct vcnl4000_data *data = iio_priv(indio_dev);
 604
 605         switch (mask) {
 606         case IIO_CHAN_INFO_INT_TIME:
 607                 if (val != 0)
 608                         return -EINVAL;
 609                 if (chan->type != IIO_PROXIMITY)
 610                         return -EINVAL;
 611                 return vcnl4040_write_ps_it(data, val2);
 612         default:
 613                 return -EINVAL;
 614         }
 615 }
 616
 617 static int vcnl4040_read_avail(struct iio_dev *indio_dev,
 618                                struct iio_chan_spec const *chan,
 619                                const int **vals, int *type, int *length,
 620                                long mask)
 621 {
 622         switch (mask) {
 623         case IIO_CHAN_INFO_INT_TIME:
 624                 *vals = (int *)vcnl4040_ps_it_times;
 625                 *type = IIO_VAL_INT_PLUS_MICRO;
 626                 *length = 2 * ARRAY_SIZE(vcnl4040_ps_it_times);
 627                 return IIO_AVAIL_LIST;
 628         default:
 629                 return -EINVAL;
 630         }
 631 }
 632
 633 static int vcnl4010_read_raw(struct iio_dev *indio_dev,
 634                              struct iio_chan_spec const *chan,
 635                              int *val, int *val2, long mask)
 636 {
 637         int ret;
 638         struct vcnl4000_data *data = iio_priv(indio_dev);
 639
 640         switch (mask) {
 641         case IIO_CHAN_INFO_RAW:
 642         case IIO_CHAN_INFO_SCALE:
 643                 ret = iio_device_claim_direct_mode(indio_dev);
 644                 if (ret)
 645                         return ret;
 646
 647                 /* Protect against event capture. */
 648                 if (vcnl4010_is_in_periodic_mode(data)) {
 649                         ret = -EBUSY;
 650                 } else {
 651                         ret = vcnl4000_read_raw(indio_dev, chan, val, val2,
 652                                                 mask);
 653                 }
 654
 655                 iio_device_release_direct_mode(indio_dev);
 656                 return ret;
 657         case IIO_CHAN_INFO_SAMP_FREQ:
 658                 switch (chan->type) {
 659                 case IIO_PROXIMITY:
 660                         ret = vcnl4010_read_proxy_samp_freq(data, val, val2);
 661                         if (ret < 0)
 662                                 return ret;
 663                         return IIO_VAL_INT_PLUS_MICRO;
 664                 default:
 665                         return -EINVAL;
 666                 }
 667         default:
 668                 return -EINVAL;
 669         }
 670 }
 671
 672 static int vcnl4010_read_avail(struct iio_dev *indio_dev,
 673                                struct iio_chan_spec const *chan,
 674                                const int **vals, int *type, int *length,
 675                                long mask)
 676 {
 677         switch (mask) {
 678         case IIO_CHAN_INFO_SAMP_FREQ:
 679                 *vals = (int *)vcnl4010_prox_sampling_frequency;
 680                 *type = IIO_VAL_INT_PLUS_MICRO;
 681                 *length = 2 * ARRAY_SIZE(vcnl4010_prox_sampling_frequency);
 682                 return IIO_AVAIL_LIST;
 683         default:
 684                 return -EINVAL;
 685         }
 686 }
 687
 688 static int vcnl4010_write_proxy_samp_freq(struct vcnl4000_data *data, int val,
 689                                           int val2)
 690 {
 691         unsigned int i;
 692         int index = -1;
 693
 694         for (i = 0; i < ARRAY_SIZE(vcnl4010_prox_sampling_frequency); i++) {
 695                 if (val == vcnl4010_prox_sampling_frequency[i][0] &&
 696                     val2 == vcnl4010_prox_sampling_frequency[i][1]) {
 697                         index = i;
 698                         break;
 699                 }
 700         }
 701
 702         if (index < 0)
 703                 return -EINVAL;
 704
 705         return i2c_smbus_write_byte_data(data->client, VCNL4010_PROX_RATE,
 706                                          index);
 707 }
 708
 709 static int vcnl4010_write_raw(struct iio_dev *indio_dev,
 710                               struct iio_chan_spec const *chan,
 711                               int val, int val2, long mask)
 712 {
 713         int ret;
 714         struct vcnl4000_data *data = iio_priv(indio_dev);
 715
 716         ret = iio_device_claim_direct_mode(indio_dev);
 717         if (ret)
 718                 return ret;
 719
 720         /* Protect against event capture. */
 721         if (vcnl4010_is_in_periodic_mode(data)) {
 722                 ret = -EBUSY;
 723                 goto end;
 724         }
 725
 726         switch (mask) {
 727         case IIO_CHAN_INFO_SAMP_FREQ:
 728                 switch (chan->type) {
 729                 case IIO_PROXIMITY:
 730                         ret = vcnl4010_write_proxy_samp_freq(data, val, val2);
 731                         goto end;
 732                 default:
 733                         ret = -EINVAL;
 734                         goto end;
 735                 }
 736         default:
 737                 ret = -EINVAL;
 738                 goto end;
 739         }
 740
 741 end:
 742         iio_device_release_direct_mode(indio_dev);
 743         return ret;
 744 }
 745
 746 static int vcnl4010_read_event(struct iio_dev *indio_dev,
 747                                const struct iio_chan_spec *chan,
 748                                enum iio_event_type type,
 749                                enum iio_event_direction dir,
 750                                enum iio_event_info info,
 751                                int *val, int *val2)
 752 {
 753         int ret;
 754         struct vcnl4000_data *data = iio_priv(indio_dev);
 755
 756         switch (info) {
 757         case IIO_EV_INFO_VALUE:
 758                 switch (dir) {
 759                 case IIO_EV_DIR_RISING:
 760                         ret = vcnl4000_read_data(data, VCNL4010_HIGH_THR_HI,
 761                                                  val);
 762                         if (ret < 0)
 763                                 return ret;
 764                         return IIO_VAL_INT;
 765                 case IIO_EV_DIR_FALLING:
 766                         ret = vcnl4000_read_data(data, VCNL4010_LOW_THR_HI,
 767                                                  val);
 768                         if (ret < 0)
 769                                 return ret;
 770                         return IIO_VAL_INT;
 771                 default:
 772                         return -EINVAL;
 773                 }
 774         default:
 775                 return -EINVAL;
 776         }
 777 }
 778
 779 static int vcnl4010_write_event(struct iio_dev *indio_dev,
 780                                 const struct iio_chan_spec *chan,
 781                                 enum iio_event_type type,
 782                                 enum iio_event_direction dir,
 783                                 enum iio_event_info info,
 784                                 int val, int val2)
 785 {
 786         int ret;
 787         struct vcnl4000_data *data = iio_priv(indio_dev);
 788
 789         switch (info) {
 790         case IIO_EV_INFO_VALUE:
 791                 switch (dir) {
 792                 case IIO_EV_DIR_RISING:
 793                         ret = vcnl4000_write_data(data, VCNL4010_HIGH_THR_HI,
 794                                                   val);
 795                         if (ret < 0)
 796                                 return ret;
 797                         return IIO_VAL_INT;
 798                 case IIO_EV_DIR_FALLING:
 799                         ret = vcnl4000_write_data(data, VCNL4010_LOW_THR_HI,
 800                                                   val);
 801                         if (ret < 0)
 802                                 return ret;
 803                         return IIO_VAL_INT;
 804                 default:
 805                         return -EINVAL;
 806                 }
 807         default:
 808                 return -EINVAL;
 809         }
 810 }
 811
 812 static int vcnl4040_read_event(struct iio_dev *indio_dev,
 813                                const struct iio_chan_spec *chan,
 814                                enum iio_event_type type,
 815                                enum iio_event_direction dir,
 816                                enum iio_event_info info,
 817                                int *val, int *val2)
 818 {
 819         int ret;
 820         struct vcnl4000_data *data = iio_priv(indio_dev);
 821
 822         switch (dir) {
 823         case IIO_EV_DIR_RISING:
 824                 ret = i2c_smbus_read_word_data(data->client,
 825                                                VCNL4040_PS_THDH_LM);
 826                 if (ret < 0)
 827                         return ret;
 828                 *val = ret;
 829                 return IIO_VAL_INT;
 830         case IIO_EV_DIR_FALLING:
 831                 ret = i2c_smbus_read_word_data(data->client,
 832                                                VCNL4040_PS_THDL_LM);
 833                 if (ret < 0)
 834                         return ret;
 835                 *val = ret;
 836                 return IIO_VAL_INT;
 837         default:
 838                 return -EINVAL;
 839         }
 840 }
 841
 842 static int vcnl4040_write_event(struct iio_dev *indio_dev,
 843                                 const struct iio_chan_spec *chan,
 844                                 enum iio_event_type type,
 845                                 enum iio_event_direction dir,
 846                                 enum iio_event_info info,
 847                                 int val, int val2)
 848 {
 849         int ret;
 850         struct vcnl4000_data *data = iio_priv(indio_dev);
 851
 852         switch (dir) {
 853         case IIO_EV_DIR_RISING:
 854                 ret = i2c_smbus_write_word_data(data->client,
 855                                                 VCNL4040_PS_THDH_LM, val);
 856                 if (ret < 0)
 857                         return ret;
 858                 return IIO_VAL_INT;
 859         case IIO_EV_DIR_FALLING:
 860                 ret = i2c_smbus_write_word_data(data->client,
 861                                                 VCNL4040_PS_THDL_LM, val);
 862                 if (ret < 0)
 863                         return ret;
 864                 return IIO_VAL_INT;
 865         default:
 866                 return -EINVAL;
 867         }
 868 }
 869
 870 static bool vcnl4010_is_thr_enabled(struct vcnl4000_data *data)
 871 {
 872         int ret;
 873
 874         ret = i2c_smbus_read_byte_data(data->client, VCNL4010_INT_CTRL);
 875         if (ret < 0)
 876                 return false;
 877
 878         return !!(ret & VCNL4010_INT_THR_EN);
 879 }
 880
 881 static int vcnl4010_read_event_config(struct iio_dev *indio_dev,
 882                                       const struct iio_chan_spec *chan,
 883                                       enum iio_event_type type,
 884                                       enum iio_event_direction dir)
 885 {
 886         struct vcnl4000_data *data = iio_priv(indio_dev);
 887
 888         switch (chan->type) {
 889         case IIO_PROXIMITY:
 890                 return vcnl4010_is_thr_enabled(data);
 891         default:
 892                 return -EINVAL;
 893         }
 894 }
 895
 896 static int vcnl4010_config_threshold(struct iio_dev *indio_dev, bool state)
 897 {
 898         struct vcnl4000_data *data = iio_priv(indio_dev);
 899         int ret;
 900         int icr;
 901         int command;
 902
 903         if (state) {
 904                 ret = iio_device_claim_direct_mode(indio_dev);
 905                 if (ret)
 906                         return ret;
 907
 908                 /* Enable periodic measurement of proximity data. */
 909                 command = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN;
 910
 911                 /*
 912                  * Enable interrupts on threshold, for proximity data by
 913                  * default.
 914                  */
 915                 icr = VCNL4010_INT_THR_EN;
 916         } else {
 917                 if (!vcnl4010_is_thr_enabled(data))
 918                         return 0;
 919
 920                 command = 0;
 921                 icr = 0;
 922         }
 923
 924         ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND,
 925                                         command);
 926         if (ret < 0)
 927                 goto end;
 928
 929         ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, icr);
 930
 931 end:
 932         if (state)
 933                 iio_device_release_direct_mode(indio_dev);
 934
 935         return ret;
 936 }
 937
 938 static int vcnl4010_write_event_config(struct iio_dev *indio_dev,
 939                                        const struct iio_chan_spec *chan,
 940                                        enum iio_event_type type,
 941                                        enum iio_event_direction dir,
 942                                        int state)
 943 {
 944         switch (chan->type) {
 945         case IIO_PROXIMITY:
 946                 return vcnl4010_config_threshold(indio_dev, state);
 947         default:
 948                 return -EINVAL;
 949         }
 950 }
 951
 952 static int vcnl4040_read_event_config(struct iio_dev *indio_dev,
 953                                       const struct iio_chan_spec *chan,
 954                                       enum iio_event_type type,
 955                                       enum iio_event_direction dir)
 956 {
 957         int ret;
 958         struct vcnl4000_data *data = iio_priv(indio_dev);
 959
 960         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 961         if (ret < 0)
 962                 return ret;
 963
 964         data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, ret);
 965
 966         return (dir == IIO_EV_DIR_RISING) ?
 967                 FIELD_GET(VCNL4040_PS_IF_AWAY, ret) :
 968                 FIELD_GET(VCNL4040_PS_IF_CLOSE, ret);
 969 }
 970
 971 static int vcnl4040_write_event_config(struct iio_dev *indio_dev,
 972                                        const struct iio_chan_spec *chan,
 973                                        enum iio_event_type type,
 974                                        enum iio_event_direction dir, int state)
 975 {
 976         int ret;
 977         u16 val, mask;
 978         struct vcnl4000_data *data = iio_priv(indio_dev);
 979
 980         mutex_lock(&data->vcnl4000_lock);
 981
 982         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 983         if (ret < 0)
 984                 goto out;
 985
 986         if (dir == IIO_EV_DIR_RISING)
 987                 mask = VCNL4040_PS_IF_AWAY;
 988         else
 989                 mask = VCNL4040_PS_IF_CLOSE;
 990
 991         val = state ? (ret | mask) : (ret & ~mask);
 992
 993         data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, val);
 994         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, val);
 995
 996 out:
 997         mutex_unlock(&data->vcnl4000_lock);
 998         data->chip_spec->set_power_state(data, data->ps_int != 0);
 999
1000         return ret;
1001 }
1002
1003 static irqreturn_t vcnl4040_irq_thread(int irq, void *p)
1004 {
1005         struct iio_dev *indio_dev = p;
1006         struct vcnl4000_data *data = iio_priv(indio_dev);
1007         int ret;
1008
1009         ret = i2c_smbus_read_word_data(data->client, VCNL4040_INT_FLAGS);
1010         if (ret < 0)
1011                 return IRQ_HANDLED;
1012
1013         if (ret & VCNL4040_PS_IF_CLOSE) {
1014                 iio_push_event(indio_dev,
1015                                IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
1016                                                     IIO_EV_TYPE_THRESH,
1017                                                     IIO_EV_DIR_RISING),
1018                                iio_get_time_ns(indio_dev));
1019         }
1020
1021         if (ret & VCNL4040_PS_IF_AWAY) {
1022                 iio_push_event(indio_dev,
1023                                IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
1024                                                     IIO_EV_TYPE_THRESH,
1025                                                     IIO_EV_DIR_FALLING),
1026                                iio_get_time_ns(indio_dev));
1027         }
1028
1029         return IRQ_HANDLED;
1030 }
1031
1032 static ssize_t vcnl4000_read_near_level(struct iio_dev *indio_dev,
1033                                         uintptr_t priv,
1034                                         const struct iio_chan_spec *chan,
1035                                         char *buf)
1036 {
1037         struct vcnl4000_data *data = iio_priv(indio_dev);
1038
1039         return sprintf(buf, "%u\n", data->near_level);
1040 }
1041
1042 static irqreturn_t vcnl4010_irq_thread(int irq, void *p)
1043 {
1044         struct iio_dev *indio_dev = p;
1045         struct vcnl4000_data *data = iio_priv(indio_dev);
1046         unsigned long isr;
1047         int ret;
1048
1049         ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR);
1050         if (ret < 0)
1051                 goto end;
1052
1053         isr = ret;
1054
1055         if (isr & VCNL4010_INT_THR) {
1056                 if (test_bit(VCNL4010_INT_THR_LOW, &isr)) {
1057                         iio_push_event(indio_dev,
1058                                        IIO_UNMOD_EVENT_CODE(
1059                                                IIO_PROXIMITY,
1060                                                1,
1061                                                IIO_EV_TYPE_THRESH,
1062                                                IIO_EV_DIR_FALLING),
1063                                        iio_get_time_ns(indio_dev));
1064                 }
1065
1066                 if (test_bit(VCNL4010_INT_THR_HIGH, &isr)) {
1067                         iio_push_event(indio_dev,
1068                                        IIO_UNMOD_EVENT_CODE(
1069                                                IIO_PROXIMITY,
1070                                                1,
1071                                                IIO_EV_TYPE_THRESH,
1072                                                IIO_EV_DIR_RISING),
1073                                        iio_get_time_ns(indio_dev));
1074                 }
1075
1076                 i2c_smbus_write_byte_data(data->client, VCNL4010_ISR,
1077                                           isr & VCNL4010_INT_THR);
1078         }
1079
1080         if (isr & VCNL4010_INT_DRDY && iio_buffer_enabled(indio_dev))
1081                 iio_trigger_poll_chained(indio_dev->trig);
1082
1083 end:
1084         return IRQ_HANDLED;
1085 }
1086
1087 static irqreturn_t vcnl4010_trigger_handler(int irq, void *p)
1088 {
1089         struct iio_poll_func *pf = p;
1090         struct iio_dev *indio_dev = pf->indio_dev;
1091         struct vcnl4000_data *data = iio_priv(indio_dev);
1092         const unsigned long *active_scan_mask = indio_dev->active_scan_mask;
1093         u16 buffer[8] __aligned(8) = {0}; /* 1x16-bit + naturally aligned ts */
1094         bool data_read = false;
1095         unsigned long isr;
1096         int val = 0;
1097         int ret;
1098
1099         ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR);
1100         if (ret < 0)
1101                 goto end;
1102
1103         isr = ret;
1104
1105         if (test_bit(0, active_scan_mask)) {
1106                 if (test_bit(VCNL4010_INT_PROXIMITY, &isr)) {
1107                         ret = vcnl4000_read_data(data,
1108                                                  VCNL4000_PS_RESULT_HI,
1109                                                  &val);
1110                         if (ret < 0)
1111                                 goto end;
1112
1113                         buffer[0] = val;
1114                         data_read = true;
1115                 }
1116         }
1117
1118         ret = i2c_smbus_write_byte_data(data->client, VCNL4010_ISR,
1119                                         isr & VCNL4010_INT_DRDY);
1120         if (ret < 0)
1121                 goto end;
1122
1123         if (!data_read)
1124                 goto end;
1125
1126         iio_push_to_buffers_with_timestamp(indio_dev, buffer,
1127                                            iio_get_time_ns(indio_dev));
1128
1129 end:
1130         iio_trigger_notify_done(indio_dev->trig);
1131         return IRQ_HANDLED;
1132 }
1133
1134 static int vcnl4010_buffer_postenable(struct iio_dev *indio_dev)
1135 {
1136         struct vcnl4000_data *data = iio_priv(indio_dev);
1137         int ret;
1138         int cmd;
1139
1140         /* Do not enable the buffer if we are already capturing events. */
1141         if (vcnl4010_is_in_periodic_mode(data))
1142                 return -EBUSY;
1143
1144         ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL,
1145                                         VCNL4010_INT_PROX_EN);
1146         if (ret < 0)
1147                 return ret;
1148
1149         cmd = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN;
1150         return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, cmd);
1151 }
1152
1153 static int vcnl4010_buffer_predisable(struct iio_dev *indio_dev)
1154 {
1155         struct vcnl4000_data *data = iio_priv(indio_dev);
1156         int ret;
1157
1158         ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 0);
1159         if (ret < 0)
1160                 return ret;
1161
1162         return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0);
1163 }
1164
1165 static const struct iio_buffer_setup_ops vcnl4010_buffer_ops = {
1166         .postenable = &vcnl4010_buffer_postenable,
1167         .predisable = &vcnl4010_buffer_predisable,
1168 };
1169
1170 static const struct iio_chan_spec_ext_info vcnl4000_ext_info[] = {
1171         {
1172                 .name = "nearlevel",
1173                 .shared = IIO_SEPARATE,
1174                 .read = vcnl4000_read_near_level,
1175         },
1176         { /* sentinel */ }
1177 };
1178
1179 static const struct iio_event_spec vcnl4000_event_spec[] = {
1180         {
1181                 .type = IIO_EV_TYPE_THRESH,
1182                 .dir = IIO_EV_DIR_RISING,
1183                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1184         }, {
1185                 .type = IIO_EV_TYPE_THRESH,
1186                 .dir = IIO_EV_DIR_FALLING,
1187                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1188         }, {
1189                 .type = IIO_EV_TYPE_THRESH,
1190                 .dir = IIO_EV_DIR_EITHER,
1191                 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
1192         }
1193 };
1194
1195 static const struct iio_event_spec vcnl4040_event_spec[] = {
1196         {
1197                 .type = IIO_EV_TYPE_THRESH,
1198                 .dir = IIO_EV_DIR_RISING,
1199                 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
1200         }, {
1201                 .type = IIO_EV_TYPE_THRESH,
1202                 .dir = IIO_EV_DIR_FALLING,
1203                 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
1204         },
1205 };
1206
1207 static const struct iio_chan_spec vcnl4000_channels[] = {
1208         {
1209                 .type = IIO_LIGHT,
1210                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1211                         BIT(IIO_CHAN_INFO_SCALE),
1212         }, {
1213                 .type = IIO_PROXIMITY,
1214                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1215                 .ext_info = vcnl4000_ext_info,
1216         }
1217 };
1218
1219 static const struct iio_chan_spec vcnl4010_channels[] = {
1220         {
1221                 .type = IIO_LIGHT,
1222                 .scan_index = -1,
1223                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1224                         BIT(IIO_CHAN_INFO_SCALE),
1225         }, {
1226                 .type = IIO_PROXIMITY,
1227                 .scan_index = 0,
1228                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1229                         BIT(IIO_CHAN_INFO_SAMP_FREQ),
1230                 .info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ),
1231                 .event_spec = vcnl4000_event_spec,
1232                 .num_event_specs = ARRAY_SIZE(vcnl4000_event_spec),
1233                 .ext_info = vcnl4000_ext_info,
1234                 .scan_type = {
1235                         .sign = 'u',
1236                         .realbits = 16,
1237                         .storagebits = 16,
1238                         .endianness = IIO_CPU,
1239                 },
1240         },
1241         IIO_CHAN_SOFT_TIMESTAMP(1),
1242 };
1243
1244 static const struct iio_chan_spec vcnl4040_channels[] = {
1245         {
1246                 .type = IIO_LIGHT,
1247                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1248                         BIT(IIO_CHAN_INFO_SCALE),
1249         }, {
1250                 .type = IIO_PROXIMITY,
1251                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1252                         BIT(IIO_CHAN_INFO_INT_TIME),
1253                 .info_mask_separate_available = BIT(IIO_CHAN_INFO_INT_TIME),
1254                 .ext_info = vcnl4000_ext_info,
1255                 .event_spec = vcnl4040_event_spec,
1256                 .num_event_specs = ARRAY_SIZE(vcnl4040_event_spec),
1257         }
1258 };
1259
1260 static const struct iio_info vcnl4000_info = {
1261         .read_raw = vcnl4000_read_raw,
1262 };
1263
1264 static const struct iio_info vcnl4010_info = {
1265         .read_raw = vcnl4010_read_raw,
1266         .read_avail = vcnl4010_read_avail,
1267         .write_raw = vcnl4010_write_raw,
1268         .read_event_value = vcnl4010_read_event,
1269         .write_event_value = vcnl4010_write_event,
1270         .read_event_config = vcnl4010_read_event_config,
1271         .write_event_config = vcnl4010_write_event_config,
1272 };
1273
1274 static const struct iio_info vcnl4040_info = {
1275         .read_raw = vcnl4000_read_raw,
1276         .write_raw = vcnl4040_write_raw,
1277         .read_event_value = vcnl4040_read_event,
1278         .write_event_value = vcnl4040_write_event,
1279         .read_event_config = vcnl4040_read_event_config,
1280         .write_event_config = vcnl4040_write_event_config,
1281         .read_avail = vcnl4040_read_avail,
1282 };
1283
1284 static const struct vcnl4000_chip_spec vcnl4000_chip_spec_cfg[] = {
1285         [VCNL4000] = {
1286                 .prod = "VCNL4000",
1287                 .init = vcnl4000_init,
1288                 .measure_light = vcnl4000_measure_light,
1289                 .measure_proximity = vcnl4000_measure_proximity,
1290                 .set_power_state = vcnl4000_set_power_state,
1291                 .channels = vcnl4000_channels,
1292                 .num_channels = ARRAY_SIZE(vcnl4000_channels),
1293                 .info = &vcnl4000_info,
1294         },
1295         [VCNL4010] = {
1296                 .prod = "VCNL4010/4020",
1297                 .init = vcnl4000_init,
1298                 .measure_light = vcnl4000_measure_light,
1299                 .measure_proximity = vcnl4000_measure_proximity,
1300                 .set_power_state = vcnl4000_set_power_state,
1301                 .channels = vcnl4010_channels,
1302                 .num_channels = ARRAY_SIZE(vcnl4010_channels),
1303                 .info = &vcnl4010_info,
1304                 .irq_thread = vcnl4010_irq_thread,
1305                 .trig_buffer_func = vcnl4010_trigger_handler,
1306                 .buffer_setup_ops = &vcnl4010_buffer_ops,
1307         },
1308         [VCNL4040] = {
1309                 .prod = "VCNL4040",
1310                 .init = vcnl4200_init,
1311                 .measure_light = vcnl4200_measure_light,
1312                 .measure_proximity = vcnl4200_measure_proximity,
1313                 .set_power_state = vcnl4200_set_power_state,
1314                 .channels = vcnl4040_channels,
1315                 .num_channels = ARRAY_SIZE(vcnl4040_channels),
1316                 .info = &vcnl4040_info,
1317                 .irq_thread = vcnl4040_irq_thread,
1318         },
1319         [VCNL4200] = {
1320                 .prod = "VCNL4200",
1321                 .init = vcnl4200_init,
1322                 .measure_light = vcnl4200_measure_light,
1323                 .measure_proximity = vcnl4200_measure_proximity,
1324                 .set_power_state = vcnl4200_set_power_state,
1325                 .channels = vcnl4000_channels,
1326                 .num_channels = ARRAY_SIZE(vcnl4000_channels),
1327                 .info = &vcnl4000_info,
1328         },
1329 };
1330
1331 static const struct iio_trigger_ops vcnl4010_trigger_ops = {
1332         .validate_device = iio_trigger_validate_own_device,
1333 };
1334
1335 static int vcnl4010_probe_trigger(struct iio_dev *indio_dev)
1336 {
1337         struct vcnl4000_data *data = iio_priv(indio_dev);
1338         struct i2c_client *client = data->client;
1339         struct iio_trigger *trigger;
1340
1341         trigger = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
1342                                          indio_dev->name,
1343                                          iio_device_id(indio_dev));
1344         if (!trigger)
1345                 return -ENOMEM;
1346
1347         trigger->ops = &vcnl4010_trigger_ops;
1348         iio_trigger_set_drvdata(trigger, indio_dev);
1349
1350         return devm_iio_trigger_register(&client->dev, trigger);
1351 }
1352
1353 static int vcnl4000_probe(struct i2c_client *client)
1354 {
1355         const struct i2c_device_id *id = i2c_client_get_device_id(client);
1356         struct vcnl4000_data *data;
1357         struct iio_dev *indio_dev;
1358         int ret;
1359
1360         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1361         if (!indio_dev)
1362                 return -ENOMEM;
1363
1364         data = iio_priv(indio_dev);
1365         i2c_set_clientdata(client, indio_dev);
1366         data->client = client;
1367         data->id = id->driver_data;
1368         data->chip_spec = &vcnl4000_chip_spec_cfg[data->id];
1369
1370         ret = data->chip_spec->init(data);
1371         if (ret < 0)
1372                 return ret;
1373
1374         dev_dbg(&client->dev, "%s Ambient light/proximity sensor, Rev: %02x\n",
1375                 data->chip_spec->prod, data->rev);
1376
1377         if (device_property_read_u32(&client->dev, "proximity-near-level",
1378                                      &data->near_level))
1379                 data->near_level = 0;
1380
1381         indio_dev->info = data->chip_spec->info;
1382         indio_dev->channels = data->chip_spec->channels;
1383         indio_dev->num_channels = data->chip_spec->num_channels;
1384         indio_dev->name = VCNL4000_DRV_NAME;
1385         indio_dev->modes = INDIO_DIRECT_MODE;
1386
1387         if (data->chip_spec->trig_buffer_func &&
1388             data->chip_spec->buffer_setup_ops) {
1389                 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev,
1390                                                       NULL,
1391                                                       data->chip_spec->trig_buffer_func,
1392                                                       data->chip_spec->buffer_setup_ops);
1393                 if (ret < 0) {
1394                         dev_err(&client->dev,
1395                                 "unable to setup iio triggered buffer\n");
1396                         return ret;
1397                 }
1398         }
1399
1400         if (client->irq && data->chip_spec->irq_thread) {
1401                 ret = devm_request_threaded_irq(&client->dev, client->irq,
1402                                                 NULL, data->chip_spec->irq_thread,
1403                                                 IRQF_TRIGGER_FALLING |
1404                                                 IRQF_ONESHOT,
1405                                                 "vcnl4000_irq",
1406                                                 indio_dev);
1407                 if (ret < 0) {
1408                         dev_err(&client->dev, "irq request failed\n");
1409                         return ret;
1410                 }
1411
1412                 ret = vcnl4010_probe_trigger(indio_dev);
1413                 if (ret < 0)
1414                         return ret;
1415         }
1416
1417         ret = pm_runtime_set_active(&client->dev);
1418         if (ret < 0)
1419                 goto fail_poweroff;
1420
1421         ret = iio_device_register(indio_dev);
1422         if (ret < 0)
1423                 goto fail_poweroff;
1424
1425         pm_runtime_enable(&client->dev);
1426         pm_runtime_set_autosuspend_delay(&client->dev, VCNL4000_SLEEP_DELAY_MS);
1427         pm_runtime_use_autosuspend(&client->dev);
1428
1429         return 0;
1430 fail_poweroff:
1431         data->chip_spec->set_power_state(data, false);
1432         return ret;
1433 }
1434
1435 static const struct of_device_id vcnl_4000_of_match[] = {
1436         {
1437                 .compatible = "vishay,vcnl4000",
1438                 .data = (void *)VCNL4000,
1439         },
1440         {
1441                 .compatible = "vishay,vcnl4010",
1442                 .data = (void *)VCNL4010,
1443         },
1444         {
1445                 .compatible = "vishay,vcnl4020",
1446                 .data = (void *)VCNL4010,
1447         },
1448         {
1449                 .compatible = "vishay,vcnl4040",
1450                 .data = (void *)VCNL4040,
1451         },
1452         {
1453                 .compatible = "vishay,vcnl4200",
1454                 .data = (void *)VCNL4200,
1455         },
1456         {},
1457 };
1458 MODULE_DEVICE_TABLE(of, vcnl_4000_of_match);
1459
1460 static void vcnl4000_remove(struct i2c_client *client)
1461 {
1462         struct iio_dev *indio_dev = i2c_get_clientdata(client);
1463         struct vcnl4000_data *data = iio_priv(indio_dev);
1464         int ret;
1465
1466         pm_runtime_dont_use_autosuspend(&client->dev);
1467         pm_runtime_disable(&client->dev);
1468         iio_device_unregister(indio_dev);
1469         pm_runtime_set_suspended(&client->dev);
1470
1471         ret = data->chip_spec->set_power_state(data, false);
1472         if (ret)
1473                 dev_warn(&client->dev, "Failed to power down (%pe)\n",
1474                          ERR_PTR(ret));
1475 }
1476
1477 static int vcnl4000_runtime_suspend(struct device *dev)
1478 {
1479         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1480         struct vcnl4000_data *data = iio_priv(indio_dev);
1481
1482         return data->chip_spec->set_power_state(data, false);
1483 }
1484
1485 static int vcnl4000_runtime_resume(struct device *dev)
1486 {
1487         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1488         struct vcnl4000_data *data = iio_priv(indio_dev);
1489
1490         return data->chip_spec->set_power_state(data, true);
1491 }
1492
1493 static DEFINE_RUNTIME_DEV_PM_OPS(vcnl4000_pm_ops, vcnl4000_runtime_suspend,
1494                                  vcnl4000_runtime_resume, NULL);
1495
1496 static struct i2c_driver vcnl4000_driver = {
1497         .driver = {
1498                 .name   = VCNL4000_DRV_NAME,
1499                 .pm     = pm_ptr(&vcnl4000_pm_ops),
1500                 .of_match_table = vcnl_4000_of_match,
1501         },
1502         .probe_new = vcnl4000_probe,
1503         .id_table = vcnl4000_id,
1504         .remove = vcnl4000_remove,
1505 };
1506
1507 module_i2c_driver(vcnl4000_driver);
1508
1509 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
1510 MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>");
1511 MODULE_DESCRIPTION("Vishay VCNL4000 proximity/ambient light sensor driver");
1512 MODULE_LICENSE("GPL");