[mirror_ubuntu-bionic-kernel.git] / drivers / misc / tsl2550.c

/*
 *  tsl2550.c - Linux kernel modules for ambient light sensor
 *
 *  Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it>
 *  Copyright (C) 2007 Eurotech S.p.A. <info@eurotech.it>
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/mutex.h>

#define TSL2550_DRV_NAME	"tsl2550"
#define DRIVER_VERSION		"1.2"

/*
 * Defines
 */

#define TSL2550_POWER_DOWN		0x00
#define TSL2550_POWER_UP		0x03
#define TSL2550_STANDARD_RANGE		0x18
#define TSL2550_EXTENDED_RANGE		0x1d
#define TSL2550_READ_ADC0		0x43
#define TSL2550_READ_ADC1		0x83

/*
 * Structs
 */

struct tsl2550_data {
	struct i2c_client *client;
	struct mutex update_lock;

	unsigned int power_state:1;
	unsigned int operating_mode:1;
};

/*
 * Global data
 */

static const u8 TSL2550_MODE_RANGE[2] = {
	TSL2550_STANDARD_RANGE, TSL2550_EXTENDED_RANGE,
};

/*
 * Management functions
 */

static int tsl2550_set_operating_mode(struct i2c_client *client, int mode)
{
	struct tsl2550_data *data = i2c_get_clientdata(client);

	int ret = i2c_smbus_write_byte(client, TSL2550_MODE_RANGE[mode]);

	data->operating_mode = mode;

	return ret;
}

static int tsl2550_set_power_state(struct i2c_client *client, int state)
{
	struct tsl2550_data *data = i2c_get_clientdata(client);
	int ret;

	if (state == 0)
		ret = i2c_smbus_write_byte(client, TSL2550_POWER_DOWN);
	else {
		ret = i2c_smbus_write_byte(client, TSL2550_POWER_UP);

		/* On power up we should reset operating mode also... */
		tsl2550_set_operating_mode(client, data->operating_mode);
	}

	data->power_state = state;

	return ret;
}

static int tsl2550_get_adc_value(struct i2c_client *client, u8 cmd)
{
	int ret;

	ret = i2c_smbus_read_byte_data(client, cmd);
	if (ret < 0)
		return ret;
	if (!(ret & 0x80))
		return -EAGAIN;
	return ret & 0x7f;	/* remove the "valid" bit */
}

/*
 * LUX calculation
 */

#define	TSL2550_MAX_LUX		1846

static const u8 ratio_lut[] = {
	100, 100, 100, 100, 100, 100, 100, 100,
	100, 100, 100, 100, 100, 100, 99, 99,
	99, 99, 99, 99, 99, 99, 99, 99,
	99, 99, 99, 98, 98, 98, 98, 98,
	98, 98, 97, 97, 97, 97, 97, 96,
	96, 96, 96, 95, 95, 95, 94, 94,
	93, 93, 93, 92, 92, 91, 91, 90,
	89, 89, 88, 87, 87, 86, 85, 84,
	83, 82, 81, 80, 79, 78, 77, 75,
	74, 73, 71, 69, 68, 66, 64, 62,
	60, 58, 56, 54, 52, 49, 47, 44,
	42, 41, 40, 40, 39, 39, 38, 38,
	37, 37, 37, 36, 36, 36, 35, 35,
	35, 35, 34, 34, 34, 34, 33, 33,
	33, 33, 32, 32, 32, 32, 32, 31,
	31, 31, 31, 31, 30, 30, 30, 30,
	30,
};

static const u16 count_lut[] = {
	0, 1, 2, 3, 4, 5, 6, 7,
	8, 9, 10, 11, 12, 13, 14, 15,
	16, 18, 20, 22, 24, 26, 28, 30,
	32, 34, 36, 38, 40, 42, 44, 46,
	49, 53, 57, 61, 65, 69, 73, 77,
	81, 85, 89, 93, 97, 101, 105, 109,
	115, 123, 131, 139, 147, 155, 163, 171,
	179, 187, 195, 203, 211, 219, 227, 235,
	247, 263, 279, 295, 311, 327, 343, 359,
	375, 391, 407, 423, 439, 455, 471, 487,
	511, 543, 575, 607, 639, 671, 703, 735,
	767, 799, 831, 863, 895, 927, 959, 991,
	1039, 1103, 1167, 1231, 1295, 1359, 1423, 1487,
	1551, 1615, 1679, 1743, 1807, 1871, 1935, 1999,
	2095, 2223, 2351, 2479, 2607, 2735, 2863, 2991,
	3119, 3247, 3375, 3503, 3631, 3759, 3887, 4015,
};

/*
 * This function is described into Taos TSL2550 Designer's Notebook
 * pages 2, 3.
 */
static int tsl2550_calculate_lux(u8 ch0, u8 ch1)
{
	unsigned int lux;

	/* Look up count from channel values */
	u16 c0 = count_lut[ch0];
	u16 c1 = count_lut[ch1];

	/*
	 * Calculate ratio.
	 * Note: the "128" is a scaling factor
	 */
	u8 r = 128;

	/* Avoid division by 0 and count 1 cannot be greater than count 0 */
	if (c1 <= c0)
		if (c0) {
			r = c1 * 128 / c0;

			/* Calculate LUX */
			lux = ((c0 - c1) * ratio_lut[r]) / 256;
		} else
			lux = 0;
	else
		return -EAGAIN;

	/* LUX range check */
	return lux > TSL2550_MAX_LUX ? TSL2550_MAX_LUX : lux;
}

/*
 * SysFS support
 */

static ssize_t tsl2550_show_power_state(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct tsl2550_data *data = i2c_get_clientdata(to_i2c_client(dev));

	return sprintf(buf, "%u\n", data->power_state);
}

static ssize_t tsl2550_store_power_state(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct tsl2550_data *data = i2c_get_clientdata(client);
	unsigned long val = simple_strtoul(buf, NULL, 10);
	int ret;

	if (val > 1)
		return -EINVAL;

	mutex_lock(&data->update_lock);
	ret = tsl2550_set_power_state(client, val);
	mutex_unlock(&data->update_lock);

	if (ret < 0)
		return ret;

	return count;
}

static DEVICE_ATTR(power_state, S_IWUSR | S_IRUGO,
		   tsl2550_show_power_state, tsl2550_store_power_state);

static ssize_t tsl2550_show_operating_mode(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct tsl2550_data *data = i2c_get_clientdata(to_i2c_client(dev));

	return sprintf(buf, "%u\n", data->operating_mode);
}

static ssize_t tsl2550_store_operating_mode(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct tsl2550_data *data = i2c_get_clientdata(client);
	unsigned long val = simple_strtoul(buf, NULL, 10);
	int ret;

	if (val > 1)
		return -EINVAL;

	if (data->power_state == 0)
		return -EBUSY;

	mutex_lock(&data->update_lock);
	ret = tsl2550_set_operating_mode(client, val);
	mutex_unlock(&data->update_lock);

	if (ret < 0)
		return ret;

	return count;
}

static DEVICE_ATTR(operating_mode, S_IWUSR | S_IRUGO,
		   tsl2550_show_operating_mode, tsl2550_store_operating_mode);

static ssize_t __tsl2550_show_lux(struct i2c_client *client, char *buf)
{
	struct tsl2550_data *data = i2c_get_clientdata(client);
	u8 ch0, ch1;
	int ret;

	ret = tsl2550_get_adc_value(client, TSL2550_READ_ADC0);
	if (ret < 0)
		return ret;
	ch0 = ret;

	ret = tsl2550_get_adc_value(client, TSL2550_READ_ADC1);
	if (ret < 0)
		return ret;
	ch1 = ret;

	/* Do the job */
	ret = tsl2550_calculate_lux(ch0, ch1);
	if (ret < 0)
		return ret;
	if (data->operating_mode == 1)
		ret *= 5;

	return sprintf(buf, "%d\n", ret);
}

static ssize_t tsl2550_show_lux1_input(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct tsl2550_data *data = i2c_get_clientdata(client);
	int ret;

	/* No LUX data if not operational */
	if (!data->power_state)
		return -EBUSY;

	mutex_lock(&data->update_lock);
	ret = __tsl2550_show_lux(client, buf);
	mutex_unlock(&data->update_lock);

	return ret;
}

static DEVICE_ATTR(lux1_input, S_IRUGO,
		   tsl2550_show_lux1_input, NULL);

static struct attribute *tsl2550_attributes[] = {
	&dev_attr_power_state.attr,
	&dev_attr_operating_mode.attr,
	&dev_attr_lux1_input.attr,
	NULL
};

static const struct attribute_group tsl2550_attr_group = {
	.attrs = tsl2550_attributes,
};

/*
 * Initialization function
 */

static int tsl2550_init_client(struct i2c_client *client)
{
	struct tsl2550_data *data = i2c_get_clientdata(client);
	int err;

	/*
	 * Probe the chip. To do so we try to power up the device and then to
	 * read back the 0x03 code
	 */
	err = i2c_smbus_read_byte_data(client, TSL2550_POWER_UP);
	if (err < 0)
		return err;
	if (err != TSL2550_POWER_UP)
		return -ENODEV;
	data->power_state = 1;

	/* Set the default operating mode */
	err = i2c_smbus_write_byte(client,
				   TSL2550_MODE_RANGE[data->operating_mode]);
	if (err < 0)
		return err;

	return 0;
}

/*
 * I2C init/probing/exit functions
 */

static struct i2c_driver tsl2550_driver;
static int tsl2550_probe(struct i2c_client *client,
				   const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct tsl2550_data *data;
	int *opmode, err = 0;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE
					    | I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
		err = -EIO;
		goto exit;
	}

	data = kzalloc(sizeof(struct tsl2550_data), GFP_KERNEL);
	if (!data) {
		err = -ENOMEM;
		goto exit;
	}
	data->client = client;
	i2c_set_clientdata(client, data);

	/* Check platform data */
	opmode = client->dev.platform_data;
	if (opmode) {
		if (*opmode < 0 || *opmode > 1) {
			dev_err(&client->dev, "invalid operating_mode (%d)\n",
					*opmode);
			err = -EINVAL;
			goto exit_kfree;
		}
		data->operating_mode = *opmode;
	} else
		data->operating_mode = 0;	/* default mode is standard */
	dev_info(&client->dev, "%s operating mode\n",
			data->operating_mode ? "extended" : "standard");

	mutex_init(&data->update_lock);

	/* Initialize the TSL2550 chip */
	err = tsl2550_init_client(client);
	if (err)
		goto exit_kfree;

	/* Register sysfs hooks */
	err = sysfs_create_group(&client->dev.kobj, &tsl2550_attr_group);
	if (err)
		goto exit_kfree;

	dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION);

	return 0;

exit_kfree:
	kfree(data);
exit:
	return err;
}

static int tsl2550_remove(struct i2c_client *client)
{
	sysfs_remove_group(&client->dev.kobj, &tsl2550_attr_group);

	/* Power down the device */
	tsl2550_set_power_state(client, 0);

	kfree(i2c_get_clientdata(client));

	return 0;
}

#ifdef CONFIG_PM_SLEEP

static int tsl2550_suspend(struct device *dev)
{
	return tsl2550_set_power_state(to_i2c_client(dev), 0);
}

static int tsl2550_resume(struct device *dev)
{
	return tsl2550_set_power_state(to_i2c_client(dev), 1);
}

static SIMPLE_DEV_PM_OPS(tsl2550_pm_ops, tsl2550_suspend, tsl2550_resume);
#define TSL2550_PM_OPS (&tsl2550_pm_ops)

#else

#define TSL2550_PM_OPS NULL

#endif /* CONFIG_PM_SLEEP */

static const struct i2c_device_id tsl2550_id[] = {
	{ "tsl2550", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, tsl2550_id);

static const struct of_device_id tsl2550_of_match[] = {
	{ .compatible = "taos,tsl2550" },
	{ }
};
MODULE_DEVICE_TABLE(of, tsl2550_of_match);

static struct i2c_driver tsl2550_driver = {
	.driver = {
		.name	= TSL2550_DRV_NAME,
		.of_match_table = tsl2550_of_match,
		.pm	= TSL2550_PM_OPS,
	},
	.probe	= tsl2550_probe,
	.remove	= tsl2550_remove,
	.id_table = tsl2550_id,
};

module_i2c_driver(tsl2550_driver);

MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
MODULE_DESCRIPTION("TSL2550 ambient light sensor driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRIVER_VERSION);
Commit	Line	Data
a92c344d RG	1	/*
	2	* tsl2550.c - Linux kernel modules for ambient light sensor
	3	*
	4	* Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it>
	5	* Copyright (C) 2007 Eurotech S.p.A. <info@eurotech.it>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	20	*/
	21
	22	#include <linux/module.h>
a92c344d RG	23	#include <linux/slab.h>
	24	#include <linux/i2c.h>
	25	#include <linux/mutex.h>
a92c344d RG	26
a92c344d RG	27	#define TSL2550_DRV_NAME "tsl2550"
ac780941	28	#define DRIVER_VERSION "1.2"
a92c344d RG	29
	30	/*
	31	* Defines
	32	*/
	33
	34	#define TSL2550_POWER_DOWN 0x00
	35	#define TSL2550_POWER_UP 0x03
	36	#define TSL2550_STANDARD_RANGE 0x18
	37	#define TSL2550_EXTENDED_RANGE 0x1d
	38	#define TSL2550_READ_ADC0 0x43
	39	#define TSL2550_READ_ADC1 0x83
	40
	41	/*
	42	* Structs
	43	*/
	44
	45	struct tsl2550_data {
	46	struct i2c_client *client;
	47	struct mutex update_lock;
	48
6a9bcced JD	49	unsigned int power_state:1;
6a9bcced JD	50	unsigned int operating_mode:1;
a92c344d RG	51	};
	52
	53	/*
	54	* Global data
	55	*/
	56
	57	static const u8 TSL2550_MODE_RANGE[2] = {
	58	TSL2550_STANDARD_RANGE, TSL2550_EXTENDED_RANGE,
	59	};
	60
	61	/*
	62	* Management functions
	63	*/
	64
	65	static int tsl2550_set_operating_mode(struct i2c_client *client, int mode)
	66	{
	67	struct tsl2550_data *data = i2c_get_clientdata(client);
	68
	69	int ret = i2c_smbus_write_byte(client, TSL2550_MODE_RANGE[mode]);
	70
	71	data->operating_mode = mode;
	72
	73	return ret;
	74	}
	75
	76	static int tsl2550_set_power_state(struct i2c_client *client, int state)
	77	{
	78	struct tsl2550_data *data = i2c_get_clientdata(client);
	79	int ret;
	80
	81	if (state == 0)
	82	ret = i2c_smbus_write_byte(client, TSL2550_POWER_DOWN);
	83	else {
	84	ret = i2c_smbus_write_byte(client, TSL2550_POWER_UP);
	85
	86	/* On power up we should reset operating mode also... */
	87	tsl2550_set_operating_mode(client, data->operating_mode);
	88	}
	89
	90	data->power_state = state;
	91
	92	return ret;
	93	}
	94
	95	static int tsl2550_get_adc_value(struct i2c_client *client, u8 cmd)
	96	{
ac780941	97	int ret;
a92c344d	98
ac780941 JD	99	ret = i2c_smbus_read_byte_data(client, cmd);
	100	if (ret < 0)
	101	return ret;
a92c344d	102	if (!(ret & 0x80))
ac780941	103	return -EAGAIN;
a92c344d RG	104	return ret & 0x7f; /* remove the "valid" bit */
	105	}
	106
	107	/*
	108	* LUX calculation
	109	*/
	110
	111	#define TSL2550_MAX_LUX 1846
	112
	113	static const u8 ratio_lut[] = {
	114	100, 100, 100, 100, 100, 100, 100, 100,
	115	100, 100, 100, 100, 100, 100, 99, 99,
	116	99, 99, 99, 99, 99, 99, 99, 99,
	117	99, 99, 99, 98, 98, 98, 98, 98,
	118	98, 98, 97, 97, 97, 97, 97, 96,
	119	96, 96, 96, 95, 95, 95, 94, 94,
	120	93, 93, 93, 92, 92, 91, 91, 90,
	121	89, 89, 88, 87, 87, 86, 85, 84,
	122	83, 82, 81, 80, 79, 78, 77, 75,
	123	74, 73, 71, 69, 68, 66, 64, 62,
	124	60, 58, 56, 54, 52, 49, 47, 44,
	125	42, 41, 40, 40, 39, 39, 38, 38,
	126	37, 37, 37, 36, 36, 36, 35, 35,
	127	35, 35, 34, 34, 34, 34, 33, 33,
	128	33, 33, 32, 32, 32, 32, 32, 31,
	129	31, 31, 31, 31, 30, 30, 30, 30,
	130	30,
	131	};
	132
	133	static const u16 count_lut[] = {
	134	0, 1, 2, 3, 4, 5, 6, 7,
	135	8, 9, 10, 11, 12, 13, 14, 15,
	136	16, 18, 20, 22, 24, 26, 28, 30,
	137	32, 34, 36, 38, 40, 42, 44, 46,
	138	49, 53, 57, 61, 65, 69, 73, 77,
	139	81, 85, 89, 93, 97, 101, 105, 109,
	140	115, 123, 131, 139, 147, 155, 163, 171,
	141	179, 187, 195, 203, 211, 219, 227, 235,
	142	247, 263, 279, 295, 311, 327, 343, 359,
	143	375, 391, 407, 423, 439, 455, 471, 487,
	144	511, 543, 575, 607, 639, 671, 703, 735,
	145	767, 799, 831, 863, 895, 927, 959, 991,
	146	1039, 1103, 1167, 1231, 1295, 1359, 1423, 1487,
	147	1551, 1615, 1679, 1743, 1807, 1871, 1935, 1999,
	148	2095, 2223, 2351, 2479, 2607, 2735, 2863, 2991,
	149	3119, 3247, 3375, 3503, 3631, 3759, 3887, 4015,
	150	};
	151
	152	/*
	153	* This function is described into Taos TSL2550 Designer's Notebook
	154	* pages 2, 3.
	155	*/
	156	static int tsl2550_calculate_lux(u8 ch0, u8 ch1)
	157	{
	158	unsigned int lux;
	159
	160	/* Look up count from channel values */
	161	u16 c0 = count_lut[ch0];
	162	u16 c1 = count_lut[ch1];
	163
	164	/*
	165	* Calculate ratio.
	166	* Note: the "128" is a scaling factor
	167	*/
168	u8 r = 128;
169
170	/* Avoid division by 0 and count 1 cannot be greater than count 0 */
96f699ad MJDC	171	if (c1 <= c0)
	172	if (c0) {
	173	r = c1 * 128 / c0;
	174
	175	/* Calculate LUX */
	176	lux = ((c0 - c1) * ratio_lut[r]) / 256;
	177	} else
	178	lux = 0;
a92c344d	179	else
96f699ad	180	return -EAGAIN;
a92c344d RG	181
	182	/* LUX range check */
	183	return lux > TSL2550_MAX_LUX ? TSL2550_MAX_LUX : lux;
	184	}
	185
	186	/*
	187	* SysFS support
	188	*/
	189
	190	static ssize_t tsl2550_show_power_state(struct device *dev,
	191	struct device_attribute attr, char buf)
	192	{
	193	struct tsl2550_data *data = i2c_get_clientdata(to_i2c_client(dev));
	194
	195	return sprintf(buf, "%u\n", data->power_state);
	196	}
	197
	198	static ssize_t tsl2550_store_power_state(struct device *dev,
	199	struct device_attribute attr, const char buf, size_t count)
	200	{
	201	struct i2c_client *client = to_i2c_client(dev);
	202	struct tsl2550_data *data = i2c_get_clientdata(client);
	203	unsigned long val = simple_strtoul(buf, NULL, 10);
	204	int ret;
	205
ae8a35ae	206	if (val > 1)
a92c344d RG	207	return -EINVAL;
	208
	209	mutex_lock(&data->update_lock);
	210	ret = tsl2550_set_power_state(client, val);
	211	mutex_unlock(&data->update_lock);
	212
	213	if (ret < 0)
	214	return ret;
	215
	216	return count;
	217	}
	218
	219	static DEVICE_ATTR(power_state, S_IWUSR \| S_IRUGO,
	220	tsl2550_show_power_state, tsl2550_store_power_state);
	221
	222	static ssize_t tsl2550_show_operating_mode(struct device *dev,
	223	struct device_attribute attr, char buf)
	224	{
	225	struct tsl2550_data *data = i2c_get_clientdata(to_i2c_client(dev));
	226
	227	return sprintf(buf, "%u\n", data->operating_mode);
	228	}
	229
	230	static ssize_t tsl2550_store_operating_mode(struct device *dev,
	231	struct device_attribute attr, const char buf, size_t count)
	232	{
	233	struct i2c_client *client = to_i2c_client(dev);
	234	struct tsl2550_data *data = i2c_get_clientdata(client);
	235	unsigned long val = simple_strtoul(buf, NULL, 10);
	236	int ret;
	237
ae8a35ae	238	if (val > 1)
a92c344d RG	239	return -EINVAL;
	240
	241	if (data->power_state == 0)
	242	return -EBUSY;
	243
	244	mutex_lock(&data->update_lock);
	245	ret = tsl2550_set_operating_mode(client, val);
	246	mutex_unlock(&data->update_lock);
	247
	248	if (ret < 0)
	249	return ret;
	250
	251	return count;
	252	}
	253
	254	static DEVICE_ATTR(operating_mode, S_IWUSR \| S_IRUGO,
	255	tsl2550_show_operating_mode, tsl2550_store_operating_mode);
	256
	257	static ssize_t __tsl2550_show_lux(struct i2c_client client, char buf)
	258	{
5f5bfb09	259	struct tsl2550_data *data = i2c_get_clientdata(client);
a92c344d RG	260	u8 ch0, ch1;
	261	int ret;
	262
	263	ret = tsl2550_get_adc_value(client, TSL2550_READ_ADC0);
	264	if (ret < 0)
	265	return ret;
	266	ch0 = ret;
	267
a92c344d RG	268	ret = tsl2550_get_adc_value(client, TSL2550_READ_ADC1);
	269	if (ret < 0)
	270	return ret;
	271	ch1 = ret;
	272
	273	/* Do the job */
	274	ret = tsl2550_calculate_lux(ch0, ch1);
	275	if (ret < 0)
	276	return ret;
5f5bfb09 MJDC	277	if (data->operating_mode == 1)
5f5bfb09 MJDC	278	ret *= 5;
a92c344d RG	279
	280	return sprintf(buf, "%d\n", ret);
	281	}
	282
	283	static ssize_t tsl2550_show_lux1_input(struct device *dev,
	284	struct device_attribute attr, char buf)
	285	{
	286	struct i2c_client *client = to_i2c_client(dev);
	287	struct tsl2550_data *data = i2c_get_clientdata(client);
	288	int ret;
	289
	290	/* No LUX data if not operational */
	291	if (!data->power_state)
	292	return -EBUSY;
	293
	294	mutex_lock(&data->update_lock);
	295	ret = __tsl2550_show_lux(client, buf);
	296	mutex_unlock(&data->update_lock);
	297
	298	return ret;
	299	}
	300
	301	static DEVICE_ATTR(lux1_input, S_IRUGO,
	302	tsl2550_show_lux1_input, NULL);
	303
	304	static struct attribute *tsl2550_attributes[] = {
	305	&dev_attr_power_state.attr,
	306	&dev_attr_operating_mode.attr,
	307	&dev_attr_lux1_input.attr,
	308	NULL
	309	};
	310
	311	static const struct attribute_group tsl2550_attr_group = {
	312	.attrs = tsl2550_attributes,
	313	};
	314
	315	/*
	316	* Initialization function
	317	*/
	318
e296fb7f	319	static int tsl2550_init_client(struct i2c_client *client)
a92c344d RG	320	{
a92c344d RG	321	struct tsl2550_data *data = i2c_get_clientdata(client);
e296fb7f	322	int err;
a92c344d	323
e296fb7f JD	324	/*
	325	* Probe the chip. To do so we try to power up the device and then to
	326	* read back the 0x03 code
	327	*/
ac780941	328	err = i2c_smbus_read_byte_data(client, TSL2550_POWER_UP);
e296fb7f JD	329	if (err < 0)
e296fb7f JD	330	return err;
ac780941	331	if (err != TSL2550_POWER_UP)
e296fb7f JD	332	return -ENODEV;
	333	data->power_state = 1;
	334
	335	/* Set the default operating mode */
	336	err = i2c_smbus_write_byte(client,
	337	TSL2550_MODE_RANGE[data->operating_mode]);
	338	if (err < 0)
	339	return err;
	340
	341	return 0;
a92c344d RG	342	}
	343
	344	/*
	345	* I2C init/probing/exit functions
	346	*/
	347
	348	static struct i2c_driver tsl2550_driver;
80c8ae28	349	static int tsl2550_probe(struct i2c_client *client,
d2653e92	350	const struct i2c_device_id *id)
a92c344d RG	351	{
	352	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	353	struct tsl2550_data *data;
	354	int *opmode, err = 0;
	355
ac780941 JD	356	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE
ac780941 JD	357	\| I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
a92c344d RG	358	err = -EIO;
	359	goto exit;
	360	}
	361
	362	data = kzalloc(sizeof(struct tsl2550_data), GFP_KERNEL);
	363	if (!data) {
	364	err = -ENOMEM;
	365	goto exit;
	366	}
	367	data->client = client;
	368	i2c_set_clientdata(client, data);
	369
	370	/* Check platform data */
	371	opmode = client->dev.platform_data;
	372	if (opmode) {
	373	if (opmode < 0 \|\| opmode > 1) {
	374	dev_err(&client->dev, "invalid operating_mode (%d)\n",
	375	*opmode);
	376	err = -EINVAL;
	377	goto exit_kfree;
	378	}
	379	data->operating_mode = *opmode;
	380	} else
	381	data->operating_mode = 0; /* default mode is standard */
	382	dev_info(&client->dev, "%s operating mode\n",
	383	data->operating_mode ? "extended" : "standard");
	384
a92c344d RG	385	mutex_init(&data->update_lock);
	386
	387	/* Initialize the TSL2550 chip */
e296fb7f JD	388	err = tsl2550_init_client(client);
	389	if (err)
	390	goto exit_kfree;
a92c344d RG	391
	392	/* Register sysfs hooks */
	393	err = sysfs_create_group(&client->dev.kobj, &tsl2550_attr_group);
	394	if (err)
	395	goto exit_kfree;
	396
	397	dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION);
	398
	399	return 0;
	400
	401	exit_kfree:
	402	kfree(data);
	403	exit:
	404	return err;
	405	}
	406
486a5c28	407	static int tsl2550_remove(struct i2c_client *client)
a92c344d RG	408	{
	409	sysfs_remove_group(&client->dev.kobj, &tsl2550_attr_group);
	410
	411	/* Power down the device */
	412	tsl2550_set_power_state(client, 0);
	413
	414	kfree(i2c_get_clientdata(client));
	415
	416	return 0;
	417	}
	418
a7761027	419	#ifdef CONFIG_PM_SLEEP
1b3e5baa	420
a7761027	421	static int tsl2550_suspend(struct device *dev)
1b3e5baa	422	{
a7761027	423	return tsl2550_set_power_state(to_i2c_client(dev), 0);
1b3e5baa RG	424	}
1b3e5baa RG	425
a7761027	426	static int tsl2550_resume(struct device *dev)
1b3e5baa	427	{
a7761027	428	return tsl2550_set_power_state(to_i2c_client(dev), 1);
1b3e5baa RG	429	}
1b3e5baa RG	430
a7761027 LPC	431	static SIMPLE_DEV_PM_OPS(tsl2550_pm_ops, tsl2550_suspend, tsl2550_resume);
	432	#define TSL2550_PM_OPS (&tsl2550_pm_ops)
	433
1b3e5baa RG	434	#else
1b3e5baa RG	435
a7761027	436	#define TSL2550_PM_OPS NULL
1b3e5baa	437
a7761027	438	#endif /* CONFIG_PM_SLEEP */
1b3e5baa	439
3760f736 JD	440	static const struct i2c_device_id tsl2550_id[] = {
	441	{ "tsl2550", 0 },
	442	{ }
	443	};
	444	MODULE_DEVICE_TABLE(i2c, tsl2550_id);
	445
d2ce8d6f JMC	446	static const struct of_device_id tsl2550_of_match[] = {
	447	{ .compatible = "taos,tsl2550" },
	448	{ }
	449	};
	450	MODULE_DEVICE_TABLE(of, tsl2550_of_match);
	451
a92c344d RG	452	static struct i2c_driver tsl2550_driver = {
	453	.driver = {
	454	.name = TSL2550_DRV_NAME,
d2ce8d6f	455	.of_match_table = tsl2550_of_match,
a7761027	456	.pm = TSL2550_PM_OPS,
a92c344d RG	457	},
a92c344d RG	458	.probe = tsl2550_probe,
2d6bed9c	459	.remove = tsl2550_remove,
3760f736	460	.id_table = tsl2550_id,
a92c344d RG	461	};
a92c344d RG	462
a64fe2ed	463	module_i2c_driver(tsl2550_driver);
a92c344d RG	464
	465	MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
	466	MODULE_DESCRIPTION("TSL2550 ambient light sensor driver");
	467	MODULE_LICENSE("GPL");
e296fb7f	468	MODULE_VERSION(DRIVER_VERSION);