drivers/iio/proximity/vl53l0x-i2c.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Support for ST VL53L0X FlightSense ToF Ranging Sensor on a i2c bus.
   4  *
   5  * Copyright (C) 2016 STMicroelectronics Imaging Division.
   6  * Copyright (C) 2018 Song Qiang <songqiang1304521@gmail.com>
   7  * Copyright (C) 2020 Ivan Drobyshevskyi <drobyshevskyi@gmail.com>
   8  *
   9  * Datasheet available at
  10  * <https://www.st.com/resource/en/datasheet/vl53l0x.pdf>
  11  *
  12  * Default 7-bit i2c slave address 0x29.
  13  *
  14  * TODO: FIFO buffer, continuous mode, range selection, sensor ID check.
  15  */
  16
  17 #include <linux/delay.h>
  18 #include <linux/gpio/consumer.h>
  19 #include <linux/i2c.h>
  20 #include <linux/irq.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/module.h>
  23 #include <linux/unaligned.h>
  24
  25 #include <linux/iio/iio.h>
  26 #include <linux/iio/buffer.h>
  27 #include <linux/iio/trigger.h>
  28 #include <linux/iio/trigger_consumer.h>
  29 #include <linux/iio/triggered_buffer.h>
  30
  31 #define VL_REG_SYSRANGE_START                           0x00
  32
  33 #define VL_REG_SYSRANGE_MODE_MASK                       GENMASK(3, 0)
  34 #define VL_REG_SYSRANGE_MODE_SINGLESHOT                 0x00
  35 #define VL_REG_SYSRANGE_MODE_START_STOP                 BIT(0)
  36 #define VL_REG_SYSRANGE_MODE_BACKTOBACK                 BIT(1)
  37 #define VL_REG_SYSRANGE_MODE_TIMED                      BIT(2)
  38 #define VL_REG_SYSRANGE_MODE_HISTOGRAM                  BIT(3)
  39
  40 #define VL_REG_SYSTEM_INTERRUPT_CONFIG_GPIO             0x0A
  41 #define VL_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY   BIT(2)
  42
  43 #define VL_REG_SYSTEM_INTERRUPT_CLEAR                   0x0B
  44
  45 #define VL_REG_RESULT_INT_STATUS                        0x13
  46 #define VL_REG_RESULT_RANGE_STATUS                      0x14
  47 #define VL_REG_IDENTIFICATION_MODEL_ID                  0xC0
  48 #define VL_REG_RESULT_RANGE_STATUS_COMPLETE             BIT(0)
  49
  50 #define VL53L0X_MODEL_ID_VAL                            0xEE
  51 #define VL53L0X_CONTINUOUS_MODE                         0x02
  52 #define VL53L0X_SINGLE_MODE                             0x01
  53
  54 struct vl53l0x_data {
  55         struct i2c_client *client;
  56         struct completion completion;
  57         struct regulator *vdd_supply;
  58         struct gpio_desc *reset_gpio;
  59         struct iio_trigger *trig;
  60
  61         struct {
  62                 u16 chan;
  63                 aligned_s64 timestamp;
  64         } scan;
  65 };
  66
  67 static int vl53l0x_clear_irq(struct vl53l0x_data *data)
  68 {       int ret;
  69
  70         ret = i2c_smbus_write_byte_data(data->client,
  71                                         VL_REG_SYSTEM_INTERRUPT_CLEAR, 1);
  72         if (ret < 0) {
  73                 dev_err(&data->client->dev, "failed to clear irq: %d\n", ret);
  74                 return -EINVAL;
  75         }
  76
  77         return 0;
  78 }
  79
  80 static irqreturn_t vl53l0x_trigger_handler(int irq, void *priv)
  81 {
  82         struct iio_poll_func *pf = priv;
  83         struct iio_dev *indio_dev = pf->indio_dev;
  84         struct vl53l0x_data *data = iio_priv(indio_dev);
  85         u8 buffer[12];
  86         int ret;
  87
  88         ret = i2c_smbus_read_i2c_block_data(data->client,
  89                                         VL_REG_RESULT_RANGE_STATUS,
  90                                         sizeof(buffer), buffer);
  91         if (ret < 0)
  92                 return ret;
  93         else if (ret != 12)
  94                 return -EREMOTEIO;
  95
  96         data->scan.chan = get_unaligned_be16(&buffer[10]);
  97         iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
  98                                         iio_get_time_ns(indio_dev));
  99
 100         iio_trigger_notify_done(indio_dev->trig);
 101         vl53l0x_clear_irq(data);
 102
 103         return IRQ_HANDLED;
 104 }
 105
 106 static irqreturn_t vl53l0x_threaded_irq(int irq, void *priv)
 107 {
 108         struct iio_dev *indio_dev = priv;
 109         struct vl53l0x_data *data = iio_priv(indio_dev);
 110
 111         if (iio_buffer_enabled(indio_dev))
 112                 iio_trigger_poll_nested(indio_dev->trig);
 113         else
 114                 complete(&data->completion);
 115
 116         return IRQ_HANDLED;
 117 }
 118
 119 static int vl53l0x_configure_irq(struct i2c_client *client,
 120                                  struct iio_dev *indio_dev)
 121 {
 122         int irq_flags = irq_get_trigger_type(client->irq);
 123         struct vl53l0x_data *data = iio_priv(indio_dev);
 124         int ret;
 125
 126         if (!irq_flags)
 127                 irq_flags = IRQF_TRIGGER_FALLING;
 128
 129         ret = devm_request_threaded_irq(&client->dev, client->irq,
 130                         NULL, vl53l0x_threaded_irq,
 131                         irq_flags | IRQF_ONESHOT, indio_dev->name, indio_dev);
 132         if (ret) {
 133                 dev_err(&client->dev, "devm_request_irq error: %d\n", ret);
 134                 return ret;
 135         }
 136
 137         ret = i2c_smbus_write_byte_data(data->client,
 138                         VL_REG_SYSTEM_INTERRUPT_CONFIG_GPIO,
 139                         VL_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
 140         if (ret < 0)
 141                 dev_err(&client->dev, "failed to configure IRQ: %d\n", ret);
 142
 143         return ret;
 144 }
 145
 146 static int vl53l0x_read_proximity(struct vl53l0x_data *data,
 147                                   const struct iio_chan_spec *chan,
 148                                   int *val)
 149 {
 150         struct i2c_client *client = data->client;
 151         u16 tries = 20;
 152         u8 buffer[12];
 153         int ret;
 154         unsigned long time_left;
 155
 156         ret = i2c_smbus_write_byte_data(client, VL_REG_SYSRANGE_START, 1);
 157         if (ret < 0)
 158                 return ret;
 159
 160         if (data->client->irq) {
 161                 reinit_completion(&data->completion);
 162
 163                 time_left = wait_for_completion_timeout(&data->completion, HZ/10);
 164                 if (time_left == 0)
 165                         return -ETIMEDOUT;
 166
 167                 ret = vl53l0x_clear_irq(data);
 168                 if (ret < 0)
 169                         return ret;
 170         } else {
 171                 do {
 172                         ret = i2c_smbus_read_byte_data(client,
 173                                                VL_REG_RESULT_RANGE_STATUS);
 174                         if (ret < 0)
 175                                 return ret;
 176
 177                         if (ret & VL_REG_RESULT_RANGE_STATUS_COMPLETE)
 178                                 break;
 179
 180                         usleep_range(1000, 5000);
 181                 } while (--tries);
 182                 if (!tries)
 183                         return -ETIMEDOUT;
 184         }
 185
 186         ret = i2c_smbus_read_i2c_block_data(client, VL_REG_RESULT_RANGE_STATUS,
 187                                             12, buffer);
 188         if (ret < 0)
 189                 return ret;
 190         else if (ret != 12)
 191                 return -EREMOTEIO;
 192
 193         /* Values should be between 30~1200 in millimeters. */
 194         *val = get_unaligned_be16(&buffer[10]);
 195
 196         return 0;
 197 }
 198
 199 static const struct iio_chan_spec vl53l0x_channels[] = {
 200         {
 201                 .type = IIO_DISTANCE,
 202                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 203                                       BIT(IIO_CHAN_INFO_SCALE),
 204                 .scan_index = 0,
 205                 .scan_type = {
 206                         .sign = 'u',
 207                         .realbits = 12,
 208                         .storagebits = 16,
 209                 },
 210         },
 211         IIO_CHAN_SOFT_TIMESTAMP(1),
 212 };
 213
 214 static int vl53l0x_read_raw(struct iio_dev *indio_dev,
 215                             const struct iio_chan_spec *chan,
 216                             int *val, int *val2, long mask)
 217 {
 218         struct vl53l0x_data *data = iio_priv(indio_dev);
 219         int ret;
 220
 221         if (chan->type != IIO_DISTANCE)
 222                 return -EINVAL;
 223
 224         switch (mask) {
 225         case IIO_CHAN_INFO_RAW:
 226                 ret = vl53l0x_read_proximity(data, chan, val);
 227                 if (ret < 0)
 228                         return ret;
 229
 230                 return IIO_VAL_INT;
 231         case IIO_CHAN_INFO_SCALE:
 232                 *val = 0;
 233                 *val2 = 1000;
 234
 235                 return IIO_VAL_INT_PLUS_MICRO;
 236         default:
 237                 return -EINVAL;
 238         }
 239 }
 240
 241 static int vl53l0x_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig)
 242 {
 243         struct vl53l0x_data *data = iio_priv(indio_dev);
 244
 245         return data->trig == trig ? 0 : -EINVAL;
 246 }
 247
 248 static const struct iio_info vl53l0x_info = {
 249         .read_raw = vl53l0x_read_raw,
 250         .validate_trigger = vl53l0x_validate_trigger,
 251 };
 252
 253 static void vl53l0x_power_off(void *_data)
 254 {
 255         struct vl53l0x_data *data = _data;
 256
 257         gpiod_set_value_cansleep(data->reset_gpio, 1);
 258
 259         regulator_disable(data->vdd_supply);
 260 }
 261
 262 static int vl53l0x_power_on(struct vl53l0x_data *data)
 263 {
 264         int ret;
 265
 266         ret = regulator_enable(data->vdd_supply);
 267         if (ret)
 268                 return ret;
 269
 270         gpiod_set_value_cansleep(data->reset_gpio, 0);
 271
 272         usleep_range(3200, 5000);
 273
 274         return 0;
 275 }
 276
 277 static int vl53l0x_buffer_postenable(struct iio_dev *indio_dev)
 278 {
 279         struct vl53l0x_data *data = iio_priv(indio_dev);
 280
 281         return i2c_smbus_write_byte_data(data->client, VL_REG_SYSRANGE_START,
 282                                                 VL53L0X_CONTINUOUS_MODE);
 283 }
 284
 285 static int vl53l0x_buffer_postdisable(struct iio_dev *indio_dev)
 286 {
 287         struct vl53l0x_data *data = iio_priv(indio_dev);
 288         int ret;
 289
 290         ret = i2c_smbus_write_byte_data(data->client, VL_REG_SYSRANGE_START,
 291                                                 VL53L0X_SINGLE_MODE);
 292         if (ret < 0)
 293                 return ret;
 294
 295         /* Let the ongoing reading finish */
 296         reinit_completion(&data->completion);
 297         wait_for_completion_timeout(&data->completion, HZ / 10);
 298
 299         return vl53l0x_clear_irq(data);
 300 }
 301
 302 static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
 303         .postenable = &vl53l0x_buffer_postenable,
 304         .postdisable = &vl53l0x_buffer_postdisable,
 305 };
 306
 307 static const struct iio_trigger_ops vl53l0x_trigger_ops = {
 308         .validate_device = iio_trigger_validate_own_device,
 309 };
 310
 311 static int vl53l0x_probe(struct i2c_client *client)
 312 {
 313         struct vl53l0x_data *data;
 314         struct iio_dev *indio_dev;
 315         int error;
 316         int ret;
 317
 318         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 319         if (!indio_dev)
 320                 return -ENOMEM;
 321
 322         data = iio_priv(indio_dev);
 323         data->client = client;
 324         i2c_set_clientdata(client, indio_dev);
 325
 326         if (!i2c_check_functionality(client->adapter,
 327                                      I2C_FUNC_SMBUS_READ_I2C_BLOCK |
 328                                      I2C_FUNC_SMBUS_BYTE_DATA))
 329                 return -EOPNOTSUPP;
 330
 331         ret = i2c_smbus_read_byte_data(data->client, VL_REG_IDENTIFICATION_MODEL_ID);
 332         if (ret < 0)
 333                 return -EINVAL;
 334
 335         if (ret != VL53L0X_MODEL_ID_VAL)
 336                 dev_info(&client->dev, "Unknown model id: 0x%x", ret);
 337
 338         data->vdd_supply = devm_regulator_get(&client->dev, "vdd");
 339         if (IS_ERR(data->vdd_supply))
 340                 return dev_err_probe(&client->dev, PTR_ERR(data->vdd_supply),
 341                                      "Unable to get VDD regulator\n");
 342
 343         data->reset_gpio = devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_HIGH);
 344         if (IS_ERR(data->reset_gpio))
 345                 return dev_err_probe(&client->dev, PTR_ERR(data->reset_gpio),
 346                                      "Cannot get reset GPIO\n");
 347
 348         error = vl53l0x_power_on(data);
 349         if (error)
 350                 return dev_err_probe(&client->dev, error,
 351                                      "Failed to power on the chip\n");
 352
 353         error = devm_add_action_or_reset(&client->dev, vl53l0x_power_off, data);
 354         if (error)
 355                 return dev_err_probe(&client->dev, error,
 356                                      "Failed to install poweroff action\n");
 357
 358         indio_dev->name = "vl53l0x";
 359         indio_dev->info = &vl53l0x_info;
 360         indio_dev->channels = vl53l0x_channels;
 361         indio_dev->num_channels = ARRAY_SIZE(vl53l0x_channels);
 362         indio_dev->modes = INDIO_DIRECT_MODE;
 363
 364         /* usage of interrupt is optional */
 365         if (client->irq) {
 366                 init_completion(&data->completion);
 367
 368                 data->trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
 369                                                 indio_dev->name,
 370                                                 iio_device_id(indio_dev));
 371                 if (!data->trig)
 372                         return -ENOMEM;
 373
 374                 data->trig->ops = &vl53l0x_trigger_ops;
 375                 iio_trigger_set_drvdata(data->trig, indio_dev);
 376                 ret = devm_iio_trigger_register(&client->dev, data->trig);
 377                 if (ret)
 378                         return ret;
 379
 380                 indio_dev->trig = iio_trigger_get(data->trig);
 381
 382                 ret = vl53l0x_configure_irq(client, indio_dev);
 383                 if (ret)
 384                         return ret;
 385
 386                 ret = devm_iio_triggered_buffer_setup(&client->dev,
 387                                         indio_dev,
 388                                         NULL,
 389                                         &vl53l0x_trigger_handler,
 390                                         &iio_triggered_buffer_setup_ops);
 391                 if (ret)
 392                         return ret;
 393         }
 394
 395         return devm_iio_device_register(&client->dev, indio_dev);
 396 }
 397
 398 static const struct i2c_device_id vl53l0x_id[] = {
 399         { "vl53l0x" },
 400         { }
 401 };
 402 MODULE_DEVICE_TABLE(i2c, vl53l0x_id);
 403
 404 static const struct of_device_id st_vl53l0x_dt_match[] = {
 405         { .compatible = "st,vl53l0x", },
 406         { }
 407 };
 408 MODULE_DEVICE_TABLE(of, st_vl53l0x_dt_match);
 409
 410 static struct i2c_driver vl53l0x_driver = {
 411         .driver = {
 412                 .name = "vl53l0x-i2c",
 413                 .of_match_table = st_vl53l0x_dt_match,
 414         },
 415         .probe = vl53l0x_probe,
 416         .id_table = vl53l0x_id,
 417 };
 418 module_i2c_driver(vl53l0x_driver);
 419
 420 MODULE_AUTHOR("Song Qiang <songqiang1304521@gmail.com>");
 421 MODULE_DESCRIPTION("ST vl53l0x ToF ranging sensor driver");
 422 MODULE_LICENSE("GPL v2");