2 * tsl2550.c - Linux kernel modules for ambient light sensor
4 * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it>
5 * Copyright (C) 2007 Eurotech S.p.A. <info@eurotech.it>
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.
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.
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.
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>
28 #define TSL2550_DRV_NAME "tsl2550"
29 #define DRIVER_VERSION "1.2"
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
47 struct i2c_client *client;
48 struct mutex update_lock;
50 unsigned int power_state:1;
51 unsigned int operating_mode:1;
58 static const u8 TSL2550_MODE_RANGE[2] = {
59 TSL2550_STANDARD_RANGE, TSL2550_EXTENDED_RANGE,
63 * Management functions
66 static int tsl2550_set_operating_mode(struct i2c_client *client, int mode)
68 struct tsl2550_data *data = i2c_get_clientdata(client);
70 int ret = i2c_smbus_write_byte(client, TSL2550_MODE_RANGE[mode]);
72 data->operating_mode = mode;
77 static int tsl2550_set_power_state(struct i2c_client *client, int state)
79 struct tsl2550_data *data = i2c_get_clientdata(client);
83 ret = i2c_smbus_write_byte(client, TSL2550_POWER_DOWN);
85 ret = i2c_smbus_write_byte(client, TSL2550_POWER_UP);
87 /* On power up we should reset operating mode also... */
88 tsl2550_set_operating_mode(client, data->operating_mode);
91 data->power_state = state;
96 static int tsl2550_get_adc_value(struct i2c_client *client, u8 cmd)
100 ret = i2c_smbus_read_byte_data(client, cmd);
105 return ret & 0x7f; /* remove the "valid" bit */
112 #define TSL2550_MAX_LUX 1846
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,
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,
154 * This function is described into Taos TSL2550 Designer's Notebook
157 static int tsl2550_calculate_lux(u8 ch0, u8 ch1)
161 /* Look up count from channel values */
162 u16 c0 = count_lut[ch0];
163 u16 c1 = count_lut[ch1];
167 * Note: the "128" is a scaling factor
171 /* Avoid division by 0 and count 1 cannot be greater than count 0 */
177 lux = ((c0 - c1) * ratio_lut[r]) / 256;
183 /* LUX range check */
184 return lux > TSL2550_MAX_LUX ? TSL2550_MAX_LUX : lux;
191 static ssize_t tsl2550_show_power_state(struct device *dev,
192 struct device_attribute *attr, char *buf)
194 struct tsl2550_data *data = i2c_get_clientdata(to_i2c_client(dev));
196 return sprintf(buf, "%u\n", data->power_state);
199 static ssize_t tsl2550_store_power_state(struct device *dev,
200 struct device_attribute *attr, const char *buf, size_t count)
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);
207 if (val < 0 || val > 1)
210 mutex_lock(&data->update_lock);
211 ret = tsl2550_set_power_state(client, val);
212 mutex_unlock(&data->update_lock);
220 static DEVICE_ATTR(power_state, S_IWUSR | S_IRUGO,
221 tsl2550_show_power_state, tsl2550_store_power_state);
223 static ssize_t tsl2550_show_operating_mode(struct device *dev,
224 struct device_attribute *attr, char *buf)
226 struct tsl2550_data *data = i2c_get_clientdata(to_i2c_client(dev));
228 return sprintf(buf, "%u\n", data->operating_mode);
231 static ssize_t tsl2550_store_operating_mode(struct device *dev,
232 struct device_attribute *attr, const char *buf, size_t count)
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);
239 if (val < 0 || val > 1)
242 if (data->power_state == 0)
245 mutex_lock(&data->update_lock);
246 ret = tsl2550_set_operating_mode(client, val);
247 mutex_unlock(&data->update_lock);
255 static DEVICE_ATTR(operating_mode, S_IWUSR | S_IRUGO,
256 tsl2550_show_operating_mode, tsl2550_store_operating_mode);
258 static ssize_t __tsl2550_show_lux(struct i2c_client *client, char *buf)
260 struct tsl2550_data *data = i2c_get_clientdata(client);
264 ret = tsl2550_get_adc_value(client, TSL2550_READ_ADC0);
269 ret = tsl2550_get_adc_value(client, TSL2550_READ_ADC1);
275 ret = tsl2550_calculate_lux(ch0, ch1);
278 if (data->operating_mode == 1)
281 return sprintf(buf, "%d\n", ret);
284 static ssize_t tsl2550_show_lux1_input(struct device *dev,
285 struct device_attribute *attr, char *buf)
287 struct i2c_client *client = to_i2c_client(dev);
288 struct tsl2550_data *data = i2c_get_clientdata(client);
291 /* No LUX data if not operational */
292 if (!data->power_state)
295 mutex_lock(&data->update_lock);
296 ret = __tsl2550_show_lux(client, buf);
297 mutex_unlock(&data->update_lock);
302 static DEVICE_ATTR(lux1_input, S_IRUGO,
303 tsl2550_show_lux1_input, NULL);
305 static struct attribute *tsl2550_attributes[] = {
306 &dev_attr_power_state.attr,
307 &dev_attr_operating_mode.attr,
308 &dev_attr_lux1_input.attr,
312 static const struct attribute_group tsl2550_attr_group = {
313 .attrs = tsl2550_attributes,
317 * Initialization function
320 static int tsl2550_init_client(struct i2c_client *client)
322 struct tsl2550_data *data = i2c_get_clientdata(client);
326 * Probe the chip. To do so we try to power up the device and then to
327 * read back the 0x03 code
329 err = i2c_smbus_read_byte_data(client, TSL2550_POWER_UP);
332 if (err != TSL2550_POWER_UP)
334 data->power_state = 1;
336 /* Set the default operating mode */
337 err = i2c_smbus_write_byte(client,
338 TSL2550_MODE_RANGE[data->operating_mode]);
346 * I2C init/probing/exit functions
349 static struct i2c_driver tsl2550_driver;
350 static int tsl2550_probe(struct i2c_client *client,
351 const struct i2c_device_id *id)
353 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
354 struct tsl2550_data *data;
355 int *opmode, err = 0;
357 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE
358 | I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
363 data = kzalloc(sizeof(struct tsl2550_data), GFP_KERNEL);
368 data->client = client;
369 i2c_set_clientdata(client, data);
371 /* Check platform data */
372 opmode = client->dev.platform_data;
374 if (*opmode < 0 || *opmode > 1) {
375 dev_err(&client->dev, "invalid operating_mode (%d)\n",
380 data->operating_mode = *opmode;
382 data->operating_mode = 0; /* default mode is standard */
383 dev_info(&client->dev, "%s operating mode\n",
384 data->operating_mode ? "extended" : "standard");
386 mutex_init(&data->update_lock);
388 /* Initialize the TSL2550 chip */
389 err = tsl2550_init_client(client);
393 /* Register sysfs hooks */
394 err = sysfs_create_group(&client->dev.kobj, &tsl2550_attr_group);
398 dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION);
408 static int tsl2550_remove(struct i2c_client *client)
410 sysfs_remove_group(&client->dev.kobj, &tsl2550_attr_group);
412 /* Power down the device */
413 tsl2550_set_power_state(client, 0);
415 kfree(i2c_get_clientdata(client));
420 #ifdef CONFIG_PM_SLEEP
422 static int tsl2550_suspend(struct device *dev)
424 return tsl2550_set_power_state(to_i2c_client(dev), 0);
427 static int tsl2550_resume(struct device *dev)
429 return tsl2550_set_power_state(to_i2c_client(dev), 1);
432 static SIMPLE_DEV_PM_OPS(tsl2550_pm_ops, tsl2550_suspend, tsl2550_resume);
433 #define TSL2550_PM_OPS (&tsl2550_pm_ops)
437 #define TSL2550_PM_OPS NULL
439 #endif /* CONFIG_PM_SLEEP */
441 static const struct i2c_device_id tsl2550_id[] = {
445 MODULE_DEVICE_TABLE(i2c, tsl2550_id);
447 static struct i2c_driver tsl2550_driver = {
449 .name = TSL2550_DRV_NAME,
450 .owner = THIS_MODULE,
451 .pm = TSL2550_PM_OPS,
453 .probe = tsl2550_probe,
454 .remove = tsl2550_remove,
455 .id_table = tsl2550_id,
458 module_i2c_driver(tsl2550_driver);
460 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
461 MODULE_DESCRIPTION("TSL2550 ambient light sensor driver");
462 MODULE_LICENSE("GPL");
463 MODULE_VERSION(DRIVER_VERSION);