drivers/iio/light/vl6180.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * vl6180.c - Support for STMicroelectronics VL6180 ALS, range and proximity
   4  * sensor
   5  *
   6  * Copyright 2017 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
   7  * Copyright 2017 Manivannan Sadhasivam <manivannanece23@gmail.com>
   8  *
   9  * IIO driver for VL6180 (7-bit I2C slave address 0x29)
  10  *
  11  * Range: 0 to 100mm
  12  * ALS: < 1 Lux up to 100 kLux
  13  * IR: 850nm
  14  *
  15  * TODO: irq, threshold events, continuous mode, hardware buffer
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/mod_devicetable.h>
  20 #include <linux/i2c.h>
  21 #include <linux/mutex.h>
  22 #include <linux/err.h>
  23 #include <linux/delay.h>
  24 #include <linux/util_macros.h>
  25
  26 #include <linux/iio/iio.h>
  27 #include <linux/iio/sysfs.h>
  28 #include <linux/iio/buffer.h>
  29 #include <linux/iio/trigger.h>
  30 #include <linux/iio/trigger_consumer.h>
  31 #include <linux/iio/triggered_buffer.h>
  32
  33 #define VL6180_DRV_NAME "vl6180"
  34
  35 /* Device identification register and value */
  36 #define VL6180_MODEL_ID 0x000
  37 #define VL6180_MODEL_ID_VAL 0xb4
  38
  39 /* Configuration registers */
  40 #define VL6180_INTR_CONFIG 0x014
  41 #define VL6180_INTR_CLEAR 0x015
  42 #define VL6180_OUT_OF_RESET 0x016
  43 #define VL6180_HOLD 0x017
  44 #define VL6180_RANGE_START 0x018
  45 #define VL6180_RANGE_INTER_MEAS_TIME 0x01b
  46 #define VL6180_ALS_START 0x038
  47 #define VL6180_ALS_INTER_MEAS_TIME 0x03e
  48 #define VL6180_ALS_GAIN 0x03f
  49 #define VL6180_ALS_IT 0x040
  50
  51 /* Status registers */
  52 #define VL6180_RANGE_STATUS 0x04d
  53 #define VL6180_ALS_STATUS 0x04e
  54 #define VL6180_INTR_STATUS 0x04f
  55
  56 /* Result value registers */
  57 #define VL6180_ALS_VALUE 0x050
  58 #define VL6180_RANGE_VALUE 0x062
  59 #define VL6180_RANGE_RATE 0x066
  60
  61 /* bits of the RANGE_START and ALS_START register */
  62 #define VL6180_MODE_CONT BIT(1) /* continuous mode */
  63 #define VL6180_STARTSTOP BIT(0) /* start measurement, auto-reset */
  64
  65 /* bits of the INTR_STATUS and INTR_CONFIG register */
  66 #define VL6180_ALS_READY BIT(5)
  67 #define VL6180_RANGE_READY BIT(2)
  68
  69 /* bits of the INTR_CLEAR register */
  70 #define VL6180_CLEAR_ERROR BIT(2)
  71 #define VL6180_CLEAR_ALS BIT(1)
  72 #define VL6180_CLEAR_RANGE BIT(0)
  73
  74 /* bits of the HOLD register */
  75 #define VL6180_HOLD_ON BIT(0)
  76
  77 /* default value for the ALS_IT register */
  78 #define VL6180_ALS_IT_100 0x63 /* 100 ms */
  79
  80 /* values for the ALS_GAIN register */
  81 #define VL6180_ALS_GAIN_1 0x46
  82 #define VL6180_ALS_GAIN_1_25 0x45
  83 #define VL6180_ALS_GAIN_1_67 0x44
  84 #define VL6180_ALS_GAIN_2_5 0x43
  85 #define VL6180_ALS_GAIN_5 0x42
  86 #define VL6180_ALS_GAIN_10 0x41
  87 #define VL6180_ALS_GAIN_20 0x40
  88 #define VL6180_ALS_GAIN_40 0x47
  89
  90 struct vl6180_data {
  91         struct i2c_client *client;
  92         struct mutex lock;
  93         struct completion completion;
  94         struct iio_trigger *trig;
  95         unsigned int als_gain_milli;
  96         unsigned int als_it_ms;
  97         unsigned int als_meas_rate;
  98         unsigned int range_meas_rate;
  99
 100         struct {
 101                 u16 chan[2];
 102                 aligned_s64 timestamp;
 103         } scan;
 104 };
 105
 106 enum { VL6180_ALS, VL6180_RANGE, VL6180_PROX };
 107
 108 /**
 109  * struct vl6180_chan_regs - Registers for accessing channels
 110  * @drdy_mask:                  Data ready bit in status register
 111  * @start_reg:                  Conversion start register
 112  * @value_reg:                  Result value register
 113  * @word:                       Register word length
 114  */
 115 struct vl6180_chan_regs {
 116         u8 drdy_mask;
 117         u16 start_reg, value_reg;
 118         bool word;
 119 };
 120
 121 static const struct vl6180_chan_regs vl6180_chan_regs_table[] = {
 122         [VL6180_ALS] = {
 123                 .drdy_mask = VL6180_ALS_READY,
 124                 .start_reg = VL6180_ALS_START,
 125                 .value_reg = VL6180_ALS_VALUE,
 126                 .word = true,
 127         },
 128         [VL6180_RANGE] = {
 129                 .drdy_mask = VL6180_RANGE_READY,
 130                 .start_reg = VL6180_RANGE_START,
 131                 .value_reg = VL6180_RANGE_VALUE,
 132                 .word = false,
 133         },
 134         [VL6180_PROX] = {
 135                 .drdy_mask = VL6180_RANGE_READY,
 136                 .start_reg = VL6180_RANGE_START,
 137                 .value_reg = VL6180_RANGE_RATE,
 138                 .word = true,
 139         },
 140 };
 141
 142 static int vl6180_read(struct i2c_client *client, u16 cmd, void *databuf,
 143                        u8 len)
 144 {
 145         __be16 cmdbuf = cpu_to_be16(cmd);
 146         struct i2c_msg msgs[2] = {
 147                 { .addr = client->addr, .len = sizeof(cmdbuf), .buf = (u8 *) &cmdbuf },
 148                 { .addr = client->addr, .len = len, .buf = databuf,
 149                   .flags = I2C_M_RD } };
 150         int ret;
 151
 152         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 153         if (ret < 0)
 154                 dev_err(&client->dev, "failed reading register 0x%04x\n", cmd);
 155
 156         return ret;
 157 }
 158
 159 static int vl6180_read_byte(struct i2c_client *client, u16 cmd)
 160 {
 161         u8 data;
 162         int ret;
 163
 164         ret = vl6180_read(client, cmd, &data, sizeof(data));
 165         if (ret < 0)
 166                 return ret;
 167
 168         return data;
 169 }
 170
 171 static int vl6180_read_word(struct i2c_client *client, u16 cmd)
 172 {
 173         __be16 data;
 174         int ret;
 175
 176         ret = vl6180_read(client, cmd, &data, sizeof(data));
 177         if (ret < 0)
 178                 return ret;
 179
 180         return be16_to_cpu(data);
 181 }
 182
 183 static int vl6180_write_byte(struct i2c_client *client, u16 cmd, u8 val)
 184 {
 185         u8 buf[3];
 186         struct i2c_msg msgs[1] = {
 187                 { .addr = client->addr, .len = sizeof(buf), .buf = (u8 *) &buf } };
 188         int ret;
 189
 190         buf[0] = cmd >> 8;
 191         buf[1] = cmd & 0xff;
 192         buf[2] = val;
 193
 194         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 195         if (ret < 0) {
 196                 dev_err(&client->dev, "failed writing register 0x%04x\n", cmd);
 197                 return ret;
 198         }
 199
 200         return 0;
 201 }
 202
 203 static int vl6180_write_word(struct i2c_client *client, u16 cmd, u16 val)
 204 {
 205         __be16 buf[2];
 206         struct i2c_msg msgs[1] = {
 207                 { .addr = client->addr, .len = sizeof(buf), .buf = (u8 *) &buf } };
 208         int ret;
 209
 210         buf[0] = cpu_to_be16(cmd);
 211         buf[1] = cpu_to_be16(val);
 212
 213         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 214         if (ret < 0) {
 215                 dev_err(&client->dev, "failed writing register 0x%04x\n", cmd);
 216                 return ret;
 217         }
 218
 219         return 0;
 220 }
 221
 222 static int vl6180_measure(struct vl6180_data *data, int addr)
 223 {
 224         struct i2c_client *client = data->client;
 225         unsigned long time_left;
 226         int tries = 20, ret;
 227         u16 value;
 228
 229         mutex_lock(&data->lock);
 230         reinit_completion(&data->completion);
 231
 232         /* Start single shot measurement */
 233         ret = vl6180_write_byte(client,
 234                 vl6180_chan_regs_table[addr].start_reg, VL6180_STARTSTOP);
 235         if (ret < 0)
 236                 goto fail;
 237
 238         if (client->irq) {
 239                 time_left = wait_for_completion_timeout(&data->completion, HZ / 10);
 240                 if (time_left == 0) {
 241                         ret = -ETIMEDOUT;
 242                         goto fail;
 243                 }
 244         } else {
 245                 while (tries--) {
 246                         ret = vl6180_read_byte(client, VL6180_INTR_STATUS);
 247                         if (ret < 0)
 248                                 goto fail;
 249
 250                         if (ret & vl6180_chan_regs_table[addr].drdy_mask)
 251                                 break;
 252                         msleep(20);
 253                 }
 254
 255                 if (tries < 0) {
 256                         ret = -EIO;
 257                         goto fail;
 258                 }
 259         }
 260
 261         /* Read result value from appropriate registers */
 262         ret = vl6180_chan_regs_table[addr].word ?
 263                 vl6180_read_word(client, vl6180_chan_regs_table[addr].value_reg) :
 264                 vl6180_read_byte(client, vl6180_chan_regs_table[addr].value_reg);
 265         if (ret < 0)
 266                 goto fail;
 267         value = ret;
 268
 269         /* Clear the interrupt flag after data read */
 270         ret = vl6180_write_byte(client, VL6180_INTR_CLEAR,
 271                 VL6180_CLEAR_ERROR | VL6180_CLEAR_ALS | VL6180_CLEAR_RANGE);
 272         if (ret < 0)
 273                 goto fail;
 274
 275         ret = value;
 276
 277 fail:
 278         mutex_unlock(&data->lock);
 279
 280         return ret;
 281 }
 282
 283 static const struct iio_chan_spec vl6180_channels[] = {
 284         {
 285                 .type = IIO_LIGHT,
 286                 .address = VL6180_ALS,
 287                 .scan_index = VL6180_ALS,
 288                 .scan_type = {
 289                         .sign = 'u',
 290                         .realbits = 16,
 291                         .storagebits = 16,
 292                 },
 293                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 294                         BIT(IIO_CHAN_INFO_INT_TIME) |
 295                         BIT(IIO_CHAN_INFO_SCALE) |
 296                         BIT(IIO_CHAN_INFO_HARDWAREGAIN) |
 297                         BIT(IIO_CHAN_INFO_SAMP_FREQ),
 298         }, {
 299                 .type = IIO_DISTANCE,
 300                 .address = VL6180_RANGE,
 301                 .scan_index = VL6180_RANGE,
 302                 .scan_type = {
 303                         .sign = 'u',
 304                         .realbits = 8,
 305                         .storagebits = 8,
 306                 },
 307                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 308                         BIT(IIO_CHAN_INFO_SCALE) |
 309                         BIT(IIO_CHAN_INFO_SAMP_FREQ),
 310         }, {
 311                 .type = IIO_PROXIMITY,
 312                 .address = VL6180_PROX,
 313                 .scan_index = VL6180_PROX,
 314                 .scan_type = {
 315                         .sign = 'u',
 316                         .realbits = 16,
 317                         .storagebits = 16,
 318                 },
 319                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 320         },
 321         IIO_CHAN_SOFT_TIMESTAMP(3),
 322 };
 323
 324 /*
 325  * Available Ambient Light Sensor gain settings, 1/1000th, and
 326  * corresponding setting for the VL6180_ALS_GAIN register
 327  */
 328 static const int vl6180_als_gain_tab[8] = {
 329         1000, 1250, 1670, 2500, 5000, 10000, 20000, 40000
 330 };
 331 static const u8 vl6180_als_gain_tab_bits[8] = {
 332         VL6180_ALS_GAIN_1,    VL6180_ALS_GAIN_1_25,
 333         VL6180_ALS_GAIN_1_67, VL6180_ALS_GAIN_2_5,
 334         VL6180_ALS_GAIN_5,    VL6180_ALS_GAIN_10,
 335         VL6180_ALS_GAIN_20,   VL6180_ALS_GAIN_40
 336 };
 337
 338 static int vl6180_read_raw(struct iio_dev *indio_dev,
 339                                 struct iio_chan_spec const *chan,
 340                                 int *val, int *val2, long mask)
 341 {
 342         struct vl6180_data *data = iio_priv(indio_dev);
 343         int ret;
 344
 345         switch (mask) {
 346         case IIO_CHAN_INFO_RAW:
 347                 ret = vl6180_measure(data, chan->address);
 348                 if (ret < 0)
 349                         return ret;
 350                 *val = ret;
 351
 352                 return IIO_VAL_INT;
 353         case IIO_CHAN_INFO_INT_TIME:
 354                 *val = data->als_it_ms;
 355                 *val2 = 1000;
 356
 357                 return IIO_VAL_FRACTIONAL;
 358
 359         case IIO_CHAN_INFO_SCALE:
 360                 switch (chan->type) {
 361                 case IIO_LIGHT:
 362                         /* one ALS count is 0.32 Lux @ gain 1, IT 100 ms */
 363                         *val = 32000; /* 0.32 * 1000 * 100 */
 364                         *val2 = data->als_gain_milli * data->als_it_ms;
 365
 366                         return IIO_VAL_FRACTIONAL;
 367
 368                 case IIO_DISTANCE:
 369                         *val = 0; /* sensor reports mm, scale to meter */
 370                         *val2 = 1000;
 371                         break;
 372                 default:
 373                         return -EINVAL;
 374                 }
 375
 376                 return IIO_VAL_INT_PLUS_MICRO;
 377         case IIO_CHAN_INFO_HARDWAREGAIN:
 378                 *val = data->als_gain_milli;
 379                 *val2 = 1000;
 380
 381                 return IIO_VAL_FRACTIONAL;
 382
 383         case IIO_CHAN_INFO_SAMP_FREQ:
 384                 switch (chan->type) {
 385                 case IIO_DISTANCE:
 386                         *val = data->range_meas_rate;
 387                         return IIO_VAL_INT;
 388                 case IIO_LIGHT:
 389                         *val = data->als_meas_rate;
 390                         return IIO_VAL_INT;
 391                 default:
 392                         return -EINVAL;
 393                 }
 394
 395         default:
 396                 return -EINVAL;
 397         }
 398 }
 399
 400 static IIO_CONST_ATTR(als_gain_available, "1 1.25 1.67 2.5 5 10 20 40");
 401
 402 static struct attribute *vl6180_attributes[] = {
 403         &iio_const_attr_als_gain_available.dev_attr.attr,
 404         NULL
 405 };
 406
 407 static const struct attribute_group vl6180_attribute_group = {
 408         .attrs = vl6180_attributes,
 409 };
 410
 411 /* HOLD is needed before updating any config registers */
 412 static int vl6180_hold(struct vl6180_data *data, bool hold)
 413 {
 414         return vl6180_write_byte(data->client, VL6180_HOLD,
 415                 hold ? VL6180_HOLD_ON : 0);
 416 }
 417
 418 static int vl6180_set_als_gain(struct vl6180_data *data, int val, int val2)
 419 {
 420         int i, ret, gain;
 421
 422         if (val < 1 || val > 40)
 423                 return -EINVAL;
 424
 425         gain = (val * 1000000 + val2) / 1000;
 426         if (gain < 1 || gain > 40000)
 427                 return -EINVAL;
 428
 429         i = find_closest(gain, vl6180_als_gain_tab,
 430                          ARRAY_SIZE(vl6180_als_gain_tab));
 431
 432         mutex_lock(&data->lock);
 433         ret = vl6180_hold(data, true);
 434         if (ret < 0)
 435                 goto fail;
 436
 437         ret = vl6180_write_byte(data->client, VL6180_ALS_GAIN,
 438                                 vl6180_als_gain_tab_bits[i]);
 439
 440         if (ret >= 0)
 441                 data->als_gain_milli = vl6180_als_gain_tab[i];
 442
 443 fail:
 444         vl6180_hold(data, false);
 445         mutex_unlock(&data->lock);
 446         return ret;
 447 }
 448
 449 static int vl6180_set_it(struct vl6180_data *data, int val, int val2)
 450 {
 451         int ret, it_ms;
 452
 453         it_ms = DIV_ROUND_CLOSEST(val2, 1000); /* round to ms */
 454         if (val != 0 || it_ms < 1 || it_ms > 512)
 455                 return -EINVAL;
 456
 457         mutex_lock(&data->lock);
 458         ret = vl6180_hold(data, true);
 459         if (ret < 0)
 460                 goto fail;
 461
 462         ret = vl6180_write_word(data->client, VL6180_ALS_IT, it_ms - 1);
 463
 464         if (ret >= 0)
 465                 data->als_it_ms = it_ms;
 466
 467 fail:
 468         vl6180_hold(data, false);
 469         mutex_unlock(&data->lock);
 470
 471         return ret;
 472 }
 473
 474 static int vl6180_meas_reg_val_from_mhz(unsigned int mhz)
 475 {
 476         unsigned int period = DIV_ROUND_CLOSEST(1000 * 1000, mhz);
 477         unsigned int reg_val = 0;
 478
 479         if (period > 10)
 480                 reg_val = period < 2550 ? (DIV_ROUND_CLOSEST(period, 10) - 1) : 254;
 481
 482         return reg_val;
 483 }
 484
 485 static int vl6180_write_raw(struct iio_dev *indio_dev,
 486                              struct iio_chan_spec const *chan,
 487                              int val, int val2, long mask)
 488 {
 489         struct vl6180_data *data = iio_priv(indio_dev);
 490         unsigned int reg_val;
 491
 492         switch (mask) {
 493         case IIO_CHAN_INFO_INT_TIME:
 494                 return vl6180_set_it(data, val, val2);
 495
 496         case IIO_CHAN_INFO_HARDWAREGAIN:
 497                 if (chan->type != IIO_LIGHT)
 498                         return -EINVAL;
 499
 500                 return vl6180_set_als_gain(data, val, val2);
 501
 502         case IIO_CHAN_INFO_SAMP_FREQ:
 503         {
 504                 guard(mutex)(&data->lock);
 505                 switch (chan->type) {
 506                 case IIO_DISTANCE:
 507                         data->range_meas_rate = val;
 508                         reg_val = vl6180_meas_reg_val_from_mhz(val);
 509                         return vl6180_write_byte(data->client,
 510                                 VL6180_RANGE_INTER_MEAS_TIME, reg_val);
 511
 512                 case IIO_LIGHT:
 513                         data->als_meas_rate = val;
 514                         reg_val = vl6180_meas_reg_val_from_mhz(val);
 515                         return vl6180_write_byte(data->client,
 516                                 VL6180_ALS_INTER_MEAS_TIME, reg_val);
 517
 518                 default:
 519                         return -EINVAL;
 520                 }
 521         }
 522
 523         default:
 524                 return -EINVAL;
 525         }
 526 }
 527
 528 static irqreturn_t vl6180_threaded_irq(int irq, void *priv)
 529 {
 530         struct iio_dev *indio_dev = priv;
 531         struct vl6180_data *data = iio_priv(indio_dev);
 532
 533         if (iio_buffer_enabled(indio_dev))
 534                 iio_trigger_poll_nested(indio_dev->trig);
 535         else
 536                 complete(&data->completion);
 537
 538         return IRQ_HANDLED;
 539 }
 540
 541 static irqreturn_t vl6180_trigger_handler(int irq, void *priv)
 542 {
 543         struct iio_poll_func *pf = priv;
 544         struct iio_dev *indio_dev = pf->indio_dev;
 545         struct vl6180_data *data = iio_priv(indio_dev);
 546         s64 time_ns = iio_get_time_ns(indio_dev);
 547         int ret, bit, i = 0;
 548
 549         iio_for_each_active_channel(indio_dev, bit) {
 550                 if (vl6180_chan_regs_table[bit].word)
 551                         ret = vl6180_read_word(data->client,
 552                                 vl6180_chan_regs_table[bit].value_reg);
 553                 else
 554                         ret = vl6180_read_byte(data->client,
 555                                 vl6180_chan_regs_table[bit].value_reg);
 556
 557                 if (ret < 0) {
 558                         dev_err(&data->client->dev,
 559                                 "failed to read from value regs: %d\n", ret);
 560                         return IRQ_HANDLED;
 561                 }
 562
 563                 data->scan.chan[i++] = ret;
 564         }
 565
 566         iio_push_to_buffers_with_timestamp(indio_dev, &data->scan, time_ns);
 567         iio_trigger_notify_done(indio_dev->trig);
 568
 569         /* Clear the interrupt flag after data read */
 570         ret = vl6180_write_byte(data->client, VL6180_INTR_CLEAR,
 571                 VL6180_CLEAR_ERROR | VL6180_CLEAR_ALS | VL6180_CLEAR_RANGE);
 572         if (ret < 0)
 573                 dev_err(&data->client->dev, "failed to clear irq: %d\n", ret);
 574
 575         return IRQ_HANDLED;
 576 }
 577
 578 static const struct iio_info vl6180_info = {
 579         .read_raw = vl6180_read_raw,
 580         .write_raw = vl6180_write_raw,
 581         .attrs = &vl6180_attribute_group,
 582         .validate_trigger = iio_validate_own_trigger,
 583 };
 584
 585 static int vl6180_buffer_postenable(struct iio_dev *indio_dev)
 586 {
 587         struct vl6180_data *data = iio_priv(indio_dev);
 588         int bit;
 589
 590         iio_for_each_active_channel(indio_dev, bit)
 591                 return vl6180_write_byte(data->client,
 592                         vl6180_chan_regs_table[bit].start_reg,
 593                         VL6180_MODE_CONT | VL6180_STARTSTOP);
 594
 595         return -EINVAL;
 596 }
 597
 598 static int vl6180_buffer_postdisable(struct iio_dev *indio_dev)
 599 {
 600         struct vl6180_data *data = iio_priv(indio_dev);
 601         int bit;
 602
 603         iio_for_each_active_channel(indio_dev, bit)
 604                 return vl6180_write_byte(data->client,
 605                         vl6180_chan_regs_table[bit].start_reg,
 606                         VL6180_STARTSTOP);
 607
 608         return -EINVAL;
 609 }
 610
 611 static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
 612         .postenable = &vl6180_buffer_postenable,
 613         .postdisable = &vl6180_buffer_postdisable,
 614 };
 615
 616 static const struct iio_trigger_ops vl6180_trigger_ops = {
 617         .validate_device = iio_trigger_validate_own_device,
 618 };
 619
 620 static int vl6180_init(struct vl6180_data *data, struct iio_dev *indio_dev)
 621 {
 622         struct i2c_client *client = data->client;
 623         int ret;
 624
 625         ret = vl6180_read_byte(client, VL6180_MODEL_ID);
 626         if (ret < 0)
 627                 return ret;
 628
 629         if (ret != VL6180_MODEL_ID_VAL) {
 630                 dev_err(&client->dev, "invalid model ID %02x\n", ret);
 631                 return -ENODEV;
 632         }
 633
 634         ret = vl6180_hold(data, true);
 635         if (ret < 0)
 636                 return ret;
 637
 638         ret = vl6180_read_byte(client, VL6180_OUT_OF_RESET);
 639         if (ret < 0)
 640                 return ret;
 641
 642         /*
 643          * Detect false reset condition here. This bit is always set when the
 644          * system comes out of reset.
 645          */
 646         if (ret != 0x01)
 647                 dev_info(&client->dev, "device is not fresh out of reset\n");
 648
 649         /* Enable ALS and Range ready interrupts */
 650         ret = vl6180_write_byte(client, VL6180_INTR_CONFIG,
 651                                 VL6180_ALS_READY | VL6180_RANGE_READY);
 652         if (ret < 0)
 653                 return ret;
 654
 655         ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
 656                                                 &vl6180_trigger_handler,
 657                                                 &iio_triggered_buffer_setup_ops);
 658         if (ret)
 659                 return ret;
 660
 661         /* Default Range inter-measurement time: 50ms or 20000 mHz */
 662         ret = vl6180_write_byte(client, VL6180_RANGE_INTER_MEAS_TIME,
 663                                 vl6180_meas_reg_val_from_mhz(20000));
 664         if (ret < 0)
 665                 return ret;
 666         data->range_meas_rate = 20000;
 667
 668         /* Default ALS inter-measurement time: 10ms or 100000 mHz */
 669         ret = vl6180_write_byte(client, VL6180_ALS_INTER_MEAS_TIME,
 670                                 vl6180_meas_reg_val_from_mhz(100000));
 671         if (ret < 0)
 672                 return ret;
 673         data->als_meas_rate = 100000;
 674
 675         /* ALS integration time: 100ms */
 676         data->als_it_ms = 100;
 677         ret = vl6180_write_word(client, VL6180_ALS_IT, VL6180_ALS_IT_100);
 678         if (ret < 0)
 679                 return ret;
 680
 681         /* ALS gain: 1 */
 682         data->als_gain_milli = 1000;
 683         ret = vl6180_write_byte(client, VL6180_ALS_GAIN, VL6180_ALS_GAIN_1);
 684         if (ret < 0)
 685                 return ret;
 686
 687         ret = vl6180_write_byte(client, VL6180_OUT_OF_RESET, 0x00);
 688         if (ret < 0)
 689                 return ret;
 690
 691         return vl6180_hold(data, false);
 692 }
 693
 694 static int vl6180_probe(struct i2c_client *client)
 695 {
 696         struct vl6180_data *data;
 697         struct iio_dev *indio_dev;
 698         int ret;
 699
 700         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 701         if (!indio_dev)
 702                 return -ENOMEM;
 703
 704         data = iio_priv(indio_dev);
 705         i2c_set_clientdata(client, indio_dev);
 706         data->client = client;
 707         mutex_init(&data->lock);
 708
 709         indio_dev->info = &vl6180_info;
 710         indio_dev->channels = vl6180_channels;
 711         indio_dev->num_channels = ARRAY_SIZE(vl6180_channels);
 712         indio_dev->name = VL6180_DRV_NAME;
 713         indio_dev->modes = INDIO_DIRECT_MODE;
 714
 715         ret = vl6180_init(data, indio_dev);
 716         if (ret < 0)
 717                 return ret;
 718
 719         if (client->irq) {
 720                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 721                                                 NULL, vl6180_threaded_irq,
 722                                                 IRQF_ONESHOT,
 723                                                 indio_dev->name, indio_dev);
 724                 if (ret)
 725                         return dev_err_probe(&client->dev, ret, "devm_request_irq error \n");
 726
 727                 init_completion(&data->completion);
 728
 729                 data->trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
 730                                                 indio_dev->name, iio_device_id(indio_dev));
 731                 if (!data->trig)
 732                         return -ENOMEM;
 733
 734                 data->trig->ops = &vl6180_trigger_ops;
 735                 iio_trigger_set_drvdata(data->trig, indio_dev);
 736                 ret = devm_iio_trigger_register(&client->dev, data->trig);
 737                 if (ret)
 738                         return ret;
 739
 740                 indio_dev->trig = iio_trigger_get(data->trig);
 741         }
 742
 743         return devm_iio_device_register(&client->dev, indio_dev);
 744 }
 745
 746 static const struct of_device_id vl6180_of_match[] = {
 747         { .compatible = "st,vl6180", },
 748         { },
 749 };
 750 MODULE_DEVICE_TABLE(of, vl6180_of_match);
 751
 752 static const struct i2c_device_id vl6180_id[] = {
 753         { "vl6180" },
 754         { }
 755 };
 756 MODULE_DEVICE_TABLE(i2c, vl6180_id);
 757
 758 static struct i2c_driver vl6180_driver = {
 759         .driver = {
 760                 .name   = VL6180_DRV_NAME,
 761                 .of_match_table = vl6180_of_match,
 762         },
 763         .probe = vl6180_probe,
 764         .id_table = vl6180_id,
 765 };
 766
 767 module_i2c_driver(vl6180_driver);
 768
 769 MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
 770 MODULE_AUTHOR("Manivannan Sadhasivam <manivannanece23@gmail.com>");
 771 MODULE_DESCRIPTION("STMicro VL6180 ALS, range and proximity sensor driver");
 772 MODULE_LICENSE("GPL");