2 * ltr501.c - Support for Lite-On LTR501 ambient light and proximity sensor
4 * Copyright 2014 Peter Meerwald <pmeerw@pmeerw.net>
6 * This file is subject to the terms and conditions of version 2 of
7 * the GNU General Public License. See the file COPYING in the main
8 * directory of this archive for more details.
10 * 7-bit I2C slave address 0x23
12 * TODO: IR LED characteristics
15 #include <linux/module.h>
16 #include <linux/i2c.h>
17 #include <linux/err.h>
18 #include <linux/delay.h>
19 #include <linux/regmap.h>
20 #include <linux/acpi.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/events.h>
24 #include <linux/iio/sysfs.h>
25 #include <linux/iio/trigger_consumer.h>
26 #include <linux/iio/buffer.h>
27 #include <linux/iio/triggered_buffer.h>
29 #define LTR501_DRV_NAME "ltr501"
31 #define LTR501_ALS_CONTR 0x80 /* ALS operation mode, SW reset */
32 #define LTR501_PS_CONTR 0x81 /* PS operation mode */
33 #define LTR501_PS_MEAS_RATE 0x84 /* measurement rate*/
34 #define LTR501_ALS_MEAS_RATE 0x85 /* ALS integ time, measurement rate*/
35 #define LTR501_PART_ID 0x86
36 #define LTR501_MANUFAC_ID 0x87
37 #define LTR501_ALS_DATA1 0x88 /* 16-bit, little endian */
38 #define LTR501_ALS_DATA0 0x8a /* 16-bit, little endian */
39 #define LTR501_ALS_PS_STATUS 0x8c
40 #define LTR501_PS_DATA 0x8d /* 16-bit, little endian */
41 #define LTR501_INTR 0x8f /* output mode, polarity, mode */
42 #define LTR501_PS_THRESH_UP 0x90 /* 11 bit, ps upper threshold */
43 #define LTR501_PS_THRESH_LOW 0x92 /* 11 bit, ps lower threshold */
44 #define LTR501_ALS_THRESH_UP 0x97 /* 16 bit, ALS upper threshold */
45 #define LTR501_ALS_THRESH_LOW 0x99 /* 16 bit, ALS lower threshold */
46 #define LTR501_INTR_PRST 0x9e /* ps thresh, als thresh */
47 #define LTR501_MAX_REG 0x9f
49 #define LTR501_ALS_CONTR_SW_RESET BIT(2)
50 #define LTR501_CONTR_PS_GAIN_MASK (BIT(3) | BIT(2))
51 #define LTR501_CONTR_PS_GAIN_SHIFT 2
52 #define LTR501_CONTR_ALS_GAIN_MASK BIT(3)
53 #define LTR501_CONTR_ACTIVE BIT(1)
55 #define LTR501_STATUS_ALS_INTR BIT(3)
56 #define LTR501_STATUS_ALS_RDY BIT(2)
57 #define LTR501_STATUS_PS_INTR BIT(1)
58 #define LTR501_STATUS_PS_RDY BIT(0)
60 #define LTR501_PS_DATA_MASK 0x7ff
61 #define LTR501_PS_THRESH_MASK 0x7ff
62 #define LTR501_ALS_THRESH_MASK 0xffff
64 #define LTR501_ALS_DEF_PERIOD 500000
65 #define LTR501_PS_DEF_PERIOD 100000
67 #define LTR501_REGMAP_NAME "ltr501_regmap"
69 #define LTR501_LUX_CONV(vis_coeff, vis_data, ir_coeff, ir_data) \
70 ((vis_coeff * vis_data) - (ir_coeff * ir_data))
72 static const int int_time_mapping
[] = {100000, 50000, 200000, 400000};
74 static const struct reg_field reg_field_it
=
75 REG_FIELD(LTR501_ALS_MEAS_RATE
, 3, 4);
76 static const struct reg_field reg_field_als_intr
=
77 REG_FIELD(LTR501_INTR
, 0, 0);
78 static const struct reg_field reg_field_ps_intr
=
79 REG_FIELD(LTR501_INTR
, 1, 1);
80 static const struct reg_field reg_field_als_rate
=
81 REG_FIELD(LTR501_ALS_MEAS_RATE
, 0, 2);
82 static const struct reg_field reg_field_ps_rate
=
83 REG_FIELD(LTR501_PS_MEAS_RATE
, 0, 3);
84 static const struct reg_field reg_field_als_prst
=
85 REG_FIELD(LTR501_INTR_PRST
, 0, 3);
86 static const struct reg_field reg_field_ps_prst
=
87 REG_FIELD(LTR501_INTR_PRST
, 4, 7);
89 struct ltr501_samp_table
{
90 int freq_val
; /* repetition frequency in micro HZ*/
91 int time_val
; /* repetition rate in micro seconds */
94 #define LTR501_RESERVED_GAIN -1
107 static struct ltr501_gain ltr501_als_gain_tbl
[] = {
112 static struct ltr501_gain ltr559_als_gain_tbl
[] = {
117 {LTR501_RESERVED_GAIN
, LTR501_RESERVED_GAIN
},
118 {LTR501_RESERVED_GAIN
, LTR501_RESERVED_GAIN
},
123 static struct ltr501_gain ltr501_ps_gain_tbl
[] = {
130 static struct ltr501_gain ltr559_ps_gain_tbl
[] = {
131 {0, 62500}, /* x16 gain */
132 {0, 31250}, /* x32 gain */
133 {0, 15625}, /* bits X1 are for x64 gain */
137 struct ltr501_chip_info
{
139 struct ltr501_gain
*als_gain
;
140 int als_gain_tbl_size
;
141 struct ltr501_gain
*ps_gain
;
142 int ps_gain_tbl_size
;
146 struct iio_chan_spec
const *channels
;
147 const int no_channels
;
148 const struct iio_info
*info
;
149 const struct iio_info
*info_no_irq
;
153 struct i2c_client
*client
;
154 struct mutex lock_als
, lock_ps
;
155 struct ltr501_chip_info
*chip_info
;
156 u8 als_contr
, ps_contr
;
157 int als_period
, ps_period
; /* period in micro seconds */
158 struct regmap
*regmap
;
159 struct regmap_field
*reg_it
;
160 struct regmap_field
*reg_als_intr
;
161 struct regmap_field
*reg_ps_intr
;
162 struct regmap_field
*reg_als_rate
;
163 struct regmap_field
*reg_ps_rate
;
164 struct regmap_field
*reg_als_prst
;
165 struct regmap_field
*reg_ps_prst
;
168 static const struct ltr501_samp_table ltr501_als_samp_table
[] = {
169 {20000000, 50000}, {10000000, 100000},
170 {5000000, 200000}, {2000000, 500000},
171 {1000000, 1000000}, {500000, 2000000},
172 {500000, 2000000}, {500000, 2000000}
175 static const struct ltr501_samp_table ltr501_ps_samp_table
[] = {
176 {20000000, 50000}, {14285714, 70000},
177 {10000000, 100000}, {5000000, 200000},
178 {2000000, 500000}, {1000000, 1000000},
179 {500000, 2000000}, {500000, 2000000},
183 static int ltr501_match_samp_freq(const struct ltr501_samp_table
*tab
,
184 int len
, int val
, int val2
)
188 freq
= val
* 1000000 + val2
;
190 for (i
= 0; i
< len
; i
++) {
191 if (tab
[i
].freq_val
== freq
)
198 static int ltr501_als_read_samp_freq(struct ltr501_data
*data
,
203 ret
= regmap_field_read(data
->reg_als_rate
, &i
);
207 if (i
< 0 || i
>= ARRAY_SIZE(ltr501_als_samp_table
))
210 *val
= ltr501_als_samp_table
[i
].freq_val
/ 1000000;
211 *val2
= ltr501_als_samp_table
[i
].freq_val
% 1000000;
213 return IIO_VAL_INT_PLUS_MICRO
;
216 static int ltr501_ps_read_samp_freq(struct ltr501_data
*data
,
221 ret
= regmap_field_read(data
->reg_ps_rate
, &i
);
225 if (i
< 0 || i
>= ARRAY_SIZE(ltr501_ps_samp_table
))
228 *val
= ltr501_ps_samp_table
[i
].freq_val
/ 1000000;
229 *val2
= ltr501_ps_samp_table
[i
].freq_val
% 1000000;
231 return IIO_VAL_INT_PLUS_MICRO
;
234 static int ltr501_als_write_samp_freq(struct ltr501_data
*data
,
239 i
= ltr501_match_samp_freq(ltr501_als_samp_table
,
240 ARRAY_SIZE(ltr501_als_samp_table
),
246 mutex_lock(&data
->lock_als
);
247 ret
= regmap_field_write(data
->reg_als_rate
, i
);
248 mutex_unlock(&data
->lock_als
);
253 static int ltr501_ps_write_samp_freq(struct ltr501_data
*data
,
258 i
= ltr501_match_samp_freq(ltr501_ps_samp_table
,
259 ARRAY_SIZE(ltr501_ps_samp_table
),
265 mutex_lock(&data
->lock_ps
);
266 ret
= regmap_field_write(data
->reg_ps_rate
, i
);
267 mutex_unlock(&data
->lock_ps
);
272 static int ltr501_als_read_samp_period(struct ltr501_data
*data
, int *val
)
276 ret
= regmap_field_read(data
->reg_als_rate
, &i
);
280 if (i
< 0 || i
>= ARRAY_SIZE(ltr501_als_samp_table
))
283 *val
= ltr501_als_samp_table
[i
].time_val
;
288 static int ltr501_ps_read_samp_period(struct ltr501_data
*data
, int *val
)
292 ret
= regmap_field_read(data
->reg_ps_rate
, &i
);
296 if (i
< 0 || i
>= ARRAY_SIZE(ltr501_ps_samp_table
))
299 *val
= ltr501_ps_samp_table
[i
].time_val
;
304 /* IR and visible spectrum coeff's are given in data sheet */
305 static unsigned long ltr501_calculate_lux(u16 vis_data
, u16 ir_data
)
307 unsigned long ratio
, lux
;
312 /* multiply numerator by 100 to avoid handling ratio < 1 */
313 ratio
= DIV_ROUND_UP(ir_data
* 100, ir_data
+ vis_data
);
316 lux
= LTR501_LUX_CONV(1774, vis_data
, -1105, ir_data
);
317 else if (ratio
>= 45 && ratio
< 64)
318 lux
= LTR501_LUX_CONV(3772, vis_data
, 1336, ir_data
);
319 else if (ratio
>= 64 && ratio
< 85)
320 lux
= LTR501_LUX_CONV(1690, vis_data
, 169, ir_data
);
327 static int ltr501_drdy(struct ltr501_data
*data
, u8 drdy_mask
)
333 ret
= regmap_read(data
->regmap
, LTR501_ALS_PS_STATUS
, &status
);
336 if ((status
& drdy_mask
) == drdy_mask
)
341 dev_err(&data
->client
->dev
, "ltr501_drdy() failed, data not ready\n");
345 static int ltr501_set_it_time(struct ltr501_data
*data
, int it
)
347 int ret
, i
, index
= -1, status
;
349 for (i
= 0; i
< ARRAY_SIZE(int_time_mapping
); i
++) {
350 if (int_time_mapping
[i
] == it
) {
355 /* Make sure integ time index is valid */
359 ret
= regmap_read(data
->regmap
, LTR501_ALS_CONTR
, &status
);
363 if (status
& LTR501_CONTR_ALS_GAIN_MASK
) {
365 * 200 ms and 400 ms integ time can only be
366 * used in dynamic range 1
371 /* 50 ms integ time can only be used in dynamic range 2 */
375 return regmap_field_write(data
->reg_it
, index
);
378 /* read int time in micro seconds */
379 static int ltr501_read_it_time(struct ltr501_data
*data
, int *val
, int *val2
)
383 ret
= regmap_field_read(data
->reg_it
, &index
);
387 /* Make sure integ time index is valid */
388 if (index
< 0 || index
>= ARRAY_SIZE(int_time_mapping
))
391 *val2
= int_time_mapping
[index
];
394 return IIO_VAL_INT_PLUS_MICRO
;
397 static int ltr501_read_als(struct ltr501_data
*data
, __le16 buf
[2])
401 ret
= ltr501_drdy(data
, LTR501_STATUS_ALS_RDY
);
404 /* always read both ALS channels in given order */
405 return regmap_bulk_read(data
->regmap
, LTR501_ALS_DATA1
,
406 buf
, 2 * sizeof(__le16
));
409 static int ltr501_read_ps(struct ltr501_data
*data
)
413 ret
= ltr501_drdy(data
, LTR501_STATUS_PS_RDY
);
417 ret
= regmap_bulk_read(data
->regmap
, LTR501_PS_DATA
,
425 static int ltr501_read_intr_prst(struct ltr501_data
*data
,
426 enum iio_chan_type type
,
429 int ret
, samp_period
, prst
;
433 ret
= regmap_field_read(data
->reg_als_prst
, &prst
);
437 ret
= ltr501_als_read_samp_period(data
, &samp_period
);
441 *val2
= samp_period
* prst
;
442 return IIO_VAL_INT_PLUS_MICRO
;
444 ret
= regmap_field_read(data
->reg_ps_prst
, &prst
);
448 ret
= ltr501_ps_read_samp_period(data
, &samp_period
);
453 *val2
= samp_period
* prst
;
454 return IIO_VAL_INT_PLUS_MICRO
;
462 static int ltr501_write_intr_prst(struct ltr501_data
*data
,
463 enum iio_chan_type type
,
466 int ret
, samp_period
, new_val
;
467 unsigned long period
;
469 if (val
< 0 || val2
< 0)
472 /* period in microseconds */
473 period
= ((val
* 1000000) + val2
);
477 ret
= ltr501_als_read_samp_period(data
, &samp_period
);
481 /* period should be atleast equal to sampling period */
482 if (period
< samp_period
)
485 new_val
= DIV_ROUND_UP(period
, samp_period
);
486 if (new_val
< 0 || new_val
> 0x0f)
489 mutex_lock(&data
->lock_als
);
490 ret
= regmap_field_write(data
->reg_als_prst
, new_val
);
491 mutex_unlock(&data
->lock_als
);
493 data
->als_period
= period
;
497 ret
= ltr501_ps_read_samp_period(data
, &samp_period
);
501 /* period should be atleast equal to rate */
502 if (period
< samp_period
)
505 new_val
= DIV_ROUND_UP(period
, samp_period
);
506 if (new_val
< 0 || new_val
> 0x0f)
509 mutex_lock(&data
->lock_ps
);
510 ret
= regmap_field_write(data
->reg_ps_prst
, new_val
);
511 mutex_unlock(&data
->lock_ps
);
513 data
->ps_period
= period
;
523 static const struct iio_event_spec ltr501_als_event_spec
[] = {
525 .type
= IIO_EV_TYPE_THRESH
,
526 .dir
= IIO_EV_DIR_RISING
,
527 .mask_separate
= BIT(IIO_EV_INFO_VALUE
),
529 .type
= IIO_EV_TYPE_THRESH
,
530 .dir
= IIO_EV_DIR_FALLING
,
531 .mask_separate
= BIT(IIO_EV_INFO_VALUE
),
533 .type
= IIO_EV_TYPE_THRESH
,
534 .dir
= IIO_EV_DIR_EITHER
,
535 .mask_separate
= BIT(IIO_EV_INFO_ENABLE
) |
536 BIT(IIO_EV_INFO_PERIOD
),
541 static const struct iio_event_spec ltr501_pxs_event_spec
[] = {
543 .type
= IIO_EV_TYPE_THRESH
,
544 .dir
= IIO_EV_DIR_RISING
,
545 .mask_separate
= BIT(IIO_EV_INFO_VALUE
),
547 .type
= IIO_EV_TYPE_THRESH
,
548 .dir
= IIO_EV_DIR_FALLING
,
549 .mask_separate
= BIT(IIO_EV_INFO_VALUE
),
551 .type
= IIO_EV_TYPE_THRESH
,
552 .dir
= IIO_EV_DIR_EITHER
,
553 .mask_separate
= BIT(IIO_EV_INFO_ENABLE
) |
554 BIT(IIO_EV_INFO_PERIOD
),
558 #define LTR501_INTENSITY_CHANNEL(_idx, _addr, _mod, _shared, \
559 _evspec, _evsize) { \
560 .type = IIO_INTENSITY, \
562 .address = (_addr), \
563 .channel2 = (_mod), \
564 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
565 .info_mask_shared_by_type = (_shared), \
566 .scan_index = (_idx), \
571 .endianness = IIO_CPU, \
573 .event_spec = _evspec,\
574 .num_event_specs = _evsize,\
577 #define LTR501_LIGHT_CHANNEL() { \
579 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
583 static const struct iio_chan_spec ltr501_channels
[] = {
584 LTR501_LIGHT_CHANNEL(),
585 LTR501_INTENSITY_CHANNEL(0, LTR501_ALS_DATA0
, IIO_MOD_LIGHT_BOTH
, 0,
586 ltr501_als_event_spec
,
587 ARRAY_SIZE(ltr501_als_event_spec
)),
588 LTR501_INTENSITY_CHANNEL(1, LTR501_ALS_DATA1
, IIO_MOD_LIGHT_IR
,
589 BIT(IIO_CHAN_INFO_SCALE
) |
590 BIT(IIO_CHAN_INFO_INT_TIME
) |
591 BIT(IIO_CHAN_INFO_SAMP_FREQ
),
594 .type
= IIO_PROXIMITY
,
595 .address
= LTR501_PS_DATA
,
596 .info_mask_separate
= BIT(IIO_CHAN_INFO_RAW
) |
597 BIT(IIO_CHAN_INFO_SCALE
),
603 .endianness
= IIO_CPU
,
605 .event_spec
= ltr501_pxs_event_spec
,
606 .num_event_specs
= ARRAY_SIZE(ltr501_pxs_event_spec
),
608 IIO_CHAN_SOFT_TIMESTAMP(3),
611 static const struct iio_chan_spec ltr301_channels
[] = {
612 LTR501_LIGHT_CHANNEL(),
613 LTR501_INTENSITY_CHANNEL(0, LTR501_ALS_DATA0
, IIO_MOD_LIGHT_BOTH
, 0,
614 ltr501_als_event_spec
,
615 ARRAY_SIZE(ltr501_als_event_spec
)),
616 LTR501_INTENSITY_CHANNEL(1, LTR501_ALS_DATA1
, IIO_MOD_LIGHT_IR
,
617 BIT(IIO_CHAN_INFO_SCALE
) |
618 BIT(IIO_CHAN_INFO_INT_TIME
) |
619 BIT(IIO_CHAN_INFO_SAMP_FREQ
),
621 IIO_CHAN_SOFT_TIMESTAMP(2),
624 static int ltr501_read_raw(struct iio_dev
*indio_dev
,
625 struct iio_chan_spec
const *chan
,
626 int *val
, int *val2
, long mask
)
628 struct ltr501_data
*data
= iio_priv(indio_dev
);
633 case IIO_CHAN_INFO_PROCESSED
:
634 switch (chan
->type
) {
636 ret
= iio_device_claim_direct_mode(indio_dev
);
640 mutex_lock(&data
->lock_als
);
641 ret
= ltr501_read_als(data
, buf
);
642 mutex_unlock(&data
->lock_als
);
643 iio_device_release_direct_mode(indio_dev
);
646 *val
= ltr501_calculate_lux(le16_to_cpu(buf
[1]),
647 le16_to_cpu(buf
[0]));
652 case IIO_CHAN_INFO_RAW
:
653 ret
= iio_device_claim_direct_mode(indio_dev
);
657 switch (chan
->type
) {
659 mutex_lock(&data
->lock_als
);
660 ret
= ltr501_read_als(data
, buf
);
661 mutex_unlock(&data
->lock_als
);
664 *val
= le16_to_cpu(chan
->address
== LTR501_ALS_DATA1
?
669 mutex_lock(&data
->lock_ps
);
670 ret
= ltr501_read_ps(data
);
671 mutex_unlock(&data
->lock_ps
);
674 *val
= ret
& LTR501_PS_DATA_MASK
;
682 iio_device_release_direct_mode(indio_dev
);
685 case IIO_CHAN_INFO_SCALE
:
686 switch (chan
->type
) {
688 i
= (data
->als_contr
& data
->chip_info
->als_gain_mask
)
689 >> data
->chip_info
->als_gain_shift
;
690 *val
= data
->chip_info
->als_gain
[i
].scale
;
691 *val2
= data
->chip_info
->als_gain
[i
].uscale
;
692 return IIO_VAL_INT_PLUS_MICRO
;
694 i
= (data
->ps_contr
& LTR501_CONTR_PS_GAIN_MASK
) >>
695 LTR501_CONTR_PS_GAIN_SHIFT
;
696 *val
= data
->chip_info
->ps_gain
[i
].scale
;
697 *val2
= data
->chip_info
->ps_gain
[i
].uscale
;
698 return IIO_VAL_INT_PLUS_MICRO
;
702 case IIO_CHAN_INFO_INT_TIME
:
703 switch (chan
->type
) {
705 return ltr501_read_it_time(data
, val
, val2
);
709 case IIO_CHAN_INFO_SAMP_FREQ
:
710 switch (chan
->type
) {
712 return ltr501_als_read_samp_freq(data
, val
, val2
);
714 return ltr501_ps_read_samp_freq(data
, val
, val2
);
722 static int ltr501_get_gain_index(struct ltr501_gain
*gain
, int size
,
727 for (i
= 0; i
< size
; i
++)
728 if (val
== gain
[i
].scale
&& val2
== gain
[i
].uscale
)
734 static int ltr501_write_raw(struct iio_dev
*indio_dev
,
735 struct iio_chan_spec
const *chan
,
736 int val
, int val2
, long mask
)
738 struct ltr501_data
*data
= iio_priv(indio_dev
);
739 int i
, ret
, freq_val
, freq_val2
;
740 struct ltr501_chip_info
*info
= data
->chip_info
;
742 ret
= iio_device_claim_direct_mode(indio_dev
);
747 case IIO_CHAN_INFO_SCALE
:
748 switch (chan
->type
) {
750 i
= ltr501_get_gain_index(info
->als_gain
,
751 info
->als_gain_tbl_size
,
758 data
->als_contr
&= ~info
->als_gain_mask
;
759 data
->als_contr
|= i
<< info
->als_gain_shift
;
761 ret
= regmap_write(data
->regmap
, LTR501_ALS_CONTR
,
765 i
= ltr501_get_gain_index(info
->ps_gain
,
766 info
->ps_gain_tbl_size
,
772 data
->ps_contr
&= ~LTR501_CONTR_PS_GAIN_MASK
;
773 data
->ps_contr
|= i
<< LTR501_CONTR_PS_GAIN_SHIFT
;
775 ret
= regmap_write(data
->regmap
, LTR501_PS_CONTR
,
784 case IIO_CHAN_INFO_INT_TIME
:
785 switch (chan
->type
) {
791 mutex_lock(&data
->lock_als
);
792 ret
= ltr501_set_it_time(data
, val2
);
793 mutex_unlock(&data
->lock_als
);
801 case IIO_CHAN_INFO_SAMP_FREQ
:
802 switch (chan
->type
) {
804 ret
= ltr501_als_read_samp_freq(data
, &freq_val
,
809 ret
= ltr501_als_write_samp_freq(data
, val
, val2
);
813 /* update persistence count when changing frequency */
814 ret
= ltr501_write_intr_prst(data
, chan
->type
,
815 0, data
->als_period
);
818 ret
= ltr501_als_write_samp_freq(data
, freq_val
,
822 ret
= ltr501_ps_read_samp_freq(data
, &freq_val
,
827 ret
= ltr501_ps_write_samp_freq(data
, val
, val2
);
831 /* update persistence count when changing frequency */
832 ret
= ltr501_write_intr_prst(data
, chan
->type
,
836 ret
= ltr501_ps_write_samp_freq(data
, freq_val
,
850 iio_device_release_direct_mode(indio_dev
);
854 static int ltr501_read_thresh(struct iio_dev
*indio_dev
,
855 const struct iio_chan_spec
*chan
,
856 enum iio_event_type type
,
857 enum iio_event_direction dir
,
858 enum iio_event_info info
,
861 struct ltr501_data
*data
= iio_priv(indio_dev
);
862 int ret
, thresh_data
;
864 switch (chan
->type
) {
867 case IIO_EV_DIR_RISING
:
868 ret
= regmap_bulk_read(data
->regmap
,
869 LTR501_ALS_THRESH_UP
,
873 *val
= thresh_data
& LTR501_ALS_THRESH_MASK
;
875 case IIO_EV_DIR_FALLING
:
876 ret
= regmap_bulk_read(data
->regmap
,
877 LTR501_ALS_THRESH_LOW
,
881 *val
= thresh_data
& LTR501_ALS_THRESH_MASK
;
888 case IIO_EV_DIR_RISING
:
889 ret
= regmap_bulk_read(data
->regmap
,
894 *val
= thresh_data
& LTR501_PS_THRESH_MASK
;
896 case IIO_EV_DIR_FALLING
:
897 ret
= regmap_bulk_read(data
->regmap
,
898 LTR501_PS_THRESH_LOW
,
902 *val
= thresh_data
& LTR501_PS_THRESH_MASK
;
914 static int ltr501_write_thresh(struct iio_dev
*indio_dev
,
915 const struct iio_chan_spec
*chan
,
916 enum iio_event_type type
,
917 enum iio_event_direction dir
,
918 enum iio_event_info info
,
921 struct ltr501_data
*data
= iio_priv(indio_dev
);
927 switch (chan
->type
) {
929 if (val
> LTR501_ALS_THRESH_MASK
)
932 case IIO_EV_DIR_RISING
:
933 mutex_lock(&data
->lock_als
);
934 ret
= regmap_bulk_write(data
->regmap
,
935 LTR501_ALS_THRESH_UP
,
937 mutex_unlock(&data
->lock_als
);
939 case IIO_EV_DIR_FALLING
:
940 mutex_lock(&data
->lock_als
);
941 ret
= regmap_bulk_write(data
->regmap
,
942 LTR501_ALS_THRESH_LOW
,
944 mutex_unlock(&data
->lock_als
);
950 if (val
> LTR501_PS_THRESH_MASK
)
953 case IIO_EV_DIR_RISING
:
954 mutex_lock(&data
->lock_ps
);
955 ret
= regmap_bulk_write(data
->regmap
,
958 mutex_unlock(&data
->lock_ps
);
960 case IIO_EV_DIR_FALLING
:
961 mutex_lock(&data
->lock_ps
);
962 ret
= regmap_bulk_write(data
->regmap
,
963 LTR501_PS_THRESH_LOW
,
965 mutex_unlock(&data
->lock_ps
);
977 static int ltr501_read_event(struct iio_dev
*indio_dev
,
978 const struct iio_chan_spec
*chan
,
979 enum iio_event_type type
,
980 enum iio_event_direction dir
,
981 enum iio_event_info info
,
987 case IIO_EV_INFO_VALUE
:
988 return ltr501_read_thresh(indio_dev
, chan
, type
, dir
,
990 case IIO_EV_INFO_PERIOD
:
991 ret
= ltr501_read_intr_prst(iio_priv(indio_dev
),
993 *val
= *val2
/ 1000000;
994 *val2
= *val2
% 1000000;
1003 static int ltr501_write_event(struct iio_dev
*indio_dev
,
1004 const struct iio_chan_spec
*chan
,
1005 enum iio_event_type type
,
1006 enum iio_event_direction dir
,
1007 enum iio_event_info info
,
1011 case IIO_EV_INFO_VALUE
:
1014 return ltr501_write_thresh(indio_dev
, chan
, type
, dir
,
1016 case IIO_EV_INFO_PERIOD
:
1017 return ltr501_write_intr_prst(iio_priv(indio_dev
), chan
->type
,
1026 static int ltr501_read_event_config(struct iio_dev
*indio_dev
,
1027 const struct iio_chan_spec
*chan
,
1028 enum iio_event_type type
,
1029 enum iio_event_direction dir
)
1031 struct ltr501_data
*data
= iio_priv(indio_dev
);
1034 switch (chan
->type
) {
1036 ret
= regmap_field_read(data
->reg_als_intr
, &status
);
1041 ret
= regmap_field_read(data
->reg_ps_intr
, &status
);
1052 static int ltr501_write_event_config(struct iio_dev
*indio_dev
,
1053 const struct iio_chan_spec
*chan
,
1054 enum iio_event_type type
,
1055 enum iio_event_direction dir
, int state
)
1057 struct ltr501_data
*data
= iio_priv(indio_dev
);
1060 /* only 1 and 0 are valid inputs */
1061 if (state
!= 1 && state
!= 0)
1064 switch (chan
->type
) {
1066 mutex_lock(&data
->lock_als
);
1067 ret
= regmap_field_write(data
->reg_als_intr
, state
);
1068 mutex_unlock(&data
->lock_als
);
1071 mutex_lock(&data
->lock_ps
);
1072 ret
= regmap_field_write(data
->reg_ps_intr
, state
);
1073 mutex_unlock(&data
->lock_ps
);
1082 static ssize_t
ltr501_show_proximity_scale_avail(struct device
*dev
,
1083 struct device_attribute
*attr
,
1086 struct ltr501_data
*data
= iio_priv(dev_to_iio_dev(dev
));
1087 struct ltr501_chip_info
*info
= data
->chip_info
;
1091 for (i
= 0; i
< info
->ps_gain_tbl_size
; i
++) {
1092 if (info
->ps_gain
[i
].scale
== LTR501_RESERVED_GAIN
)
1094 len
+= scnprintf(buf
+ len
, PAGE_SIZE
- len
, "%d.%06d ",
1095 info
->ps_gain
[i
].scale
,
1096 info
->ps_gain
[i
].uscale
);
1099 buf
[len
- 1] = '\n';
1104 static ssize_t
ltr501_show_intensity_scale_avail(struct device
*dev
,
1105 struct device_attribute
*attr
,
1108 struct ltr501_data
*data
= iio_priv(dev_to_iio_dev(dev
));
1109 struct ltr501_chip_info
*info
= data
->chip_info
;
1113 for (i
= 0; i
< info
->als_gain_tbl_size
; i
++) {
1114 if (info
->als_gain
[i
].scale
== LTR501_RESERVED_GAIN
)
1116 len
+= scnprintf(buf
+ len
, PAGE_SIZE
- len
, "%d.%06d ",
1117 info
->als_gain
[i
].scale
,
1118 info
->als_gain
[i
].uscale
);
1121 buf
[len
- 1] = '\n';
1126 static IIO_CONST_ATTR_INT_TIME_AVAIL("0.05 0.1 0.2 0.4");
1127 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("20 10 5 2 1 0.5");
1129 static IIO_DEVICE_ATTR(in_proximity_scale_available
, S_IRUGO
,
1130 ltr501_show_proximity_scale_avail
, NULL
, 0);
1131 static IIO_DEVICE_ATTR(in_intensity_scale_available
, S_IRUGO
,
1132 ltr501_show_intensity_scale_avail
, NULL
, 0);
1134 static struct attribute
*ltr501_attributes
[] = {
1135 &iio_dev_attr_in_proximity_scale_available
.dev_attr
.attr
,
1136 &iio_dev_attr_in_intensity_scale_available
.dev_attr
.attr
,
1137 &iio_const_attr_integration_time_available
.dev_attr
.attr
,
1138 &iio_const_attr_sampling_frequency_available
.dev_attr
.attr
,
1142 static struct attribute
*ltr301_attributes
[] = {
1143 &iio_dev_attr_in_intensity_scale_available
.dev_attr
.attr
,
1144 &iio_const_attr_integration_time_available
.dev_attr
.attr
,
1145 &iio_const_attr_sampling_frequency_available
.dev_attr
.attr
,
1149 static const struct attribute_group ltr501_attribute_group
= {
1150 .attrs
= ltr501_attributes
,
1153 static const struct attribute_group ltr301_attribute_group
= {
1154 .attrs
= ltr301_attributes
,
1157 static const struct iio_info ltr501_info_no_irq
= {
1158 .read_raw
= ltr501_read_raw
,
1159 .write_raw
= ltr501_write_raw
,
1160 .attrs
= <r501_attribute_group
,
1161 .driver_module
= THIS_MODULE
,
1164 static const struct iio_info ltr501_info
= {
1165 .read_raw
= ltr501_read_raw
,
1166 .write_raw
= ltr501_write_raw
,
1167 .attrs
= <r501_attribute_group
,
1168 .read_event_value
= <r501_read_event
,
1169 .write_event_value
= <r501_write_event
,
1170 .read_event_config
= <r501_read_event_config
,
1171 .write_event_config
= <r501_write_event_config
,
1172 .driver_module
= THIS_MODULE
,
1175 static const struct iio_info ltr301_info_no_irq
= {
1176 .read_raw
= ltr501_read_raw
,
1177 .write_raw
= ltr501_write_raw
,
1178 .attrs
= <r301_attribute_group
,
1179 .driver_module
= THIS_MODULE
,
1182 static const struct iio_info ltr301_info
= {
1183 .read_raw
= ltr501_read_raw
,
1184 .write_raw
= ltr501_write_raw
,
1185 .attrs
= <r301_attribute_group
,
1186 .read_event_value
= <r501_read_event
,
1187 .write_event_value
= <r501_write_event
,
1188 .read_event_config
= <r501_read_event_config
,
1189 .write_event_config
= <r501_write_event_config
,
1190 .driver_module
= THIS_MODULE
,
1193 static struct ltr501_chip_info ltr501_chip_info_tbl
[] = {
1196 .als_gain
= ltr501_als_gain_tbl
,
1197 .als_gain_tbl_size
= ARRAY_SIZE(ltr501_als_gain_tbl
),
1198 .ps_gain
= ltr501_ps_gain_tbl
,
1199 .ps_gain_tbl_size
= ARRAY_SIZE(ltr501_ps_gain_tbl
),
1200 .als_mode_active
= BIT(0) | BIT(1),
1201 .als_gain_mask
= BIT(3),
1202 .als_gain_shift
= 3,
1203 .info
= <r501_info
,
1204 .info_no_irq
= <r501_info_no_irq
,
1205 .channels
= ltr501_channels
,
1206 .no_channels
= ARRAY_SIZE(ltr501_channels
),
1210 .als_gain
= ltr559_als_gain_tbl
,
1211 .als_gain_tbl_size
= ARRAY_SIZE(ltr559_als_gain_tbl
),
1212 .ps_gain
= ltr559_ps_gain_tbl
,
1213 .ps_gain_tbl_size
= ARRAY_SIZE(ltr559_ps_gain_tbl
),
1214 .als_mode_active
= BIT(1),
1215 .als_gain_mask
= BIT(2) | BIT(3) | BIT(4),
1216 .als_gain_shift
= 2,
1217 .info
= <r501_info
,
1218 .info_no_irq
= <r501_info_no_irq
,
1219 .channels
= ltr501_channels
,
1220 .no_channels
= ARRAY_SIZE(ltr501_channels
),
1224 .als_gain
= ltr501_als_gain_tbl
,
1225 .als_gain_tbl_size
= ARRAY_SIZE(ltr501_als_gain_tbl
),
1226 .als_mode_active
= BIT(0) | BIT(1),
1227 .als_gain_mask
= BIT(3),
1228 .als_gain_shift
= 3,
1229 .info
= <r301_info
,
1230 .info_no_irq
= <r301_info_no_irq
,
1231 .channels
= ltr301_channels
,
1232 .no_channels
= ARRAY_SIZE(ltr301_channels
),
1236 static int ltr501_write_contr(struct ltr501_data
*data
, u8 als_val
, u8 ps_val
)
1240 ret
= regmap_write(data
->regmap
, LTR501_ALS_CONTR
, als_val
);
1244 return regmap_write(data
->regmap
, LTR501_PS_CONTR
, ps_val
);
1247 static irqreturn_t
ltr501_trigger_handler(int irq
, void *p
)
1249 struct iio_poll_func
*pf
= p
;
1250 struct iio_dev
*indio_dev
= pf
->indio_dev
;
1251 struct ltr501_data
*data
= iio_priv(indio_dev
);
1258 memset(buf
, 0, sizeof(buf
));
1260 /* figure out which data needs to be ready */
1261 if (test_bit(0, indio_dev
->active_scan_mask
) ||
1262 test_bit(1, indio_dev
->active_scan_mask
))
1263 mask
|= LTR501_STATUS_ALS_RDY
;
1264 if (test_bit(2, indio_dev
->active_scan_mask
))
1265 mask
|= LTR501_STATUS_PS_RDY
;
1267 ret
= ltr501_drdy(data
, mask
);
1271 if (mask
& LTR501_STATUS_ALS_RDY
) {
1272 ret
= regmap_bulk_read(data
->regmap
, LTR501_ALS_DATA1
,
1273 (u8
*)als_buf
, sizeof(als_buf
));
1276 if (test_bit(0, indio_dev
->active_scan_mask
))
1277 buf
[j
++] = le16_to_cpu(als_buf
[1]);
1278 if (test_bit(1, indio_dev
->active_scan_mask
))
1279 buf
[j
++] = le16_to_cpu(als_buf
[0]);
1282 if (mask
& LTR501_STATUS_PS_RDY
) {
1283 ret
= regmap_bulk_read(data
->regmap
, LTR501_PS_DATA
,
1287 buf
[j
++] = psdata
& LTR501_PS_DATA_MASK
;
1290 iio_push_to_buffers_with_timestamp(indio_dev
, buf
,
1291 iio_get_time_ns(indio_dev
));
1294 iio_trigger_notify_done(indio_dev
->trig
);
1299 static irqreturn_t
ltr501_interrupt_handler(int irq
, void *private)
1301 struct iio_dev
*indio_dev
= private;
1302 struct ltr501_data
*data
= iio_priv(indio_dev
);
1305 ret
= regmap_read(data
->regmap
, LTR501_ALS_PS_STATUS
, &status
);
1307 dev_err(&data
->client
->dev
,
1308 "irq read int reg failed\n");
1312 if (status
& LTR501_STATUS_ALS_INTR
)
1313 iio_push_event(indio_dev
,
1314 IIO_UNMOD_EVENT_CODE(IIO_INTENSITY
, 0,
1317 iio_get_time_ns(indio_dev
));
1319 if (status
& LTR501_STATUS_PS_INTR
)
1320 iio_push_event(indio_dev
,
1321 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY
, 0,
1324 iio_get_time_ns(indio_dev
));
1329 static int ltr501_init(struct ltr501_data
*data
)
1333 ret
= regmap_read(data
->regmap
, LTR501_ALS_CONTR
, &status
);
1337 data
->als_contr
= status
| data
->chip_info
->als_mode_active
;
1339 ret
= regmap_read(data
->regmap
, LTR501_PS_CONTR
, &status
);
1343 data
->ps_contr
= status
| LTR501_CONTR_ACTIVE
;
1345 ret
= ltr501_read_intr_prst(data
, IIO_INTENSITY
, &data
->als_period
);
1349 ret
= ltr501_read_intr_prst(data
, IIO_PROXIMITY
, &data
->ps_period
);
1353 return ltr501_write_contr(data
, data
->als_contr
, data
->ps_contr
);
1356 static bool ltr501_is_volatile_reg(struct device
*dev
, unsigned int reg
)
1359 case LTR501_ALS_DATA1
:
1360 case LTR501_ALS_DATA0
:
1361 case LTR501_ALS_PS_STATUS
:
1362 case LTR501_PS_DATA
:
1369 static struct regmap_config ltr501_regmap_config
= {
1370 .name
= LTR501_REGMAP_NAME
,
1373 .max_register
= LTR501_MAX_REG
,
1374 .cache_type
= REGCACHE_RBTREE
,
1375 .volatile_reg
= ltr501_is_volatile_reg
,
1378 static int ltr501_powerdown(struct ltr501_data
*data
)
1380 return ltr501_write_contr(data
, data
->als_contr
&
1381 ~data
->chip_info
->als_mode_active
,
1382 data
->ps_contr
& ~LTR501_CONTR_ACTIVE
);
1385 static const char *ltr501_match_acpi_device(struct device
*dev
, int *chip_idx
)
1387 const struct acpi_device_id
*id
;
1389 id
= acpi_match_device(dev
->driver
->acpi_match_table
, dev
);
1392 *chip_idx
= id
->driver_data
;
1393 return dev_name(dev
);
1396 static int ltr501_probe(struct i2c_client
*client
,
1397 const struct i2c_device_id
*id
)
1399 struct ltr501_data
*data
;
1400 struct iio_dev
*indio_dev
;
1401 struct regmap
*regmap
;
1402 int ret
, partid
, chip_idx
= 0;
1403 const char *name
= NULL
;
1405 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*data
));
1409 regmap
= devm_regmap_init_i2c(client
, <r501_regmap_config
);
1410 if (IS_ERR(regmap
)) {
1411 dev_err(&client
->dev
, "Regmap initialization failed.\n");
1412 return PTR_ERR(regmap
);
1415 data
= iio_priv(indio_dev
);
1416 i2c_set_clientdata(client
, indio_dev
);
1417 data
->client
= client
;
1418 data
->regmap
= regmap
;
1419 mutex_init(&data
->lock_als
);
1420 mutex_init(&data
->lock_ps
);
1422 data
->reg_it
= devm_regmap_field_alloc(&client
->dev
, regmap
,
1424 if (IS_ERR(data
->reg_it
)) {
1425 dev_err(&client
->dev
, "Integ time reg field init failed.\n");
1426 return PTR_ERR(data
->reg_it
);
1429 data
->reg_als_intr
= devm_regmap_field_alloc(&client
->dev
, regmap
,
1430 reg_field_als_intr
);
1431 if (IS_ERR(data
->reg_als_intr
)) {
1432 dev_err(&client
->dev
, "ALS intr mode reg field init failed\n");
1433 return PTR_ERR(data
->reg_als_intr
);
1436 data
->reg_ps_intr
= devm_regmap_field_alloc(&client
->dev
, regmap
,
1438 if (IS_ERR(data
->reg_ps_intr
)) {
1439 dev_err(&client
->dev
, "PS intr mode reg field init failed.\n");
1440 return PTR_ERR(data
->reg_ps_intr
);
1443 data
->reg_als_rate
= devm_regmap_field_alloc(&client
->dev
, regmap
,
1444 reg_field_als_rate
);
1445 if (IS_ERR(data
->reg_als_rate
)) {
1446 dev_err(&client
->dev
, "ALS samp rate field init failed.\n");
1447 return PTR_ERR(data
->reg_als_rate
);
1450 data
->reg_ps_rate
= devm_regmap_field_alloc(&client
->dev
, regmap
,
1452 if (IS_ERR(data
->reg_ps_rate
)) {
1453 dev_err(&client
->dev
, "PS samp rate field init failed.\n");
1454 return PTR_ERR(data
->reg_ps_rate
);
1457 data
->reg_als_prst
= devm_regmap_field_alloc(&client
->dev
, regmap
,
1458 reg_field_als_prst
);
1459 if (IS_ERR(data
->reg_als_prst
)) {
1460 dev_err(&client
->dev
, "ALS prst reg field init failed\n");
1461 return PTR_ERR(data
->reg_als_prst
);
1464 data
->reg_ps_prst
= devm_regmap_field_alloc(&client
->dev
, regmap
,
1466 if (IS_ERR(data
->reg_ps_prst
)) {
1467 dev_err(&client
->dev
, "PS prst reg field init failed.\n");
1468 return PTR_ERR(data
->reg_ps_prst
);
1471 ret
= regmap_read(data
->regmap
, LTR501_PART_ID
, &partid
);
1477 chip_idx
= id
->driver_data
;
1478 } else if (ACPI_HANDLE(&client
->dev
)) {
1479 name
= ltr501_match_acpi_device(&client
->dev
, &chip_idx
);
1484 data
->chip_info
= <r501_chip_info_tbl
[chip_idx
];
1486 if ((partid
>> 4) != data
->chip_info
->partid
)
1489 indio_dev
->dev
.parent
= &client
->dev
;
1490 indio_dev
->info
= data
->chip_info
->info
;
1491 indio_dev
->channels
= data
->chip_info
->channels
;
1492 indio_dev
->num_channels
= data
->chip_info
->no_channels
;
1493 indio_dev
->name
= name
;
1494 indio_dev
->modes
= INDIO_DIRECT_MODE
;
1496 ret
= ltr501_init(data
);
1500 if (client
->irq
> 0) {
1501 ret
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
1502 NULL
, ltr501_interrupt_handler
,
1503 IRQF_TRIGGER_FALLING
|
1505 "ltr501_thresh_event",
1508 dev_err(&client
->dev
, "request irq (%d) failed\n",
1513 indio_dev
->info
= data
->chip_info
->info_no_irq
;
1516 ret
= iio_triggered_buffer_setup(indio_dev
, NULL
,
1517 ltr501_trigger_handler
, NULL
);
1519 goto powerdown_on_error
;
1521 ret
= iio_device_register(indio_dev
);
1523 goto error_unreg_buffer
;
1528 iio_triggered_buffer_cleanup(indio_dev
);
1530 ltr501_powerdown(data
);
1534 static int ltr501_remove(struct i2c_client
*client
)
1536 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
1538 iio_device_unregister(indio_dev
);
1539 iio_triggered_buffer_cleanup(indio_dev
);
1540 ltr501_powerdown(iio_priv(indio_dev
));
1545 #ifdef CONFIG_PM_SLEEP
1546 static int ltr501_suspend(struct device
*dev
)
1548 struct ltr501_data
*data
= iio_priv(i2c_get_clientdata(
1549 to_i2c_client(dev
)));
1550 return ltr501_powerdown(data
);
1553 static int ltr501_resume(struct device
*dev
)
1555 struct ltr501_data
*data
= iio_priv(i2c_get_clientdata(
1556 to_i2c_client(dev
)));
1558 return ltr501_write_contr(data
, data
->als_contr
,
1563 static SIMPLE_DEV_PM_OPS(ltr501_pm_ops
, ltr501_suspend
, ltr501_resume
);
1565 static const struct acpi_device_id ltr_acpi_match
[] = {
1566 {"LTER0501", ltr501
},
1567 {"LTER0559", ltr559
},
1568 {"LTER0301", ltr301
},
1571 MODULE_DEVICE_TABLE(acpi
, ltr_acpi_match
);
1573 static const struct i2c_device_id ltr501_id
[] = {
1574 { "ltr501", ltr501
},
1575 { "ltr559", ltr559
},
1576 { "ltr301", ltr301
},
1579 MODULE_DEVICE_TABLE(i2c
, ltr501_id
);
1581 static struct i2c_driver ltr501_driver
= {
1583 .name
= LTR501_DRV_NAME
,
1584 .pm
= <r501_pm_ops
,
1585 .acpi_match_table
= ACPI_PTR(ltr_acpi_match
),
1587 .probe
= ltr501_probe
,
1588 .remove
= ltr501_remove
,
1589 .id_table
= ltr501_id
,
1592 module_i2c_driver(ltr501_driver
);
1594 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
1595 MODULE_DESCRIPTION("Lite-On LTR501 ambient light and proximity sensor driver");
1596 MODULE_LICENSE("GPL");