[mirror_ubuntu-hirsute-kernel.git] / drivers / iio / proximity / srf04.c

/*
 * SRF04: ultrasonic sensor for distance measuring by using GPIOs
 *
 * Copyright (c) 2017 Andreas Klinger <ak@it-klinger.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * For details about the device see:
 * http://www.robot-electronics.co.uk/htm/srf04tech.htm
 *
 * the measurement cycle as timing diagram looks like:
 *
 *          +---+
 * GPIO     |   |
 * trig:  --+   +------------------------------------------------------
 *          ^   ^
 *          |<->|
 *         udelay(trigger_pulse_us)
 *
 * ultra           +-+ +-+ +-+
 * sonic           | | | | | |
 * burst: ---------+ +-+ +-+ +-----------------------------------------
 *                           .
 * ultra                     .              +-+ +-+ +-+
 * sonic                     .              | | | | | |
 * echo:  ----------------------------------+ +-+ +-+ +----------------
 *                           .                        .
 *                           +------------------------+
 * GPIO                      |                        |
 * echo:  -------------------+                        +---------------
 *                           ^                        ^
 *                           interrupt                interrupt
 *                           (ts_rising)              (ts_falling)
 *                           |<---------------------->|
 *                              pulse time measured
 *                              --> one round trip of ultra sonic waves
 */
#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>

struct srf04_cfg {
	unsigned long trigger_pulse_us;
};

struct srf04_data {
	struct device		*dev;
	struct gpio_desc	*gpiod_trig;
	struct gpio_desc	*gpiod_echo;
	struct mutex		lock;
	int			irqnr;
	ktime_t			ts_rising;
	ktime_t			ts_falling;
	struct completion	rising;
	struct completion	falling;
	const struct srf04_cfg	*cfg;
};

static const struct srf04_cfg srf04_cfg = {
	.trigger_pulse_us = 10,
};

static const struct srf04_cfg mb_lv_cfg = {
	.trigger_pulse_us = 20,
};

static irqreturn_t srf04_handle_irq(int irq, void *dev_id)
{
	struct iio_dev *indio_dev = dev_id;
	struct srf04_data *data = iio_priv(indio_dev);
	ktime_t now = ktime_get();

	if (gpiod_get_value(data->gpiod_echo)) {
		data->ts_rising = now;
		complete(&data->rising);
	} else {
		data->ts_falling = now;
		complete(&data->falling);
	}

	return IRQ_HANDLED;
}

static int srf04_read(struct srf04_data *data)
{
	int ret;
	ktime_t ktime_dt;
	u64 dt_ns;
	u32 time_ns, distance_mm;

	/*
	 * just one read-echo-cycle can take place at a time
	 * ==> lock against concurrent reading calls
	 */
	mutex_lock(&data->lock);

	reinit_completion(&data->rising);
	reinit_completion(&data->falling);

	gpiod_set_value(data->gpiod_trig, 1);
	udelay(data->cfg->trigger_pulse_us);
	gpiod_set_value(data->gpiod_trig, 0);

	/* it cannot take more than 20 ms */
	ret = wait_for_completion_killable_timeout(&data->rising, HZ/50);
	if (ret < 0) {
		mutex_unlock(&data->lock);
		return ret;
	} else if (ret == 0) {
		mutex_unlock(&data->lock);
		return -ETIMEDOUT;
	}

	ret = wait_for_completion_killable_timeout(&data->falling, HZ/50);
	if (ret < 0) {
		mutex_unlock(&data->lock);
		return ret;
	} else if (ret == 0) {
		mutex_unlock(&data->lock);
		return -ETIMEDOUT;
	}

	ktime_dt = ktime_sub(data->ts_falling, data->ts_rising);

	mutex_unlock(&data->lock);

	dt_ns = ktime_to_ns(ktime_dt);
	/*
	 * measuring more than 3 meters is beyond the capabilities of
	 * the sensor
	 * ==> filter out invalid results for not measuring echos of
	 *     another us sensor
	 *
	 * formula:
	 *         distance       3 m
	 * time = ---------- = --------- = 9404389 ns
	 *          speed       319 m/s
	 *
	 * using a minimum speed at -20 °C of 319 m/s
	 */
	if (dt_ns > 9404389)
		return -EIO;

	time_ns = dt_ns;

	/*
	 * the speed as function of the temperature is approximately:
	 *
	 * speed = 331,5 + 0,6 * Temp
	 *   with Temp in °C
	 *   and speed in m/s
	 *
	 * use 343 m/s as ultrasonic speed at 20 °C here in absence of the
	 * temperature
	 *
	 * therefore:
	 *             time     343
	 * distance = ------ * -----
	 *             10^6       2
	 *   with time in ns
	 *   and distance in mm (one way)
	 *
	 * because we limit to 3 meters the multiplication with 343 just
	 * fits into 32 bit
	 */
	distance_mm = time_ns * 343 / 2000000;

	return distance_mm;
}

static int srf04_read_raw(struct iio_dev *indio_dev,
			    struct iio_chan_spec const *channel, int *val,
			    int *val2, long info)
{
	struct srf04_data *data = iio_priv(indio_dev);
	int ret;

	if (channel->type != IIO_DISTANCE)
		return -EINVAL;

	switch (info) {
	case IIO_CHAN_INFO_RAW:
		ret = srf04_read(data);
		if (ret < 0)
			return ret;
		*val = ret;
		return IIO_VAL_INT;
	case IIO_CHAN_INFO_SCALE:
		/*
		 * theoretical maximum resolution is 3 mm
		 * 1 LSB is 1 mm
		 */
		*val = 0;
		*val2 = 1000;
		return IIO_VAL_INT_PLUS_MICRO;
	default:
		return -EINVAL;
	}
}

static const struct iio_info srf04_iio_info = {
	.read_raw		= srf04_read_raw,
};

static const struct iio_chan_spec srf04_chan_spec[] = {
	{
		.type = IIO_DISTANCE,
		.info_mask_separate =
				BIT(IIO_CHAN_INFO_RAW) |
				BIT(IIO_CHAN_INFO_SCALE),
	},
};

static const struct of_device_id of_srf04_match[] = {
	{ .compatible = "devantech,srf04", .data = &srf04_cfg},
	{ .compatible = "maxbotix,mb1000", .data = &mb_lv_cfg},
	{ .compatible = "maxbotix,mb1010", .data = &mb_lv_cfg},
	{ .compatible = "maxbotix,mb1020", .data = &mb_lv_cfg},
	{ .compatible = "maxbotix,mb1030", .data = &mb_lv_cfg},
	{ .compatible = "maxbotix,mb1040", .data = &mb_lv_cfg},
	{},
};

MODULE_DEVICE_TABLE(of, of_srf04_match);

static int srf04_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct srf04_data *data;
	struct iio_dev *indio_dev;
	int ret;

	indio_dev = devm_iio_device_alloc(dev, sizeof(struct srf04_data));
	if (!indio_dev) {
		dev_err(dev, "failed to allocate IIO device\n");
		return -ENOMEM;
	}

	data = iio_priv(indio_dev);
	data->dev = dev;
	data->cfg = of_match_device(of_srf04_match, dev)->data;

	mutex_init(&data->lock);
	init_completion(&data->rising);
	init_completion(&data->falling);

	data->gpiod_trig = devm_gpiod_get(dev, "trig", GPIOD_OUT_LOW);
	if (IS_ERR(data->gpiod_trig)) {
		dev_err(dev, "failed to get trig-gpios: err=%ld\n",
					PTR_ERR(data->gpiod_trig));
		return PTR_ERR(data->gpiod_trig);
	}

	data->gpiod_echo = devm_gpiod_get(dev, "echo", GPIOD_IN);
	if (IS_ERR(data->gpiod_echo)) {
		dev_err(dev, "failed to get echo-gpios: err=%ld\n",
					PTR_ERR(data->gpiod_echo));
		return PTR_ERR(data->gpiod_echo);
	}

	if (gpiod_cansleep(data->gpiod_echo)) {
		dev_err(data->dev, "cansleep-GPIOs not supported\n");
		return -ENODEV;
	}

	data->irqnr = gpiod_to_irq(data->gpiod_echo);
	if (data->irqnr < 0) {
		dev_err(data->dev, "gpiod_to_irq: %d\n", data->irqnr);
		return data->irqnr;
	}

	ret = devm_request_irq(dev, data->irqnr, srf04_handle_irq,
			IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
			pdev->name, indio_dev);
	if (ret < 0) {
		dev_err(data->dev, "request_irq: %d\n", ret);
		return ret;
	}

	platform_set_drvdata(pdev, indio_dev);

	indio_dev->name = "srf04";
	indio_dev->dev.parent = &pdev->dev;
	indio_dev->info = &srf04_iio_info;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->channels = srf04_chan_spec;
	indio_dev->num_channels = ARRAY_SIZE(srf04_chan_spec);

	return devm_iio_device_register(dev, indio_dev);
}

static struct platform_driver srf04_driver = {
	.probe		= srf04_probe,
	.driver		= {
		.name		= "srf04-gpio",
		.of_match_table	= of_srf04_match,
	},
};

module_platform_driver(srf04_driver);

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