[net-next-2.6.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/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)
{
	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 __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
6a9bcced JD	50	unsigned int power_state:1;
6a9bcced JD	51	unsigned int operating_mode:1;
a92c344d RG	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	{
5f5bfb09	260	struct tsl2550_data *data = i2c_get_clientdata(client);
a92c344d RG	261	u8 ch0, ch1;
	262	int ret;
	263
	264	ret = tsl2550_get_adc_value(client, TSL2550_READ_ADC0);
	265	if (ret < 0)
	266	return ret;
	267	ch0 = ret;
	268
a92c344d RG	269	ret = tsl2550_get_adc_value(client, TSL2550_READ_ADC1);
	270	if (ret < 0)
	271	return ret;
	272	ch1 = ret;
	273
	274	/* Do the job */
	275	ret = tsl2550_calculate_lux(ch0, ch1);
	276	if (ret < 0)
	277	return ret;
5f5bfb09 MJDC	278	if (data->operating_mode == 1)
5f5bfb09 MJDC	279	ret *= 5;
a92c344d RG	280
	281	return sprintf(buf, "%d\n", ret);
	282	}
	283
	284	static ssize_t tsl2550_show_lux1_input(struct device *dev,
	285	struct device_attribute attr, char buf)
	286	{
	287	struct i2c_client *client = to_i2c_client(dev);
	288	struct tsl2550_data *data = i2c_get_clientdata(client);
	289	int ret;
	290
	291	/* No LUX data if not operational */
	292	if (!data->power_state)
	293	return -EBUSY;
	294
	295	mutex_lock(&data->update_lock);
	296	ret = __tsl2550_show_lux(client, buf);
	297	mutex_unlock(&data->update_lock);
	298
	299	return ret;
	300	}
	301
	302	static DEVICE_ATTR(lux1_input, S_IRUGO,
	303	tsl2550_show_lux1_input, NULL);
	304
	305	static struct attribute *tsl2550_attributes[] = {
	306	&dev_attr_power_state.attr,
	307	&dev_attr_operating_mode.attr,
	308	&dev_attr_lux1_input.attr,
	309	NULL
	310	};
	311
	312	static const struct attribute_group tsl2550_attr_group = {
	313	.attrs = tsl2550_attributes,
	314	};
	315
	316	/*
	317	* Initialization function
	318	*/
	319
e296fb7f	320	static int tsl2550_init_client(struct i2c_client *client)
a92c344d RG	321	{
a92c344d RG	322	struct tsl2550_data *data = i2c_get_clientdata(client);
e296fb7f	323	int err;
a92c344d	324
e296fb7f JD	325	/*
	326	* Probe the chip. To do so we try to power up the device and then to
	327	* read back the 0x03 code
	328	*/
ac780941	329	err = i2c_smbus_read_byte_data(client, TSL2550_POWER_UP);
e296fb7f JD	330	if (err < 0)
e296fb7f JD	331	return err;
ac780941	332	if (err != TSL2550_POWER_UP)
e296fb7f JD	333	return -ENODEV;
	334	data->power_state = 1;
	335
	336	/* Set the default operating mode */
	337	err = i2c_smbus_write_byte(client,
	338	TSL2550_MODE_RANGE[data->operating_mode]);
	339	if (err < 0)
	340	return err;
	341
	342	return 0;
a92c344d RG	343	}
	344
	345	/*
	346	* I2C init/probing/exit functions
	347	*/
	348
	349	static struct i2c_driver tsl2550_driver;
d2653e92 JD	350	static int __devinit tsl2550_probe(struct i2c_client *client,
d2653e92 JD	351	const struct i2c_device_id *id)
a92c344d RG	352	{
	353	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	354	struct tsl2550_data *data;
	355	int *opmode, err = 0;
	356
ac780941 JD	357	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE
ac780941 JD	358	\| I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
a92c344d RG	359	err = -EIO;
	360	goto exit;
	361	}
	362
	363	data = kzalloc(sizeof(struct tsl2550_data), GFP_KERNEL);
	364	if (!data) {
	365	err = -ENOMEM;
	366	goto exit;
	367	}
	368	data->client = client;
	369	i2c_set_clientdata(client, data);
	370
	371	/* Check platform data */
	372	opmode = client->dev.platform_data;
	373	if (opmode) {
	374	if (opmode < 0 \|\| opmode > 1) {
	375	dev_err(&client->dev, "invalid operating_mode (%d)\n",
	376	*opmode);
	377	err = -EINVAL;
	378	goto exit_kfree;
	379	}
	380	data->operating_mode = *opmode;
	381	} else
	382	data->operating_mode = 0; /* default mode is standard */
	383	dev_info(&client->dev, "%s operating mode\n",
	384	data->operating_mode ? "extended" : "standard");
	385
a92c344d RG	386	mutex_init(&data->update_lock);
	387
	388	/* Initialize the TSL2550 chip */
e296fb7f JD	389	err = tsl2550_init_client(client);
	390	if (err)
	391	goto exit_kfree;
a92c344d RG	392
	393	/* Register sysfs hooks */
	394	err = sysfs_create_group(&client->dev.kobj, &tsl2550_attr_group);
	395	if (err)
	396	goto exit_kfree;
	397
	398	dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION);
	399
	400	return 0;
	401
	402	exit_kfree:
	403	kfree(data);
	404	exit:
	405	return err;
	406	}
	407
	408	static int __devexit tsl2550_remove(struct i2c_client *client)
	409	{
	410	sysfs_remove_group(&client->dev.kobj, &tsl2550_attr_group);
	411
	412	/* Power down the device */
	413	tsl2550_set_power_state(client, 0);
	414
	415	kfree(i2c_get_clientdata(client));
	416
	417	return 0;
	418	}
	419
1b3e5baa RG	420	#ifdef CONFIG_PM
	421
	422	static int tsl2550_suspend(struct i2c_client *client, pm_message_t mesg)
	423	{
	424	return tsl2550_set_power_state(client, 0);
	425	}
	426
	427	static int tsl2550_resume(struct i2c_client *client)
	428	{
	429	return tsl2550_set_power_state(client, 1);
	430	}
	431
	432	#else
	433
	434	#define tsl2550_suspend NULL
	435	#define tsl2550_resume NULL
	436
	437	#endif /* CONFIG_PM */
	438
3760f736 JD	439	static const struct i2c_device_id tsl2550_id[] = {
	440	{ "tsl2550", 0 },
	441	{ }
	442	};
	443	MODULE_DEVICE_TABLE(i2c, tsl2550_id);
	444
a92c344d RG	445	static struct i2c_driver tsl2550_driver = {
	446	.driver = {
	447	.name = TSL2550_DRV_NAME,
	448	.owner = THIS_MODULE,
	449	},
1b3e5baa RG	450	.suspend = tsl2550_suspend,
1b3e5baa RG	451	.resume = tsl2550_resume,
a92c344d RG	452	.probe = tsl2550_probe,
a92c344d RG	453	.remove = __devexit_p(tsl2550_remove),
3760f736	454	.id_table = tsl2550_id,
a92c344d RG	455	};
	456
	457	static int __init tsl2550_init(void)
	458	{
	459	return i2c_add_driver(&tsl2550_driver);
	460	}
	461
	462	static void __exit tsl2550_exit(void)
	463	{
	464	i2c_del_driver(&tsl2550_driver);
	465	}
	466
	467	MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
	468	MODULE_DESCRIPTION("TSL2550 ambient light sensor driver");
	469	MODULE_LICENSE("GPL");
e296fb7f	470	MODULE_VERSION(DRIVER_VERSION);
a92c344d RG	471
	472	module_init(tsl2550_init);
	473	module_exit(tsl2550_exit);