mb1232.c: add distance iio sensor with i2c (16b05261) · Commits · e / devices / android_kernel_fairphone_FP5

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");