LXR linux/drivers/iio/proximity/ping.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * PING: ultrasonic sensor for distance measuring by using only one GPIOs
   4 *
   5 * Copyright (c) 2019 Andreas Klinger <ak@it-klinger.de>
   6 *
   7 * For details about the devices see:
   8 * http://parallax.com/sites/default/files/downloads/28041-LaserPING-2m-Rangefinder-Guide.pdf
   9 * http://parallax.com/sites/default/files/downloads/28015-PING-Documentation-v1.6.pdf
  10 *
  11 * the measurement cycle as timing diagram looks like:
  12 *
  13 * GPIO      ___              ________________________
  14 * ping:  __/   \____________/                        \________________
  15 *          ^   ^            ^                        ^
  16 *          |<->|            interrupt                interrupt
  17 *         udelay(5)         (ts_rising)              (ts_falling)
  18 *                           |<---------------------->|
  19 *                           .  pulse time measured   .
  20 *                           .  --> one round trip of ultra sonic waves
  21 * ultra                     .                        .
  22 * sonic            _   _   _.                        .
  23 * burst: _________/ \_/ \_/ \_________________________________________
  24 *                                                    .
  25 * ultra                                              .
  26 * sonic                                     _   _   _.
  27 * echo:  __________________________________/ \_/ \_/ \________________
  28 */
  29#include <linux/err.h>
  30#include <linux/gpio/consumer.h>
  31#include <linux/kernel.h>
  32#include <linux/module.h>
  33#include <linux/of.h>
  34#include <linux/of_device.h>
  35#include <linux/platform_device.h>
  36#include <linux/property.h>
  37#include <linux/sched.h>
  38#include <linux/interrupt.h>
  39#include <linux/delay.h>
  40#include <linux/iio/iio.h>
  41#include <linux/iio/sysfs.h>
  42
  43struct ping_cfg {
  44        unsigned long   trigger_pulse_us;       /* length of trigger pulse */
  45        int             laserping_error;        /* support error code in */
  46                                                /*   pulse width of laser */
  47                                                /*   ping sensors */
  48        s64             timeout_ns;             /* timeout in ns */
  49};
  50
  51struct ping_data {
  52        struct device           *dev;
  53        struct gpio_desc        *gpiod_ping;
  54        struct mutex            lock;
  55        int                     irqnr;
  56        ktime_t                 ts_rising;
  57        ktime_t                 ts_falling;
  58        struct completion       rising;
  59        struct completion       falling;
  60        const struct ping_cfg   *cfg;
  61};
  62
  63static const struct ping_cfg pa_ping_cfg = {
  64        .trigger_pulse_us       = 5,
  65        .laserping_error        = 0,
  66        .timeout_ns             = 18500000,     /* 3 meters */
  67};
  68
  69static const struct ping_cfg pa_laser_ping_cfg = {
  70        .trigger_pulse_us       = 5,
  71        .laserping_error        = 1,
  72        .timeout_ns             = 15500000,     /* 2 meters plus error codes */
  73};
  74
  75static irqreturn_t ping_handle_irq(int irq, void *dev_id)
  76{
  77        struct iio_dev *indio_dev = dev_id;
  78        struct ping_data *data = iio_priv(indio_dev);
  79        ktime_t now = ktime_get();
  80
  81        if (gpiod_get_value(data->gpiod_ping)) {
  82                data->ts_rising = now;
  83                complete(&data->rising);
  84        } else {
  85                data->ts_falling = now;
  86                complete(&data->falling);
  87        }
  88
  89        return IRQ_HANDLED;
  90}
  91
  92static int ping_read(struct iio_dev *indio_dev)
  93{
  94        struct ping_data *data = iio_priv(indio_dev);
  95        int ret;
  96        ktime_t ktime_dt;
  97        s64 dt_ns;
  98        u32 time_ns, distance_mm;
  99        struct platform_device *pdev = to_platform_device(data->dev);
 100
 101        /*
 102         * just one read-echo-cycle can take place at a time
 103         * ==> lock against concurrent reading calls
 104         */
 105        mutex_lock(&data->lock);
 106
 107        reinit_completion(&data->rising);
 108        reinit_completion(&data->falling);
 109
 110        gpiod_set_value(data->gpiod_ping, 1);
 111        udelay(data->cfg->trigger_pulse_us);
 112        gpiod_set_value(data->gpiod_ping, 0);
 113
 114        ret = gpiod_direction_input(data->gpiod_ping);
 115        if (ret < 0) {
 116                mutex_unlock(&data->lock);
 117                return ret;
 118        }
 119
 120        data->irqnr = gpiod_to_irq(data->gpiod_ping);
 121        if (data->irqnr < 0) {
 122                dev_err(data->dev, "gpiod_to_irq: %d\n", data->irqnr);
 123                mutex_unlock(&data->lock);
 124                return data->irqnr;
 125        }
 126
 127        ret = request_irq(data->irqnr, ping_handle_irq,
 128                                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 129                                                        pdev->name, indio_dev);
 130        if (ret < 0) {
 131                dev_err(data->dev, "request_irq: %d\n", ret);
 132                mutex_unlock(&data->lock);
 133                return ret;
 134        }
 135
 136        /* it should not take more than 20 ms until echo is rising */
 137        ret = wait_for_completion_killable_timeout(&data->rising, HZ/50);
 138        if (ret < 0)
 139                goto err_reset_direction;
 140        else if (ret == 0) {
 141                ret = -ETIMEDOUT;
 142                goto err_reset_direction;
 143        }
 144
 145        /* it cannot take more than 50 ms until echo is falling */
 146        ret = wait_for_completion_killable_timeout(&data->falling, HZ/20);
 147        if (ret < 0)
 148                goto err_reset_direction;
 149        else if (ret == 0) {
 150                ret = -ETIMEDOUT;
 151                goto err_reset_direction;
 152        }
 153
 154        ktime_dt = ktime_sub(data->ts_falling, data->ts_rising);
 155
 156        free_irq(data->irqnr, indio_dev);
 157
 158        ret = gpiod_direction_output(data->gpiod_ping, GPIOD_OUT_LOW);
 159        if (ret < 0) {
 160                mutex_unlock(&data->lock);
 161                return ret;
 162        }
 163
 164        mutex_unlock(&data->lock);
 165
 166        dt_ns = ktime_to_ns(ktime_dt);
 167        if (dt_ns > data->cfg->timeout_ns) {
 168                dev_dbg(data->dev, "distance out of range: dt=%lldns\n",
 169                                                                dt_ns);
 170                return -EIO;
 171        }
 172
 173        time_ns = dt_ns;
 174
 175        /*
 176         * read error code of laser ping sensor and give users chance to
 177         * figure out error by using dynamic debuggging
 178         */
 179        if (data->cfg->laserping_error) {
 180                if ((time_ns > 12500000) && (time_ns <= 13500000)) {
 181                        dev_dbg(data->dev, "target too close or to far\n");
 182                        return -EIO;
 183                }
 184                if ((time_ns > 13500000) && (time_ns <= 14500000)) {
 185                        dev_dbg(data->dev, "internal sensor error\n");
 186                        return -EIO;
 187                }
 188                if ((time_ns > 14500000) && (time_ns <= 15500000)) {
 189                        dev_dbg(data->dev, "internal sensor timeout\n");
 190                        return -EIO;
 191                }
 192        }
 193
 194        /*
 195         * the speed as function of the temperature is approximately:
 196         *
 197         * speed = 331,5 + 0,6 * Temp
 198         *   with Temp in °C
 199         *   and speed in m/s
 200         *
 201         * use 343,5 m/s as ultrasonic speed at 20 °C here in absence of the
 202         * temperature
 203         *
 204         * therefore:
 205         *             time     343,5     time * 232
 206         * distance = ------ * ------- = ------------
 207         *             10^6         2        1350800
 208         *   with time in ns
 209         *   and distance in mm (one way)
 210         *
 211         * because we limit to 3 meters the multiplication with 232 just
 212         * fits into 32 bit
 213         */
 214        distance_mm = time_ns * 232 / 1350800;
 215
 216        return distance_mm;
 217
 218err_reset_direction:
 219        free_irq(data->irqnr, indio_dev);
 220        mutex_unlock(&data->lock);
 221
 222        if (gpiod_direction_output(data->gpiod_ping, GPIOD_OUT_LOW))
 223                dev_dbg(data->dev, "error in gpiod_direction_output\n");
 224        return ret;
 225}
 226
 227static int ping_read_raw(struct iio_dev *indio_dev,
 228                            struct iio_chan_spec const *channel, int *val,
 229                            int *val2, long info)
 230{
 231        int ret;
 232
 233        if (channel->type != IIO_DISTANCE)
 234                return -EINVAL;
 235
 236        switch (info) {
 237        case IIO_CHAN_INFO_RAW:
 238                ret = ping_read(indio_dev);
 239                if (ret < 0)
 240                        return ret;
 241                *val = ret;
 242                return IIO_VAL_INT;
 243        case IIO_CHAN_INFO_SCALE:
 244                /*
 245                 * maximum resolution in datasheet is 1 mm
 246                 * 1 LSB is 1 mm
 247                 */
 248                *val = 0;
 249                *val2 = 1000;
 250                return IIO_VAL_INT_PLUS_MICRO;
 251        default:
 252                return -EINVAL;
 253        }
 254}
 255
 256static const struct iio_info ping_iio_info = {
 257        .read_raw               = ping_read_raw,
 258};
 259
 260static const struct iio_chan_spec ping_chan_spec[] = {
 261        {
 262                .type = IIO_DISTANCE,
 263                .info_mask_separate =
 264                                BIT(IIO_CHAN_INFO_RAW) |
 265                                BIT(IIO_CHAN_INFO_SCALE),
 266        },
 267};
 268
 269static const struct of_device_id of_ping_match[] = {
 270        { .compatible = "parallax,ping", .data = &pa_ping_cfg},
 271        { .compatible = "parallax,laserping", .data = &pa_laser_ping_cfg},
 272        {},
 273};
 274
 275MODULE_DEVICE_TABLE(of, of_ping_match);
 276
 277static int ping_probe(struct platform_device *pdev)
 278{
 279        struct device *dev = &pdev->dev;
 280        struct ping_data *data;
 281        struct iio_dev *indio_dev;
 282
 283        indio_dev = devm_iio_device_alloc(dev, sizeof(struct ping_data));
 284        if (!indio_dev) {
 285                dev_err(dev, "failed to allocate IIO device\n");
 286                return -ENOMEM;
 287        }
 288
 289        data = iio_priv(indio_dev);
 290        data->dev = dev;
 291        data->cfg = of_device_get_match_data(dev);
 292
 293        mutex_init(&data->lock);
 294        init_completion(&data->rising);
 295        init_completion(&data->falling);
 296
 297        data->gpiod_ping = devm_gpiod_get(dev, "ping", GPIOD_OUT_LOW);
 298        if (IS_ERR(data->gpiod_ping)) {
 299                dev_err(dev, "failed to get ping-gpios: err=%ld\n",
 300                                                PTR_ERR(data->gpiod_ping));
 301                return PTR_ERR(data->gpiod_ping);
 302        }
 303
 304        if (gpiod_cansleep(data->gpiod_ping)) {
 305                dev_err(data->dev, "cansleep-GPIOs not supported\n");
 306                return -ENODEV;
 307        }
 308
 309        platform_set_drvdata(pdev, indio_dev);
 310
 311        indio_dev->name = "ping";
 312        indio_dev->info = &ping_iio_info;
 313        indio_dev->modes = INDIO_DIRECT_MODE;
 314        indio_dev->channels = ping_chan_spec;
 315        indio_dev->num_channels = ARRAY_SIZE(ping_chan_spec);
 316
 317        return devm_iio_device_register(dev, indio_dev);
 318}
 319
 320static struct platform_driver ping_driver = {
 321        .probe          = ping_probe,
 322        .driver         = {
 323                .name           = "ping-gpio",
 324                .of_match_table = of_ping_match,
 325        },
 326};
 327
 328module_platform_driver(ping_driver);
 329
 330MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>");
 331MODULE_DESCRIPTION("PING sensors for distance measuring using one GPIOs");
 332MODULE_LICENSE("GPL");
 333MODULE_ALIAS("platform:ping");
 334