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