[mirror_ubuntu-bionic-kernel.git] / drivers / i2c / chips / 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/init.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 < 0 || 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 < 0 || 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)
{
	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;

	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 __devinit 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 __devexit 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

static int tsl2550_suspend(struct i2c_client *client, pm_message_t mesg)
{
	return tsl2550_set_power_state(client, 0);
}

static int tsl2550_resume(struct i2c_client *client)
{
	return tsl2550_set_power_state(client, 1);
}

#else

#define tsl2550_suspend		NULL
#define tsl2550_resume		NULL

#endif /* CONFIG_PM */

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

static struct i2c_driver tsl2550_driver = {
	.driver = {
		.name	= TSL2550_DRV_NAME,
		.owner	= THIS_MODULE,
	},
	.suspend = tsl2550_suspend,
	.resume	= tsl2550_resume,
	.probe	= tsl2550_probe,
	.remove	= __devexit_p(tsl2550_remove),
	.id_table = tsl2550_id,
};

static int __init tsl2550_init(void)
{
	return i2c_add_driver(&tsl2550_driver);
}

static void __exit tsl2550_exit(void)
{
	i2c_del_driver(&tsl2550_driver);
}

MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
MODULE_DESCRIPTION("TSL2550 ambient light sensor driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRIVER_VERSION);

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