1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * IIO driver for Lite-On LTR390 ALS and UV sensor
4 * (7-bit I2C slave address 0x53)
5 *
6 * Based on the work of:
7 * Shreeya Patel and Shi Zhigang (LTRF216 Driver)
8 *
9 * Copyright (C) 2023 Anshul Dalal <anshulusr@gmail.com>
10 *
11 * Datasheet:
12 * https://optoelectronics.liteon.com/upload/download/DS86-2015-0004/LTR-390UV_Final_%20DS_V1%201.pdf
13 *
14 * TODO:
15 * - Support for configurable gain and resolution
16 * - Sensor suspend/resume support
17 * - Add support for reading the ALS
18 * - Interrupt support
19 */
20
21 #include <linux/bitfield.h>
22 #include <linux/device.h>
23 #include <linux/i2c.h>
24 #include <linux/irq.h>
25 #include <linux/interrupt.h>
26 #include <linux/math.h>
27 #include <linux/module.h>
28 #include <linux/mutex.h>
29 #include <linux/pm_runtime.h>
30 #include <linux/regmap.h>
31
32 #include <linux/iio/iio.h>
33 #include <linux/iio/events.h>
34
35 #include <linux/unaligned.h>
36
37 #define LTR390_MAIN_CTRL 0x00
38 #define LTR390_ALS_UVS_MEAS_RATE 0x04
39 #define LTR390_ALS_UVS_GAIN 0x05
40 #define LTR390_PART_ID 0x06
41 #define LTR390_MAIN_STATUS 0x07
42
43 #define LTR390_ALS_DATA 0x0D
44 #define LTR390_ALS_DATA_BYTE(n) (LTR390_ALS_DATA + (n))
45
46 #define LTR390_UVS_DATA 0x10
47 #define LTR390_UVS_DATA_BYTE(n) (LTR390_UVS_DATA + (n))
48
49 #define LTR390_INT_CFG 0x19
50 #define LTR390_INT_PST 0x1A
51
52 #define LTR390_THRESH_UP 0x21
53 #define LTR390_THRESH_UP_BYTE(n) (LTR390_THRESH_UP + (n))
54
55 #define LTR390_THRESH_LOW 0x24
56 #define LTR390_THRESH_LOW_BYTE(n) (LTR390_THRESH_LOW + (n))
57
58 #define LTR390_PART_NUMBER_ID 0xb
59 #define LTR390_ALS_UVS_GAIN_MASK GENMASK(2, 0)
60 #define LTR390_ALS_UVS_MEAS_RATE_MASK GENMASK(2, 0)
61 #define LTR390_ALS_UVS_INT_TIME_MASK GENMASK(6, 4)
62 #define LTR390_ALS_UVS_INT_TIME(x) FIELD_PREP(LTR390_ALS_UVS_INT_TIME_MASK, (x))
63 #define LTR390_INT_PST_MASK GENMASK(7, 4)
64 #define LTR390_INT_PST_VAL(x) FIELD_PREP(LTR390_INT_PST_MASK, (x))
65
66 #define LTR390_SW_RESET BIT(4)
67 #define LTR390_UVS_MODE BIT(3)
68 #define LTR390_SENSOR_ENABLE BIT(1)
69 #define LTR390_LS_INT_EN BIT(2)
70 #define LTR390_LS_INT_SEL_UVS BIT(5)
71
72 #define LTR390_FRACTIONAL_PRECISION 100
73
74 /*
75 * At 20-bit resolution (integration time: 400ms) and 18x gain, 2300 counts of
76 * the sensor are equal to 1 UV Index [Datasheet Page#8].
77 *
78 * For the default resolution of 18-bit (integration time: 100ms) and default
79 * gain of 3x, the counts/uvi are calculated as follows:
80 * 2300 / ((3/18) * (100/400)) = 95.83
81 */
82 #define LTR390_COUNTS_PER_UVI 96
83
84 /*
85 * Window Factor is needed when the device is under Window glass with coated
86 * tinted ink. This is to compensate for the light loss due to the lower
87 * transmission rate of the window glass and helps * in calculating lux.
88 */
89 #define LTR390_WINDOW_FACTOR 1
90
91 enum ltr390_mode {
92 LTR390_SET_ALS_MODE,
93 LTR390_SET_UVS_MODE,
94 };
95
96 enum ltr390_meas_rate {
97 LTR390_GET_FREQ,
98 LTR390_GET_PERIOD,
99 };
100
101 struct ltr390_data {
102 struct regmap *regmap;
103 struct i2c_client *client;
104 /* Protects device from simulataneous reads */
105 struct mutex lock;
106 enum ltr390_mode mode;
107 int gain;
108 int int_time_us;
109 bool irq_enabled;
110 };
111
112 static const struct regmap_range ltr390_readable_reg_ranges[] = {
113 regmap_reg_range(LTR390_MAIN_CTRL, LTR390_MAIN_CTRL),
114 regmap_reg_range(LTR390_ALS_UVS_MEAS_RATE, LTR390_MAIN_STATUS),
115 regmap_reg_range(LTR390_ALS_DATA_BYTE(0), LTR390_UVS_DATA_BYTE(2)),
116 regmap_reg_range(LTR390_INT_CFG, LTR390_INT_PST),
117 regmap_reg_range(LTR390_THRESH_UP_BYTE(0), LTR390_THRESH_LOW_BYTE(2)),
118 };
119
120 static const struct regmap_access_table ltr390_readable_reg_table = {
121 .yes_ranges = ltr390_readable_reg_ranges,
122 .n_yes_ranges = ARRAY_SIZE(ltr390_readable_reg_ranges),
123 };
124
125 static const struct regmap_range ltr390_writeable_reg_ranges[] = {
126 regmap_reg_range(LTR390_MAIN_CTRL, LTR390_MAIN_CTRL),
127 regmap_reg_range(LTR390_ALS_UVS_MEAS_RATE, LTR390_ALS_UVS_GAIN),
128 regmap_reg_range(LTR390_INT_CFG, LTR390_INT_PST),
129 regmap_reg_range(LTR390_THRESH_UP_BYTE(0), LTR390_THRESH_LOW_BYTE(2)),
130 };
131
132 static const struct regmap_access_table ltr390_writeable_reg_table = {
133 .yes_ranges = ltr390_writeable_reg_ranges,
134 .n_yes_ranges = ARRAY_SIZE(ltr390_writeable_reg_ranges),
135 };
136
137 static const struct regmap_config ltr390_regmap_config = {
138 .name = "ltr390",
139 .reg_bits = 8,
140 .reg_stride = 1,
141 .val_bits = 8,
142 .max_register = LTR390_THRESH_LOW_BYTE(2),
143 .rd_table = <r390_readable_reg_table,
144 .wr_table = <r390_writeable_reg_table,
145 };
146
147 /* Sampling frequency is in mili Hz and mili Seconds */
148 static const int ltr390_samp_freq_table[][2] = {
149 [0] = { 40000, 25 },
150 [1] = { 20000, 50 },
151 [2] = { 10000, 100 },
152 [3] = { 5000, 200 },
153 [4] = { 2000, 500 },
154 [5] = { 1000, 1000 },
155 [6] = { 500, 2000 },
156 [7] = { 500, 2000 },
157 };
158
ltr390_register_read(struct ltr390_data * data,u8 register_address)159 static int ltr390_register_read(struct ltr390_data *data, u8 register_address)
160 {
161 struct device *dev = &data->client->dev;
162 int ret;
163 u8 recieve_buffer[3];
164
165 ret = regmap_bulk_read(data->regmap, register_address, recieve_buffer,
166 sizeof(recieve_buffer));
167 if (ret) {
168 dev_err(dev, "failed to read measurement data");
169 return ret;
170 }
171
172 return get_unaligned_le24(recieve_buffer);
173 }
174
ltr390_set_mode(struct ltr390_data * data,enum ltr390_mode mode)175 static int ltr390_set_mode(struct ltr390_data *data, enum ltr390_mode mode)
176 {
177 int ret;
178
179 if (data->mode == mode)
180 return 0;
181
182 switch (mode) {
183 case LTR390_SET_ALS_MODE:
184 ret = regmap_clear_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_UVS_MODE);
185 break;
186
187 case LTR390_SET_UVS_MODE:
188 ret = regmap_set_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_UVS_MODE);
189 break;
190 }
191
192 if (ret)
193 return ret;
194
195 data->mode = mode;
196 return 0;
197 }
198
ltr390_counts_per_uvi(struct ltr390_data * data)199 static int ltr390_counts_per_uvi(struct ltr390_data *data)
200 {
201 const int orig_gain = 18;
202 const int orig_int_time = 400;
203
204 return DIV_ROUND_CLOSEST(23 * data->gain * data->int_time_us, 10 * orig_gain * orig_int_time);
205 }
206
ltr390_get_samp_freq_or_period(struct ltr390_data * data,enum ltr390_meas_rate option)207 static int ltr390_get_samp_freq_or_period(struct ltr390_data *data,
208 enum ltr390_meas_rate option)
209 {
210 int ret, value;
211
212 ret = regmap_read(data->regmap, LTR390_ALS_UVS_MEAS_RATE, &value);
213 if (ret < 0)
214 return ret;
215 value = FIELD_GET(LTR390_ALS_UVS_MEAS_RATE_MASK, value);
216
217 return ltr390_samp_freq_table[value][option];
218 }
219
220
ltr390_do_read_raw(struct iio_dev * iio_device,struct iio_chan_spec const * chan,int * val,int * val2,long mask)221 static int ltr390_do_read_raw(struct iio_dev *iio_device,
222 struct iio_chan_spec const *chan, int *val,
223 int *val2, long mask)
224 {
225 int ret;
226 struct ltr390_data *data = iio_priv(iio_device);
227
228 guard(mutex)(&data->lock);
229 switch (mask) {
230 case IIO_CHAN_INFO_RAW:
231 switch (chan->type) {
232 case IIO_UVINDEX:
233 ret = ltr390_set_mode(data, LTR390_SET_UVS_MODE);
234 if (ret < 0)
235 return ret;
236
237 ret = ltr390_register_read(data, LTR390_UVS_DATA);
238 if (ret < 0)
239 return ret;
240 break;
241
242 case IIO_LIGHT:
243 ret = ltr390_set_mode(data, LTR390_SET_ALS_MODE);
244 if (ret < 0)
245 return ret;
246
247 ret = ltr390_register_read(data, LTR390_ALS_DATA);
248 if (ret < 0)
249 return ret;
250 break;
251
252 default:
253 return -EINVAL;
254 }
255 *val = ret;
256 return IIO_VAL_INT;
257 case IIO_CHAN_INFO_SCALE:
258 switch (chan->type) {
259 case IIO_UVINDEX:
260 *val = LTR390_WINDOW_FACTOR * LTR390_FRACTIONAL_PRECISION;
261 *val2 = ltr390_counts_per_uvi(data);
262 return IIO_VAL_FRACTIONAL;
263
264 case IIO_LIGHT:
265 *val = LTR390_WINDOW_FACTOR * 6 * 100;
266 *val2 = data->gain * data->int_time_us;
267 return IIO_VAL_FRACTIONAL;
268
269 default:
270 return -EINVAL;
271 }
272
273 case IIO_CHAN_INFO_INT_TIME:
274 *val = data->int_time_us;
275 return IIO_VAL_INT;
276
277 case IIO_CHAN_INFO_SAMP_FREQ:
278 *val = ltr390_get_samp_freq_or_period(data, LTR390_GET_FREQ);
279 return IIO_VAL_INT;
280
281 default:
282 return -EINVAL;
283 }
284 }
285
ltr390_read_raw(struct iio_dev * iio_device,struct iio_chan_spec const * chan,int * val,int * val2,long mask)286 static int ltr390_read_raw(struct iio_dev *iio_device,
287 struct iio_chan_spec const *chan,
288 int *val, int *val2, long mask)
289 {
290 int ret;
291 struct ltr390_data *data = iio_priv(iio_device);
292 struct device *dev = &data->client->dev;
293
294 ret = pm_runtime_resume_and_get(dev);
295 if (ret < 0) {
296 dev_err(dev, "runtime PM failed to resume: %d\n", ret);
297 return ret;
298 }
299
300 ret = ltr390_do_read_raw(iio_device, chan, val, val2, mask);
301
302 pm_runtime_put_autosuspend(dev);
303
304 return ret;
305 }
306
307 /* integration time in us */
308 static const int ltr390_int_time_map_us[] = { 400000, 200000, 100000, 50000, 25000, 12500 };
309 static const int ltr390_gain_map[] = { 1, 3, 6, 9, 18 };
310 static const int ltr390_freq_map[] = { 40000, 20000, 10000, 5000, 2000, 1000, 500, 500 };
311
312 static const struct iio_event_spec ltr390_event_spec[] = {
313 {
314 .type = IIO_EV_TYPE_THRESH,
315 .dir = IIO_EV_DIR_RISING,
316 .mask_separate = BIT(IIO_EV_INFO_VALUE),
317 }, {
318 .type = IIO_EV_TYPE_THRESH,
319 .dir = IIO_EV_DIR_FALLING,
320 .mask_separate = BIT(IIO_EV_INFO_VALUE),
321 }, {
322 .type = IIO_EV_TYPE_THRESH,
323 .dir = IIO_EV_DIR_EITHER,
324 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
325 BIT(IIO_EV_INFO_PERIOD),
326 }
327 };
328
329 static const struct iio_chan_spec ltr390_channels[] = {
330 /* UV sensor */
331 {
332 .type = IIO_UVINDEX,
333 .scan_index = 0,
334 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
335 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | BIT(IIO_CHAN_INFO_SAMP_FREQ),
336 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
337 BIT(IIO_CHAN_INFO_SCALE) |
338 BIT(IIO_CHAN_INFO_SAMP_FREQ),
339 .event_spec = ltr390_event_spec,
340 .num_event_specs = ARRAY_SIZE(ltr390_event_spec),
341 },
342 /* ALS sensor */
343 {
344 .type = IIO_LIGHT,
345 .scan_index = 1,
346 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
347 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | BIT(IIO_CHAN_INFO_SAMP_FREQ),
348 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
349 BIT(IIO_CHAN_INFO_SCALE) |
350 BIT(IIO_CHAN_INFO_SAMP_FREQ),
351 .event_spec = ltr390_event_spec,
352 .num_event_specs = ARRAY_SIZE(ltr390_event_spec),
353 },
354 };
355
ltr390_set_gain(struct ltr390_data * data,int val)356 static int ltr390_set_gain(struct ltr390_data *data, int val)
357 {
358 int ret, idx;
359
360 for (idx = 0; idx < ARRAY_SIZE(ltr390_gain_map); idx++) {
361 if (ltr390_gain_map[idx] != val)
362 continue;
363
364 guard(mutex)(&data->lock);
365 ret = regmap_update_bits(data->regmap,
366 LTR390_ALS_UVS_GAIN,
367 LTR390_ALS_UVS_GAIN_MASK, idx);
368 if (ret)
369 return ret;
370
371 data->gain = ltr390_gain_map[idx];
372 return 0;
373 }
374
375 return -EINVAL;
376 }
377
ltr390_set_int_time(struct ltr390_data * data,int val)378 static int ltr390_set_int_time(struct ltr390_data *data, int val)
379 {
380 int ret, idx;
381
382 for (idx = 0; idx < ARRAY_SIZE(ltr390_int_time_map_us); idx++) {
383 if (ltr390_int_time_map_us[idx] != val)
384 continue;
385
386 guard(mutex)(&data->lock);
387 ret = regmap_update_bits(data->regmap,
388 LTR390_ALS_UVS_MEAS_RATE,
389 LTR390_ALS_UVS_INT_TIME_MASK,
390 LTR390_ALS_UVS_INT_TIME(idx));
391 if (ret)
392 return ret;
393
394 data->int_time_us = ltr390_int_time_map_us[idx];
395 return 0;
396 }
397
398 return -EINVAL;
399 }
400
ltr390_set_samp_freq(struct ltr390_data * data,int val)401 static int ltr390_set_samp_freq(struct ltr390_data *data, int val)
402 {
403 int idx;
404
405 for (idx = 0; idx < ARRAY_SIZE(ltr390_samp_freq_table); idx++) {
406 if (ltr390_samp_freq_table[idx][0] != val)
407 continue;
408
409 guard(mutex)(&data->lock);
410 return regmap_update_bits(data->regmap,
411 LTR390_ALS_UVS_MEAS_RATE,
412 LTR390_ALS_UVS_MEAS_RATE_MASK, idx);
413 }
414
415 return -EINVAL;
416 }
417
ltr390_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)418 static int ltr390_read_avail(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
419 const int **vals, int *type, int *length, long mask)
420 {
421 switch (mask) {
422 case IIO_CHAN_INFO_SCALE:
423 *length = ARRAY_SIZE(ltr390_gain_map);
424 *type = IIO_VAL_INT;
425 *vals = ltr390_gain_map;
426 return IIO_AVAIL_LIST;
427 case IIO_CHAN_INFO_INT_TIME:
428 *length = ARRAY_SIZE(ltr390_int_time_map_us);
429 *type = IIO_VAL_INT;
430 *vals = ltr390_int_time_map_us;
431 return IIO_AVAIL_LIST;
432 case IIO_CHAN_INFO_SAMP_FREQ:
433 *length = ARRAY_SIZE(ltr390_freq_map);
434 *type = IIO_VAL_INT;
435 *vals = ltr390_freq_map;
436 return IIO_AVAIL_LIST;
437 default:
438 return -EINVAL;
439 }
440 }
441
ltr390_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)442 static int ltr390_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
443 int val, int val2, long mask)
444 {
445 struct ltr390_data *data = iio_priv(indio_dev);
446
447 switch (mask) {
448 case IIO_CHAN_INFO_SCALE:
449 if (val2 != 0)
450 return -EINVAL;
451
452 return ltr390_set_gain(data, val);
453
454 case IIO_CHAN_INFO_INT_TIME:
455 if (val2 != 0)
456 return -EINVAL;
457
458 return ltr390_set_int_time(data, val);
459
460 case IIO_CHAN_INFO_SAMP_FREQ:
461 if (val2 != 0)
462 return -EINVAL;
463
464 return ltr390_set_samp_freq(data, val);
465
466 default:
467 return -EINVAL;
468 }
469 }
470
ltr390_read_intr_prst(struct ltr390_data * data,int * val)471 static int ltr390_read_intr_prst(struct ltr390_data *data, int *val)
472 {
473 int ret, prst, samp_period;
474
475 samp_period = ltr390_get_samp_freq_or_period(data, LTR390_GET_PERIOD);
476 ret = regmap_read(data->regmap, LTR390_INT_PST, &prst);
477 if (ret < 0)
478 return ret;
479 *val = prst * samp_period;
480
481 return IIO_VAL_INT;
482 }
483
ltr390_write_intr_prst(struct ltr390_data * data,int val)484 static int ltr390_write_intr_prst(struct ltr390_data *data, int val)
485 {
486 int ret, samp_period, new_val;
487
488 samp_period = ltr390_get_samp_freq_or_period(data, LTR390_GET_PERIOD);
489
490 /* persist period should be greater than or equal to samp period */
491 if (val < samp_period)
492 return -EINVAL;
493
494 new_val = DIV_ROUND_UP(val, samp_period);
495 if (new_val < 0 || new_val > 0x0f)
496 return -EINVAL;
497
498 guard(mutex)(&data->lock);
499 ret = regmap_update_bits(data->regmap,
500 LTR390_INT_PST,
501 LTR390_INT_PST_MASK,
502 LTR390_INT_PST_VAL(new_val));
503 if (ret)
504 return ret;
505
506 return 0;
507 }
508
ltr390_read_threshold(struct iio_dev * indio_dev,enum iio_event_direction dir,int * val,int * val2)509 static int ltr390_read_threshold(struct iio_dev *indio_dev,
510 enum iio_event_direction dir,
511 int *val, int *val2)
512 {
513 struct ltr390_data *data = iio_priv(indio_dev);
514 int ret;
515
516 switch (dir) {
517 case IIO_EV_DIR_RISING:
518 ret = ltr390_register_read(data, LTR390_THRESH_UP);
519 if (ret < 0)
520 return ret;
521 *val = ret;
522 return IIO_VAL_INT;
523
524 case IIO_EV_DIR_FALLING:
525 ret = ltr390_register_read(data, LTR390_THRESH_LOW);
526 if (ret < 0)
527 return ret;
528 *val = ret;
529 return IIO_VAL_INT;
530 default:
531 return -EINVAL;
532 }
533 }
534
ltr390_write_threshold(struct iio_dev * indio_dev,enum iio_event_direction dir,int val,int val2)535 static int ltr390_write_threshold(struct iio_dev *indio_dev,
536 enum iio_event_direction dir,
537 int val, int val2)
538 {
539 struct ltr390_data *data = iio_priv(indio_dev);
540
541 guard(mutex)(&data->lock);
542 switch (dir) {
543 case IIO_EV_DIR_RISING:
544 return regmap_bulk_write(data->regmap, LTR390_THRESH_UP, &val, 3);
545
546 case IIO_EV_DIR_FALLING:
547 return regmap_bulk_write(data->regmap, LTR390_THRESH_LOW, &val, 3);
548
549 default:
550 return -EINVAL;
551 }
552 }
553
ltr390_read_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)554 static int ltr390_read_event_value(struct iio_dev *indio_dev,
555 const struct iio_chan_spec *chan,
556 enum iio_event_type type,
557 enum iio_event_direction dir,
558 enum iio_event_info info,
559 int *val, int *val2)
560 {
561 switch (info) {
562 case IIO_EV_INFO_VALUE:
563 return ltr390_read_threshold(indio_dev, dir, val, val2);
564
565 case IIO_EV_INFO_PERIOD:
566 return ltr390_read_intr_prst(iio_priv(indio_dev), val);
567
568 default:
569 return -EINVAL;
570 }
571 }
572
ltr390_write_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)573 static int ltr390_write_event_value(struct iio_dev *indio_dev,
574 const struct iio_chan_spec *chan,
575 enum iio_event_type type,
576 enum iio_event_direction dir,
577 enum iio_event_info info,
578 int val, int val2)
579 {
580 switch (info) {
581 case IIO_EV_INFO_VALUE:
582 if (val2 != 0)
583 return -EINVAL;
584
585 return ltr390_write_threshold(indio_dev, dir, val, val2);
586
587 case IIO_EV_INFO_PERIOD:
588 if (val2 != 0)
589 return -EINVAL;
590
591 return ltr390_write_intr_prst(iio_priv(indio_dev), val);
592
593 default:
594 return -EINVAL;
595 }
596 }
597
ltr390_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)598 static int ltr390_read_event_config(struct iio_dev *indio_dev,
599 const struct iio_chan_spec *chan,
600 enum iio_event_type type,
601 enum iio_event_direction dir)
602 {
603 struct ltr390_data *data = iio_priv(indio_dev);
604 int ret, status;
605
606 ret = regmap_read(data->regmap, LTR390_INT_CFG, &status);
607 if (ret < 0)
608 return ret;
609
610 return FIELD_GET(LTR390_LS_INT_EN, status);
611 }
612
ltr390_do_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)613 static int ltr390_do_event_config(struct iio_dev *indio_dev,
614 const struct iio_chan_spec *chan,
615 enum iio_event_type type,
616 enum iio_event_direction dir,
617 bool state)
618 {
619 struct ltr390_data *data = iio_priv(indio_dev);
620 int ret;
621
622 if (!state)
623 return regmap_clear_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_EN);
624
625 ret = regmap_set_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_EN);
626 if (ret < 0)
627 return ret;
628
629 switch (chan->type) {
630 case IIO_LIGHT:
631 ret = ltr390_set_mode(data, LTR390_SET_ALS_MODE);
632 if (ret < 0)
633 return ret;
634
635 return regmap_clear_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_SEL_UVS);
636
637 case IIO_UVINDEX:
638 ret = ltr390_set_mode(data, LTR390_SET_UVS_MODE);
639 if (ret < 0)
640 return ret;
641
642 return regmap_set_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_SEL_UVS);
643
644 default:
645 return -EINVAL;
646 }
647 }
648
ltr390_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)649 static int ltr390_write_event_config(struct iio_dev *indio_dev,
650 const struct iio_chan_spec *chan,
651 enum iio_event_type type,
652 enum iio_event_direction dir,
653 bool state)
654 {
655 int ret;
656 struct ltr390_data *data = iio_priv(indio_dev);
657 struct device *dev = &data->client->dev;
658
659 guard(mutex)(&data->lock);
660
661 if (state && !data->irq_enabled) {
662 ret = pm_runtime_resume_and_get(dev);
663 if (ret < 0) {
664 dev_err(dev, "runtime PM failed to resume: %d\n", ret);
665 return ret;
666 }
667 data->irq_enabled = true;
668 }
669
670 ret = ltr390_do_event_config(indio_dev, chan, type, dir, state);
671
672 if (!state && data->irq_enabled) {
673 data->irq_enabled = false;
674 pm_runtime_put_autosuspend(dev);
675 }
676
677 return ret;
678 }
679
ltr390_debugfs_reg_access(struct iio_dev * indio_dev,unsigned int reg,unsigned int writeval,unsigned int * readval)680 static int ltr390_debugfs_reg_access(struct iio_dev *indio_dev,
681 unsigned int reg, unsigned int writeval,
682 unsigned int *readval)
683 {
684 struct ltr390_data *data = iio_priv(indio_dev);
685
686 guard(mutex)(&data->lock);
687
688 if (readval)
689 return regmap_read(data->regmap, reg, readval);
690
691 return regmap_write(data->regmap, reg, writeval);
692 }
693
694 static const struct iio_info ltr390_info = {
695 .read_raw = ltr390_read_raw,
696 .write_raw = ltr390_write_raw,
697 .read_avail = ltr390_read_avail,
698 .read_event_value = ltr390_read_event_value,
699 .read_event_config = ltr390_read_event_config,
700 .write_event_value = ltr390_write_event_value,
701 .write_event_config = ltr390_write_event_config,
702 .debugfs_reg_access = ltr390_debugfs_reg_access,
703 };
704
ltr390_interrupt_handler(int irq,void * private)705 static irqreturn_t ltr390_interrupt_handler(int irq, void *private)
706 {
707 struct iio_dev *indio_dev = private;
708 struct ltr390_data *data = iio_priv(indio_dev);
709 int ret, status;
710
711 /* Reading the status register to clear the interrupt flag, Datasheet pg: 17*/
712 ret = regmap_read(data->regmap, LTR390_MAIN_STATUS, &status);
713 if (ret < 0)
714 return ret;
715
716 switch (data->mode) {
717 case LTR390_SET_ALS_MODE:
718 iio_push_event(indio_dev,
719 IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0,
720 IIO_EV_TYPE_THRESH,
721 IIO_EV_DIR_EITHER),
722 iio_get_time_ns(indio_dev));
723 break;
724
725 case LTR390_SET_UVS_MODE:
726 iio_push_event(indio_dev,
727 IIO_UNMOD_EVENT_CODE(IIO_UVINDEX, 0,
728 IIO_EV_TYPE_THRESH,
729 IIO_EV_DIR_EITHER),
730 iio_get_time_ns(indio_dev));
731 break;
732 }
733
734 return IRQ_HANDLED;
735 }
736
ltr390_powerdown(void * priv)737 static void ltr390_powerdown(void *priv)
738 {
739 struct ltr390_data *data = priv;
740 struct device *dev = &data->client->dev;
741 int ret;
742
743 guard(mutex)(&data->lock);
744
745 /* Ensure that power off and interrupts are disabled */
746 if (data->irq_enabled) {
747 ret = regmap_clear_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_EN);
748 if (ret < 0)
749 dev_err(dev, "failed to disable interrupts\n");
750
751 data->irq_enabled = false;
752 pm_runtime_put_autosuspend(dev);
753 }
754
755 ret = regmap_clear_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SENSOR_ENABLE);
756 if (ret < 0)
757 dev_err(dev, "failed to disable sensor\n");
758 }
759
ltr390_pm_init(struct ltr390_data * data)760 static int ltr390_pm_init(struct ltr390_data *data)
761 {
762 int ret;
763 struct device *dev = &data->client->dev;
764
765 ret = devm_pm_runtime_set_active_enabled(dev);
766 if (ret)
767 return dev_err_probe(dev, ret, "failed to enable runtime PM\n");
768
769 pm_runtime_set_autosuspend_delay(dev, 1000);
770 pm_runtime_use_autosuspend(dev);
771 return 0;
772 }
773
ltr390_probe(struct i2c_client * client)774 static int ltr390_probe(struct i2c_client *client)
775 {
776 struct ltr390_data *data;
777 struct iio_dev *indio_dev;
778 struct device *dev;
779 int ret, part_number;
780
781 dev = &client->dev;
782 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
783 if (!indio_dev)
784 return -ENOMEM;
785
786 i2c_set_clientdata(client, indio_dev);
787
788 data = iio_priv(indio_dev);
789 data->regmap = devm_regmap_init_i2c(client, <r390_regmap_config);
790 if (IS_ERR(data->regmap))
791 return dev_err_probe(dev, PTR_ERR(data->regmap),
792 "regmap initialization failed\n");
793
794 data->client = client;
795 /* default value of integration time from pg: 15 of the datasheet */
796 data->int_time_us = 100000;
797 /* default value of gain from pg: 16 of the datasheet */
798 data->gain = 3;
799 /* default mode for ltr390 is ALS mode */
800 data->mode = LTR390_SET_ALS_MODE;
801 /* default value of irq_enabled is false */
802 data->irq_enabled = false;
803
804 mutex_init(&data->lock);
805
806 indio_dev->info = <r390_info;
807 indio_dev->channels = ltr390_channels;
808 indio_dev->num_channels = ARRAY_SIZE(ltr390_channels);
809 indio_dev->name = "ltr390";
810
811 ret = regmap_read(data->regmap, LTR390_PART_ID, &part_number);
812 if (ret)
813 return dev_err_probe(dev, ret,
814 "failed to get sensor's part id\n");
815 /* Lower 4 bits of `part_number` change with hardware revisions */
816 if (part_number >> 4 != LTR390_PART_NUMBER_ID)
817 dev_info(dev, "received invalid product id: 0x%x", part_number);
818 dev_dbg(dev, "LTR390, product id: 0x%x\n", part_number);
819
820 /* reset sensor, chip fails to respond to this, so ignore any errors */
821 regmap_set_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SW_RESET);
822
823 /* Wait for the registers to reset before proceeding */
824 usleep_range(1000, 2000);
825
826 ret = regmap_set_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SENSOR_ENABLE);
827 if (ret)
828 return dev_err_probe(dev, ret, "failed to enable the sensor\n");
829
830 ret = devm_add_action_or_reset(dev, ltr390_powerdown, data);
831 if (ret)
832 return dev_err_probe(dev, ret, "failed to add action or reset\n");
833
834 if (client->irq) {
835 ret = devm_request_threaded_irq(dev, client->irq,
836 NULL, ltr390_interrupt_handler,
837 IRQF_ONESHOT,
838 "ltr390_thresh_event",
839 indio_dev);
840 if (ret)
841 return dev_err_probe(dev, ret,
842 "request irq (%d) failed\n", client->irq);
843 }
844
845 ret = ltr390_pm_init(data);
846 if (ret)
847 return dev_err_probe(dev, ret, "failed to initialize runtime PM\n");
848
849 return devm_iio_device_register(dev, indio_dev);
850 }
851
ltr390_suspend(struct device * dev)852 static int ltr390_suspend(struct device *dev)
853 {
854 struct iio_dev *indio_dev = dev_get_drvdata(dev);
855 struct ltr390_data *data = iio_priv(indio_dev);
856
857 return regmap_clear_bits(data->regmap, LTR390_MAIN_CTRL,
858 LTR390_SENSOR_ENABLE);
859 }
860
ltr390_resume(struct device * dev)861 static int ltr390_resume(struct device *dev)
862 {
863 struct iio_dev *indio_dev = dev_get_drvdata(dev);
864 struct ltr390_data *data = iio_priv(indio_dev);
865
866 return regmap_set_bits(data->regmap, LTR390_MAIN_CTRL,
867 LTR390_SENSOR_ENABLE);
868 }
869
ltr390_runtime_suspend(struct device * dev)870 static int ltr390_runtime_suspend(struct device *dev)
871 {
872 struct iio_dev *indio_dev = dev_get_drvdata(dev);
873 struct ltr390_data *data = iio_priv(indio_dev);
874
875 return regmap_clear_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SENSOR_ENABLE);
876 }
877
ltr390_runtime_resume(struct device * dev)878 static int ltr390_runtime_resume(struct device *dev)
879 {
880 struct iio_dev *indio_dev = dev_get_drvdata(dev);
881 struct ltr390_data *data = iio_priv(indio_dev);
882
883 return regmap_set_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SENSOR_ENABLE);
884 }
885
886 static const struct dev_pm_ops ltr390_pm_ops = {
887 SYSTEM_SLEEP_PM_OPS(ltr390_suspend, ltr390_resume)
888 RUNTIME_PM_OPS(ltr390_runtime_suspend, ltr390_runtime_resume, NULL)
889 };
890
891 static const struct i2c_device_id ltr390_id[] = {
892 { "ltr390" },
893 { }
894 };
895 MODULE_DEVICE_TABLE(i2c, ltr390_id);
896
897 static const struct of_device_id ltr390_of_table[] = {
898 { .compatible = "liteon,ltr390" },
899 { }
900 };
901 MODULE_DEVICE_TABLE(of, ltr390_of_table);
902
903 static struct i2c_driver ltr390_driver = {
904 .driver = {
905 .name = "ltr390",
906 .of_match_table = ltr390_of_table,
907 .pm = pm_ptr(<r390_pm_ops),
908 },
909 .probe = ltr390_probe,
910 .id_table = ltr390_id,
911 };
912 module_i2c_driver(ltr390_driver);
913
914 MODULE_AUTHOR("Anshul Dalal <anshulusr@gmail.com>");
915 MODULE_DESCRIPTION("Lite-On LTR390 ALS and UV sensor Driver");
916 MODULE_LICENSE("GPL");
917