GNU Linux-libre 5.19-rc6-gnu
[releases.git] / drivers / misc / tsl2550.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
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>
7  */
8
9 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/i2c.h>
12 #include <linux/mutex.h>
13
14 #define TSL2550_DRV_NAME        "tsl2550"
15 #define DRIVER_VERSION          "1.2"
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
36         unsigned int power_state:1;
37         unsigned int operating_mode:1;
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 {
84         int ret;
85
86         ret = i2c_smbus_read_byte_data(client, cmd);
87         if (ret < 0)
88                 return ret;
89         if (!(ret & 0x80))
90                 return -EAGAIN;
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
151         /* Avoid division by 0 and count 1 cannot be greater than count 0 */
152         if (c1 <= c0)
153                 if (c0) {
154                         /*
155                          * Calculate ratio.
156                          * Note: the "128" is a scaling factor
157                          */
158                         u8 r = c1 * 128 / c0;
159
160                         /* Calculate LUX */
161                         lux = ((c0 - c1) * ratio_lut[r]) / 256;
162                 } else
163                         lux = 0;
164         else
165                 return 0;
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
191         if (val > 1)
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
223         if (val > 1)
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 {
244         struct tsl2550_data *data = i2c_get_clientdata(client);
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
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;
262         if (data->operating_mode == 1)
263                 ret *= 5;
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
304 static int tsl2550_init_client(struct i2c_client *client)
305 {
306         struct tsl2550_data *data = i2c_get_clientdata(client);
307         int err;
308
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          */
313         err = i2c_smbus_read_byte_data(client, TSL2550_POWER_UP);
314         if (err < 0)
315                 return err;
316         if (err != TSL2550_POWER_UP)
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;
327 }
328
329 /*
330  * I2C init/probing/exit functions
331  */
332
333 static struct i2c_driver tsl2550_driver;
334 static int tsl2550_probe(struct i2c_client *client,
335                                    const struct i2c_device_id *id)
336 {
337         struct i2c_adapter *adapter = client->adapter;
338         struct tsl2550_data *data;
339         int *opmode, err = 0;
340
341         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE
342                                             | I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
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
370         mutex_init(&data->update_lock);
371
372         /* Initialize the TSL2550 chip */
373         err = tsl2550_init_client(client);
374         if (err)
375                 goto exit_kfree;
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
392 static int tsl2550_remove(struct i2c_client *client)
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
404 #ifdef CONFIG_PM_SLEEP
405
406 static int tsl2550_suspend(struct device *dev)
407 {
408         return tsl2550_set_power_state(to_i2c_client(dev), 0);
409 }
410
411 static int tsl2550_resume(struct device *dev)
412 {
413         return tsl2550_set_power_state(to_i2c_client(dev), 1);
414 }
415
416 static SIMPLE_DEV_PM_OPS(tsl2550_pm_ops, tsl2550_suspend, tsl2550_resume);
417 #define TSL2550_PM_OPS (&tsl2550_pm_ops)
418
419 #else
420
421 #define TSL2550_PM_OPS NULL
422
423 #endif /* CONFIG_PM_SLEEP */
424
425 static const struct i2c_device_id tsl2550_id[] = {
426         { "tsl2550", 0 },
427         { }
428 };
429 MODULE_DEVICE_TABLE(i2c, tsl2550_id);
430
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
437 static struct i2c_driver tsl2550_driver = {
438         .driver = {
439                 .name   = TSL2550_DRV_NAME,
440                 .of_match_table = tsl2550_of_match,
441                 .pm     = TSL2550_PM_OPS,
442         },
443         .probe  = tsl2550_probe,
444         .remove = tsl2550_remove,
445         .id_table = tsl2550_id,
446 };
447
448 module_i2c_driver(tsl2550_driver);
449
450 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
451 MODULE_DESCRIPTION("TSL2550 ambient light sensor driver");
452 MODULE_LICENSE("GPL");
453 MODULE_VERSION(DRIVER_VERSION);