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 static const int int_time_mapping[] = {100000, 50000, 200000, 400000};
71 static const struct reg_field reg_field_it =
72 REG_FIELD(LTR501_ALS_MEAS_RATE, 3, 4);
73 static const struct reg_field reg_field_als_intr =
74 REG_FIELD(LTR501_INTR, 0, 0);
75 static const struct reg_field reg_field_ps_intr =
76 REG_FIELD(LTR501_INTR, 1, 1);
77 static const struct reg_field reg_field_als_rate =
78 REG_FIELD(LTR501_ALS_MEAS_RATE, 0, 2);
79 static const struct reg_field reg_field_ps_rate =
80 REG_FIELD(LTR501_PS_MEAS_RATE, 0, 3);
81 static const struct reg_field reg_field_als_prst =
82 REG_FIELD(LTR501_INTR_PRST, 0, 3);
83 static const struct reg_field reg_field_ps_prst =
84 REG_FIELD(LTR501_INTR_PRST, 4, 7);
86 struct ltr501_samp_table {
87 int freq_val; /* repetition frequency in micro HZ*/
88 int time_val; /* repetition rate in micro seconds */
92 struct i2c_client *client;
93 struct mutex lock_als, lock_ps;
94 u8 als_contr, ps_contr;
95 int als_period, ps_period; /* period in micro seconds */
96 struct regmap *regmap;
97 struct regmap_field *reg_it;
98 struct regmap_field *reg_als_intr;
99 struct regmap_field *reg_ps_intr;
100 struct regmap_field *reg_als_rate;
101 struct regmap_field *reg_ps_rate;
102 struct regmap_field *reg_als_prst;
103 struct regmap_field *reg_ps_prst;
106 static const struct ltr501_samp_table ltr501_als_samp_table[] = {
107 {20000000, 50000}, {10000000, 100000},
108 {5000000, 200000}, {2000000, 500000},
109 {1000000, 1000000}, {500000, 2000000},
110 {500000, 2000000}, {500000, 2000000}
113 static const struct ltr501_samp_table ltr501_ps_samp_table[] = {
114 {20000000, 50000}, {14285714, 70000},
115 {10000000, 100000}, {5000000, 200000},
116 {2000000, 500000}, {1000000, 1000000},
117 {500000, 2000000}, {500000, 2000000},
121 static unsigned int ltr501_match_samp_freq(const struct ltr501_samp_table *tab,
122 int len, int val, int val2)
126 freq = val * 1000000 + val2;
128 for (i = 0; i < len; i++) {
129 if (tab[i].freq_val == freq)
136 static int ltr501_als_read_samp_freq(struct ltr501_data *data,
141 ret = regmap_field_read(data->reg_als_rate, &i);
145 if (i < 0 || i >= ARRAY_SIZE(ltr501_als_samp_table))
148 *val = ltr501_als_samp_table[i].freq_val / 1000000;
149 *val2 = ltr501_als_samp_table[i].freq_val % 1000000;
151 return IIO_VAL_INT_PLUS_MICRO;
154 static int ltr501_ps_read_samp_freq(struct ltr501_data *data,
159 ret = regmap_field_read(data->reg_ps_rate, &i);
163 if (i < 0 || i >= ARRAY_SIZE(ltr501_ps_samp_table))
166 *val = ltr501_ps_samp_table[i].freq_val / 1000000;
167 *val2 = ltr501_ps_samp_table[i].freq_val % 1000000;
169 return IIO_VAL_INT_PLUS_MICRO;
172 static int ltr501_als_write_samp_freq(struct ltr501_data *data,
177 i = ltr501_match_samp_freq(ltr501_als_samp_table,
178 ARRAY_SIZE(ltr501_als_samp_table),
184 mutex_lock(&data->lock_als);
185 ret = regmap_field_write(data->reg_als_rate, i);
186 mutex_unlock(&data->lock_als);
191 static int ltr501_ps_write_samp_freq(struct ltr501_data *data,
196 i = ltr501_match_samp_freq(ltr501_ps_samp_table,
197 ARRAY_SIZE(ltr501_ps_samp_table),
203 mutex_lock(&data->lock_ps);
204 ret = regmap_field_write(data->reg_ps_rate, i);
205 mutex_unlock(&data->lock_ps);
210 static int ltr501_als_read_samp_period(struct ltr501_data *data, int *val)
214 ret = regmap_field_read(data->reg_als_rate, &i);
218 if (i < 0 || i >= ARRAY_SIZE(ltr501_als_samp_table))
221 *val = ltr501_als_samp_table[i].time_val;
226 static int ltr501_ps_read_samp_period(struct ltr501_data *data, int *val)
230 ret = regmap_field_read(data->reg_ps_rate, &i);
234 if (i < 0 || i >= ARRAY_SIZE(ltr501_ps_samp_table))
237 *val = ltr501_ps_samp_table[i].time_val;
242 static int ltr501_drdy(struct ltr501_data *data, u8 drdy_mask)
248 ret = regmap_read(data->regmap, LTR501_ALS_PS_STATUS, &status);
251 if ((status & drdy_mask) == drdy_mask)
256 dev_err(&data->client->dev, "ltr501_drdy() failed, data not ready\n");
260 static int ltr501_set_it_time(struct ltr501_data *data, int it)
262 int ret, i, index = -1, status;
264 for (i = 0; i < ARRAY_SIZE(int_time_mapping); i++) {
265 if (int_time_mapping[i] == it) {
270 /* Make sure integ time index is valid */
274 ret = regmap_read(data->regmap, LTR501_ALS_CONTR, &status);
278 if (status & LTR501_CONTR_ALS_GAIN_MASK) {
280 * 200 ms and 400 ms integ time can only be
281 * used in dynamic range 1
286 /* 50 ms integ time can only be used in dynamic range 2 */
290 return regmap_field_write(data->reg_it, index);
293 /* read int time in micro seconds */
294 static int ltr501_read_it_time(struct ltr501_data *data, int *val, int *val2)
298 ret = regmap_field_read(data->reg_it, &index);
302 /* Make sure integ time index is valid */
303 if (index < 0 || index >= ARRAY_SIZE(int_time_mapping))
306 *val2 = int_time_mapping[index];
309 return IIO_VAL_INT_PLUS_MICRO;
312 static int ltr501_read_als(struct ltr501_data *data, __le16 buf[2])
316 ret = ltr501_drdy(data, LTR501_STATUS_ALS_RDY);
319 /* always read both ALS channels in given order */
320 return regmap_bulk_read(data->regmap, LTR501_ALS_DATA1,
321 buf, 2 * sizeof(__le16));
324 static int ltr501_read_ps(struct ltr501_data *data)
328 ret = ltr501_drdy(data, LTR501_STATUS_PS_RDY);
332 ret = regmap_bulk_read(data->regmap, LTR501_PS_DATA,
340 static int ltr501_read_intr_prst(struct ltr501_data *data,
341 enum iio_chan_type type,
344 int ret, samp_period, prst;
348 ret = regmap_field_read(data->reg_als_prst, &prst);
352 ret = ltr501_als_read_samp_period(data, &samp_period);
356 *val2 = samp_period * prst;
357 return IIO_VAL_INT_PLUS_MICRO;
359 ret = regmap_field_read(data->reg_ps_prst, &prst);
363 ret = ltr501_ps_read_samp_period(data, &samp_period);
368 *val2 = samp_period * prst;
369 return IIO_VAL_INT_PLUS_MICRO;
377 static int ltr501_write_intr_prst(struct ltr501_data *data,
378 enum iio_chan_type type,
381 int ret, samp_period, new_val;
382 unsigned long period;
384 if (val < 0 || val2 < 0)
387 /* period in microseconds */
388 period = ((val * 1000000) + val2);
392 ret = ltr501_als_read_samp_period(data, &samp_period);
396 /* period should be atleast equal to sampling period */
397 if (period < samp_period)
400 new_val = DIV_ROUND_UP(period, samp_period);
401 if (new_val < 0 || new_val > 0x0f)
404 mutex_lock(&data->lock_als);
405 ret = regmap_field_write(data->reg_als_prst, new_val);
406 mutex_unlock(&data->lock_als);
408 data->als_period = period;
412 ret = ltr501_ps_read_samp_period(data, &samp_period);
416 /* period should be atleast equal to rate */
417 if (period < samp_period)
420 new_val = DIV_ROUND_UP(period, samp_period);
421 if (new_val < 0 || new_val > 0x0f)
424 mutex_lock(&data->lock_ps);
425 ret = regmap_field_write(data->reg_ps_prst, new_val);
426 mutex_unlock(&data->lock_ps);
428 data->ps_period = period;
438 static const struct iio_event_spec ltr501_als_event_spec[] = {
440 .type = IIO_EV_TYPE_THRESH,
441 .dir = IIO_EV_DIR_RISING,
442 .mask_separate = BIT(IIO_EV_INFO_VALUE),
444 .type = IIO_EV_TYPE_THRESH,
445 .dir = IIO_EV_DIR_FALLING,
446 .mask_separate = BIT(IIO_EV_INFO_VALUE),
448 .type = IIO_EV_TYPE_THRESH,
449 .dir = IIO_EV_DIR_EITHER,
450 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
451 BIT(IIO_EV_INFO_PERIOD),
456 static const struct iio_event_spec ltr501_pxs_event_spec[] = {
458 .type = IIO_EV_TYPE_THRESH,
459 .dir = IIO_EV_DIR_RISING,
460 .mask_separate = BIT(IIO_EV_INFO_VALUE),
462 .type = IIO_EV_TYPE_THRESH,
463 .dir = IIO_EV_DIR_FALLING,
464 .mask_separate = BIT(IIO_EV_INFO_VALUE),
466 .type = IIO_EV_TYPE_THRESH,
467 .dir = IIO_EV_DIR_EITHER,
468 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
469 BIT(IIO_EV_INFO_PERIOD),
473 #define LTR501_INTENSITY_CHANNEL(_idx, _addr, _mod, _shared, \
474 _evspec, _evsize) { \
475 .type = IIO_INTENSITY, \
477 .address = (_addr), \
478 .channel2 = (_mod), \
479 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
480 .info_mask_shared_by_type = (_shared), \
481 .scan_index = (_idx), \
486 .endianness = IIO_CPU, \
488 .event_spec = _evspec,\
489 .num_event_specs = _evsize,\
492 static const struct iio_chan_spec ltr501_channels[] = {
493 LTR501_INTENSITY_CHANNEL(0, LTR501_ALS_DATA0, IIO_MOD_LIGHT_BOTH, 0,
494 ltr501_als_event_spec,
495 ARRAY_SIZE(ltr501_als_event_spec)),
496 LTR501_INTENSITY_CHANNEL(1, LTR501_ALS_DATA1, IIO_MOD_LIGHT_IR,
497 BIT(IIO_CHAN_INFO_SCALE) |
498 BIT(IIO_CHAN_INFO_INT_TIME) |
499 BIT(IIO_CHAN_INFO_SAMP_FREQ),
502 .type = IIO_PROXIMITY,
503 .address = LTR501_PS_DATA,
504 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
505 BIT(IIO_CHAN_INFO_SCALE),
511 .endianness = IIO_CPU,
513 .event_spec = ltr501_pxs_event_spec,
514 .num_event_specs = ARRAY_SIZE(ltr501_pxs_event_spec),
516 IIO_CHAN_SOFT_TIMESTAMP(3),
519 static const int ltr501_ps_gain[4][2] = {
520 {1, 0}, {0, 250000}, {0, 125000}, {0, 62500}
523 static int ltr501_read_raw(struct iio_dev *indio_dev,
524 struct iio_chan_spec const *chan,
525 int *val, int *val2, long mask)
527 struct ltr501_data *data = iio_priv(indio_dev);
532 case IIO_CHAN_INFO_RAW:
533 if (iio_buffer_enabled(indio_dev))
536 switch (chan->type) {
538 mutex_lock(&data->lock_als);
539 ret = ltr501_read_als(data, buf);
540 mutex_unlock(&data->lock_als);
543 *val = le16_to_cpu(chan->address == LTR501_ALS_DATA1 ?
547 mutex_lock(&data->lock_ps);
548 ret = ltr501_read_ps(data);
549 mutex_unlock(&data->lock_ps);
552 *val = ret & LTR501_PS_DATA_MASK;
557 case IIO_CHAN_INFO_SCALE:
558 switch (chan->type) {
560 if (data->als_contr & LTR501_CONTR_ALS_GAIN_MASK) {
563 return IIO_VAL_INT_PLUS_MICRO;
569 i = (data->ps_contr & LTR501_CONTR_PS_GAIN_MASK) >>
570 LTR501_CONTR_PS_GAIN_SHIFT;
571 *val = ltr501_ps_gain[i][0];
572 *val2 = ltr501_ps_gain[i][1];
573 return IIO_VAL_INT_PLUS_MICRO;
577 case IIO_CHAN_INFO_INT_TIME:
578 switch (chan->type) {
580 return ltr501_read_it_time(data, val, val2);
584 case IIO_CHAN_INFO_SAMP_FREQ:
585 switch (chan->type) {
587 return ltr501_als_read_samp_freq(data, val, val2);
589 return ltr501_ps_read_samp_freq(data, val, val2);
597 static int ltr501_get_ps_gain_index(int val, int val2)
601 for (i = 0; i < ARRAY_SIZE(ltr501_ps_gain); i++)
602 if (val == ltr501_ps_gain[i][0] && val2 == ltr501_ps_gain[i][1])
608 static int ltr501_write_raw(struct iio_dev *indio_dev,
609 struct iio_chan_spec const *chan,
610 int val, int val2, long mask)
612 struct ltr501_data *data = iio_priv(indio_dev);
613 int i, ret, freq_val, freq_val2;
615 if (iio_buffer_enabled(indio_dev))
619 case IIO_CHAN_INFO_SCALE:
620 switch (chan->type) {
622 if (val == 0 && val2 == 5000)
623 data->als_contr |= LTR501_CONTR_ALS_GAIN_MASK;
624 else if (val == 1 && val2 == 0)
625 data->als_contr &= ~LTR501_CONTR_ALS_GAIN_MASK;
629 return regmap_write(data->regmap, LTR501_ALS_CONTR,
632 i = ltr501_get_ps_gain_index(val, val2);
635 data->ps_contr &= ~LTR501_CONTR_PS_GAIN_MASK;
636 data->ps_contr |= i << LTR501_CONTR_PS_GAIN_SHIFT;
638 return regmap_write(data->regmap, LTR501_PS_CONTR,
643 case IIO_CHAN_INFO_INT_TIME:
644 switch (chan->type) {
648 mutex_lock(&data->lock_als);
649 i = ltr501_set_it_time(data, val2);
650 mutex_unlock(&data->lock_als);
655 case IIO_CHAN_INFO_SAMP_FREQ:
656 switch (chan->type) {
658 ret = ltr501_als_read_samp_freq(data, &freq_val,
663 ret = ltr501_als_write_samp_freq(data, val, val2);
667 /* update persistence count when changing frequency */
668 ret = ltr501_write_intr_prst(data, chan->type,
669 0, data->als_period);
672 return ltr501_als_write_samp_freq(data,
677 ret = ltr501_ps_read_samp_freq(data, &freq_val,
682 ret = ltr501_ps_write_samp_freq(data, val, val2);
686 /* update persistence count when changing frequency */
687 ret = ltr501_write_intr_prst(data, chan->type,
691 return ltr501_ps_write_samp_freq(data,
702 static int ltr501_read_thresh(struct iio_dev *indio_dev,
703 const struct iio_chan_spec *chan,
704 enum iio_event_type type,
705 enum iio_event_direction dir,
706 enum iio_event_info info,
709 struct ltr501_data *data = iio_priv(indio_dev);
710 int ret, thresh_data;
712 switch (chan->type) {
715 case IIO_EV_DIR_RISING:
716 ret = regmap_bulk_read(data->regmap,
717 LTR501_ALS_THRESH_UP,
721 *val = thresh_data & LTR501_ALS_THRESH_MASK;
723 case IIO_EV_DIR_FALLING:
724 ret = regmap_bulk_read(data->regmap,
725 LTR501_ALS_THRESH_LOW,
729 *val = thresh_data & LTR501_ALS_THRESH_MASK;
736 case IIO_EV_DIR_RISING:
737 ret = regmap_bulk_read(data->regmap,
742 *val = thresh_data & LTR501_PS_THRESH_MASK;
744 case IIO_EV_DIR_FALLING:
745 ret = regmap_bulk_read(data->regmap,
746 LTR501_PS_THRESH_LOW,
750 *val = thresh_data & LTR501_PS_THRESH_MASK;
762 static int ltr501_write_thresh(struct iio_dev *indio_dev,
763 const struct iio_chan_spec *chan,
764 enum iio_event_type type,
765 enum iio_event_direction dir,
766 enum iio_event_info info,
769 struct ltr501_data *data = iio_priv(indio_dev);
775 switch (chan->type) {
777 if (val > LTR501_ALS_THRESH_MASK)
780 case IIO_EV_DIR_RISING:
781 mutex_lock(&data->lock_als);
782 ret = regmap_bulk_write(data->regmap,
783 LTR501_ALS_THRESH_UP,
785 mutex_unlock(&data->lock_als);
787 case IIO_EV_DIR_FALLING:
788 mutex_lock(&data->lock_als);
789 ret = regmap_bulk_write(data->regmap,
790 LTR501_ALS_THRESH_LOW,
792 mutex_unlock(&data->lock_als);
799 if (val > LTR501_PS_THRESH_MASK)
801 case IIO_EV_DIR_RISING:
802 mutex_lock(&data->lock_ps);
803 ret = regmap_bulk_write(data->regmap,
806 mutex_unlock(&data->lock_ps);
808 case IIO_EV_DIR_FALLING:
809 mutex_lock(&data->lock_ps);
810 ret = regmap_bulk_write(data->regmap,
811 LTR501_PS_THRESH_LOW,
813 mutex_unlock(&data->lock_ps);
825 static int ltr501_read_event(struct iio_dev *indio_dev,
826 const struct iio_chan_spec *chan,
827 enum iio_event_type type,
828 enum iio_event_direction dir,
829 enum iio_event_info info,
835 case IIO_EV_INFO_VALUE:
836 return ltr501_read_thresh(indio_dev, chan, type, dir,
838 case IIO_EV_INFO_PERIOD:
839 ret = ltr501_read_intr_prst(iio_priv(indio_dev),
841 *val = *val2 / 1000000;
842 *val2 = *val2 % 1000000;
851 static int ltr501_write_event(struct iio_dev *indio_dev,
852 const struct iio_chan_spec *chan,
853 enum iio_event_type type,
854 enum iio_event_direction dir,
855 enum iio_event_info info,
859 case IIO_EV_INFO_VALUE:
862 return ltr501_write_thresh(indio_dev, chan, type, dir,
864 case IIO_EV_INFO_PERIOD:
865 return ltr501_write_intr_prst(iio_priv(indio_dev), chan->type,
874 static int ltr501_read_event_config(struct iio_dev *indio_dev,
875 const struct iio_chan_spec *chan,
876 enum iio_event_type type,
877 enum iio_event_direction dir)
879 struct ltr501_data *data = iio_priv(indio_dev);
882 switch (chan->type) {
884 ret = regmap_field_read(data->reg_als_intr, &status);
889 ret = regmap_field_read(data->reg_ps_intr, &status);
900 static int ltr501_write_event_config(struct iio_dev *indio_dev,
901 const struct iio_chan_spec *chan,
902 enum iio_event_type type,
903 enum iio_event_direction dir, int state)
905 struct ltr501_data *data = iio_priv(indio_dev);
908 /* only 1 and 0 are valid inputs */
909 if (state != 1 || state != 0)
912 switch (chan->type) {
914 mutex_lock(&data->lock_als);
915 ret = regmap_field_write(data->reg_als_intr, state);
916 mutex_unlock(&data->lock_als);
919 mutex_lock(&data->lock_ps);
920 ret = regmap_field_write(data->reg_ps_intr, state);
921 mutex_unlock(&data->lock_ps);
930 static IIO_CONST_ATTR(in_proximity_scale_available, "1 0.25 0.125 0.0625");
931 static IIO_CONST_ATTR(in_intensity_scale_available, "1 0.005");
932 static IIO_CONST_ATTR_INT_TIME_AVAIL("0.05 0.1 0.2 0.4");
933 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("20 10 5 2 1 0.5");
935 static struct attribute *ltr501_attributes[] = {
936 &iio_const_attr_in_proximity_scale_available.dev_attr.attr,
937 &iio_const_attr_in_intensity_scale_available.dev_attr.attr,
938 &iio_const_attr_integration_time_available.dev_attr.attr,
939 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
943 static const struct attribute_group ltr501_attribute_group = {
944 .attrs = ltr501_attributes,
947 static const struct iio_info ltr501_info_no_irq = {
948 .read_raw = ltr501_read_raw,
949 .write_raw = ltr501_write_raw,
950 .attrs = <r501_attribute_group,
951 .driver_module = THIS_MODULE,
954 static const struct iio_info ltr501_info = {
955 .read_raw = ltr501_read_raw,
956 .write_raw = ltr501_write_raw,
957 .attrs = <r501_attribute_group,
958 .read_event_value = <r501_read_event,
959 .write_event_value = <r501_write_event,
960 .read_event_config = <r501_read_event_config,
961 .write_event_config = <r501_write_event_config,
962 .driver_module = THIS_MODULE,
965 static int ltr501_write_contr(struct ltr501_data *data, u8 als_val, u8 ps_val)
969 ret = regmap_write(data->regmap, LTR501_ALS_CONTR, als_val);
973 return regmap_write(data->regmap, LTR501_PS_CONTR, ps_val);
976 static irqreturn_t ltr501_trigger_handler(int irq, void *p)
978 struct iio_poll_func *pf = p;
979 struct iio_dev *indio_dev = pf->indio_dev;
980 struct ltr501_data *data = iio_priv(indio_dev);
987 memset(buf, 0, sizeof(buf));
989 /* figure out which data needs to be ready */
990 if (test_bit(0, indio_dev->active_scan_mask) ||
991 test_bit(1, indio_dev->active_scan_mask))
992 mask |= LTR501_STATUS_ALS_RDY;
993 if (test_bit(2, indio_dev->active_scan_mask))
994 mask |= LTR501_STATUS_PS_RDY;
996 ret = ltr501_drdy(data, mask);
1000 if (mask & LTR501_STATUS_ALS_RDY) {
1001 ret = regmap_bulk_read(data->regmap, LTR501_ALS_DATA1,
1002 (u8 *)als_buf, sizeof(als_buf));
1005 if (test_bit(0, indio_dev->active_scan_mask))
1006 buf[j++] = le16_to_cpu(als_buf[1]);
1007 if (test_bit(1, indio_dev->active_scan_mask))
1008 buf[j++] = le16_to_cpu(als_buf[0]);
1011 if (mask & LTR501_STATUS_PS_RDY) {
1012 ret = regmap_bulk_read(data->regmap, LTR501_PS_DATA,
1016 buf[j++] = psdata & LTR501_PS_DATA_MASK;
1019 iio_push_to_buffers_with_timestamp(indio_dev, buf, iio_get_time_ns());
1022 iio_trigger_notify_done(indio_dev->trig);
1027 static irqreturn_t ltr501_interrupt_handler(int irq, void *private)
1029 struct iio_dev *indio_dev = private;
1030 struct ltr501_data *data = iio_priv(indio_dev);
1033 ret = regmap_read(data->regmap, LTR501_ALS_PS_STATUS, &status);
1035 dev_err(&data->client->dev,
1036 "irq read int reg failed\n");
1040 if (status & LTR501_STATUS_ALS_INTR)
1041 iio_push_event(indio_dev,
1042 IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
1047 if (status & LTR501_STATUS_PS_INTR)
1048 iio_push_event(indio_dev,
1049 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
1057 static int ltr501_init(struct ltr501_data *data)
1061 ret = regmap_read(data->regmap, LTR501_ALS_CONTR, &status);
1065 data->als_contr = status | LTR501_CONTR_ACTIVE;
1067 ret = regmap_read(data->regmap, LTR501_PS_CONTR, &status);
1071 data->ps_contr = status | LTR501_CONTR_ACTIVE;
1073 ret = ltr501_read_intr_prst(data, IIO_INTENSITY, &data->als_period);
1077 ret = ltr501_read_intr_prst(data, IIO_PROXIMITY, &data->ps_period);
1081 return ltr501_write_contr(data, data->als_contr, data->ps_contr);
1084 static bool ltr501_is_volatile_reg(struct device *dev, unsigned int reg)
1087 case LTR501_ALS_DATA1:
1088 case LTR501_ALS_DATA0:
1089 case LTR501_ALS_PS_STATUS:
1090 case LTR501_PS_DATA:
1097 static struct regmap_config ltr501_regmap_config = {
1098 .name = LTR501_REGMAP_NAME,
1101 .max_register = LTR501_MAX_REG,
1102 .cache_type = REGCACHE_RBTREE,
1103 .volatile_reg = ltr501_is_volatile_reg,
1106 static int ltr501_powerdown(struct ltr501_data *data)
1108 return ltr501_write_contr(data, data->als_contr & ~LTR501_CONTR_ACTIVE,
1109 data->ps_contr & ~LTR501_CONTR_ACTIVE);
1112 static int ltr501_probe(struct i2c_client *client,
1113 const struct i2c_device_id *id)
1115 struct ltr501_data *data;
1116 struct iio_dev *indio_dev;
1117 struct regmap *regmap;
1120 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1124 regmap = devm_regmap_init_i2c(client, <r501_regmap_config);
1125 if (IS_ERR(regmap)) {
1126 dev_err(&client->dev, "Regmap initialization failed.\n");
1127 return PTR_ERR(regmap);
1130 data = iio_priv(indio_dev);
1131 i2c_set_clientdata(client, indio_dev);
1132 data->client = client;
1133 data->regmap = regmap;
1134 mutex_init(&data->lock_als);
1135 mutex_init(&data->lock_ps);
1137 data->reg_it = devm_regmap_field_alloc(&client->dev, regmap,
1139 if (IS_ERR(data->reg_it)) {
1140 dev_err(&client->dev, "Integ time reg field init failed.\n");
1141 return PTR_ERR(data->reg_it);
1144 data->reg_als_intr = devm_regmap_field_alloc(&client->dev, regmap,
1145 reg_field_als_intr);
1146 if (IS_ERR(data->reg_als_intr)) {
1147 dev_err(&client->dev, "ALS intr mode reg field init failed\n");
1148 return PTR_ERR(data->reg_als_intr);
1151 data->reg_ps_intr = devm_regmap_field_alloc(&client->dev, regmap,
1153 if (IS_ERR(data->reg_ps_intr)) {
1154 dev_err(&client->dev, "PS intr mode reg field init failed.\n");
1155 return PTR_ERR(data->reg_ps_intr);
1158 data->reg_als_rate = devm_regmap_field_alloc(&client->dev, regmap,
1159 reg_field_als_rate);
1160 if (IS_ERR(data->reg_als_rate)) {
1161 dev_err(&client->dev, "ALS samp rate field init failed.\n");
1162 return PTR_ERR(data->reg_als_rate);
1165 data->reg_ps_rate = devm_regmap_field_alloc(&client->dev, regmap,
1167 if (IS_ERR(data->reg_ps_rate)) {
1168 dev_err(&client->dev, "PS samp rate field init failed.\n");
1169 return PTR_ERR(data->reg_ps_rate);
1172 data->reg_als_prst = devm_regmap_field_alloc(&client->dev, regmap,
1173 reg_field_als_prst);
1174 if (IS_ERR(data->reg_als_prst)) {
1175 dev_err(&client->dev, "ALS prst reg field init failed\n");
1176 return PTR_ERR(data->reg_als_prst);
1179 data->reg_ps_prst = devm_regmap_field_alloc(&client->dev, regmap,
1181 if (IS_ERR(data->reg_ps_prst)) {
1182 dev_err(&client->dev, "PS prst reg field init failed.\n");
1183 return PTR_ERR(data->reg_ps_prst);
1186 ret = regmap_read(data->regmap, LTR501_PART_ID, &partid);
1189 if ((partid >> 4) != 0x8)
1192 indio_dev->dev.parent = &client->dev;
1193 indio_dev->channels = ltr501_channels;
1194 indio_dev->num_channels = ARRAY_SIZE(ltr501_channels);
1195 indio_dev->name = LTR501_DRV_NAME;
1196 indio_dev->modes = INDIO_DIRECT_MODE;
1198 ret = ltr501_init(data);
1202 if (client->irq > 0) {
1203 indio_dev->info = <r501_info;
1204 ret = devm_request_threaded_irq(&client->dev, client->irq,
1205 NULL, ltr501_interrupt_handler,
1206 IRQF_TRIGGER_FALLING |
1208 "ltr501_thresh_event",
1211 dev_err(&client->dev, "request irq (%d) failed\n",
1216 indio_dev->info = <r501_info_no_irq;
1219 ret = iio_triggered_buffer_setup(indio_dev, NULL,
1220 ltr501_trigger_handler, NULL);
1222 goto powerdown_on_error;
1224 ret = iio_device_register(indio_dev);
1226 goto error_unreg_buffer;
1231 iio_triggered_buffer_cleanup(indio_dev);
1233 ltr501_powerdown(data);
1237 static int ltr501_remove(struct i2c_client *client)
1239 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1241 iio_device_unregister(indio_dev);
1242 iio_triggered_buffer_cleanup(indio_dev);
1243 ltr501_powerdown(iio_priv(indio_dev));
1248 #ifdef CONFIG_PM_SLEEP
1249 static int ltr501_suspend(struct device *dev)
1251 struct ltr501_data *data = iio_priv(i2c_get_clientdata(
1252 to_i2c_client(dev)));
1253 return ltr501_powerdown(data);
1256 static int ltr501_resume(struct device *dev)
1258 struct ltr501_data *data = iio_priv(i2c_get_clientdata(
1259 to_i2c_client(dev)));
1261 return ltr501_write_contr(data, data->als_contr,
1266 static SIMPLE_DEV_PM_OPS(ltr501_pm_ops, ltr501_suspend, ltr501_resume);
1268 static const struct acpi_device_id ltr_acpi_match[] = {
1272 MODULE_DEVICE_TABLE(acpi, ltr_acpi_match);
1274 static const struct i2c_device_id ltr501_id[] = {
1278 MODULE_DEVICE_TABLE(i2c, ltr501_id);
1280 static struct i2c_driver ltr501_driver = {
1282 .name = LTR501_DRV_NAME,
1283 .pm = <r501_pm_ops,
1284 .acpi_match_table = ACPI_PTR(ltr_acpi_match),
1285 .owner = THIS_MODULE,
1287 .probe = ltr501_probe,
1288 .remove = ltr501_remove,
1289 .id_table = ltr501_id,
1292 module_i2c_driver(ltr501_driver);
1294 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
1295 MODULE_DESCRIPTION("Lite-On LTR501 ambient light and proximity sensor driver");
1296 MODULE_LICENSE("GPL");