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

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