Commit 16b05261 authored by Andreas Klinger's avatar Andreas Klinger Committed by Jonathan Cameron
Browse files

mb1232.c: add distance iio sensor with i2c 



Add I2CXL-MaxSonar ultrasonic distance sensors of types mb1202, mb1212,
mb1222, mb1232, mb1242, mb7040, mb7137 using an i2c interface

Implemented functionality:
- reading the distance via in_distance_raw
- buffered mode with trigger
- make use of interrupt to announce completion of ranging

Add mb1232 driver to Kconfig and Makefile

Signed-off-by: default avatarAndreas Klinger <ak@it-klinger.de>
Signed-off-by: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
parent 7483e40d

drivers/iio/proximity/Kconfig

+12 −0
Original line number Diff line number Diff line
@@ -45,6 +45,18 @@ config LIDAR_LITE_V2 
	  To compile this driver as a module, choose M here: the

	  module will be called pulsedlight-lite-v2



config MB1232

	tristate "MaxSonar I2CXL family ultrasonic sensors"

	depends on I2C

	help

	  Say Y to build a driver for the ultrasonic sensors I2CXL of

	  MaxBotix which have an i2c interface. It can be used to measure

	  the distance of objects. Supported types are mb1202, mb1212,

	  mb1222, mb1232, mb1242, mb7040, mb7137



	  To compile this driver as a module, choose M here: the

	  module will be called mb1232.



config RFD77402

	tristate "RFD77402 ToF sensor"

	depends on I2C

drivers/iio/proximity/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ 
obj-$(CONFIG_AS3935)		+= as3935.o

obj-$(CONFIG_ISL29501)		+= isl29501.o

obj-$(CONFIG_LIDAR_LITE_V2)	+= pulsedlight-lidar-lite-v2.o

obj-$(CONFIG_MB1232)		+= mb1232.o

obj-$(CONFIG_RFD77402)		+= rfd77402.o

obj-$(CONFIG_SRF04)		+= srf04.o

obj-$(CONFIG_SRF08)		+= srf08.o

drivers/iio/proximity/mb1232.c

0 → 100644
+272 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0+

/*

 * mb1232.c - Support for MaxBotix I2CXL-MaxSonar-EZ series ultrasonic

 *   ranger with i2c interface

 * actually tested with mb1232 type

 *

 * Copyright (c) 2019 Andreas Klinger <ak@it-klinger.de>

 *

 * For details about the device see:

 * https://www.maxbotix.com/documents/I2CXL-MaxSonar-EZ_Datasheet.pdf

 */



#include <linux/err.h>

#include <linux/i2c.h>

#include <linux/of_irq.h>

#include <linux/delay.h>

#include <linux/module.h>

#include <linux/bitops.h>

#include <linux/iio/iio.h>

#include <linux/iio/sysfs.h>

#include <linux/iio/buffer.h>

#include <linux/iio/trigger_consumer.h>

#include <linux/iio/triggered_buffer.h>



/* registers of MaxSonar device */

#define MB1232_RANGE_COMMAND	0x51	/* Command for reading range */

#define MB1232_ADDR_UNLOCK_1	0xAA	/* Command 1 for changing address */

#define MB1232_ADDR_UNLOCK_2	0xA5	/* Command 2 for changing address */



struct mb1232_data {

	struct i2c_client	*client;



	struct mutex		lock;



	/*

	 * optionally a gpio can be used to announce when ranging has

	 * finished

	 * since we are just using the falling trigger of it we request

	 * only the interrupt for announcing when data is ready to be read

	 */

	struct completion	ranging;

	int			irqnr;

};



static irqreturn_t mb1232_handle_irq(int irq, void *dev_id)

{

	struct iio_dev *indio_dev = dev_id;

	struct mb1232_data *data = iio_priv(indio_dev);



	complete(&data->ranging);



	return IRQ_HANDLED;

}



static s16 mb1232_read_distance(struct mb1232_data *data)

{

	struct i2c_client *client = data->client;

	int ret;

	s16 distance;

	__be16 buf;



	mutex_lock(&data->lock);



	reinit_completion(&data->ranging);



	ret = i2c_smbus_write_byte(client, MB1232_RANGE_COMMAND);

	if (ret < 0) {

		dev_err(&client->dev, "write command - err: %d\n", ret);

		goto error_unlock;

	}



	if (data->irqnr >= 0) {

		/* it cannot take more than 100 ms */

		ret = wait_for_completion_killable_timeout(&data->ranging,

									HZ/10);

		if (ret < 0)

			goto error_unlock;

		else if (ret == 0) {

			ret = -ETIMEDOUT;

			goto error_unlock;

		}

	} else {

		/* use simple sleep if announce irq is not connected */

		msleep(15);

	}



	ret = i2c_master_recv(client, (char *)&buf, sizeof(buf));

	if (ret < 0) {

		dev_err(&client->dev, "i2c_master_recv: ret=%d\n", ret);

		goto error_unlock;

	}



	distance = __be16_to_cpu(buf);

	/* check for not returning misleading error codes */

	if (distance < 0) {

		dev_err(&client->dev, "distance=%d\n", distance);

		ret = -EINVAL;

		goto error_unlock;

	}



	mutex_unlock(&data->lock);



	return distance;



error_unlock:

	mutex_unlock(&data->lock);



	return ret;

}



static irqreturn_t mb1232_trigger_handler(int irq, void *p)

{

	struct iio_poll_func *pf = p;

	struct iio_dev *indio_dev = pf->indio_dev;

	struct mb1232_data *data = iio_priv(indio_dev);

	/*

	 * triggered buffer

	 * 16-bit channel + 48-bit padding + 64-bit timestamp

	 */

	s16 buffer[8] = { 0 };



	buffer[0] = mb1232_read_distance(data);

	if (buffer[0] < 0)

		goto err;



	iio_push_to_buffers_with_timestamp(indio_dev, buffer, pf->timestamp);



err:

	iio_trigger_notify_done(indio_dev->trig);

	return IRQ_HANDLED;

}



static int mb1232_read_raw(struct iio_dev *indio_dev,

			    struct iio_chan_spec const *channel, int *val,

			    int *val2, long mask)

{

	struct mb1232_data *data = iio_priv(indio_dev);

	int ret;



	if (channel->type != IIO_DISTANCE)

		return -EINVAL;



	switch (mask) {

	case IIO_CHAN_INFO_RAW:

		ret = mb1232_read_distance(data);

		if (ret < 0)

			return ret;

		*val = ret;

		return IIO_VAL_INT;

	case IIO_CHAN_INFO_SCALE:

		/* 1 LSB is 1 cm */

		*val = 0;

		*val2 = 10000;

		return IIO_VAL_INT_PLUS_MICRO;

	default:

		return -EINVAL;

	}

}



static const struct iio_chan_spec mb1232_channels[] = {

	{

		.type = IIO_DISTANCE,

		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |

				      BIT(IIO_CHAN_INFO_SCALE),

		.scan_index = 0,

		.scan_type = {

			.sign = 's',

			.realbits = 16,

			.storagebits = 16,

			.endianness = IIO_CPU,

		},

	},

	IIO_CHAN_SOFT_TIMESTAMP(1),

};



static const struct iio_info mb1232_info = {

	.read_raw = mb1232_read_raw,

};



static int mb1232_probe(struct i2c_client *client,

					 const struct i2c_device_id *id)

{

	struct iio_dev *indio_dev;

	struct mb1232_data *data;

	int ret;

	struct device *dev = &client->dev;



	if (!i2c_check_functionality(client->adapter,

					I2C_FUNC_SMBUS_READ_BYTE |

					I2C_FUNC_SMBUS_WRITE_BYTE))

		return -ENODEV;



	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));

	if (!indio_dev)

		return -ENOMEM;



	data = iio_priv(indio_dev);

	i2c_set_clientdata(client, indio_dev);

	data->client = client;



	indio_dev->info = &mb1232_info;

	indio_dev->name = id->name;

	indio_dev->dev.parent = dev;

	indio_dev->modes = INDIO_DIRECT_MODE;

	indio_dev->channels = mb1232_channels;

	indio_dev->num_channels = ARRAY_SIZE(mb1232_channels);



	mutex_init(&data->lock);



	init_completion(&data->ranging);



	data->irqnr = irq_of_parse_and_map(dev->of_node, 0);

	if (data->irqnr <= 0) {

		/* usage of interrupt is optional */

		data->irqnr = -1;

	} else {

		ret = devm_request_irq(dev, data->irqnr, mb1232_handle_irq,

				IRQF_TRIGGER_FALLING, id->name, indio_dev);

		if (ret < 0) {

			dev_err(dev, "request_irq: %d\n", ret);

			return ret;

		}

	}



	ret = devm_iio_triggered_buffer_setup(dev, indio_dev,

			iio_pollfunc_store_time, mb1232_trigger_handler, NULL);

	if (ret < 0) {

		dev_err(dev, "setup of iio triggered buffer failed\n");

		return ret;

	}



	return devm_iio_device_register(dev, indio_dev);

}



static const struct of_device_id of_mb1232_match[] = {

	{ .compatible = "maxbotix,mb1202", },

	{ .compatible = "maxbotix,mb1212", },

	{ .compatible = "maxbotix,mb1222", },

	{ .compatible = "maxbotix,mb1232", },

	{ .compatible = "maxbotix,mb1242", },

	{ .compatible = "maxbotix,mb7040", },

	{ .compatible = "maxbotix,mb7137", },

	{},

};



MODULE_DEVICE_TABLE(of, of_mb1232_match);



static const struct i2c_device_id mb1232_id[] = {

	{ "maxbotix-mb1202", },

	{ "maxbotix-mb1212", },

	{ "maxbotix-mb1222", },

	{ "maxbotix-mb1232", },

	{ "maxbotix-mb1242", },

	{ "maxbotix-mb7040", },

	{ "maxbotix-mb7137", },

	{ }

};

MODULE_DEVICE_TABLE(i2c, mb1232_id);



static struct i2c_driver mb1232_driver = {

	.driver = {

		.name	= "maxbotix-mb1232",

		.of_match_table	= of_mb1232_match,

	},

	.probe = mb1232_probe,

	.id_table = mb1232_id,

};

module_i2c_driver(mb1232_driver);



MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>");

MODULE_DESCRIPTION("Maxbotix I2CXL-MaxSonar i2c ultrasonic ranger driver");

MODULE_LICENSE("GPL");

CRA Git | Maintained and supported by SUSTech CRA and CCSE