Loading...
Note: File does not exist in v3.1.
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/regmap.h>
30
31#include <linux/iio/iio.h>
32#include <linux/iio/events.h>
33
34#include <linux/unaligned.h>
35
36#define LTR390_MAIN_CTRL 0x00
37#define LTR390_ALS_UVS_MEAS_RATE 0x04
38#define LTR390_ALS_UVS_GAIN 0x05
39#define LTR390_PART_ID 0x06
40#define LTR390_MAIN_STATUS 0x07
41#define LTR390_ALS_DATA 0x0D
42#define LTR390_UVS_DATA 0x10
43#define LTR390_INT_CFG 0x19
44#define LTR390_INT_PST 0x1A
45#define LTR390_THRESH_UP 0x21
46#define LTR390_THRESH_LOW 0x24
47
48#define LTR390_PART_NUMBER_ID 0xb
49#define LTR390_ALS_UVS_GAIN_MASK GENMASK(2, 0)
50#define LTR390_ALS_UVS_MEAS_RATE_MASK GENMASK(2, 0)
51#define LTR390_ALS_UVS_INT_TIME_MASK GENMASK(6, 4)
52#define LTR390_ALS_UVS_INT_TIME(x) FIELD_PREP(LTR390_ALS_UVS_INT_TIME_MASK, (x))
53#define LTR390_INT_PST_MASK GENMASK(7, 4)
54#define LTR390_INT_PST_VAL(x) FIELD_PREP(LTR390_INT_PST_MASK, (x))
55
56#define LTR390_SW_RESET BIT(4)
57#define LTR390_UVS_MODE BIT(3)
58#define LTR390_SENSOR_ENABLE BIT(1)
59#define LTR390_LS_INT_EN BIT(2)
60#define LTR390_LS_INT_SEL_UVS BIT(5)
61
62#define LTR390_FRACTIONAL_PRECISION 100
63
64/*
65 * At 20-bit resolution (integration time: 400ms) and 18x gain, 2300 counts of
66 * the sensor are equal to 1 UV Index [Datasheet Page#8].
67 *
68 * For the default resolution of 18-bit (integration time: 100ms) and default
69 * gain of 3x, the counts/uvi are calculated as follows:
70 * 2300 / ((3/18) * (100/400)) = 95.83
71 */
72#define LTR390_COUNTS_PER_UVI 96
73
74/*
75 * Window Factor is needed when the device is under Window glass with coated
76 * tinted ink. This is to compensate for the light loss due to the lower
77 * transmission rate of the window glass and helps * in calculating lux.
78 */
79#define LTR390_WINDOW_FACTOR 1
80
81enum ltr390_mode {
82 LTR390_SET_ALS_MODE,
83 LTR390_SET_UVS_MODE,
84};
85
86enum ltr390_meas_rate {
87 LTR390_GET_FREQ,
88 LTR390_GET_PERIOD,
89};
90
91struct ltr390_data {
92 struct regmap *regmap;
93 struct i2c_client *client;
94 /* Protects device from simulataneous reads */
95 struct mutex lock;
96 enum ltr390_mode mode;
97 int gain;
98 int int_time_us;
99};
100
101static const struct regmap_config ltr390_regmap_config = {
102 .name = "ltr390",
103 .reg_bits = 8,
104 .reg_stride = 1,
105 .val_bits = 8,
106};
107
108/* Sampling frequency is in mili Hz and mili Seconds */
109static const int ltr390_samp_freq_table[][2] = {
110 [0] = { 40000, 25 },
111 [1] = { 20000, 50 },
112 [2] = { 10000, 100 },
113 [3] = { 5000, 200 },
114 [4] = { 2000, 500 },
115 [5] = { 1000, 1000 },
116 [6] = { 500, 2000 },
117 [7] = { 500, 2000 },
118};
119
120static int ltr390_register_read(struct ltr390_data *data, u8 register_address)
121{
122 struct device *dev = &data->client->dev;
123 int ret;
124 u8 recieve_buffer[3];
125
126 ret = regmap_bulk_read(data->regmap, register_address, recieve_buffer,
127 sizeof(recieve_buffer));
128 if (ret) {
129 dev_err(dev, "failed to read measurement data");
130 return ret;
131 }
132
133 return get_unaligned_le24(recieve_buffer);
134}
135
136static int ltr390_set_mode(struct ltr390_data *data, enum ltr390_mode mode)
137{
138 int ret;
139
140 if (data->mode == mode)
141 return 0;
142
143 switch (mode) {
144 case LTR390_SET_ALS_MODE:
145 ret = regmap_clear_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_UVS_MODE);
146 break;
147
148 case LTR390_SET_UVS_MODE:
149 ret = regmap_set_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_UVS_MODE);
150 break;
151 }
152
153 if (ret)
154 return ret;
155
156 data->mode = mode;
157 return 0;
158}
159
160static int ltr390_counts_per_uvi(struct ltr390_data *data)
161{
162 const int orig_gain = 18;
163 const int orig_int_time = 400;
164
165 return DIV_ROUND_CLOSEST(23 * data->gain * data->int_time_us, 10 * orig_gain * orig_int_time);
166}
167
168static int ltr390_get_samp_freq_or_period(struct ltr390_data *data,
169 enum ltr390_meas_rate option)
170{
171 int ret, value;
172
173 ret = regmap_read(data->regmap, LTR390_ALS_UVS_MEAS_RATE, &value);
174 if (ret < 0)
175 return ret;
176 value = FIELD_GET(LTR390_ALS_UVS_MEAS_RATE_MASK, value);
177
178 return ltr390_samp_freq_table[value][option];
179}
180
181static int ltr390_read_raw(struct iio_dev *iio_device,
182 struct iio_chan_spec const *chan, int *val,
183 int *val2, long mask)
184{
185 int ret;
186 struct ltr390_data *data = iio_priv(iio_device);
187
188 guard(mutex)(&data->lock);
189 switch (mask) {
190 case IIO_CHAN_INFO_RAW:
191 switch (chan->type) {
192 case IIO_UVINDEX:
193 ret = ltr390_set_mode(data, LTR390_SET_UVS_MODE);
194 if (ret < 0)
195 return ret;
196
197 ret = ltr390_register_read(data, LTR390_UVS_DATA);
198 if (ret < 0)
199 return ret;
200 break;
201
202 case IIO_LIGHT:
203 ret = ltr390_set_mode(data, LTR390_SET_ALS_MODE);
204 if (ret < 0)
205 return ret;
206
207 ret = ltr390_register_read(data, LTR390_ALS_DATA);
208 if (ret < 0)
209 return ret;
210 break;
211
212 default:
213 return -EINVAL;
214 }
215 *val = ret;
216 return IIO_VAL_INT;
217 case IIO_CHAN_INFO_SCALE:
218 switch (chan->type) {
219 case IIO_UVINDEX:
220 *val = LTR390_WINDOW_FACTOR * LTR390_FRACTIONAL_PRECISION;
221 *val2 = ltr390_counts_per_uvi(data);
222 return IIO_VAL_FRACTIONAL;
223
224 case IIO_LIGHT:
225 *val = LTR390_WINDOW_FACTOR * 6 * 100;
226 *val2 = data->gain * data->int_time_us;
227 return IIO_VAL_FRACTIONAL;
228
229 default:
230 return -EINVAL;
231 }
232
233 case IIO_CHAN_INFO_INT_TIME:
234 *val = data->int_time_us;
235 return IIO_VAL_INT;
236
237 case IIO_CHAN_INFO_SAMP_FREQ:
238 *val = ltr390_get_samp_freq_or_period(data, LTR390_GET_FREQ);
239 return IIO_VAL_INT;
240
241 default:
242 return -EINVAL;
243 }
244}
245
246/* integration time in us */
247static const int ltr390_int_time_map_us[] = { 400000, 200000, 100000, 50000, 25000, 12500 };
248static const int ltr390_gain_map[] = { 1, 3, 6, 9, 18 };
249static const int ltr390_freq_map[] = { 40000, 20000, 10000, 5000, 2000, 1000, 500, 500 };
250
251static const struct iio_event_spec ltr390_event_spec[] = {
252 {
253 .type = IIO_EV_TYPE_THRESH,
254 .dir = IIO_EV_DIR_RISING,
255 .mask_separate = BIT(IIO_EV_INFO_VALUE),
256 }, {
257 .type = IIO_EV_TYPE_THRESH,
258 .dir = IIO_EV_DIR_FALLING,
259 .mask_separate = BIT(IIO_EV_INFO_VALUE),
260 }, {
261 .type = IIO_EV_TYPE_THRESH,
262 .dir = IIO_EV_DIR_EITHER,
263 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
264 BIT(IIO_EV_INFO_PERIOD),
265 }
266};
267
268static const struct iio_chan_spec ltr390_channels[] = {
269 /* UV sensor */
270 {
271 .type = IIO_UVINDEX,
272 .scan_index = 0,
273 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
274 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | BIT(IIO_CHAN_INFO_SAMP_FREQ),
275 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
276 BIT(IIO_CHAN_INFO_SCALE) |
277 BIT(IIO_CHAN_INFO_SAMP_FREQ),
278 .event_spec = ltr390_event_spec,
279 .num_event_specs = ARRAY_SIZE(ltr390_event_spec),
280 },
281 /* ALS sensor */
282 {
283 .type = IIO_LIGHT,
284 .scan_index = 1,
285 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
286 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | BIT(IIO_CHAN_INFO_SAMP_FREQ),
287 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
288 BIT(IIO_CHAN_INFO_SCALE) |
289 BIT(IIO_CHAN_INFO_SAMP_FREQ),
290 .event_spec = ltr390_event_spec,
291 .num_event_specs = ARRAY_SIZE(ltr390_event_spec),
292 },
293};
294
295static int ltr390_set_gain(struct ltr390_data *data, int val)
296{
297 int ret, idx;
298
299 for (idx = 0; idx < ARRAY_SIZE(ltr390_gain_map); idx++) {
300 if (ltr390_gain_map[idx] != val)
301 continue;
302
303 guard(mutex)(&data->lock);
304 ret = regmap_update_bits(data->regmap,
305 LTR390_ALS_UVS_GAIN,
306 LTR390_ALS_UVS_GAIN_MASK, idx);
307 if (ret)
308 return ret;
309
310 data->gain = ltr390_gain_map[idx];
311 return 0;
312 }
313
314 return -EINVAL;
315}
316
317static int ltr390_set_int_time(struct ltr390_data *data, int val)
318{
319 int ret, idx;
320
321 for (idx = 0; idx < ARRAY_SIZE(ltr390_int_time_map_us); idx++) {
322 if (ltr390_int_time_map_us[idx] != val)
323 continue;
324
325 guard(mutex)(&data->lock);
326 ret = regmap_update_bits(data->regmap,
327 LTR390_ALS_UVS_MEAS_RATE,
328 LTR390_ALS_UVS_INT_TIME_MASK,
329 LTR390_ALS_UVS_INT_TIME(idx));
330 if (ret)
331 return ret;
332
333 data->int_time_us = ltr390_int_time_map_us[idx];
334 return 0;
335 }
336
337 return -EINVAL;
338}
339
340static int ltr390_set_samp_freq(struct ltr390_data *data, int val)
341{
342 int idx;
343
344 for (idx = 0; idx < ARRAY_SIZE(ltr390_samp_freq_table); idx++) {
345 if (ltr390_samp_freq_table[idx][0] != val)
346 continue;
347
348 guard(mutex)(&data->lock);
349 return regmap_update_bits(data->regmap,
350 LTR390_ALS_UVS_MEAS_RATE,
351 LTR390_ALS_UVS_MEAS_RATE_MASK, idx);
352 }
353
354 return -EINVAL;
355}
356
357static int ltr390_read_avail(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
358 const int **vals, int *type, int *length, long mask)
359{
360 switch (mask) {
361 case IIO_CHAN_INFO_SCALE:
362 *length = ARRAY_SIZE(ltr390_gain_map);
363 *type = IIO_VAL_INT;
364 *vals = ltr390_gain_map;
365 return IIO_AVAIL_LIST;
366 case IIO_CHAN_INFO_INT_TIME:
367 *length = ARRAY_SIZE(ltr390_int_time_map_us);
368 *type = IIO_VAL_INT;
369 *vals = ltr390_int_time_map_us;
370 return IIO_AVAIL_LIST;
371 case IIO_CHAN_INFO_SAMP_FREQ:
372 *length = ARRAY_SIZE(ltr390_freq_map);
373 *type = IIO_VAL_INT;
374 *vals = ltr390_freq_map;
375 return IIO_AVAIL_LIST;
376 default:
377 return -EINVAL;
378 }
379}
380
381static int ltr390_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
382 int val, int val2, long mask)
383{
384 struct ltr390_data *data = iio_priv(indio_dev);
385
386 switch (mask) {
387 case IIO_CHAN_INFO_SCALE:
388 if (val2 != 0)
389 return -EINVAL;
390
391 return ltr390_set_gain(data, val);
392
393 case IIO_CHAN_INFO_INT_TIME:
394 if (val2 != 0)
395 return -EINVAL;
396
397 return ltr390_set_int_time(data, val);
398
399 case IIO_CHAN_INFO_SAMP_FREQ:
400 if (val2 != 0)
401 return -EINVAL;
402
403 return ltr390_set_samp_freq(data, val);
404
405 default:
406 return -EINVAL;
407 }
408}
409
410static int ltr390_read_intr_prst(struct ltr390_data *data, int *val)
411{
412 int ret, prst, samp_period;
413
414 samp_period = ltr390_get_samp_freq_or_period(data, LTR390_GET_PERIOD);
415 ret = regmap_read(data->regmap, LTR390_INT_PST, &prst);
416 if (ret < 0)
417 return ret;
418 *val = prst * samp_period;
419
420 return IIO_VAL_INT;
421}
422
423static int ltr390_write_intr_prst(struct ltr390_data *data, int val)
424{
425 int ret, samp_period, new_val;
426
427 samp_period = ltr390_get_samp_freq_or_period(data, LTR390_GET_PERIOD);
428
429 /* persist period should be greater than or equal to samp period */
430 if (val < samp_period)
431 return -EINVAL;
432
433 new_val = DIV_ROUND_UP(val, samp_period);
434 if (new_val < 0 || new_val > 0x0f)
435 return -EINVAL;
436
437 guard(mutex)(&data->lock);
438 ret = regmap_update_bits(data->regmap,
439 LTR390_INT_PST,
440 LTR390_INT_PST_MASK,
441 LTR390_INT_PST_VAL(new_val));
442 if (ret)
443 return ret;
444
445 return 0;
446}
447
448static int ltr390_read_threshold(struct iio_dev *indio_dev,
449 enum iio_event_direction dir,
450 int *val, int *val2)
451{
452 struct ltr390_data *data = iio_priv(indio_dev);
453 int ret;
454
455 switch (dir) {
456 case IIO_EV_DIR_RISING:
457 ret = ltr390_register_read(data, LTR390_THRESH_UP);
458 if (ret < 0)
459 return ret;
460 *val = ret;
461 return IIO_VAL_INT;
462
463 case IIO_EV_DIR_FALLING:
464 ret = ltr390_register_read(data, LTR390_THRESH_LOW);
465 if (ret < 0)
466 return ret;
467 *val = ret;
468 return IIO_VAL_INT;
469 default:
470 return -EINVAL;
471 }
472}
473
474static int ltr390_write_threshold(struct iio_dev *indio_dev,
475 enum iio_event_direction dir,
476 int val, int val2)
477{
478 struct ltr390_data *data = iio_priv(indio_dev);
479
480 guard(mutex)(&data->lock);
481 switch (dir) {
482 case IIO_EV_DIR_RISING:
483 return regmap_bulk_write(data->regmap, LTR390_THRESH_UP, &val, 3);
484
485 case IIO_EV_DIR_FALLING:
486 return regmap_bulk_write(data->regmap, LTR390_THRESH_LOW, &val, 3);
487
488 default:
489 return -EINVAL;
490 }
491}
492
493static int ltr390_read_event_value(struct iio_dev *indio_dev,
494 const struct iio_chan_spec *chan,
495 enum iio_event_type type,
496 enum iio_event_direction dir,
497 enum iio_event_info info,
498 int *val, int *val2)
499{
500 switch (info) {
501 case IIO_EV_INFO_VALUE:
502 return ltr390_read_threshold(indio_dev, dir, val, val2);
503
504 case IIO_EV_INFO_PERIOD:
505 return ltr390_read_intr_prst(iio_priv(indio_dev), val);
506
507 default:
508 return -EINVAL;
509 }
510}
511
512static int ltr390_write_event_value(struct iio_dev *indio_dev,
513 const struct iio_chan_spec *chan,
514 enum iio_event_type type,
515 enum iio_event_direction dir,
516 enum iio_event_info info,
517 int val, int val2)
518{
519 switch (info) {
520 case IIO_EV_INFO_VALUE:
521 if (val2 != 0)
522 return -EINVAL;
523
524 return ltr390_write_threshold(indio_dev, dir, val, val2);
525
526 case IIO_EV_INFO_PERIOD:
527 if (val2 != 0)
528 return -EINVAL;
529
530 return ltr390_write_intr_prst(iio_priv(indio_dev), val);
531
532 default:
533 return -EINVAL;
534 }
535}
536
537static int ltr390_read_event_config(struct iio_dev *indio_dev,
538 const struct iio_chan_spec *chan,
539 enum iio_event_type type,
540 enum iio_event_direction dir)
541{
542 struct ltr390_data *data = iio_priv(indio_dev);
543 int ret, status;
544
545 ret = regmap_read(data->regmap, LTR390_INT_CFG, &status);
546 if (ret < 0)
547 return ret;
548
549 return FIELD_GET(LTR390_LS_INT_EN, status);
550}
551
552static int ltr390_write_event_config(struct iio_dev *indio_dev,
553 const struct iio_chan_spec *chan,
554 enum iio_event_type type,
555 enum iio_event_direction dir,
556 bool state)
557{
558 struct ltr390_data *data = iio_priv(indio_dev);
559 int ret;
560
561 if (!state)
562 return regmap_clear_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_EN);
563
564 guard(mutex)(&data->lock);
565 ret = regmap_set_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_EN);
566 if (ret < 0)
567 return ret;
568
569 switch (chan->type) {
570 case IIO_LIGHT:
571 ret = ltr390_set_mode(data, LTR390_SET_ALS_MODE);
572 if (ret < 0)
573 return ret;
574
575 return regmap_clear_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_SEL_UVS);
576
577 case IIO_UVINDEX:
578 ret = ltr390_set_mode(data, LTR390_SET_UVS_MODE);
579 if (ret < 0)
580 return ret;
581
582 return regmap_set_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_SEL_UVS);
583
584 default:
585 return -EINVAL;
586 }
587}
588
589static const struct iio_info ltr390_info = {
590 .read_raw = ltr390_read_raw,
591 .write_raw = ltr390_write_raw,
592 .read_avail = ltr390_read_avail,
593 .read_event_value = ltr390_read_event_value,
594 .read_event_config = ltr390_read_event_config,
595 .write_event_value = ltr390_write_event_value,
596 .write_event_config = ltr390_write_event_config,
597};
598
599static irqreturn_t ltr390_interrupt_handler(int irq, void *private)
600{
601 struct iio_dev *indio_dev = private;
602 struct ltr390_data *data = iio_priv(indio_dev);
603 int ret, status;
604
605 /* Reading the status register to clear the interrupt flag, Datasheet pg: 17*/
606 ret = regmap_read(data->regmap, LTR390_MAIN_STATUS, &status);
607 if (ret < 0)
608 return ret;
609
610 switch (data->mode) {
611 case LTR390_SET_ALS_MODE:
612 iio_push_event(indio_dev,
613 IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0,
614 IIO_EV_TYPE_THRESH,
615 IIO_EV_DIR_EITHER),
616 iio_get_time_ns(indio_dev));
617 break;
618
619 case LTR390_SET_UVS_MODE:
620 iio_push_event(indio_dev,
621 IIO_UNMOD_EVENT_CODE(IIO_UVINDEX, 0,
622 IIO_EV_TYPE_THRESH,
623 IIO_EV_DIR_EITHER),
624 iio_get_time_ns(indio_dev));
625 break;
626 }
627
628 return IRQ_HANDLED;
629}
630
631static int ltr390_probe(struct i2c_client *client)
632{
633 struct ltr390_data *data;
634 struct iio_dev *indio_dev;
635 struct device *dev;
636 int ret, part_number;
637
638 dev = &client->dev;
639 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
640 if (!indio_dev)
641 return -ENOMEM;
642
643 data = iio_priv(indio_dev);
644
645 data->regmap = devm_regmap_init_i2c(client, <r390_regmap_config);
646 if (IS_ERR(data->regmap))
647 return dev_err_probe(dev, PTR_ERR(data->regmap),
648 "regmap initialization failed\n");
649
650 data->client = client;
651 /* default value of integration time from pg: 15 of the datasheet */
652 data->int_time_us = 100000;
653 /* default value of gain from pg: 16 of the datasheet */
654 data->gain = 3;
655 /* default mode for ltr390 is ALS mode */
656 data->mode = LTR390_SET_ALS_MODE;
657
658 mutex_init(&data->lock);
659
660 indio_dev->info = <r390_info;
661 indio_dev->channels = ltr390_channels;
662 indio_dev->num_channels = ARRAY_SIZE(ltr390_channels);
663 indio_dev->name = "ltr390";
664
665 ret = regmap_read(data->regmap, LTR390_PART_ID, &part_number);
666 if (ret)
667 return dev_err_probe(dev, ret,
668 "failed to get sensor's part id\n");
669 /* Lower 4 bits of `part_number` change with hardware revisions */
670 if (part_number >> 4 != LTR390_PART_NUMBER_ID)
671 dev_info(dev, "received invalid product id: 0x%x", part_number);
672 dev_dbg(dev, "LTR390, product id: 0x%x\n", part_number);
673
674 /* reset sensor, chip fails to respond to this, so ignore any errors */
675 regmap_set_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SW_RESET);
676
677 /* Wait for the registers to reset before proceeding */
678 usleep_range(1000, 2000);
679
680 ret = regmap_set_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SENSOR_ENABLE);
681 if (ret)
682 return dev_err_probe(dev, ret, "failed to enable the sensor\n");
683
684 if (client->irq) {
685 ret = devm_request_threaded_irq(dev, client->irq,
686 NULL, ltr390_interrupt_handler,
687 IRQF_ONESHOT,
688 "ltr390_thresh_event",
689 indio_dev);
690 if (ret)
691 return dev_err_probe(dev, ret,
692 "request irq (%d) failed\n", client->irq);
693 }
694
695 return devm_iio_device_register(dev, indio_dev);
696}
697
698static int ltr390_suspend(struct device *dev)
699{
700 struct iio_dev *indio_dev = dev_get_drvdata(dev);
701 struct ltr390_data *data = iio_priv(indio_dev);
702
703 return regmap_clear_bits(data->regmap, LTR390_MAIN_CTRL,
704 LTR390_SENSOR_ENABLE);
705}
706
707static int ltr390_resume(struct device *dev)
708{
709 struct iio_dev *indio_dev = dev_get_drvdata(dev);
710 struct ltr390_data *data = iio_priv(indio_dev);
711
712 return regmap_set_bits(data->regmap, LTR390_MAIN_CTRL,
713 LTR390_SENSOR_ENABLE);
714}
715
716static DEFINE_SIMPLE_DEV_PM_OPS(ltr390_pm_ops, ltr390_suspend, ltr390_resume);
717
718static const struct i2c_device_id ltr390_id[] = {
719 { "ltr390" },
720 { /* Sentinel */ }
721};
722MODULE_DEVICE_TABLE(i2c, ltr390_id);
723
724static const struct of_device_id ltr390_of_table[] = {
725 { .compatible = "liteon,ltr390" },
726 { /* Sentinel */ }
727};
728MODULE_DEVICE_TABLE(of, ltr390_of_table);
729
730static struct i2c_driver ltr390_driver = {
731 .driver = {
732 .name = "ltr390",
733 .of_match_table = ltr390_of_table,
734 .pm = pm_sleep_ptr(<r390_pm_ops),
735 },
736 .probe = ltr390_probe,
737 .id_table = ltr390_id,
738};
739module_i2c_driver(ltr390_driver);
740
741MODULE_AUTHOR("Anshul Dalal <anshulusr@gmail.com>");
742MODULE_DESCRIPTION("Lite-On LTR390 ALS and UV sensor Driver");
743MODULE_LICENSE("GPL");