drivers/iio/proximity/pulsedlight-lidar-lite-v2.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * pulsedlight-lidar-lite-v2.c - Support for PulsedLight LIDAR sensor
   4  *
   5  * Copyright (C) 2015, 2017-2018
   6  * Author: Matt Ranostay <matt.ranostay@konsulko.com>
   7  *
   8  * TODO: interrupt mode, and signal strength reporting
   9  */
  10
  11 #include <linux/err.h>
  12 #include <linux/init.h>
  13 #include <linux/i2c.h>
  14 #include <linux/delay.h>
  15 #include <linux/module.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/iio/iio.h>
  18 #include <linux/iio/sysfs.h>
  19 #include <linux/iio/buffer.h>
  20 #include <linux/iio/trigger.h>
  21 #include <linux/iio/triggered_buffer.h>
  22 #include <linux/iio/trigger_consumer.h>
  23
  24 #define LIDAR_REG_CONTROL               0x00
  25 #define LIDAR_REG_CONTROL_ACQUIRE       BIT(2)
  26
  27 #define LIDAR_REG_STATUS                0x01
  28 #define LIDAR_REG_STATUS_INVALID        BIT(3)
  29 #define LIDAR_REG_STATUS_READY          BIT(0)
  30
  31 #define LIDAR_REG_DATA_HBYTE            0x0f
  32 #define LIDAR_REG_DATA_LBYTE            0x10
  33 #define LIDAR_REG_DATA_WORD_READ        BIT(7)
  34
  35 #define LIDAR_REG_PWR_CONTROL   0x65
  36
  37 #define LIDAR_DRV_NAME "lidar"
  38
  39 struct lidar_data {
  40         struct iio_dev *indio_dev;
  41         struct i2c_client *client;
  42
  43         int (*xfer)(struct lidar_data *data, u8 reg, u8 *val, int len);
  44         int i2c_enabled;
  45
  46         /* Ensure timestamp is naturally aligned */
  47         struct {
  48                 u16 chan;
  49                 s64 timestamp __aligned(8);
  50         } scan;
  51 };
  52
  53 static const struct iio_chan_spec lidar_channels[] = {
  54         {
  55                 .type = IIO_DISTANCE,
  56                 .info_mask_separate =
  57                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  58                 .scan_index = 0,
  59                 .scan_type = {
  60                         .sign = 'u',
  61                         .realbits = 16,
  62                         .storagebits = 16,
  63                 },
  64         },
  65         IIO_CHAN_SOFT_TIMESTAMP(1),
  66 };
  67
  68 static int lidar_i2c_xfer(struct lidar_data *data, u8 reg, u8 *val, int len)
  69 {
  70         struct i2c_client *client = data->client;
  71         struct i2c_msg msg[2];
  72         int ret;
  73
  74         msg[0].addr = client->addr;
  75         msg[0].flags = client->flags | I2C_M_STOP;
  76         msg[0].len = 1;
  77         msg[0].buf  = (char *) &reg;
  78
  79         msg[1].addr = client->addr;
  80         msg[1].flags = client->flags | I2C_M_RD;
  81         msg[1].len = len;
  82         msg[1].buf = (char *) val;
  83
  84         ret = i2c_transfer(client->adapter, msg, 2);
  85
  86         return (ret == 2) ? 0 : -EIO;
  87 }
  88
  89 static int lidar_smbus_xfer(struct lidar_data *data, u8 reg, u8 *val, int len)
  90 {
  91         struct i2c_client *client = data->client;
  92         int ret;
  93
  94         /*
  95          * Device needs a STOP condition between address write, and data read
  96          * so in turn i2c_smbus_read_byte_data cannot be used
  97          */
  98
  99         while (len--) {
 100                 ret = i2c_smbus_write_byte(client, reg++);
 101                 if (ret < 0) {
 102                         dev_err(&client->dev, "cannot write addr value");
 103                         return ret;
 104                 }
 105
 106                 ret = i2c_smbus_read_byte(client);
 107                 if (ret < 0) {
 108                         dev_err(&client->dev, "cannot read data value");
 109                         return ret;
 110                 }
 111
 112                 *(val++) = ret;
 113         }
 114
 115         return 0;
 116 }
 117
 118 static int lidar_read_byte(struct lidar_data *data, u8 reg)
 119 {
 120         int ret;
 121         u8 val;
 122
 123         ret = data->xfer(data, reg, &val, 1);
 124         if (ret < 0)
 125                 return ret;
 126
 127         return val;
 128 }
 129
 130 static inline int lidar_write_control(struct lidar_data *data, int val)
 131 {
 132         return i2c_smbus_write_byte_data(data->client, LIDAR_REG_CONTROL, val);
 133 }
 134
 135 static inline int lidar_write_power(struct lidar_data *data, int val)
 136 {
 137         return i2c_smbus_write_byte_data(data->client,
 138                                          LIDAR_REG_PWR_CONTROL, val);
 139 }
 140
 141 static int lidar_read_measurement(struct lidar_data *data, u16 *reg)
 142 {
 143         int ret = data->xfer(data, LIDAR_REG_DATA_HBYTE |
 144                         (data->i2c_enabled ? LIDAR_REG_DATA_WORD_READ : 0),
 145                         (u8 *) reg, 2);
 146
 147         if (!ret)
 148                 *reg = be16_to_cpu(*reg);
 149
 150         return ret;
 151 }
 152
 153 static int lidar_get_measurement(struct lidar_data *data, u16 *reg)
 154 {
 155         struct i2c_client *client = data->client;
 156         int tries = 10;
 157         int ret;
 158
 159         pm_runtime_get_sync(&client->dev);
 160
 161         /* start sample */
 162         ret = lidar_write_control(data, LIDAR_REG_CONTROL_ACQUIRE);
 163         if (ret < 0) {
 164                 dev_err(&client->dev, "cannot send start measurement command");
 165                 pm_runtime_put_noidle(&client->dev);
 166                 return ret;
 167         }
 168
 169         while (tries--) {
 170                 usleep_range(1000, 2000);
 171
 172                 ret = lidar_read_byte(data, LIDAR_REG_STATUS);
 173                 if (ret < 0)
 174                         break;
 175
 176                 /* return -EINVAL since laser is likely pointed out of range */
 177                 if (ret & LIDAR_REG_STATUS_INVALID) {
 178                         *reg = 0;
 179                         ret = -EINVAL;
 180                         break;
 181                 }
 182
 183                 /* sample ready to read */
 184                 if (!(ret & LIDAR_REG_STATUS_READY)) {
 185                         ret = lidar_read_measurement(data, reg);
 186                         break;
 187                 }
 188                 ret = -EIO;
 189         }
 190         pm_runtime_mark_last_busy(&client->dev);
 191         pm_runtime_put_autosuspend(&client->dev);
 192
 193         return ret;
 194 }
 195
 196 static int lidar_read_raw(struct iio_dev *indio_dev,
 197                           struct iio_chan_spec const *chan,
 198                           int *val, int *val2, long mask)
 199 {
 200         struct lidar_data *data = iio_priv(indio_dev);
 201         int ret = -EINVAL;
 202
 203         switch (mask) {
 204         case IIO_CHAN_INFO_RAW: {
 205                 u16 reg;
 206
 207                 if (iio_device_claim_direct_mode(indio_dev))
 208                         return -EBUSY;
 209
 210                 ret = lidar_get_measurement(data, &reg);
 211                 if (!ret) {
 212                         *val = reg;
 213                         ret = IIO_VAL_INT;
 214                 }
 215                 iio_device_release_direct_mode(indio_dev);
 216                 break;
 217         }
 218         case IIO_CHAN_INFO_SCALE:
 219                 *val = 0;
 220                 *val2 = 10000;
 221                 ret = IIO_VAL_INT_PLUS_MICRO;
 222                 break;
 223         }
 224
 225         return ret;
 226 }
 227
 228 static irqreturn_t lidar_trigger_handler(int irq, void *private)
 229 {
 230         struct iio_poll_func *pf = private;
 231         struct iio_dev *indio_dev = pf->indio_dev;
 232         struct lidar_data *data = iio_priv(indio_dev);
 233         int ret;
 234
 235         ret = lidar_get_measurement(data, &data->scan.chan);
 236         if (!ret) {
 237                 iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 238                                                    iio_get_time_ns(indio_dev));
 239         } else if (ret != -EINVAL) {
 240                 dev_err(&data->client->dev, "cannot read LIDAR measurement");
 241         }
 242
 243         iio_trigger_notify_done(indio_dev->trig);
 244
 245         return IRQ_HANDLED;
 246 }
 247
 248 static const struct iio_info lidar_info = {
 249         .read_raw = lidar_read_raw,
 250 };
 251
 252 static int lidar_probe(struct i2c_client *client,
 253                        const struct i2c_device_id *id)
 254 {
 255         struct lidar_data *data;
 256         struct iio_dev *indio_dev;
 257         int ret;
 258
 259         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 260         if (!indio_dev)
 261                 return -ENOMEM;
 262         data = iio_priv(indio_dev);
 263
 264         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 265                 data->xfer = lidar_i2c_xfer;
 266                 data->i2c_enabled = 1;
 267         } else if (i2c_check_functionality(client->adapter,
 268                                 I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BYTE))
 269                 data->xfer = lidar_smbus_xfer;
 270         else
 271                 return -EOPNOTSUPP;
 272
 273         indio_dev->info = &lidar_info;
 274         indio_dev->name = LIDAR_DRV_NAME;
 275         indio_dev->channels = lidar_channels;
 276         indio_dev->num_channels = ARRAY_SIZE(lidar_channels);
 277         indio_dev->dev.parent = &client->dev;
 278         indio_dev->modes = INDIO_DIRECT_MODE;
 279
 280         i2c_set_clientdata(client, indio_dev);
 281
 282         data->client = client;
 283         data->indio_dev = indio_dev;
 284
 285         ret = iio_triggered_buffer_setup(indio_dev, NULL,
 286                                          lidar_trigger_handler, NULL);
 287         if (ret)
 288                 return ret;
 289
 290         ret = iio_device_register(indio_dev);
 291         if (ret)
 292                 goto error_unreg_buffer;
 293
 294         pm_runtime_set_autosuspend_delay(&client->dev, 1000);
 295         pm_runtime_use_autosuspend(&client->dev);
 296
 297         ret = pm_runtime_set_active(&client->dev);
 298         if (ret)
 299                 goto error_unreg_buffer;
 300         pm_runtime_enable(&client->dev);
 301         pm_runtime_idle(&client->dev);
 302
 303         return 0;
 304
 305 error_unreg_buffer:
 306         iio_triggered_buffer_cleanup(indio_dev);
 307
 308         return ret;
 309 }
 310
 311 static int lidar_remove(struct i2c_client *client)
 312 {
 313         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 314
 315         iio_device_unregister(indio_dev);
 316         iio_triggered_buffer_cleanup(indio_dev);
 317
 318         pm_runtime_disable(&client->dev);
 319         pm_runtime_set_suspended(&client->dev);
 320
 321         return 0;
 322 }
 323
 324 static const struct i2c_device_id lidar_id[] = {
 325         {"lidar-lite-v2", 0},
 326         {"lidar-lite-v3", 0},
 327         { },
 328 };
 329 MODULE_DEVICE_TABLE(i2c, lidar_id);
 330
 331 static const struct of_device_id lidar_dt_ids[] = {
 332         { .compatible = "pulsedlight,lidar-lite-v2" },
 333         { .compatible = "grmn,lidar-lite-v3" },
 334         { }
 335 };
 336 MODULE_DEVICE_TABLE(of, lidar_dt_ids);
 337
 338 #ifdef CONFIG_PM
 339 static int lidar_pm_runtime_suspend(struct device *dev)
 340 {
 341         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 342         struct lidar_data *data = iio_priv(indio_dev);
 343
 344         return lidar_write_power(data, 0x0f);
 345 }
 346
 347 static int lidar_pm_runtime_resume(struct device *dev)
 348 {
 349         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 350         struct lidar_data *data = iio_priv(indio_dev);
 351         int ret = lidar_write_power(data, 0);
 352
 353         /* regulator and FPGA needs settling time */
 354         usleep_range(15000, 20000);
 355
 356         return ret;
 357 }
 358 #endif
 359
 360 static const struct dev_pm_ops lidar_pm_ops = {
 361         SET_RUNTIME_PM_OPS(lidar_pm_runtime_suspend,
 362                            lidar_pm_runtime_resume, NULL)
 363 };
 364
 365 static struct i2c_driver lidar_driver = {
 366         .driver = {
 367                 .name   = LIDAR_DRV_NAME,
 368                 .of_match_table = of_match_ptr(lidar_dt_ids),
 369                 .pm     = &lidar_pm_ops,
 370         },
 371         .probe          = lidar_probe,
 372         .remove         = lidar_remove,
 373         .id_table       = lidar_id,
 374 };
 375 module_i2c_driver(lidar_driver);
 376
 377 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
 378 MODULE_DESCRIPTION("PulsedLight LIDAR sensor");
 379 MODULE_LICENSE("GPL");