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

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  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>
 */

#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];

	/* Avoid division by 0 and count 1 cannot be greater than count 0 */
	if (c1 <= c0)
		if (c0) {
			/*
			 * Calculate ratio.
			 * Note: the "128" is a scaling factor
			 */
			u8 r = c1 * 128 / c0;

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

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