Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3a11fbb0 authored by Tomasz Duszynski's avatar Tomasz Duszynski Committed by Jonathan Cameron
Browse files

iio: light: add support for ROHM BH1710/BH1715/BH1721/BH1750/BH1751 ambient light sensors 



Add support for ROHM BH1710/BH1715/BH1721/BH1750/BH1751 ambient light
sensors.

Signed-off-by: default avatarTomasz Duszynski <tduszyns@gmail.com>
Signed-off-by: default avatarJonathan Cameron <jic23@kernel.org>
parent 54628687

drivers/iio/light/Kconfig

+10 −0
Original line number Diff line number Diff line
@@ -37,6 +37,16 @@ config APDS9300 
	 To compile this driver as a module, choose M here: the

	 module will be called apds9300.



config BH1750

	tristate "ROHM BH1750 ambient light sensor"

	depends on I2C

	help

	 Say Y here to build support for the ROHM BH1710, BH1715, BH1721,

	 BH1750, BH1751 ambient light sensors.



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

	 be called bh1750.



config CM32181

	depends on I2C

	tristate "CM32181 driver"

drivers/iio/light/Makefile

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

obj-$(CONFIG_AL3320A)		+= al3320a.o

obj-$(CONFIG_APDS9300)		+= apds9300.o

obj-$(CONFIG_BH1750)		+= bh1750.o

obj-$(CONFIG_CM32181)		+= cm32181.o

obj-$(CONFIG_CM3232)		+= cm3232.o

obj-$(CONFIG_CM3323)		+= cm3323.o

drivers/iio/light/bh1750.c

0 → 100644
+334 −0
Original line number Diff line number Diff line 
/*

 * ROHM BH1710/BH1715/BH1721/BH1750/BH1751 ambient light sensor driver

 *

 * Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 *

 * Data sheets:

 *  http://rohmfs.rohm.com/en/products/databook/datasheet/ic/sensor/light/bh1710fvc-e.pdf

 *  http://rohmfs.rohm.com/en/products/databook/datasheet/ic/sensor/light/bh1715fvc-e.pdf

 *  http://rohmfs.rohm.com/en/products/databook/datasheet/ic/sensor/light/bh1721fvc-e.pdf

 *  http://rohmfs.rohm.com/en/products/databook/datasheet/ic/sensor/light/bh1750fvi-e.pdf

 *  http://rohmfs.rohm.com/en/products/databook/datasheet/ic/sensor/light/bh1751fvi-e.pdf

 *

 * 7-bit I2C slave addresses:

 *  0x23 (ADDR pin low)

 *  0x5C (ADDR pin high)

 *

 */



#include <linux/delay.h>

#include <linux/i2c.h>

#include <linux/iio/iio.h>

#include <linux/iio/sysfs.h>

#include <linux/module.h>



#define BH1750_POWER_DOWN		0x00

#define BH1750_ONE_TIME_H_RES_MODE	0x20 /* auto-mode for BH1721 */

#define BH1750_CHANGE_INT_TIME_H_BIT	0x40

#define BH1750_CHANGE_INT_TIME_L_BIT	0x60



enum {

	BH1710,

	BH1721,

	BH1750,

};



struct bh1750_chip_info;

struct bh1750_data {

	struct i2c_client *client;

	struct mutex lock;

	const struct bh1750_chip_info *chip_info;

	u16 mtreg;

};



struct bh1750_chip_info {

	u16 mtreg_min;

	u16 mtreg_max;

	u16 mtreg_default;

	int mtreg_to_usec;

	int mtreg_to_scale;



	/*

	 * For BH1710/BH1721 all possible integration time values won't fit

	 * into one page so displaying is limited to every second one.

	 * Note, that user can still write proper values which were not

	 * listed.

	 */

	int inc;



	u16 int_time_low_mask;

	u16 int_time_high_mask;

}



static const bh1750_chip_info_tbl[] = {

	[BH1710] = { 140, 1022, 300, 400,  250000000, 2, 0x001F, 0x03E0 },

	[BH1721] = { 140, 1020, 300, 400,  250000000, 2, 0x0010, 0x03E0 },

	[BH1750] = { 31,  254,  69,  1740, 57500000,  1, 0x001F, 0x00E0 },

};



static int bh1750_change_int_time(struct bh1750_data *data, int usec)

{

	int ret;

	u16 val;

	u8 regval;

	const struct bh1750_chip_info *chip_info = data->chip_info;



	if ((usec % chip_info->mtreg_to_usec) != 0)

		return -EINVAL;



	val = usec / chip_info->mtreg_to_usec;

	if (val < chip_info->mtreg_min || val > chip_info->mtreg_max)

		return -EINVAL;



	ret = i2c_smbus_write_byte(data->client, BH1750_POWER_DOWN);

	if (ret < 0)

		return ret;



	regval = (val & chip_info->int_time_high_mask) >> 5;

	ret = i2c_smbus_write_byte(data->client,

				   BH1750_CHANGE_INT_TIME_H_BIT | regval);

	if (ret < 0)

		return ret;



	regval = val & chip_info->int_time_low_mask;

	ret = i2c_smbus_write_byte(data->client,

				   BH1750_CHANGE_INT_TIME_L_BIT | regval);

	if (ret < 0)

		return ret;



	data->mtreg = val;



	return 0;

}



static int bh1750_read(struct bh1750_data *data, int *val)

{

	int ret;

	__be16 result;

	const struct bh1750_chip_info *chip_info = data->chip_info;

	unsigned long delay = chip_info->mtreg_to_usec * data->mtreg;



	/*

	 * BH1721 will enter continuous mode on receiving this command.

	 * Note, that this eliminates need for bh1750_resume().

	 */

	ret = i2c_smbus_write_byte(data->client, BH1750_ONE_TIME_H_RES_MODE);

	if (ret < 0)

		return ret;



	usleep_range(delay + 15000, delay + 40000);



	ret = i2c_master_recv(data->client, (char *)&result, 2);

	if (ret < 0)

		return ret;



	*val = be16_to_cpu(result);



	return 0;

}



static int bh1750_read_raw(struct iio_dev *indio_dev,

			   struct iio_chan_spec const *chan,

			   int *val, int *val2, long mask)

{

	int ret, tmp;

	struct bh1750_data *data = iio_priv(indio_dev);

	const struct bh1750_chip_info *chip_info = data->chip_info;



	switch (mask) {

	case IIO_CHAN_INFO_RAW:

		switch (chan->type) {

		case IIO_LIGHT:

			mutex_lock(&data->lock);

			ret = bh1750_read(data, val);

			mutex_unlock(&data->lock);

			if (ret < 0)

				return ret;



			return IIO_VAL_INT;

		default:

			return -EINVAL;

		}

	case IIO_CHAN_INFO_SCALE:

		tmp = chip_info->mtreg_to_scale / data->mtreg;

		*val = tmp / 1000000;

		*val2 = tmp % 1000000;

		return IIO_VAL_INT_PLUS_MICRO;

	case IIO_CHAN_INFO_INT_TIME:

		*val = 0;

		*val2 = chip_info->mtreg_to_usec * data->mtreg;

		return IIO_VAL_INT_PLUS_MICRO;

	default:

		return -EINVAL;

	}

}



static int bh1750_write_raw(struct iio_dev *indio_dev,

			    struct iio_chan_spec const *chan,

			    int val, int val2, long mask)

{

	int ret;

	struct bh1750_data *data = iio_priv(indio_dev);



	switch (mask) {

	case IIO_CHAN_INFO_INT_TIME:

		if (val != 0)

			return -EINVAL;



		mutex_lock(&data->lock);

		ret = bh1750_change_int_time(data, val2);

		mutex_unlock(&data->lock);

		return ret;

	default:

		return -EINVAL;

	}

}



static ssize_t bh1750_show_int_time_available(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	int i;

	size_t len = 0;

	struct bh1750_data *data = iio_priv(dev_to_iio_dev(dev));

	const struct bh1750_chip_info *chip_info = data->chip_info;



	for (i = chip_info->mtreg_min; i <= chip_info->mtreg_max; i += chip_info->inc)

		len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06d ",

				 chip_info->mtreg_to_usec * i);



	buf[len - 1] = '\n';



	return len;

}



static IIO_DEV_ATTR_INT_TIME_AVAIL(bh1750_show_int_time_available);



static struct attribute *bh1750_attributes[] = {

	&iio_dev_attr_integration_time_available.dev_attr.attr,

	NULL,

};



static struct attribute_group bh1750_attribute_group = {

	.attrs = bh1750_attributes,

};



static const struct iio_info bh1750_info = {

	.driver_module = THIS_MODULE,

	.attrs = &bh1750_attribute_group,

	.read_raw = bh1750_read_raw,

	.write_raw = bh1750_write_raw,

};



static const struct iio_chan_spec bh1750_channels[] = {

	{

		.type = IIO_LIGHT,

		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |

				      BIT(IIO_CHAN_INFO_SCALE) |

				      BIT(IIO_CHAN_INFO_INT_TIME)

	}

};



static int bh1750_probe(struct i2c_client *client,

			const struct i2c_device_id *id)

{

	int ret, usec;

	struct bh1750_data *data;

	struct iio_dev *indio_dev;



	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |

				I2C_FUNC_SMBUS_WRITE_BYTE))

		return -ENODEV;



	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));

	if (!indio_dev)

		return -ENOMEM;



	data = iio_priv(indio_dev);

	i2c_set_clientdata(client, indio_dev);

	data->client = client;

	data->chip_info = &bh1750_chip_info_tbl[id->driver_data];



	usec = data->chip_info->mtreg_to_usec * data->chip_info->mtreg_default;

	ret = bh1750_change_int_time(data, usec);

	if (ret < 0)

		return ret;



	mutex_init(&data->lock);

	indio_dev->dev.parent = &client->dev;

	indio_dev->info = &bh1750_info;

	indio_dev->name = id->name;

	indio_dev->channels = bh1750_channels;

	indio_dev->num_channels = ARRAY_SIZE(bh1750_channels);

	indio_dev->modes = INDIO_DIRECT_MODE;



	return iio_device_register(indio_dev);

}



static int bh1750_remove(struct i2c_client *client)

{

	struct iio_dev *indio_dev = i2c_get_clientdata(client);

	struct bh1750_data *data = iio_priv(indio_dev);



	iio_device_unregister(indio_dev);



	mutex_lock(&data->lock);

	i2c_smbus_write_byte(client, BH1750_POWER_DOWN);

	mutex_unlock(&data->lock);



	return 0;

}



#ifdef CONFIG_PM_SLEEP

static int bh1750_suspend(struct device *dev)

{

	int ret;

	struct bh1750_data *data =

		iio_priv(i2c_get_clientdata(to_i2c_client(dev)));



	/*

	 * This is mainly for BH1721 which doesn't enter power down

	 * mode automatically.

	 */

	mutex_lock(&data->lock);

	ret = i2c_smbus_write_byte(data->client, BH1750_POWER_DOWN);

	mutex_unlock(&data->lock);



	return ret;

}



static SIMPLE_DEV_PM_OPS(bh1750_pm_ops, bh1750_suspend, NULL);

#define BH1750_PM_OPS (&bh1750_pm_ops)

#else

#define BH1750_PM_OPS NULL

#endif



static const struct i2c_device_id bh1750_id[] = {

	{ "bh1710", BH1710 },

	{ "bh1715", BH1750 },

	{ "bh1721", BH1721 },

	{ "bh1750", BH1750 },

	{ "bh1751", BH1750 },

	{ }

};

MODULE_DEVICE_TABLE(i2c, bh1750_id);



static struct i2c_driver bh1750_driver = {

	.driver = {

		.name = "bh1750",

		.owner = THIS_MODULE,

		.pm = BH1750_PM_OPS,

	},

	.probe = bh1750_probe,

	.remove = bh1750_remove,

	.id_table = bh1750_id,



};

module_i2c_driver(bh1750_driver);



MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");

MODULE_DESCRIPTION("ROHM BH1710/BH1715/BH1721/BH1750/BH1751 als driver");

MODULE_LICENSE("GPL v2");