drivers/iio/proximity/srf04.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * SRF04: ultrasonic sensor for distance measuring by using GPIOs
   4  *
   5  * Copyright (c) 2017 Andreas Klinger <ak@it-klinger.de>
   6  *
   7  * For details about the device see:
   8  * https://www.robot-electronics.co.uk/htm/srf04tech.htm
   9  *
  10  * the measurement cycle as timing diagram looks like:
  11  *
  12  *          +---+
  13  * GPIO     |   |
  14  * trig:  --+   +------------------------------------------------------
  15  *          ^   ^
  16  *          |<->|
  17  *         udelay(trigger_pulse_us)
  18  *
  19  * ultra           +-+ +-+ +-+
  20  * sonic           | | | | | |
  21  * burst: ---------+ +-+ +-+ +-----------------------------------------
  22  *                           .
  23  * ultra                     .              +-+ +-+ +-+
  24  * sonic                     .              | | | | | |
  25  * echo:  ----------------------------------+ +-+ +-+ +----------------
  26  *                           .                        .
  27  *                           +------------------------+
  28  * GPIO                      |                        |
  29  * echo:  -------------------+                        +---------------
  30  *                           ^                        ^
  31  *                           interrupt                interrupt
  32  *                           (ts_rising)              (ts_falling)
  33  *                           |<---------------------->|
  34  *                              pulse time measured
  35  *                              --> one round trip of ultra sonic waves
  36  */
  37 #include <linux/err.h>
  38 #include <linux/gpio/consumer.h>
  39 #include <linux/kernel.h>
  40 #include <linux/module.h>
  41 #include <linux/of.h>
  42 #include <linux/of_device.h>
  43 #include <linux/platform_device.h>
  44 #include <linux/property.h>
  45 #include <linux/sched.h>
  46 #include <linux/interrupt.h>
  47 #include <linux/delay.h>
  48 #include <linux/pm_runtime.h>
  49 #include <linux/iio/iio.h>
  50 #include <linux/iio/sysfs.h>
  51
  52 struct srf04_cfg {
  53         unsigned long trigger_pulse_us;
  54 };
  55
  56 struct srf04_data {
  57         struct device           *dev;
  58         struct gpio_desc        *gpiod_trig;
  59         struct gpio_desc        *gpiod_echo;
  60         struct gpio_desc        *gpiod_power;
  61         struct mutex            lock;
  62         int                     irqnr;
  63         ktime_t                 ts_rising;
  64         ktime_t                 ts_falling;
  65         struct completion       rising;
  66         struct completion       falling;
  67         const struct srf04_cfg  *cfg;
  68         int                     startup_time_ms;
  69 };
  70
  71 static const struct srf04_cfg srf04_cfg = {
  72         .trigger_pulse_us = 10,
  73 };
  74
  75 static const struct srf04_cfg mb_lv_cfg = {
  76         .trigger_pulse_us = 20,
  77 };
  78
  79 static irqreturn_t srf04_handle_irq(int irq, void *dev_id)
  80 {
  81         struct iio_dev *indio_dev = dev_id;
  82         struct srf04_data *data = iio_priv(indio_dev);
  83         ktime_t now = ktime_get();
  84
  85         if (gpiod_get_value(data->gpiod_echo)) {
  86                 data->ts_rising = now;
  87                 complete(&data->rising);
  88         } else {
  89                 data->ts_falling = now;
  90                 complete(&data->falling);
  91         }
  92
  93         return IRQ_HANDLED;
  94 }
  95
  96 static int srf04_read(struct srf04_data *data)
  97 {
  98         int ret;
  99         ktime_t ktime_dt;
 100         u64 dt_ns;
 101         u32 time_ns, distance_mm;
 102
 103         if (data->gpiod_power) {
 104                 ret = pm_runtime_resume_and_get(data->dev);
 105                 if (ret < 0)
 106                         return ret;
 107         }
 108         /*
 109          * just one read-echo-cycle can take place at a time
 110          * ==> lock against concurrent reading calls
 111          */
 112         mutex_lock(&data->lock);
 113
 114         reinit_completion(&data->rising);
 115         reinit_completion(&data->falling);
 116
 117         gpiod_set_value(data->gpiod_trig, 1);
 118         udelay(data->cfg->trigger_pulse_us);
 119         gpiod_set_value(data->gpiod_trig, 0);
 120
 121         if (data->gpiod_power) {
 122                 pm_runtime_mark_last_busy(data->dev);
 123                 pm_runtime_put_autosuspend(data->dev);
 124         }
 125
 126         /* it should not take more than 20 ms until echo is rising */
 127         ret = wait_for_completion_killable_timeout(&data->rising, HZ/50);
 128         if (ret < 0) {
 129                 mutex_unlock(&data->lock);
 130                 return ret;
 131         } else if (ret == 0) {
 132                 mutex_unlock(&data->lock);
 133                 return -ETIMEDOUT;
 134         }
 135
 136         /* it cannot take more than 50 ms until echo is falling */
 137         ret = wait_for_completion_killable_timeout(&data->falling, HZ/20);
 138         if (ret < 0) {
 139                 mutex_unlock(&data->lock);
 140                 return ret;
 141         } else if (ret == 0) {
 142                 mutex_unlock(&data->lock);
 143                 return -ETIMEDOUT;
 144         }
 145
 146         ktime_dt = ktime_sub(data->ts_falling, data->ts_rising);
 147
 148         mutex_unlock(&data->lock);
 149
 150         dt_ns = ktime_to_ns(ktime_dt);
 151         /*
 152          * measuring more than 6,45 meters is beyond the capabilities of
 153          * the supported sensors
 154          * ==> filter out invalid results for not measuring echos of
 155          *     another us sensor
 156          *
 157          * formula:
 158          *         distance     6,45 * 2 m
 159          * time = ---------- = ------------ = 40438871 ns
 160          *          speed         319 m/s
 161          *
 162          * using a minimum speed at -20 °C of 319 m/s
 163          */
 164         if (dt_ns > 40438871)
 165                 return -EIO;
 166
 167         time_ns = dt_ns;
 168
 169         /*
 170          * the speed as function of the temperature is approximately:
 171          *
 172          * speed = 331,5 + 0,6 * Temp
 173          *   with Temp in °C
 174          *   and speed in m/s
 175          *
 176          * use 343,5 m/s as ultrasonic speed at 20 °C here in absence of the
 177          * temperature
 178          *
 179          * therefore:
 180          *             time     343,5     time * 106
 181          * distance = ------ * ------- = ------------
 182          *             10^6         2         617176
 183          *   with time in ns
 184          *   and distance in mm (one way)
 185          *
 186          * because we limit to 6,45 meters the multiplication with 106 just
 187          * fits into 32 bit
 188          */
 189         distance_mm = time_ns * 106 / 617176;
 190
 191         return distance_mm;
 192 }
 193
 194 static int srf04_read_raw(struct iio_dev *indio_dev,
 195                             struct iio_chan_spec const *channel, int *val,
 196                             int *val2, long info)
 197 {
 198         struct srf04_data *data = iio_priv(indio_dev);
 199         int ret;
 200
 201         if (channel->type != IIO_DISTANCE)
 202                 return -EINVAL;
 203
 204         switch (info) {
 205         case IIO_CHAN_INFO_RAW:
 206                 ret = srf04_read(data);
 207                 if (ret < 0)
 208                         return ret;
 209                 *val = ret;
 210                 return IIO_VAL_INT;
 211         case IIO_CHAN_INFO_SCALE:
 212                 /*
 213                  * theoretical maximum resolution is 3 mm
 214                  * 1 LSB is 1 mm
 215                  */
 216                 *val = 0;
 217                 *val2 = 1000;
 218                 return IIO_VAL_INT_PLUS_MICRO;
 219         default:
 220                 return -EINVAL;
 221         }
 222 }
 223
 224 static const struct iio_info srf04_iio_info = {
 225         .read_raw               = srf04_read_raw,
 226 };
 227
 228 static const struct iio_chan_spec srf04_chan_spec[] = {
 229         {
 230                 .type = IIO_DISTANCE,
 231                 .info_mask_separate =
 232                                 BIT(IIO_CHAN_INFO_RAW) |
 233                                 BIT(IIO_CHAN_INFO_SCALE),
 234         },
 235 };
 236
 237 static const struct of_device_id of_srf04_match[] = {
 238         { .compatible = "devantech,srf04", .data = &srf04_cfg},
 239         { .compatible = "maxbotix,mb1000", .data = &mb_lv_cfg},
 240         { .compatible = "maxbotix,mb1010", .data = &mb_lv_cfg},
 241         { .compatible = "maxbotix,mb1020", .data = &mb_lv_cfg},
 242         { .compatible = "maxbotix,mb1030", .data = &mb_lv_cfg},
 243         { .compatible = "maxbotix,mb1040", .data = &mb_lv_cfg},
 244         {},
 245 };
 246
 247 MODULE_DEVICE_TABLE(of, of_srf04_match);
 248
 249 static int srf04_probe(struct platform_device *pdev)
 250 {
 251         struct device *dev = &pdev->dev;
 252         struct srf04_data *data;
 253         struct iio_dev *indio_dev;
 254         int ret;
 255
 256         indio_dev = devm_iio_device_alloc(dev, sizeof(struct srf04_data));
 257         if (!indio_dev) {
 258                 dev_err(dev, "failed to allocate IIO device\n");
 259                 return -ENOMEM;
 260         }
 261
 262         data = iio_priv(indio_dev);
 263         data->dev = dev;
 264         data->cfg = of_match_device(of_srf04_match, dev)->data;
 265
 266         mutex_init(&data->lock);
 267         init_completion(&data->rising);
 268         init_completion(&data->falling);
 269
 270         data->gpiod_trig = devm_gpiod_get(dev, "trig", GPIOD_OUT_LOW);
 271         if (IS_ERR(data->gpiod_trig)) {
 272                 dev_err(dev, "failed to get trig-gpios: err=%ld\n",
 273                                         PTR_ERR(data->gpiod_trig));
 274                 return PTR_ERR(data->gpiod_trig);
 275         }
 276
 277         data->gpiod_echo = devm_gpiod_get(dev, "echo", GPIOD_IN);
 278         if (IS_ERR(data->gpiod_echo)) {
 279                 dev_err(dev, "failed to get echo-gpios: err=%ld\n",
 280                                         PTR_ERR(data->gpiod_echo));
 281                 return PTR_ERR(data->gpiod_echo);
 282         }
 283
 284         data->gpiod_power = devm_gpiod_get_optional(dev, "power",
 285                                                                 GPIOD_OUT_LOW);
 286         if (IS_ERR(data->gpiod_power)) {
 287                 dev_err(dev, "failed to get power-gpios: err=%ld\n",
 288                                                 PTR_ERR(data->gpiod_power));
 289                 return PTR_ERR(data->gpiod_power);
 290         }
 291         if (data->gpiod_power) {
 292
 293                 if (of_property_read_u32(dev->of_node, "startup-time-ms",
 294                                                 &data->startup_time_ms))
 295                         data->startup_time_ms = 100;
 296                 dev_dbg(dev, "using power gpio: startup-time-ms=%d\n",
 297                                                         data->startup_time_ms);
 298         }
 299
 300         if (gpiod_cansleep(data->gpiod_echo)) {
 301                 dev_err(data->dev, "cansleep-GPIOs not supported\n");
 302                 return -ENODEV;
 303         }
 304
 305         data->irqnr = gpiod_to_irq(data->gpiod_echo);
 306         if (data->irqnr < 0) {
 307                 dev_err(data->dev, "gpiod_to_irq: %d\n", data->irqnr);
 308                 return data->irqnr;
 309         }
 310
 311         ret = devm_request_irq(dev, data->irqnr, srf04_handle_irq,
 312                         IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 313                         pdev->name, indio_dev);
 314         if (ret < 0) {
 315                 dev_err(data->dev, "request_irq: %d\n", ret);
 316                 return ret;
 317         }
 318
 319         platform_set_drvdata(pdev, indio_dev);
 320
 321         indio_dev->name = "srf04";
 322         indio_dev->info = &srf04_iio_info;
 323         indio_dev->modes = INDIO_DIRECT_MODE;
 324         indio_dev->channels = srf04_chan_spec;
 325         indio_dev->num_channels = ARRAY_SIZE(srf04_chan_spec);
 326
 327         ret = iio_device_register(indio_dev);
 328         if (ret < 0) {
 329                 dev_err(data->dev, "iio_device_register: %d\n", ret);
 330                 return ret;
 331         }
 332
 333         if (data->gpiod_power) {
 334                 pm_runtime_set_autosuspend_delay(data->dev, 1000);
 335                 pm_runtime_use_autosuspend(data->dev);
 336
 337                 ret = pm_runtime_set_active(data->dev);
 338                 if (ret) {
 339                         dev_err(data->dev, "pm_runtime_set_active: %d\n", ret);
 340                         iio_device_unregister(indio_dev);
 341                 }
 342
 343                 pm_runtime_enable(data->dev);
 344                 pm_runtime_idle(data->dev);
 345         }
 346
 347         return ret;
 348 }
 349
 350 static int srf04_remove(struct platform_device *pdev)
 351 {
 352         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 353         struct srf04_data *data = iio_priv(indio_dev);
 354
 355         iio_device_unregister(indio_dev);
 356
 357         if (data->gpiod_power) {
 358                 pm_runtime_disable(data->dev);
 359                 pm_runtime_set_suspended(data->dev);
 360         }
 361
 362         return 0;
 363 }
 364
 365 static int __maybe_unused srf04_pm_runtime_suspend(struct device *dev)
 366 {
 367         struct platform_device *pdev = container_of(dev,
 368                                                 struct platform_device, dev);
 369         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 370         struct srf04_data *data = iio_priv(indio_dev);
 371
 372         gpiod_set_value(data->gpiod_power, 0);
 373
 374         return 0;
 375 }
 376
 377 static int __maybe_unused srf04_pm_runtime_resume(struct device *dev)
 378 {
 379         struct platform_device *pdev = container_of(dev,
 380                                                 struct platform_device, dev);
 381         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 382         struct srf04_data *data = iio_priv(indio_dev);
 383
 384         gpiod_set_value(data->gpiod_power, 1);
 385         msleep(data->startup_time_ms);
 386
 387         return 0;
 388 }
 389
 390 static const struct dev_pm_ops srf04_pm_ops = {
 391         SET_RUNTIME_PM_OPS(srf04_pm_runtime_suspend,
 392                                 srf04_pm_runtime_resume, NULL)
 393 };
 394
 395 static struct platform_driver srf04_driver = {
 396         .probe          = srf04_probe,
 397         .remove         = srf04_remove,
 398         .driver         = {
 399                 .name           = "srf04-gpio",
 400                 .of_match_table = of_srf04_match,
 401                 .pm             = &srf04_pm_ops,
 402         },
 403 };
 404
 405 module_platform_driver(srf04_driver);
 406
 407 MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>");
 408 MODULE_DESCRIPTION("SRF04 ultrasonic sensor for distance measuring using GPIOs");
 409 MODULE_LICENSE("GPL");
 410 MODULE_ALIAS("platform:srf04");