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