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 #include <linux/units.h>
  28
  29 #include <linux/iio/buffer.h>
  30 #include <linux/iio/events.h>
  31 #include <linux/iio/iio.h>
  32 #include <linux/iio/sysfs.h>
  33 #include <linux/iio/trigger.h>
  34 #include <linux/iio/trigger_consumer.h>
  35 #include <linux/iio/triggered_buffer.h>
  36
  37 #define VCNL4000_DRV_NAME "vcnl4000"
  38 #define VCNL4000_PROD_ID        0x01
  39 #define VCNL4010_PROD_ID        0x02 /* for VCNL4020, VCNL4010 */
  40 #define VCNL4040_PROD_ID        0x86
  41 #define VCNL4200_PROD_ID        0x58
  42
  43 #define VCNL4000_COMMAND        0x80 /* Command register */
  44 #define VCNL4000_PROD_REV       0x81 /* Product ID and Revision ID */
  45 #define VCNL4010_PROX_RATE      0x82 /* Proximity rate */
  46 #define VCNL4000_LED_CURRENT    0x83 /* IR LED current for proximity mode */
  47 #define VCNL4000_AL_PARAM       0x84 /* Ambient light parameter register */
  48 #define VCNL4010_ALS_PARAM      0x84 /* ALS rate */
  49 #define VCNL4000_AL_RESULT_HI   0x85 /* Ambient light result register, MSB */
  50 #define VCNL4000_AL_RESULT_LO   0x86 /* Ambient light result register, LSB */
  51 #define VCNL4000_PS_RESULT_HI   0x87 /* Proximity result register, MSB */
  52 #define VCNL4000_PS_RESULT_LO   0x88 /* Proximity result register, LSB */
  53 #define VCNL4000_PS_MEAS_FREQ   0x89 /* Proximity test signal frequency */
  54 #define VCNL4010_INT_CTRL       0x89 /* Interrupt control */
  55 #define VCNL4000_PS_MOD_ADJ     0x8a /* Proximity modulator timing adjustment */
  56 #define VCNL4010_LOW_THR_HI     0x8a /* Low threshold, MSB */
  57 #define VCNL4010_LOW_THR_LO     0x8b /* Low threshold, LSB */
  58 #define VCNL4010_HIGH_THR_HI    0x8c /* High threshold, MSB */
  59 #define VCNL4010_HIGH_THR_LO    0x8d /* High threshold, LSB */
  60 #define VCNL4010_ISR            0x8e /* Interrupt status */
  61
  62 #define VCNL4200_AL_CONF        0x00 /* Ambient light configuration */
  63 #define VCNL4200_PS_CONF1       0x03 /* Proximity configuration */
  64 #define VCNL4200_PS_CONF3       0x04 /* Proximity configuration */
  65 #define VCNL4040_PS_THDL_LM     0x06 /* Proximity threshold low */
  66 #define VCNL4040_PS_THDH_LM     0x07 /* Proximity threshold high */
  67 #define VCNL4040_ALS_THDL_LM    0x02 /* Ambient light threshold low */
  68 #define VCNL4040_ALS_THDH_LM    0x01 /* Ambient light threshold high */
  69 #define VCNL4200_PS_DATA        0x08 /* Proximity data */
  70 #define VCNL4200_AL_DATA        0x09 /* Ambient light data */
  71 #define VCNL4040_INT_FLAGS      0x0b /* Interrupt register */
  72 #define VCNL4200_INT_FLAGS      0x0d /* Interrupt register */
  73 #define VCNL4200_DEV_ID         0x0e /* Device ID, slave address and version */
  74
  75 #define VCNL4040_DEV_ID         0x0c /* Device ID and version */
  76
  77 /* Bit masks for COMMAND register */
  78 #define VCNL4000_AL_RDY         BIT(6) /* ALS data ready? */
  79 #define VCNL4000_PS_RDY         BIT(5) /* proximity data ready? */
  80 #define VCNL4000_AL_OD          BIT(4) /* start on-demand ALS measurement */
  81 #define VCNL4000_PS_OD          BIT(3) /* start on-demand proximity measurement */
  82 #define VCNL4000_ALS_EN         BIT(2) /* start ALS measurement */
  83 #define VCNL4000_PROX_EN        BIT(1) /* start proximity measurement */
  84 #define VCNL4000_SELF_TIMED_EN  BIT(0) /* start self-timed measurement */
  85
  86 #define VCNL4040_ALS_CONF_ALS_SHUTDOWN  BIT(0)
  87 #define VCNL4040_ALS_CONF_IT            GENMASK(7, 6) /* Ambient integration time */
  88 #define VCNL4040_ALS_CONF_INT_EN        BIT(1) /* Ambient light Interrupt enable */
  89 #define VCNL4040_ALS_CONF_PERS  GENMASK(3, 2) /* Ambient interrupt persistence setting */
  90 #define VCNL4040_PS_CONF1_PS_SHUTDOWN   BIT(0)
  91 #define VCNL4040_PS_CONF2_PS_IT GENMASK(3, 1) /* Proximity integration time */
  92 #define VCNL4040_CONF1_PS_PERS  GENMASK(5, 4) /* Proximity interrupt persistence setting */
  93 #define VCNL4040_PS_CONF2_PS_HD         BIT(11) /* Proximity high definition */
  94 #define VCNL4040_PS_CONF2_PS_INT        GENMASK(9, 8) /* Proximity interrupt mode */
  95 #define VCNL4040_PS_CONF3_MPS           GENMASK(6, 5) /* Proximity multi pulse number */
  96 #define VCNL4040_PS_MS_LED_I            GENMASK(10, 8) /* Proximity current */
  97 #define VCNL4040_PS_IF_AWAY             BIT(8) /* Proximity event cross low threshold */
  98 #define VCNL4040_PS_IF_CLOSE            BIT(9) /* Proximity event cross high threshold */
  99 #define VCNL4040_ALS_RISING             BIT(12) /* Ambient Light cross high threshold */
 100 #define VCNL4040_ALS_FALLING            BIT(13) /* Ambient Light cross low threshold */
 101
 102 /* Bit masks for interrupt registers. */
 103 #define VCNL4010_INT_THR_SEL    BIT(0) /* Select threshold interrupt source */
 104 #define VCNL4010_INT_THR_EN     BIT(1) /* Threshold interrupt type */
 105 #define VCNL4010_INT_ALS_EN     BIT(2) /* Enable on ALS data ready */
 106 #define VCNL4010_INT_PROX_EN    BIT(3) /* Enable on proximity data ready */
 107
 108 #define VCNL4010_INT_THR_HIGH   0 /* High threshold exceeded */
 109 #define VCNL4010_INT_THR_LOW    1 /* Low threshold exceeded */
 110 #define VCNL4010_INT_ALS        2 /* ALS data ready */
 111 #define VCNL4010_INT_PROXIMITY  3 /* Proximity data ready */
 112
 113 #define VCNL4010_INT_THR \
 114         (BIT(VCNL4010_INT_THR_LOW) | BIT(VCNL4010_INT_THR_HIGH))
 115 #define VCNL4010_INT_DRDY \
 116         (BIT(VCNL4010_INT_PROXIMITY) | BIT(VCNL4010_INT_ALS))
 117
 118 #define VCNL4040_CONF3_PS_MPS_16BITS    3       /* 8 multi pulses */
 119 #define VCNL4040_CONF3_PS_LED_I_16BITS  3       /* 120 mA */
 120
 121 #define VCNL4040_CONF3_PS_SAMPLE_16BITS \
 122         (FIELD_PREP(VCNL4040_PS_CONF3_MPS, VCNL4040_CONF3_PS_MPS_16BITS) | \
 123          FIELD_PREP(VCNL4040_PS_MS_LED_I, VCNL4040_CONF3_PS_LED_I_16BITS))
 124
 125 static const int vcnl4010_prox_sampling_frequency[][2] = {
 126         {1, 950000},
 127         {3, 906250},
 128         {7, 812500},
 129         {16, 625000},
 130         {31, 250000},
 131         {62, 500000},
 132         {125, 0},
 133         {250, 0},
 134 };
 135
 136 static const int vcnl4040_ps_it_times[][2] = {
 137         {0, 100},
 138         {0, 150},
 139         {0, 200},
 140         {0, 250},
 141         {0, 300},
 142         {0, 350},
 143         {0, 400},
 144         {0, 800},
 145 };
 146
 147 static const int vcnl4200_ps_it_times[][2] = {
 148         {0, 96},
 149         {0, 144},
 150         {0, 192},
 151         {0, 384},
 152         {0, 768},
 153         {0, 864},
 154 };
 155
 156 static const int vcnl4040_als_it_times[][2] = {
 157         {0, 80000},
 158         {0, 160000},
 159         {0, 320000},
 160         {0, 640000},
 161 };
 162
 163 static const int vcnl4200_als_it_times[][2] = {
 164         {0, 50000},
 165         {0, 100000},
 166         {0, 200000},
 167         {0, 400000},
 168 };
 169
 170 static const int vcnl4040_ps_calibbias_ua[][2] = {
 171         {0, 50000},
 172         {0, 75000},
 173         {0, 100000},
 174         {0, 120000},
 175         {0, 140000},
 176         {0, 160000},
 177         {0, 180000},
 178         {0, 200000},
 179 };
 180
 181 static const int vcnl4040_als_persistence[] = {1, 2, 4, 8};
 182 static const int vcnl4040_ps_persistence[] = {1, 2, 3, 4};
 183 static const int vcnl4040_ps_oversampling_ratio[] = {1, 2, 4, 8};
 184
 185 #define VCNL4000_SLEEP_DELAY_MS 2000 /* before we enter pm_runtime_suspend */
 186
 187 enum vcnl4000_device_ids {
 188         VCNL4000,
 189         VCNL4010,
 190         VCNL4040,
 191         VCNL4200,
 192 };
 193
 194 struct vcnl4200_channel {
 195         u8 reg;
 196         ktime_t last_measurement;
 197         ktime_t sampling_rate;
 198         struct mutex lock;
 199 };
 200
 201 struct vcnl4000_data {
 202         struct i2c_client *client;
 203         enum vcnl4000_device_ids id;
 204         int rev;
 205         int al_scale;
 206         int ps_scale;
 207         u8 ps_int;              /* proximity interrupt mode */
 208         u8 als_int;             /* ambient light interrupt mode*/
 209         const struct vcnl4000_chip_spec *chip_spec;
 210         struct mutex vcnl4000_lock;
 211         struct vcnl4200_channel vcnl4200_al;
 212         struct vcnl4200_channel vcnl4200_ps;
 213         uint32_t near_level;
 214 };
 215
 216 struct vcnl4000_chip_spec {
 217         const char *prod;
 218         struct iio_chan_spec const *channels;
 219         const int num_channels;
 220         const struct iio_info *info;
 221         const struct iio_buffer_setup_ops *buffer_setup_ops;
 222         int (*init)(struct vcnl4000_data *data);
 223         int (*measure_light)(struct vcnl4000_data *data, int *val);
 224         int (*measure_proximity)(struct vcnl4000_data *data, int *val);
 225         int (*set_power_state)(struct vcnl4000_data *data, bool on);
 226         irqreturn_t (*irq_thread)(int irq, void *priv);
 227         irqreturn_t (*trig_buffer_func)(int irq, void *priv);
 228
 229         u8 int_reg;
 230         const int(*ps_it_times)[][2];
 231         const int num_ps_it_times;
 232         const int(*als_it_times)[][2];
 233         const int num_als_it_times;
 234         const unsigned int ulux_step;
 235 };
 236
 237 static const struct i2c_device_id vcnl4000_id[] = {
 238         { "vcnl4000", VCNL4000 },
 239         { "vcnl4010", VCNL4010 },
 240         { "vcnl4020", VCNL4010 },
 241         { "vcnl4040", VCNL4040 },
 242         { "vcnl4200", VCNL4200 },
 243         { }
 244 };
 245 MODULE_DEVICE_TABLE(i2c, vcnl4000_id);
 246
 247 static int vcnl4000_set_power_state(struct vcnl4000_data *data, bool on)
 248 {
 249         /* no suspend op */
 250         return 0;
 251 }
 252
 253 static int vcnl4000_init(struct vcnl4000_data *data)
 254 {
 255         int ret, prod_id;
 256
 257         ret = i2c_smbus_read_byte_data(data->client, VCNL4000_PROD_REV);
 258         if (ret < 0)
 259                 return ret;
 260
 261         prod_id = ret >> 4;
 262         switch (prod_id) {
 263         case VCNL4000_PROD_ID:
 264                 if (data->id != VCNL4000)
 265                         dev_warn(&data->client->dev,
 266                                         "wrong device id, use vcnl4000");
 267                 break;
 268         case VCNL4010_PROD_ID:
 269                 if (data->id != VCNL4010)
 270                         dev_warn(&data->client->dev,
 271                                         "wrong device id, use vcnl4010/4020");
 272                 break;
 273         default:
 274                 return -ENODEV;
 275         }
 276
 277         data->rev = ret & 0xf;
 278         data->al_scale = 250000;
 279
 280         return data->chip_spec->set_power_state(data, true);
 281 };
 282
 283 static ssize_t vcnl4000_write_als_enable(struct vcnl4000_data *data, bool en)
 284 {
 285         int ret;
 286
 287         mutex_lock(&data->vcnl4000_lock);
 288
 289         ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
 290         if (ret < 0)
 291                 goto out;
 292
 293         if (en)
 294                 ret &= ~VCNL4040_ALS_CONF_ALS_SHUTDOWN;
 295         else
 296                 ret |= VCNL4040_ALS_CONF_ALS_SHUTDOWN;
 297
 298         ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF, ret);
 299
 300 out:
 301         mutex_unlock(&data->vcnl4000_lock);
 302
 303         return ret;
 304 }
 305
 306 static ssize_t vcnl4000_write_ps_enable(struct vcnl4000_data *data, bool en)
 307 {
 308         int ret;
 309
 310         mutex_lock(&data->vcnl4000_lock);
 311
 312         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 313         if (ret < 0)
 314                 goto out;
 315
 316         if (en)
 317                 ret &= ~VCNL4040_PS_CONF1_PS_SHUTDOWN;
 318         else
 319                 ret |= VCNL4040_PS_CONF1_PS_SHUTDOWN;
 320
 321         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, ret);
 322
 323 out:
 324         mutex_unlock(&data->vcnl4000_lock);
 325
 326         return ret;
 327 }
 328
 329 static int vcnl4200_set_power_state(struct vcnl4000_data *data, bool on)
 330 {
 331         int ret;
 332
 333         /* Do not power down if interrupts are enabled */
 334         if (!on && (data->ps_int || data->als_int))
 335                 return 0;
 336
 337         ret = vcnl4000_write_als_enable(data, on);
 338         if (ret < 0)
 339                 return ret;
 340
 341         ret = vcnl4000_write_ps_enable(data, on);
 342         if (ret < 0)
 343                 return ret;
 344
 345         if (on) {
 346                 /* Wait at least one integration cycle before fetching data */
 347                 data->vcnl4200_al.last_measurement = ktime_get();
 348                 data->vcnl4200_ps.last_measurement = ktime_get();
 349         }
 350
 351         return 0;
 352 }
 353
 354 static int vcnl4200_init(struct vcnl4000_data *data)
 355 {
 356         int ret, id;
 357         u16 regval;
 358
 359         ret = i2c_smbus_read_word_data(data->client, VCNL4200_DEV_ID);
 360         if (ret < 0)
 361                 return ret;
 362
 363         id = ret & 0xff;
 364
 365         if (id != VCNL4200_PROD_ID) {
 366                 ret = i2c_smbus_read_word_data(data->client, VCNL4040_DEV_ID);
 367                 if (ret < 0)
 368                         return ret;
 369
 370                 id = ret & 0xff;
 371
 372                 if (id != VCNL4040_PROD_ID)
 373                         return -ENODEV;
 374         }
 375
 376         dev_dbg(&data->client->dev, "device id 0x%x", id);
 377
 378         data->rev = (ret >> 8) & 0xf;
 379         data->ps_int = 0;
 380         data->als_int = 0;
 381
 382         data->vcnl4200_al.reg = VCNL4200_AL_DATA;
 383         data->vcnl4200_ps.reg = VCNL4200_PS_DATA;
 384         switch (id) {
 385         case VCNL4200_PROD_ID:
 386                 /* Default wait time is 50ms, add 20% tolerance. */
 387                 data->vcnl4200_al.sampling_rate = ktime_set(0, 60000 * 1000);
 388                 /* Default wait time is 4.8ms, add 20% tolerance. */
 389                 data->vcnl4200_ps.sampling_rate = ktime_set(0, 5760 * 1000);
 390                 break;
 391         case VCNL4040_PROD_ID:
 392                 /* Default wait time is 80ms, add 20% tolerance. */
 393                 data->vcnl4200_al.sampling_rate = ktime_set(0, 96000 * 1000);
 394                 /* Default wait time is 5ms, add 20% tolerance. */
 395                 data->vcnl4200_ps.sampling_rate = ktime_set(0, 6000 * 1000);
 396                 break;
 397         }
 398         data->al_scale = data->chip_spec->ulux_step;
 399         data->ps_scale = 16;
 400         mutex_init(&data->vcnl4200_al.lock);
 401         mutex_init(&data->vcnl4200_ps.lock);
 402
 403         /* Use 16 bits proximity sensor readings */
 404         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 405         if (ret < 0)
 406                 return ret;
 407
 408         regval = ret | VCNL4040_PS_CONF2_PS_HD;
 409         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1,
 410                                         regval);
 411         if (ret < 0)
 412                 return ret;
 413
 414         /* Align proximity sensor sample rate to 16 bits data width */
 415         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3);
 416         if (ret < 0)
 417                 return ret;
 418
 419         regval = ret | VCNL4040_CONF3_PS_SAMPLE_16BITS;
 420         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF3,
 421                                         regval);
 422         if (ret < 0)
 423                 return ret;
 424
 425         ret = data->chip_spec->set_power_state(data, true);
 426         if (ret < 0)
 427                 return ret;
 428
 429         return 0;
 430 };
 431
 432 static int vcnl4000_read_data(struct vcnl4000_data *data, u8 data_reg, int *val)
 433 {
 434         s32 ret;
 435
 436         ret = i2c_smbus_read_word_swapped(data->client, data_reg);
 437         if (ret < 0)
 438                 return ret;
 439
 440         *val = ret;
 441         return 0;
 442 }
 443
 444 static int vcnl4000_write_data(struct vcnl4000_data *data, u8 data_reg, int val)
 445 {
 446         if (val > U16_MAX)
 447                 return -ERANGE;
 448
 449         return i2c_smbus_write_word_swapped(data->client, data_reg, val);
 450 }
 451
 452
 453 static int vcnl4000_measure(struct vcnl4000_data *data, u8 req_mask,
 454                                 u8 rdy_mask, u8 data_reg, int *val)
 455 {
 456         int tries = 20;
 457         int ret;
 458
 459         mutex_lock(&data->vcnl4000_lock);
 460
 461         ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND,
 462                                         req_mask);
 463         if (ret < 0)
 464                 goto fail;
 465
 466         /* wait for data to become ready */
 467         while (tries--) {
 468                 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND);
 469                 if (ret < 0)
 470                         goto fail;
 471                 if (ret & rdy_mask)
 472                         break;
 473                 msleep(20); /* measurement takes up to 100 ms */
 474         }
 475
 476         if (tries < 0) {
 477                 dev_err(&data->client->dev,
 478                         "vcnl4000_measure() failed, data not ready\n");
 479                 ret = -EIO;
 480                 goto fail;
 481         }
 482
 483         ret = vcnl4000_read_data(data, data_reg, val);
 484         if (ret < 0)
 485                 goto fail;
 486
 487         mutex_unlock(&data->vcnl4000_lock);
 488
 489         return 0;
 490
 491 fail:
 492         mutex_unlock(&data->vcnl4000_lock);
 493         return ret;
 494 }
 495
 496 static int vcnl4200_measure(struct vcnl4000_data *data,
 497                 struct vcnl4200_channel *chan, int *val)
 498 {
 499         int ret;
 500         s64 delta;
 501         ktime_t next_measurement;
 502
 503         mutex_lock(&chan->lock);
 504
 505         next_measurement = ktime_add(chan->last_measurement,
 506                         chan->sampling_rate);
 507         delta = ktime_us_delta(next_measurement, ktime_get());
 508         if (delta > 0)
 509                 usleep_range(delta, delta + 500);
 510         chan->last_measurement = ktime_get();
 511
 512         mutex_unlock(&chan->lock);
 513
 514         ret = i2c_smbus_read_word_data(data->client, chan->reg);
 515         if (ret < 0)
 516                 return ret;
 517
 518         *val = ret;
 519
 520         return 0;
 521 }
 522
 523 static int vcnl4000_measure_light(struct vcnl4000_data *data, int *val)
 524 {
 525         return vcnl4000_measure(data,
 526                         VCNL4000_AL_OD, VCNL4000_AL_RDY,
 527                         VCNL4000_AL_RESULT_HI, val);
 528 }
 529
 530 static int vcnl4200_measure_light(struct vcnl4000_data *data, int *val)
 531 {
 532         return vcnl4200_measure(data, &data->vcnl4200_al, val);
 533 }
 534
 535 static int vcnl4000_measure_proximity(struct vcnl4000_data *data, int *val)
 536 {
 537         return vcnl4000_measure(data,
 538                         VCNL4000_PS_OD, VCNL4000_PS_RDY,
 539                         VCNL4000_PS_RESULT_HI, val);
 540 }
 541
 542 static int vcnl4200_measure_proximity(struct vcnl4000_data *data, int *val)
 543 {
 544         return vcnl4200_measure(data, &data->vcnl4200_ps, val);
 545 }
 546
 547 static int vcnl4010_read_proxy_samp_freq(struct vcnl4000_data *data, int *val,
 548                                          int *val2)
 549 {
 550         int ret;
 551
 552         ret = i2c_smbus_read_byte_data(data->client, VCNL4010_PROX_RATE);
 553         if (ret < 0)
 554                 return ret;
 555
 556         if (ret >= ARRAY_SIZE(vcnl4010_prox_sampling_frequency))
 557                 return -EINVAL;
 558
 559         *val = vcnl4010_prox_sampling_frequency[ret][0];
 560         *val2 = vcnl4010_prox_sampling_frequency[ret][1];
 561
 562         return 0;
 563 }
 564
 565 static bool vcnl4010_is_in_periodic_mode(struct vcnl4000_data *data)
 566 {
 567         int ret;
 568
 569         ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND);
 570         if (ret < 0)
 571                 return false;
 572
 573         return !!(ret & VCNL4000_SELF_TIMED_EN);
 574 }
 575
 576 static int vcnl4000_set_pm_runtime_state(struct vcnl4000_data *data, bool on)
 577 {
 578         struct device *dev = &data->client->dev;
 579         int ret;
 580
 581         if (on) {
 582                 ret = pm_runtime_resume_and_get(dev);
 583         } else {
 584                 pm_runtime_mark_last_busy(dev);
 585                 ret = pm_runtime_put_autosuspend(dev);
 586         }
 587
 588         return ret;
 589 }
 590
 591 static int vcnl4040_read_als_it(struct vcnl4000_data *data, int *val, int *val2)
 592 {
 593         int ret;
 594
 595         ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
 596         if (ret < 0)
 597                 return ret;
 598
 599         ret = FIELD_GET(VCNL4040_ALS_CONF_IT, ret);
 600         if (ret >= data->chip_spec->num_als_it_times)
 601                 return -EINVAL;
 602
 603         *val = (*data->chip_spec->als_it_times)[ret][0];
 604         *val2 = (*data->chip_spec->als_it_times)[ret][1];
 605
 606         return 0;
 607 }
 608
 609 static ssize_t vcnl4040_write_als_it(struct vcnl4000_data *data, int val)
 610 {
 611         unsigned int i;
 612         int ret;
 613         u16 regval;
 614
 615         for (i = 0; i < data->chip_spec->num_als_it_times; i++) {
 616                 if (val == (*data->chip_spec->als_it_times)[i][1])
 617                         break;
 618         }
 619
 620         if (i == data->chip_spec->num_als_it_times)
 621                 return -EINVAL;
 622
 623         data->vcnl4200_al.sampling_rate = ktime_set(0, val * 1200);
 624         data->al_scale = div_u64(mul_u32_u32(data->chip_spec->ulux_step,
 625                          (*data->chip_spec->als_it_times)[0][1]),
 626                          val);
 627
 628         mutex_lock(&data->vcnl4000_lock);
 629
 630         ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
 631         if (ret < 0)
 632                 goto out_unlock;
 633
 634         regval = FIELD_PREP(VCNL4040_ALS_CONF_IT, i);
 635         regval |= (ret & ~VCNL4040_ALS_CONF_IT);
 636         ret = i2c_smbus_write_word_data(data->client,
 637                                         VCNL4200_AL_CONF,
 638                                         regval);
 639
 640 out_unlock:
 641         mutex_unlock(&data->vcnl4000_lock);
 642         return ret;
 643 }
 644
 645 static int vcnl4040_read_ps_it(struct vcnl4000_data *data, int *val, int *val2)
 646 {
 647         int ret;
 648
 649         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 650         if (ret < 0)
 651                 return ret;
 652
 653         ret = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret);
 654
 655         if (ret >= data->chip_spec->num_ps_it_times)
 656                 return -EINVAL;
 657
 658         *val = (*data->chip_spec->ps_it_times)[ret][0];
 659         *val2 = (*data->chip_spec->ps_it_times)[ret][1];
 660
 661         return 0;
 662 }
 663
 664 static ssize_t vcnl4040_write_ps_it(struct vcnl4000_data *data, int val)
 665 {
 666         unsigned int i;
 667         int ret, index = -1;
 668         u16 regval;
 669
 670         for (i = 0; i < data->chip_spec->num_ps_it_times; i++) {
 671                 if (val == (*data->chip_spec->ps_it_times)[i][1]) {
 672                         index = i;
 673                         break;
 674                 }
 675         }
 676
 677         if (index < 0)
 678                 return -EINVAL;
 679
 680         data->vcnl4200_ps.sampling_rate = ktime_set(0, val * 60 * NSEC_PER_USEC);
 681
 682         mutex_lock(&data->vcnl4000_lock);
 683
 684         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 685         if (ret < 0)
 686                 goto out;
 687
 688         regval = (ret & ~VCNL4040_PS_CONF2_PS_IT) |
 689             FIELD_PREP(VCNL4040_PS_CONF2_PS_IT, index);
 690         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1,
 691                                         regval);
 692
 693 out:
 694         mutex_unlock(&data->vcnl4000_lock);
 695         return ret;
 696 }
 697
 698 static ssize_t vcnl4040_read_als_period(struct vcnl4000_data *data, int *val, int *val2)
 699 {
 700         int ret, ret_pers, it;
 701         int64_t val_c;
 702
 703         ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
 704         if (ret < 0)
 705                 return ret;
 706
 707         ret_pers = FIELD_GET(VCNL4040_ALS_CONF_PERS, ret);
 708         if (ret_pers >= ARRAY_SIZE(vcnl4040_als_persistence))
 709                 return -EINVAL;
 710
 711         it = FIELD_GET(VCNL4040_ALS_CONF_IT, ret);
 712         if (it >= data->chip_spec->num_als_it_times)
 713                 return -EINVAL;
 714
 715         val_c = mul_u32_u32((*data->chip_spec->als_it_times)[it][1],
 716                             vcnl4040_als_persistence[ret_pers]);
 717         *val = div_u64_rem(val_c, MICRO, val2);
 718
 719         return IIO_VAL_INT_PLUS_MICRO;
 720 }
 721
 722 static ssize_t vcnl4040_write_als_period(struct vcnl4000_data *data, int val, int val2)
 723 {
 724         unsigned int i;
 725         int ret, it;
 726         u16 regval;
 727         u64 val_n = mul_u32_u32(val, MICRO) + val2;
 728
 729         ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
 730         if (ret < 0)
 731                 return ret;
 732
 733         it = FIELD_GET(VCNL4040_ALS_CONF_IT, ret);
 734         if (it >= data->chip_spec->num_als_it_times)
 735                 return -EINVAL;
 736
 737         for (i = 0; i < ARRAY_SIZE(vcnl4040_als_persistence) - 1; i++) {
 738                 if (val_n < mul_u32_u32(vcnl4040_als_persistence[i],
 739                                         (*data->chip_spec->als_it_times)[it][1]))
 740                         break;
 741         }
 742
 743         mutex_lock(&data->vcnl4000_lock);
 744
 745         ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
 746         if (ret < 0)
 747                 goto out_unlock;
 748
 749         regval = FIELD_PREP(VCNL4040_ALS_CONF_PERS, i);
 750         regval |= (ret & ~VCNL4040_ALS_CONF_PERS);
 751         ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF,
 752                                         regval);
 753
 754 out_unlock:
 755         mutex_unlock(&data->vcnl4000_lock);
 756         return ret;
 757 }
 758
 759 static ssize_t vcnl4040_read_ps_period(struct vcnl4000_data *data, int *val, int *val2)
 760 {
 761         int ret, ret_pers, it;
 762
 763         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 764         if (ret < 0)
 765                 return ret;
 766
 767         ret_pers = FIELD_GET(VCNL4040_CONF1_PS_PERS, ret);
 768         if (ret_pers >= ARRAY_SIZE(vcnl4040_ps_persistence))
 769                 return -EINVAL;
 770
 771         it = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret);
 772         if (it >= data->chip_spec->num_ps_it_times)
 773                 return -EINVAL;
 774
 775         *val = (*data->chip_spec->ps_it_times)[it][0];
 776         *val2 = (*data->chip_spec->ps_it_times)[it][1] *
 777                 vcnl4040_ps_persistence[ret_pers];
 778
 779         return IIO_VAL_INT_PLUS_MICRO;
 780 }
 781
 782 static ssize_t vcnl4040_write_ps_period(struct vcnl4000_data *data, int val, int val2)
 783 {
 784         int ret, it, i;
 785         u16 regval;
 786
 787         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 788         if (ret < 0)
 789                 return ret;
 790
 791         it = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret);
 792         if (it >= data->chip_spec->num_ps_it_times)
 793                 return -EINVAL;
 794
 795         if (val > 0)
 796                 i = ARRAY_SIZE(vcnl4040_ps_persistence) - 1;
 797         else {
 798                 for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_persistence) - 1; i++) {
 799                         if (val2 <= vcnl4040_ps_persistence[i] *
 800                                         (*data->chip_spec->ps_it_times)[it][1])
 801                                 break;
 802                 }
 803         }
 804
 805         mutex_lock(&data->vcnl4000_lock);
 806
 807         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
 808         if (ret < 0)
 809                 goto out_unlock;
 810
 811         regval = FIELD_PREP(VCNL4040_CONF1_PS_PERS, i);
 812         regval |= (ret & ~VCNL4040_CONF1_PS_PERS);
 813         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1,
 814                                         regval);
 815
 816 out_unlock:
 817         mutex_unlock(&data->vcnl4000_lock);
 818         return ret;
 819 }
 820
 821 static ssize_t vcnl4040_read_ps_oversampling_ratio(struct vcnl4000_data *data, int *val)
 822 {
 823         int ret;
 824
 825         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3);
 826         if (ret < 0)
 827                 return ret;
 828
 829         ret = FIELD_GET(VCNL4040_PS_CONF3_MPS, ret);
 830         if (ret >= ARRAY_SIZE(vcnl4040_ps_oversampling_ratio))
 831                 return -EINVAL;
 832
 833         *val = vcnl4040_ps_oversampling_ratio[ret];
 834
 835         return ret;
 836 }
 837
 838 static ssize_t vcnl4040_write_ps_oversampling_ratio(struct vcnl4000_data *data, int val)
 839 {
 840         unsigned int i;
 841         int ret;
 842         u16 regval;
 843
 844         for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_oversampling_ratio); i++) {
 845                 if (val == vcnl4040_ps_oversampling_ratio[i])
 846                         break;
 847         }
 848
 849         if (i >= ARRAY_SIZE(vcnl4040_ps_oversampling_ratio))
 850                 return -EINVAL;
 851
 852         mutex_lock(&data->vcnl4000_lock);
 853
 854         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3);
 855         if (ret < 0)
 856                 goto out_unlock;
 857
 858         regval = FIELD_PREP(VCNL4040_PS_CONF3_MPS, i);
 859         regval |= (ret & ~VCNL4040_PS_CONF3_MPS);
 860         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF3,
 861                                         regval);
 862
 863 out_unlock:
 864         mutex_unlock(&data->vcnl4000_lock);
 865         return ret;
 866 }
 867
 868 static ssize_t vcnl4040_read_ps_calibbias(struct vcnl4000_data *data, int *val, int *val2)
 869 {
 870         int ret;
 871
 872         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3);
 873         if (ret < 0)
 874                 return ret;
 875
 876         ret = FIELD_GET(VCNL4040_PS_MS_LED_I, ret);
 877         if (ret >= ARRAY_SIZE(vcnl4040_ps_calibbias_ua))
 878                 return -EINVAL;
 879
 880         *val = vcnl4040_ps_calibbias_ua[ret][0];
 881         *val2 = vcnl4040_ps_calibbias_ua[ret][1];
 882
 883         return ret;
 884 }
 885
 886 static ssize_t vcnl4040_write_ps_calibbias(struct vcnl4000_data *data, int val)
 887 {
 888         unsigned int i;
 889         int ret;
 890         u16 regval;
 891
 892         for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_calibbias_ua); i++) {
 893                 if (val == vcnl4040_ps_calibbias_ua[i][1])
 894                         break;
 895         }
 896
 897         if (i >= ARRAY_SIZE(vcnl4040_ps_calibbias_ua))
 898                 return -EINVAL;
 899
 900         mutex_lock(&data->vcnl4000_lock);
 901
 902         ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3);
 903         if (ret < 0)
 904                 goto out_unlock;
 905
 906         regval = (ret & ~VCNL4040_PS_MS_LED_I);
 907         regval |= FIELD_PREP(VCNL4040_PS_MS_LED_I, i);
 908         ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF3,
 909                                         regval);
 910
 911 out_unlock:
 912         mutex_unlock(&data->vcnl4000_lock);
 913         return ret;
 914 }
 915
 916 static int vcnl4000_read_raw(struct iio_dev *indio_dev,
 917                                 struct iio_chan_spec const *chan,
 918                                 int *val, int *val2, long mask)
 919 {
 920         int ret;
 921         struct vcnl4000_data *data = iio_priv(indio_dev);
 922
 923         switch (mask) {
 924         case IIO_CHAN_INFO_RAW:
 925                 ret = vcnl4000_set_pm_runtime_state(data, true);
 926                 if  (ret < 0)
 927                         return ret;
 928
 929                 switch (chan->type) {
 930                 case IIO_LIGHT:
 931                         ret = data->chip_spec->measure_light(data, val);
 932                         if (!ret)
 933                                 ret = IIO_VAL_INT;
 934                         break;
 935                 case IIO_PROXIMITY:
 936                         ret = data->chip_spec->measure_proximity(data, val);
 937                         *val2 = data->ps_scale;
 938                         if (!ret)
 939                                 ret = IIO_VAL_FRACTIONAL;
 940                         break;
 941                 default:
 942                         ret = -EINVAL;
 943                 }
 944                 vcnl4000_set_pm_runtime_state(data, false);
 945                 return ret;
 946         case IIO_CHAN_INFO_SCALE:
 947                 if (chan->type != IIO_LIGHT)
 948                         return -EINVAL;
 949
 950                 *val = 0;
 951                 *val2 = data->al_scale;
 952                 return IIO_VAL_INT_PLUS_MICRO;
 953         case IIO_CHAN_INFO_INT_TIME:
 954                 switch (chan->type) {
 955                 case IIO_LIGHT:
 956                         ret = vcnl4040_read_als_it(data, val, val2);
 957                         break;
 958                 case IIO_PROXIMITY:
 959                         ret = vcnl4040_read_ps_it(data, val, val2);
 960                         break;
 961                 default:
 962                         return -EINVAL;
 963                 }
 964                 if (ret < 0)
 965                         return ret;
 966                 return IIO_VAL_INT_PLUS_MICRO;
 967         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
 968                 switch (chan->type) {
 969                 case IIO_PROXIMITY:
 970                         ret = vcnl4040_read_ps_oversampling_ratio(data, val);
 971                         if (ret < 0)
 972                                 return ret;
 973                         return IIO_VAL_INT;
 974                 default:
 975                         return -EINVAL;
 976                 }
 977         case IIO_CHAN_INFO_CALIBBIAS:
 978                 switch (chan->type) {
 979                 case IIO_PROXIMITY:
 980                         ret = vcnl4040_read_ps_calibbias(data, val, val2);
 981                         if (ret < 0)
 982                                 return ret;
 983                         return IIO_VAL_INT_PLUS_MICRO;
 984                 default:
 985                         return -EINVAL;
 986                 }
 987         default:
 988                 return -EINVAL;
 989         }
 990 }
 991
 992 static int vcnl4040_write_raw(struct iio_dev *indio_dev,
 993                               struct iio_chan_spec const *chan,
 994                               int val, int val2, long mask)
 995 {
 996         struct vcnl4000_data *data = iio_priv(indio_dev);
 997
 998         switch (mask) {
 999         case IIO_CHAN_INFO_INT_TIME:
1000                 if (val != 0)
1001                         return -EINVAL;
1002                 switch (chan->type) {
1003                 case IIO_LIGHT:
1004                         return vcnl4040_write_als_it(data, val2);
1005                 case IIO_PROXIMITY:
1006                         return vcnl4040_write_ps_it(data, val2);
1007                 default:
1008                         return -EINVAL;
1009                 }
1010         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
1011                 switch (chan->type) {
1012                 case IIO_PROXIMITY:
1013                         return vcnl4040_write_ps_oversampling_ratio(data, val);
1014                 default:
1015                         return -EINVAL;
1016                 }
1017         case IIO_CHAN_INFO_CALIBBIAS:
1018                 switch (chan->type) {
1019                 case IIO_PROXIMITY:
1020                         return vcnl4040_write_ps_calibbias(data, val2);
1021                 default:
1022                         return -EINVAL;
1023                 }
1024         default:
1025                 return -EINVAL;
1026         }
1027 }
1028
1029 static int vcnl4040_read_avail(struct iio_dev *indio_dev,
1030                                struct iio_chan_spec const *chan,
1031                                const int **vals, int *type, int *length,
1032                                long mask)
1033 {
1034         struct vcnl4000_data *data = iio_priv(indio_dev);
1035
1036         switch (mask) {
1037         case IIO_CHAN_INFO_INT_TIME:
1038                 switch (chan->type) {
1039                 case IIO_LIGHT:
1040                         *vals = (int *)(*data->chip_spec->als_it_times);
1041                         *length = 2 * data->chip_spec->num_als_it_times;
1042                         break;
1043                 case IIO_PROXIMITY:
1044                         *vals = (int *)(*data->chip_spec->ps_it_times);
1045                         *length = 2 * data->chip_spec->num_ps_it_times;
1046                         break;
1047                 default:
1048                         return -EINVAL;
1049                 }
1050                 *type = IIO_VAL_INT_PLUS_MICRO;
1051                 return IIO_AVAIL_LIST;
1052         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
1053                 switch (chan->type) {
1054                 case IIO_PROXIMITY:
1055                         *vals = (int *)vcnl4040_ps_oversampling_ratio;
1056                         *length = ARRAY_SIZE(vcnl4040_ps_oversampling_ratio);
1057                         *type = IIO_VAL_INT;
1058                         return IIO_AVAIL_LIST;
1059                 default:
1060                         return -EINVAL;
1061                 }
1062         case IIO_CHAN_INFO_CALIBBIAS:
1063                 switch (chan->type) {
1064                 case IIO_PROXIMITY:
1065                         *vals = (int *)vcnl4040_ps_calibbias_ua;
1066                         *length = 2 * ARRAY_SIZE(vcnl4040_ps_calibbias_ua);
1067                         *type = IIO_VAL_INT_PLUS_MICRO;
1068                         return IIO_AVAIL_LIST;
1069                 default:
1070                         return -EINVAL;
1071                 }
1072         default:
1073                 return -EINVAL;
1074         }
1075 }
1076
1077 static int vcnl4010_read_raw(struct iio_dev *indio_dev,
1078                              struct iio_chan_spec const *chan,
1079                              int *val, int *val2, long mask)
1080 {
1081         int ret;
1082         struct vcnl4000_data *data = iio_priv(indio_dev);
1083
1084         switch (mask) {
1085         case IIO_CHAN_INFO_RAW:
1086         case IIO_CHAN_INFO_SCALE:
1087                 ret = iio_device_claim_direct_mode(indio_dev);
1088                 if (ret)
1089                         return ret;
1090
1091                 /* Protect against event capture. */
1092                 if (vcnl4010_is_in_periodic_mode(data)) {
1093                         ret = -EBUSY;
1094                 } else {
1095                         ret = vcnl4000_read_raw(indio_dev, chan, val, val2,
1096                                                 mask);
1097                 }
1098
1099                 iio_device_release_direct_mode(indio_dev);
1100                 return ret;
1101         case IIO_CHAN_INFO_SAMP_FREQ:
1102                 switch (chan->type) {
1103                 case IIO_PROXIMITY:
1104                         ret = vcnl4010_read_proxy_samp_freq(data, val, val2);
1105                         if (ret < 0)
1106                                 return ret;
1107                         return IIO_VAL_INT_PLUS_MICRO;
1108                 default:
1109                         return -EINVAL;
1110                 }
1111         default:
1112                 return -EINVAL;
1113         }
1114 }
1115
1116 static int vcnl4010_read_avail(struct iio_dev *indio_dev,
1117                                struct iio_chan_spec const *chan,
1118                                const int **vals, int *type, int *length,
1119                                long mask)
1120 {
1121         switch (mask) {
1122         case IIO_CHAN_INFO_SAMP_FREQ:
1123                 *vals = (int *)vcnl4010_prox_sampling_frequency;
1124                 *type = IIO_VAL_INT_PLUS_MICRO;
1125                 *length = 2 * ARRAY_SIZE(vcnl4010_prox_sampling_frequency);
1126                 return IIO_AVAIL_LIST;
1127         default:
1128                 return -EINVAL;
1129         }
1130 }
1131
1132 static int vcnl4010_write_proxy_samp_freq(struct vcnl4000_data *data, int val,
1133                                           int val2)
1134 {
1135         unsigned int i;
1136         int index = -1;
1137
1138         for (i = 0; i < ARRAY_SIZE(vcnl4010_prox_sampling_frequency); i++) {
1139                 if (val == vcnl4010_prox_sampling_frequency[i][0] &&
1140                     val2 == vcnl4010_prox_sampling_frequency[i][1]) {
1141                         index = i;
1142                         break;
1143                 }
1144         }
1145
1146         if (index < 0)
1147                 return -EINVAL;
1148
1149         return i2c_smbus_write_byte_data(data->client, VCNL4010_PROX_RATE,
1150                                          index);
1151 }
1152
1153 static int vcnl4010_write_raw(struct iio_dev *indio_dev,
1154                               struct iio_chan_spec const *chan,
1155                               int val, int val2, long mask)
1156 {
1157         int ret;
1158         struct vcnl4000_data *data = iio_priv(indio_dev);
1159
1160         ret = iio_device_claim_direct_mode(indio_dev);
1161         if (ret)
1162                 return ret;
1163
1164         /* Protect against event capture. */
1165         if (vcnl4010_is_in_periodic_mode(data)) {
1166                 ret = -EBUSY;
1167                 goto end;
1168         }
1169
1170         switch (mask) {
1171         case IIO_CHAN_INFO_SAMP_FREQ:
1172                 switch (chan->type) {
1173                 case IIO_PROXIMITY:
1174                         ret = vcnl4010_write_proxy_samp_freq(data, val, val2);
1175                         goto end;
1176                 default:
1177                         ret = -EINVAL;
1178                         goto end;
1179                 }
1180         default:
1181                 ret = -EINVAL;
1182                 goto end;
1183         }
1184
1185 end:
1186         iio_device_release_direct_mode(indio_dev);
1187         return ret;
1188 }
1189
1190 static int vcnl4010_read_event(struct iio_dev *indio_dev,
1191                                const struct iio_chan_spec *chan,
1192                                enum iio_event_type type,
1193                                enum iio_event_direction dir,
1194                                enum iio_event_info info,
1195                                int *val, int *val2)
1196 {
1197         int ret;
1198         struct vcnl4000_data *data = iio_priv(indio_dev);
1199
1200         switch (info) {
1201         case IIO_EV_INFO_VALUE:
1202                 switch (dir) {
1203                 case IIO_EV_DIR_RISING:
1204                         ret = vcnl4000_read_data(data, VCNL4010_HIGH_THR_HI,
1205                                                  val);
1206                         if (ret < 0)
1207                                 return ret;
1208                         return IIO_VAL_INT;
1209                 case IIO_EV_DIR_FALLING:
1210                         ret = vcnl4000_read_data(data, VCNL4010_LOW_THR_HI,
1211                                                  val);
1212                         if (ret < 0)
1213                                 return ret;
1214                         return IIO_VAL_INT;
1215                 default:
1216                         return -EINVAL;
1217                 }
1218         default:
1219                 return -EINVAL;
1220         }
1221 }
1222
1223 static int vcnl4010_write_event(struct iio_dev *indio_dev,
1224                                 const struct iio_chan_spec *chan,
1225                                 enum iio_event_type type,
1226                                 enum iio_event_direction dir,
1227                                 enum iio_event_info info,
1228                                 int val, int val2)
1229 {
1230         int ret;
1231         struct vcnl4000_data *data = iio_priv(indio_dev);
1232
1233         switch (info) {
1234         case IIO_EV_INFO_VALUE:
1235                 switch (dir) {
1236                 case IIO_EV_DIR_RISING:
1237                         ret = vcnl4000_write_data(data, VCNL4010_HIGH_THR_HI,
1238                                                   val);
1239                         if (ret < 0)
1240                                 return ret;
1241                         return IIO_VAL_INT;
1242                 case IIO_EV_DIR_FALLING:
1243                         ret = vcnl4000_write_data(data, VCNL4010_LOW_THR_HI,
1244                                                   val);
1245                         if (ret < 0)
1246                                 return ret;
1247                         return IIO_VAL_INT;
1248                 default:
1249                         return -EINVAL;
1250                 }
1251         default:
1252                 return -EINVAL;
1253         }
1254 }
1255
1256 static int vcnl4040_read_event(struct iio_dev *indio_dev,
1257                                const struct iio_chan_spec *chan,
1258                                enum iio_event_type type,
1259                                enum iio_event_direction dir,
1260                                enum iio_event_info info,
1261                                int *val, int *val2)
1262 {
1263         int ret;
1264         struct vcnl4000_data *data = iio_priv(indio_dev);
1265
1266         switch (chan->type) {
1267         case IIO_LIGHT:
1268                 switch (info) {
1269                 case IIO_EV_INFO_PERIOD:
1270                         return vcnl4040_read_als_period(data, val, val2);
1271                 case IIO_EV_INFO_VALUE:
1272                         switch (dir) {
1273                         case IIO_EV_DIR_RISING:
1274                                 ret = i2c_smbus_read_word_data(data->client,
1275                                                                VCNL4040_ALS_THDH_LM);
1276                                 break;
1277                         case IIO_EV_DIR_FALLING:
1278                                 ret = i2c_smbus_read_word_data(data->client,
1279                                                                VCNL4040_ALS_THDL_LM);
1280                                 break;
1281                         default:
1282                                 return -EINVAL;
1283                         }
1284                         break;
1285                 default:
1286                         return -EINVAL;
1287                 }
1288                 break;
1289         case IIO_PROXIMITY:
1290                 switch (info) {
1291                 case IIO_EV_INFO_PERIOD:
1292                         return vcnl4040_read_ps_period(data, val, val2);
1293                 case IIO_EV_INFO_VALUE:
1294                         switch (dir) {
1295                         case IIO_EV_DIR_RISING:
1296                                 ret = i2c_smbus_read_word_data(data->client,
1297                                                                VCNL4040_PS_THDH_LM);
1298                                 break;
1299                         case IIO_EV_DIR_FALLING:
1300                                 ret = i2c_smbus_read_word_data(data->client,
1301                                                                VCNL4040_PS_THDL_LM);
1302                                 break;
1303                         default:
1304                                 return -EINVAL;
1305                         }
1306                         break;
1307                 default:
1308                         return -EINVAL;
1309                 }
1310                 break;
1311         default:
1312                 return -EINVAL;
1313         }
1314         if (ret < 0)
1315                 return ret;
1316         *val = ret;
1317         return IIO_VAL_INT;
1318 }
1319
1320 static int vcnl4040_write_event(struct iio_dev *indio_dev,
1321                                 const struct iio_chan_spec *chan,
1322                                 enum iio_event_type type,
1323                                 enum iio_event_direction dir,
1324                                 enum iio_event_info info,
1325                                 int val, int val2)
1326 {
1327         int ret;
1328         struct vcnl4000_data *data = iio_priv(indio_dev);
1329
1330         switch (chan->type) {
1331         case IIO_LIGHT:
1332                 switch (info) {
1333                 case IIO_EV_INFO_PERIOD:
1334                         return vcnl4040_write_als_period(data, val, val2);
1335                 case IIO_EV_INFO_VALUE:
1336                         switch (dir) {
1337                         case IIO_EV_DIR_RISING:
1338                                 ret = i2c_smbus_write_word_data(data->client,
1339                                                                 VCNL4040_ALS_THDH_LM,
1340                                                                 val);
1341                                 break;
1342                         case IIO_EV_DIR_FALLING:
1343                                 ret = i2c_smbus_write_word_data(data->client,
1344                                                                 VCNL4040_ALS_THDL_LM,
1345                                                                 val);
1346                                 break;
1347                         default:
1348                                 return -EINVAL;
1349                         }
1350                         break;
1351                 default:
1352                         return -EINVAL;
1353                 }
1354                 break;
1355         case IIO_PROXIMITY:
1356                 switch (info) {
1357                 case IIO_EV_INFO_PERIOD:
1358                         return vcnl4040_write_ps_period(data, val, val2);
1359                 case IIO_EV_INFO_VALUE:
1360                         switch (dir) {
1361                         case IIO_EV_DIR_RISING:
1362                                 ret = i2c_smbus_write_word_data(data->client,
1363                                                                 VCNL4040_PS_THDH_LM,
1364                                                                 val);
1365                                 break;
1366                         case IIO_EV_DIR_FALLING:
1367                                 ret = i2c_smbus_write_word_data(data->client,
1368                                                                 VCNL4040_PS_THDL_LM,
1369                                                                 val);
1370                                 break;
1371                         default:
1372                                 return -EINVAL;
1373                         }
1374                         break;
1375                 default:
1376                         return -EINVAL;
1377                 }
1378                 break;
1379         default:
1380                 return -EINVAL;
1381         }
1382         if (ret < 0)
1383                 return ret;
1384         return IIO_VAL_INT;
1385 }
1386
1387 static bool vcnl4010_is_thr_enabled(struct vcnl4000_data *data)
1388 {
1389         int ret;
1390
1391         ret = i2c_smbus_read_byte_data(data->client, VCNL4010_INT_CTRL);
1392         if (ret < 0)
1393                 return false;
1394
1395         return !!(ret & VCNL4010_INT_THR_EN);
1396 }
1397
1398 static int vcnl4010_read_event_config(struct iio_dev *indio_dev,
1399                                       const struct iio_chan_spec *chan,
1400                                       enum iio_event_type type,
1401                                       enum iio_event_direction dir)
1402 {
1403         struct vcnl4000_data *data = iio_priv(indio_dev);
1404
1405         switch (chan->type) {
1406         case IIO_PROXIMITY:
1407                 return vcnl4010_is_thr_enabled(data);
1408         default:
1409                 return -EINVAL;
1410         }
1411 }
1412
1413 static int vcnl4010_config_threshold(struct iio_dev *indio_dev, bool state)
1414 {
1415         struct vcnl4000_data *data = iio_priv(indio_dev);
1416         int ret;
1417         int icr;
1418         int command;
1419
1420         if (state) {
1421                 ret = iio_device_claim_direct_mode(indio_dev);
1422                 if (ret)
1423                         return ret;
1424
1425                 /* Enable periodic measurement of proximity data. */
1426                 command = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN;
1427
1428                 /*
1429                  * Enable interrupts on threshold, for proximity data by
1430                  * default.
1431                  */
1432                 icr = VCNL4010_INT_THR_EN;
1433         } else {
1434                 if (!vcnl4010_is_thr_enabled(data))
1435                         return 0;
1436
1437                 command = 0;
1438                 icr = 0;
1439         }
1440
1441         ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND,
1442                                         command);
1443         if (ret < 0)
1444                 goto end;
1445
1446         ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, icr);
1447
1448 end:
1449         if (state)
1450                 iio_device_release_direct_mode(indio_dev);
1451
1452         return ret;
1453 }
1454
1455 static int vcnl4010_write_event_config(struct iio_dev *indio_dev,
1456                                        const struct iio_chan_spec *chan,
1457                                        enum iio_event_type type,
1458                                        enum iio_event_direction dir,
1459                                        int state)
1460 {
1461         switch (chan->type) {
1462         case IIO_PROXIMITY:
1463                 return vcnl4010_config_threshold(indio_dev, state);
1464         default:
1465                 return -EINVAL;
1466         }
1467 }
1468
1469 static int vcnl4040_read_event_config(struct iio_dev *indio_dev,
1470                                       const struct iio_chan_spec *chan,
1471                                       enum iio_event_type type,
1472                                       enum iio_event_direction dir)
1473 {
1474         int ret;
1475         struct vcnl4000_data *data = iio_priv(indio_dev);
1476
1477         switch (chan->type) {
1478         case IIO_LIGHT:
1479                 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
1480                 if (ret < 0)
1481                         return ret;
1482
1483                 data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, ret);
1484
1485                 return data->als_int;
1486         case IIO_PROXIMITY:
1487                 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
1488                 if (ret < 0)
1489                         return ret;
1490
1491                 data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, ret);
1492
1493                 return (dir == IIO_EV_DIR_RISING) ?
1494                         FIELD_GET(VCNL4040_PS_IF_AWAY, ret) :
1495                         FIELD_GET(VCNL4040_PS_IF_CLOSE, ret);
1496         default:
1497                 return -EINVAL;
1498         }
1499 }
1500
1501 static int vcnl4040_write_event_config(struct iio_dev *indio_dev,
1502                                        const struct iio_chan_spec *chan,
1503                                        enum iio_event_type type,
1504                                        enum iio_event_direction dir, int state)
1505 {
1506         int ret = -EINVAL;
1507         u16 val, mask;
1508         struct vcnl4000_data *data = iio_priv(indio_dev);
1509
1510         mutex_lock(&data->vcnl4000_lock);
1511
1512         switch (chan->type) {
1513         case IIO_LIGHT:
1514                 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
1515                 if (ret < 0)
1516                         goto out;
1517
1518                 mask = VCNL4040_ALS_CONF_INT_EN;
1519                 if (state)
1520                         val = (ret | mask);
1521                 else
1522                         val = (ret & ~mask);
1523
1524                 data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, val);
1525                 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF,
1526                                                 val);
1527                 break;
1528         case IIO_PROXIMITY:
1529                 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
1530                 if (ret < 0)
1531                         goto out;
1532
1533                 if (dir == IIO_EV_DIR_RISING)
1534                         mask = VCNL4040_PS_IF_AWAY;
1535                 else
1536                         mask = VCNL4040_PS_IF_CLOSE;
1537
1538                 val = state ? (ret | mask) : (ret & ~mask);
1539
1540                 data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, val);
1541                 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1,
1542                                                 val);
1543                 break;
1544         default:
1545                 break;
1546         }
1547
1548 out:
1549         mutex_unlock(&data->vcnl4000_lock);
1550
1551         return ret;
1552 }
1553
1554 static irqreturn_t vcnl4040_irq_thread(int irq, void *p)
1555 {
1556         struct iio_dev *indio_dev = p;
1557         struct vcnl4000_data *data = iio_priv(indio_dev);
1558         int ret;
1559
1560         ret = i2c_smbus_read_word_data(data->client, data->chip_spec->int_reg);
1561         if (ret < 0)
1562                 return IRQ_HANDLED;
1563
1564         if (ret & VCNL4040_PS_IF_CLOSE) {
1565                 iio_push_event(indio_dev,
1566                                IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
1567                                                     IIO_EV_TYPE_THRESH,
1568                                                     IIO_EV_DIR_RISING),
1569                                iio_get_time_ns(indio_dev));
1570         }
1571
1572         if (ret & VCNL4040_PS_IF_AWAY) {
1573                 iio_push_event(indio_dev,
1574                                IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
1575                                                     IIO_EV_TYPE_THRESH,
1576                                                     IIO_EV_DIR_FALLING),
1577                                iio_get_time_ns(indio_dev));
1578         }
1579
1580         if (ret & VCNL4040_ALS_FALLING) {
1581                 iio_push_event(indio_dev,
1582                                IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0,
1583                                                     IIO_EV_TYPE_THRESH,
1584                                                     IIO_EV_DIR_FALLING),
1585                                iio_get_time_ns(indio_dev));
1586         }
1587
1588         if (ret & VCNL4040_ALS_RISING) {
1589                 iio_push_event(indio_dev,
1590                                IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0,
1591                                                     IIO_EV_TYPE_THRESH,
1592                                                     IIO_EV_DIR_RISING),
1593                                iio_get_time_ns(indio_dev));
1594         }
1595
1596         return IRQ_HANDLED;
1597 }
1598
1599 static ssize_t vcnl4000_read_near_level(struct iio_dev *indio_dev,
1600                                         uintptr_t priv,
1601                                         const struct iio_chan_spec *chan,
1602                                         char *buf)
1603 {
1604         struct vcnl4000_data *data = iio_priv(indio_dev);
1605
1606         return sprintf(buf, "%u\n", data->near_level);
1607 }
1608
1609 static irqreturn_t vcnl4010_irq_thread(int irq, void *p)
1610 {
1611         struct iio_dev *indio_dev = p;
1612         struct vcnl4000_data *data = iio_priv(indio_dev);
1613         unsigned long isr;
1614         int ret;
1615
1616         ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR);
1617         if (ret < 0)
1618                 goto end;
1619
1620         isr = ret;
1621
1622         if (isr & VCNL4010_INT_THR) {
1623                 if (test_bit(VCNL4010_INT_THR_LOW, &isr)) {
1624                         iio_push_event(indio_dev,
1625                                        IIO_UNMOD_EVENT_CODE(
1626                                                IIO_PROXIMITY,
1627                                                1,
1628                                                IIO_EV_TYPE_THRESH,
1629                                                IIO_EV_DIR_FALLING),
1630                                        iio_get_time_ns(indio_dev));
1631                 }
1632
1633                 if (test_bit(VCNL4010_INT_THR_HIGH, &isr)) {
1634                         iio_push_event(indio_dev,
1635                                        IIO_UNMOD_EVENT_CODE(
1636                                                IIO_PROXIMITY,
1637                                                1,
1638                                                IIO_EV_TYPE_THRESH,
1639                                                IIO_EV_DIR_RISING),
1640                                        iio_get_time_ns(indio_dev));
1641                 }
1642
1643                 i2c_smbus_write_byte_data(data->client, VCNL4010_ISR,
1644                                           isr & VCNL4010_INT_THR);
1645         }
1646
1647         if (isr & VCNL4010_INT_DRDY && iio_buffer_enabled(indio_dev))
1648                 iio_trigger_poll_nested(indio_dev->trig);
1649
1650 end:
1651         return IRQ_HANDLED;
1652 }
1653
1654 static irqreturn_t vcnl4010_trigger_handler(int irq, void *p)
1655 {
1656         struct iio_poll_func *pf = p;
1657         struct iio_dev *indio_dev = pf->indio_dev;
1658         struct vcnl4000_data *data = iio_priv(indio_dev);
1659         const unsigned long *active_scan_mask = indio_dev->active_scan_mask;
1660         u16 buffer[8] __aligned(8) = {0}; /* 1x16-bit + naturally aligned ts */
1661         bool data_read = false;
1662         unsigned long isr;
1663         int val = 0;
1664         int ret;
1665
1666         ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR);
1667         if (ret < 0)
1668                 goto end;
1669
1670         isr = ret;
1671
1672         if (test_bit(0, active_scan_mask)) {
1673                 if (test_bit(VCNL4010_INT_PROXIMITY, &isr)) {
1674                         ret = vcnl4000_read_data(data,
1675                                                  VCNL4000_PS_RESULT_HI,
1676                                                  &val);
1677                         if (ret < 0)
1678                                 goto end;
1679
1680                         buffer[0] = val;
1681                         data_read = true;
1682                 }
1683         }
1684
1685         ret = i2c_smbus_write_byte_data(data->client, VCNL4010_ISR,
1686                                         isr & VCNL4010_INT_DRDY);
1687         if (ret < 0)
1688                 goto end;
1689
1690         if (!data_read)
1691                 goto end;
1692
1693         iio_push_to_buffers_with_timestamp(indio_dev, buffer,
1694                                            iio_get_time_ns(indio_dev));
1695
1696 end:
1697         iio_trigger_notify_done(indio_dev->trig);
1698         return IRQ_HANDLED;
1699 }
1700
1701 static int vcnl4010_buffer_postenable(struct iio_dev *indio_dev)
1702 {
1703         struct vcnl4000_data *data = iio_priv(indio_dev);
1704         int ret;
1705         int cmd;
1706
1707         /* Do not enable the buffer if we are already capturing events. */
1708         if (vcnl4010_is_in_periodic_mode(data))
1709                 return -EBUSY;
1710
1711         ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL,
1712                                         VCNL4010_INT_PROX_EN);
1713         if (ret < 0)
1714                 return ret;
1715
1716         cmd = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN;
1717         return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, cmd);
1718 }
1719
1720 static int vcnl4010_buffer_predisable(struct iio_dev *indio_dev)
1721 {
1722         struct vcnl4000_data *data = iio_priv(indio_dev);
1723         int ret;
1724
1725         ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 0);
1726         if (ret < 0)
1727                 return ret;
1728
1729         return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0);
1730 }
1731
1732 static const struct iio_buffer_setup_ops vcnl4010_buffer_ops = {
1733         .postenable = &vcnl4010_buffer_postenable,
1734         .predisable = &vcnl4010_buffer_predisable,
1735 };
1736
1737 static const struct iio_chan_spec_ext_info vcnl4000_ext_info[] = {
1738         {
1739                 .name = "nearlevel",
1740                 .shared = IIO_SEPARATE,
1741                 .read = vcnl4000_read_near_level,
1742         },
1743         { /* sentinel */ }
1744 };
1745
1746 static const struct iio_event_spec vcnl4000_event_spec[] = {
1747         {
1748                 .type = IIO_EV_TYPE_THRESH,
1749                 .dir = IIO_EV_DIR_RISING,
1750                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1751         }, {
1752                 .type = IIO_EV_TYPE_THRESH,
1753                 .dir = IIO_EV_DIR_FALLING,
1754                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1755         }, {
1756                 .type = IIO_EV_TYPE_THRESH,
1757                 .dir = IIO_EV_DIR_EITHER,
1758                 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
1759         }
1760 };
1761
1762 static const struct iio_event_spec vcnl4040_als_event_spec[] = {
1763         {
1764                 .type = IIO_EV_TYPE_THRESH,
1765                 .dir = IIO_EV_DIR_RISING,
1766                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1767         }, {
1768                 .type = IIO_EV_TYPE_THRESH,
1769                 .dir = IIO_EV_DIR_FALLING,
1770                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1771         }, {
1772                 .type = IIO_EV_TYPE_THRESH,
1773                 .dir = IIO_EV_DIR_EITHER,
1774                 .mask_separate = BIT(IIO_EV_INFO_ENABLE) | BIT(IIO_EV_INFO_PERIOD),
1775         },
1776 };
1777
1778 static const struct iio_event_spec vcnl4040_event_spec[] = {
1779         {
1780                 .type = IIO_EV_TYPE_THRESH,
1781                 .dir = IIO_EV_DIR_RISING,
1782                 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
1783         }, {
1784                 .type = IIO_EV_TYPE_THRESH,
1785                 .dir = IIO_EV_DIR_FALLING,
1786                 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
1787         }, {
1788                 .type = IIO_EV_TYPE_THRESH,
1789                 .dir = IIO_EV_DIR_EITHER,
1790                 .mask_separate = BIT(IIO_EV_INFO_PERIOD),
1791         },
1792 };
1793
1794 static const struct iio_chan_spec vcnl4000_channels[] = {
1795         {
1796                 .type = IIO_LIGHT,
1797                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1798                         BIT(IIO_CHAN_INFO_SCALE),
1799         }, {
1800                 .type = IIO_PROXIMITY,
1801                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1802                 .ext_info = vcnl4000_ext_info,
1803         }
1804 };
1805
1806 static const struct iio_chan_spec vcnl4010_channels[] = {
1807         {
1808                 .type = IIO_LIGHT,
1809                 .scan_index = -1,
1810                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1811                         BIT(IIO_CHAN_INFO_SCALE),
1812         }, {
1813                 .type = IIO_PROXIMITY,
1814                 .scan_index = 0,
1815                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1816                         BIT(IIO_CHAN_INFO_SAMP_FREQ),
1817                 .info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ),
1818                 .event_spec = vcnl4000_event_spec,
1819                 .num_event_specs = ARRAY_SIZE(vcnl4000_event_spec),
1820                 .ext_info = vcnl4000_ext_info,
1821                 .scan_type = {
1822                         .sign = 'u',
1823                         .realbits = 16,
1824                         .storagebits = 16,
1825                         .endianness = IIO_CPU,
1826                 },
1827         },
1828         IIO_CHAN_SOFT_TIMESTAMP(1),
1829 };
1830
1831 static const struct iio_chan_spec vcnl4040_channels[] = {
1832         {
1833                 .type = IIO_LIGHT,
1834                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1835                         BIT(IIO_CHAN_INFO_SCALE) |
1836                         BIT(IIO_CHAN_INFO_INT_TIME),
1837                 .info_mask_separate_available = BIT(IIO_CHAN_INFO_INT_TIME),
1838                 .event_spec = vcnl4040_als_event_spec,
1839                 .num_event_specs = ARRAY_SIZE(vcnl4040_als_event_spec),
1840         }, {
1841                 .type = IIO_PROXIMITY,
1842                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1843                         BIT(IIO_CHAN_INFO_INT_TIME) |
1844                         BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) |
1845                         BIT(IIO_CHAN_INFO_CALIBBIAS),
1846                 .info_mask_separate_available = BIT(IIO_CHAN_INFO_INT_TIME) |
1847                         BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) |
1848                         BIT(IIO_CHAN_INFO_CALIBBIAS),
1849                 .ext_info = vcnl4000_ext_info,
1850                 .event_spec = vcnl4040_event_spec,
1851                 .num_event_specs = ARRAY_SIZE(vcnl4040_event_spec),
1852         }
1853 };
1854
1855 static const struct iio_info vcnl4000_info = {
1856         .read_raw = vcnl4000_read_raw,
1857 };
1858
1859 static const struct iio_info vcnl4010_info = {
1860         .read_raw = vcnl4010_read_raw,
1861         .read_avail = vcnl4010_read_avail,
1862         .write_raw = vcnl4010_write_raw,
1863         .read_event_value = vcnl4010_read_event,
1864         .write_event_value = vcnl4010_write_event,
1865         .read_event_config = vcnl4010_read_event_config,
1866         .write_event_config = vcnl4010_write_event_config,
1867 };
1868
1869 static const struct iio_info vcnl4040_info = {
1870         .read_raw = vcnl4000_read_raw,
1871         .write_raw = vcnl4040_write_raw,
1872         .read_event_value = vcnl4040_read_event,
1873         .write_event_value = vcnl4040_write_event,
1874         .read_event_config = vcnl4040_read_event_config,
1875         .write_event_config = vcnl4040_write_event_config,
1876         .read_avail = vcnl4040_read_avail,
1877 };
1878
1879 static const struct vcnl4000_chip_spec vcnl4000_chip_spec_cfg[] = {
1880         [VCNL4000] = {
1881                 .prod = "VCNL4000",
1882                 .init = vcnl4000_init,
1883                 .measure_light = vcnl4000_measure_light,
1884                 .measure_proximity = vcnl4000_measure_proximity,
1885                 .set_power_state = vcnl4000_set_power_state,
1886                 .channels = vcnl4000_channels,
1887                 .num_channels = ARRAY_SIZE(vcnl4000_channels),
1888                 .info = &vcnl4000_info,
1889         },
1890         [VCNL4010] = {
1891                 .prod = "VCNL4010/4020",
1892                 .init = vcnl4000_init,
1893                 .measure_light = vcnl4000_measure_light,
1894                 .measure_proximity = vcnl4000_measure_proximity,
1895                 .set_power_state = vcnl4000_set_power_state,
1896                 .channels = vcnl4010_channels,
1897                 .num_channels = ARRAY_SIZE(vcnl4010_channels),
1898                 .info = &vcnl4010_info,
1899                 .irq_thread = vcnl4010_irq_thread,
1900                 .trig_buffer_func = vcnl4010_trigger_handler,
1901                 .buffer_setup_ops = &vcnl4010_buffer_ops,
1902         },
1903         [VCNL4040] = {
1904                 .prod = "VCNL4040",
1905                 .init = vcnl4200_init,
1906                 .measure_light = vcnl4200_measure_light,
1907                 .measure_proximity = vcnl4200_measure_proximity,
1908                 .set_power_state = vcnl4200_set_power_state,
1909                 .channels = vcnl4040_channels,
1910                 .num_channels = ARRAY_SIZE(vcnl4040_channels),
1911                 .info = &vcnl4040_info,
1912                 .irq_thread = vcnl4040_irq_thread,
1913                 .int_reg = VCNL4040_INT_FLAGS,
1914                 .ps_it_times = &vcnl4040_ps_it_times,
1915                 .num_ps_it_times = ARRAY_SIZE(vcnl4040_ps_it_times),
1916                 .als_it_times = &vcnl4040_als_it_times,
1917                 .num_als_it_times = ARRAY_SIZE(vcnl4040_als_it_times),
1918                 .ulux_step = 100000,
1919         },
1920         [VCNL4200] = {
1921                 .prod = "VCNL4200",
1922                 .init = vcnl4200_init,
1923                 .measure_light = vcnl4200_measure_light,
1924                 .measure_proximity = vcnl4200_measure_proximity,
1925                 .set_power_state = vcnl4200_set_power_state,
1926                 .channels = vcnl4040_channels,
1927                 .num_channels = ARRAY_SIZE(vcnl4000_channels),
1928                 .info = &vcnl4040_info,
1929                 .irq_thread = vcnl4040_irq_thread,
1930                 .int_reg = VCNL4200_INT_FLAGS,
1931                 .ps_it_times = &vcnl4200_ps_it_times,
1932                 .num_ps_it_times = ARRAY_SIZE(vcnl4200_ps_it_times),
1933                 .als_it_times = &vcnl4200_als_it_times,
1934                 .num_als_it_times = ARRAY_SIZE(vcnl4200_als_it_times),
1935                 .ulux_step = 24000,
1936         },
1937 };
1938
1939 static const struct iio_trigger_ops vcnl4010_trigger_ops = {
1940         .validate_device = iio_trigger_validate_own_device,
1941 };
1942
1943 static int vcnl4010_probe_trigger(struct iio_dev *indio_dev)
1944 {
1945         struct vcnl4000_data *data = iio_priv(indio_dev);
1946         struct i2c_client *client = data->client;
1947         struct iio_trigger *trigger;
1948
1949         trigger = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
1950                                          indio_dev->name,
1951                                          iio_device_id(indio_dev));
1952         if (!trigger)
1953                 return -ENOMEM;
1954
1955         trigger->ops = &vcnl4010_trigger_ops;
1956         iio_trigger_set_drvdata(trigger, indio_dev);
1957
1958         return devm_iio_trigger_register(&client->dev, trigger);
1959 }
1960
1961 static int vcnl4000_probe(struct i2c_client *client)
1962 {
1963         const struct i2c_device_id *id = i2c_client_get_device_id(client);
1964         struct vcnl4000_data *data;
1965         struct iio_dev *indio_dev;
1966         int ret;
1967
1968         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1969         if (!indio_dev)
1970                 return -ENOMEM;
1971
1972         data = iio_priv(indio_dev);
1973         i2c_set_clientdata(client, indio_dev);
1974         data->client = client;
1975         data->id = id->driver_data;
1976         data->chip_spec = &vcnl4000_chip_spec_cfg[data->id];
1977
1978         mutex_init(&data->vcnl4000_lock);
1979
1980         ret = data->chip_spec->init(data);
1981         if (ret < 0)
1982                 return ret;
1983
1984         dev_dbg(&client->dev, "%s Ambient light/proximity sensor, Rev: %02x\n",
1985                 data->chip_spec->prod, data->rev);
1986
1987         if (device_property_read_u32(&client->dev, "proximity-near-level",
1988                                      &data->near_level))
1989                 data->near_level = 0;
1990
1991         indio_dev->info = data->chip_spec->info;
1992         indio_dev->channels = data->chip_spec->channels;
1993         indio_dev->num_channels = data->chip_spec->num_channels;
1994         indio_dev->name = VCNL4000_DRV_NAME;
1995         indio_dev->modes = INDIO_DIRECT_MODE;
1996
1997         if (data->chip_spec->trig_buffer_func &&
1998             data->chip_spec->buffer_setup_ops) {
1999                 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev,
2000                                                       NULL,
2001                                                       data->chip_spec->trig_buffer_func,
2002                                                       data->chip_spec->buffer_setup_ops);
2003                 if (ret < 0) {
2004                         dev_err(&client->dev,
2005                                 "unable to setup iio triggered buffer\n");
2006                         return ret;
2007                 }
2008         }
2009
2010         if (client->irq && data->chip_spec->irq_thread) {
2011                 ret = devm_request_threaded_irq(&client->dev, client->irq,
2012                                                 NULL, data->chip_spec->irq_thread,
2013                                                 IRQF_TRIGGER_FALLING |
2014                                                 IRQF_ONESHOT,
2015                                                 "vcnl4000_irq",
2016                                                 indio_dev);
2017                 if (ret < 0) {
2018                         dev_err(&client->dev, "irq request failed\n");
2019                         return ret;
2020                 }
2021
2022                 ret = vcnl4010_probe_trigger(indio_dev);
2023                 if (ret < 0)
2024                         return ret;
2025         }
2026
2027         ret = pm_runtime_set_active(&client->dev);
2028         if (ret < 0)
2029                 goto fail_poweroff;
2030
2031         ret = iio_device_register(indio_dev);
2032         if (ret < 0)
2033                 goto fail_poweroff;
2034
2035         pm_runtime_enable(&client->dev);
2036         pm_runtime_set_autosuspend_delay(&client->dev, VCNL4000_SLEEP_DELAY_MS);
2037         pm_runtime_use_autosuspend(&client->dev);
2038
2039         return 0;
2040 fail_poweroff:
2041         data->chip_spec->set_power_state(data, false);
2042         return ret;
2043 }
2044
2045 static const struct of_device_id vcnl_4000_of_match[] = {
2046         {
2047                 .compatible = "vishay,vcnl4000",
2048                 .data = (void *)VCNL4000,
2049         },
2050         {
2051                 .compatible = "vishay,vcnl4010",
2052                 .data = (void *)VCNL4010,
2053         },
2054         {
2055                 .compatible = "vishay,vcnl4020",
2056                 .data = (void *)VCNL4010,
2057         },
2058         {
2059                 .compatible = "vishay,vcnl4040",
2060                 .data = (void *)VCNL4040,
2061         },
2062         {
2063                 .compatible = "vishay,vcnl4200",
2064                 .data = (void *)VCNL4200,
2065         },
2066         {},
2067 };
2068 MODULE_DEVICE_TABLE(of, vcnl_4000_of_match);
2069
2070 static void vcnl4000_remove(struct i2c_client *client)
2071 {
2072         struct iio_dev *indio_dev = i2c_get_clientdata(client);
2073         struct vcnl4000_data *data = iio_priv(indio_dev);
2074         int ret;
2075
2076         pm_runtime_dont_use_autosuspend(&client->dev);
2077         pm_runtime_disable(&client->dev);
2078         iio_device_unregister(indio_dev);
2079         pm_runtime_set_suspended(&client->dev);
2080
2081         ret = data->chip_spec->set_power_state(data, false);
2082         if (ret)
2083                 dev_warn(&client->dev, "Failed to power down (%pe)\n",
2084                          ERR_PTR(ret));
2085 }
2086
2087 static int vcnl4000_runtime_suspend(struct device *dev)
2088 {
2089         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
2090         struct vcnl4000_data *data = iio_priv(indio_dev);
2091
2092         return data->chip_spec->set_power_state(data, false);
2093 }
2094
2095 static int vcnl4000_runtime_resume(struct device *dev)
2096 {
2097         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
2098         struct vcnl4000_data *data = iio_priv(indio_dev);
2099
2100         return data->chip_spec->set_power_state(data, true);
2101 }
2102
2103 static DEFINE_RUNTIME_DEV_PM_OPS(vcnl4000_pm_ops, vcnl4000_runtime_suspend,
2104                                  vcnl4000_runtime_resume, NULL);
2105
2106 static struct i2c_driver vcnl4000_driver = {
2107         .driver = {
2108                 .name   = VCNL4000_DRV_NAME,
2109                 .pm     = pm_ptr(&vcnl4000_pm_ops),
2110                 .of_match_table = vcnl_4000_of_match,
2111         },
2112         .probe = vcnl4000_probe,
2113         .id_table = vcnl4000_id,
2114         .remove = vcnl4000_remove,
2115 };
2116
2117 module_i2c_driver(vcnl4000_driver);
2118
2119 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
2120 MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>");
2121 MODULE_DESCRIPTION("Vishay VCNL4000 proximity/ambient light sensor driver");
2122 MODULE_LICENSE("GPL");