blob: b00335652e52ac45087a65510f0c82a799920879 [file] [log] [blame]
Rodolfo Giomettia92c3442007-07-12 14:12:30 +02001/*
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>
Rodolfo Giomettia92c3442007-07-12 14:12:30 +020023#include <linux/slab.h>
24#include <linux/i2c.h>
25#include <linux/mutex.h>
Rodolfo Giomettia92c3442007-07-12 14:12:30 +020026
27#define TSL2550_DRV_NAME "tsl2550"
Jean Delvareac780942009-09-18 22:45:44 +020028#define DRIVER_VERSION "1.2"
Rodolfo Giomettia92c3442007-07-12 14:12:30 +020029
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
45struct tsl2550_data {
46 struct i2c_client *client;
47 struct mutex update_lock;
48
Jean Delvare6a9bcce2010-03-13 20:56:54 +010049 unsigned int power_state:1;
50 unsigned int operating_mode:1;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +020051};
52
53/*
54 * Global data
55 */
56
57static const u8 TSL2550_MODE_RANGE[2] = {
58 TSL2550_STANDARD_RANGE, TSL2550_EXTENDED_RANGE,
59};
60
61/*
62 * Management functions
63 */
64
65static 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
76static 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
95static int tsl2550_get_adc_value(struct i2c_client *client, u8 cmd)
96{
Jean Delvareac780942009-09-18 22:45:44 +020097 int ret;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +020098
Jean Delvareac780942009-09-18 22:45:44 +020099 ret = i2c_smbus_read_byte_data(client, cmd);
100 if (ret < 0)
101 return ret;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200102 if (!(ret & 0x80))
Jean Delvareac780942009-09-18 22:45:44 +0200103 return -EAGAIN;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200104 return ret & 0x7f; /* remove the "valid" bit */
105}
106
107/*
108 * LUX calculation
109 */
110
111#define TSL2550_MAX_LUX 1846
112
113static 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
133static 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 */
156static 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 */
Michele Jr De Candia96f699a2009-07-28 16:33:03 +0200171 if (c1 <= c0)
172 if (c0) {
173 r = c1 * 128 / c0;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200174
Michele Jr De Candia96f699a2009-07-28 16:33:03 +0200175 /* Calculate LUX */
176 lux = ((c0 - c1) * ratio_lut[r]) / 256;
177 } else
178 lux = 0;
179 else
180 return -EAGAIN;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200181
182 /* LUX range check */
183 return lux > TSL2550_MAX_LUX ? TSL2550_MAX_LUX : lux;
184}
185
186/*
187 * SysFS support
188 */
189
190static 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
198static 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
Chen Gangae8a35a2013-04-07 11:28:42 +0800206 if (val > 1)
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200207 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
219static DEVICE_ATTR(power_state, S_IWUSR | S_IRUGO,
220 tsl2550_show_power_state, tsl2550_store_power_state);
221
222static 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
230static 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
Chen Gangae8a35a2013-04-07 11:28:42 +0800238 if (val > 1)
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200239 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
254static DEVICE_ATTR(operating_mode, S_IWUSR | S_IRUGO,
255 tsl2550_show_operating_mode, tsl2550_store_operating_mode);
256
257static ssize_t __tsl2550_show_lux(struct i2c_client *client, char *buf)
258{
Michele Jr De Candia5f5bfb02009-11-26 09:22:32 +0100259 struct tsl2550_data *data = i2c_get_clientdata(client);
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200260 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
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200268 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;
Michele Jr De Candia5f5bfb02009-11-26 09:22:32 +0100277 if (data->operating_mode == 1)
278 ret *= 5;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200279
280 return sprintf(buf, "%d\n", ret);
281}
282
283static 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
301static DEVICE_ATTR(lux1_input, S_IRUGO,
302 tsl2550_show_lux1_input, NULL);
303
304static 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
311static const struct attribute_group tsl2550_attr_group = {
312 .attrs = tsl2550_attributes,
313};
314
315/*
316 * Initialization function
317 */
318
Jean Delvaree296fb72007-07-12 14:12:31 +0200319static int tsl2550_init_client(struct i2c_client *client)
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200320{
321 struct tsl2550_data *data = i2c_get_clientdata(client);
Jean Delvaree296fb72007-07-12 14:12:31 +0200322 int err;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200323
Jean Delvaree296fb72007-07-12 14:12:31 +0200324 /*
325 * Probe the chip. To do so we try to power up the device and then to
326 * read back the 0x03 code
327 */
Jean Delvareac780942009-09-18 22:45:44 +0200328 err = i2c_smbus_read_byte_data(client, TSL2550_POWER_UP);
Jean Delvaree296fb72007-07-12 14:12:31 +0200329 if (err < 0)
330 return err;
Jean Delvareac780942009-09-18 22:45:44 +0200331 if (err != TSL2550_POWER_UP)
Jean Delvaree296fb72007-07-12 14:12:31 +0200332 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;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200342}
343
344/*
345 * I2C init/probing/exit functions
346 */
347
348static struct i2c_driver tsl2550_driver;
Bill Pemberton80c8ae22012-11-19 13:23:05 -0500349static int tsl2550_probe(struct i2c_client *client,
Jean Delvared2653e92008-04-29 23:11:39 +0200350 const struct i2c_device_id *id)
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200351{
352 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
353 struct tsl2550_data *data;
354 int *opmode, err = 0;
355
Jean Delvareac780942009-09-18 22:45:44 +0200356 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE
357 | I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200358 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
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200385 mutex_init(&data->update_lock);
386
387 /* Initialize the TSL2550 chip */
Jean Delvaree296fb72007-07-12 14:12:31 +0200388 err = tsl2550_init_client(client);
389 if (err)
390 goto exit_kfree;
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200391
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
401exit_kfree:
402 kfree(data);
403exit:
404 return err;
405}
406
Bill Pemberton486a5c22012-11-19 13:26:02 -0500407static int tsl2550_remove(struct i2c_client *client)
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200408{
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
Lars-Peter Clausena7761022013-04-11 11:24:42 +0200419#ifdef CONFIG_PM_SLEEP
Rodolfo Giometti1b3e5ba2008-01-27 18:14:45 +0100420
Lars-Peter Clausena7761022013-04-11 11:24:42 +0200421static int tsl2550_suspend(struct device *dev)
Rodolfo Giometti1b3e5ba2008-01-27 18:14:45 +0100422{
Lars-Peter Clausena7761022013-04-11 11:24:42 +0200423 return tsl2550_set_power_state(to_i2c_client(dev), 0);
Rodolfo Giometti1b3e5ba2008-01-27 18:14:45 +0100424}
425
Lars-Peter Clausena7761022013-04-11 11:24:42 +0200426static int tsl2550_resume(struct device *dev)
Rodolfo Giometti1b3e5ba2008-01-27 18:14:45 +0100427{
Lars-Peter Clausena7761022013-04-11 11:24:42 +0200428 return tsl2550_set_power_state(to_i2c_client(dev), 1);
Rodolfo Giometti1b3e5ba2008-01-27 18:14:45 +0100429}
430
Lars-Peter Clausena7761022013-04-11 11:24:42 +0200431static SIMPLE_DEV_PM_OPS(tsl2550_pm_ops, tsl2550_suspend, tsl2550_resume);
432#define TSL2550_PM_OPS (&tsl2550_pm_ops)
433
Rodolfo Giometti1b3e5ba2008-01-27 18:14:45 +0100434#else
435
Lars-Peter Clausena7761022013-04-11 11:24:42 +0200436#define TSL2550_PM_OPS NULL
Rodolfo Giometti1b3e5ba2008-01-27 18:14:45 +0100437
Lars-Peter Clausena7761022013-04-11 11:24:42 +0200438#endif /* CONFIG_PM_SLEEP */
Rodolfo Giometti1b3e5ba2008-01-27 18:14:45 +0100439
Jean Delvare3760f732008-04-29 23:11:40 +0200440static const struct i2c_device_id tsl2550_id[] = {
441 { "tsl2550", 0 },
442 { }
443};
444MODULE_DEVICE_TABLE(i2c, tsl2550_id);
445
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200446static struct i2c_driver tsl2550_driver = {
447 .driver = {
448 .name = TSL2550_DRV_NAME,
449 .owner = THIS_MODULE,
Lars-Peter Clausena7761022013-04-11 11:24:42 +0200450 .pm = TSL2550_PM_OPS,
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200451 },
452 .probe = tsl2550_probe,
Bill Pemberton2d6bed92012-11-19 13:21:23 -0500453 .remove = tsl2550_remove,
Jean Delvare3760f732008-04-29 23:11:40 +0200454 .id_table = tsl2550_id,
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200455};
456
Axel Lina64fe2e2012-01-22 15:36:45 +0800457module_i2c_driver(tsl2550_driver);
Rodolfo Giomettia92c3442007-07-12 14:12:30 +0200458
459MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
460MODULE_DESCRIPTION("TSL2550 ambient light sensor driver");
461MODULE_LICENSE("GPL");
Jean Delvaree296fb72007-07-12 14:12:31 +0200462MODULE_VERSION(DRIVER_VERSION);