2 * apds9960.c - Support for Avago APDS9960 gesture/RGB/ALS/proximity sensor
4 * Copyright (C) 2015 Matt Ranostay <mranostay@gmail.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * TODO: gesture + proximity calib offsets
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/interrupt.h>
22 #include <linux/delay.h>
23 #include <linux/mutex.h>
24 #include <linux/err.h>
25 #include <linux/irq.h>
26 #include <linux/gpio.h>
27 #include <linux/i2c.h>
28 #include <linux/pm_runtime.h>
29 #include <linux/regmap.h>
30 #include <linux/iio/iio.h>
31 #include <linux/iio/buffer.h>
32 #include <linux/iio/events.h>
33 #include <linux/iio/kfifo_buf.h>
34 #include <linux/iio/sysfs.h>
35 #include <linux/of_gpio.h>
37 #define APDS9960_REGMAP_NAME "apds9960_regmap"
38 #define APDS9960_DRV_NAME "apds9960"
40 #define APDS9960_REG_RAM_START 0x00
41 #define APDS9960_REG_RAM_END 0x7f
43 #define APDS9960_REG_ENABLE 0x80
44 #define APDS9960_REG_ATIME 0x81
45 #define APDS9960_REG_WTIME 0x83
47 #define APDS9960_REG_AILTL 0x84
48 #define APDS9960_REG_AILTH 0x85
49 #define APDS9960_REG_AIHTL 0x86
50 #define APDS9960_REG_AIHTH 0x87
52 #define APDS9960_REG_PILT 0x89
53 #define APDS9960_REG_PIHT 0x8b
54 #define APDS9960_REG_PERS 0x8c
56 #define APDS9960_REG_CONFIG_1 0x8d
57 #define APDS9960_REG_PPULSE 0x8e
59 #define APDS9960_REG_CONTROL 0x8f
60 #define APDS9960_REG_CONTROL_AGAIN_MASK 0x03
61 #define APDS9960_REG_CONTROL_PGAIN_MASK 0x0c
62 #define APDS9960_REG_CONTROL_AGAIN_MASK_SHIFT 0
63 #define APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT 2
65 #define APDS9960_REG_CONFIG_2 0x90
66 #define APDS9960_REG_CONFIG_2_GGAIN_MASK 0x60
67 #define APDS9960_REG_CONFIG_2_GGAIN_MASK_SHIFT 5
69 #define APDS9960_REG_ID 0x92
71 #define APDS9960_REG_STATUS 0x93
72 #define APDS9960_REG_STATUS_PS_INT BIT(5)
73 #define APDS9960_REG_STATUS_ALS_INT BIT(4)
74 #define APDS9960_REG_STATUS_GINT BIT(2)
76 #define APDS9960_REG_PDATA 0x9c
77 #define APDS9960_REG_POFFSET_UR 0x9d
78 #define APDS9960_REG_POFFSET_DL 0x9e
79 #define APDS9960_REG_CONFIG_3 0x9f
81 #define APDS9960_REG_GPENTH 0xa0
82 #define APDS9960_REG_GEXTH 0xa1
84 #define APDS9960_REG_GCONF_1 0xa2
85 #define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK 0xc0
86 #define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT 6
88 #define APDS9960_REG_GCONF_2 0xa3
89 #define APDS9960_REG_GOFFSET_U 0xa4
90 #define APDS9960_REG_GOFFSET_D 0xa5
91 #define APDS9960_REG_GPULSE 0xa6
92 #define APDS9960_REG_GOFFSET_L 0xa7
93 #define APDS9960_REG_GOFFSET_R 0xa9
94 #define APDS9960_REG_GCONF_3 0xaa
96 #define APDS9960_REG_GCONF_4 0xab
97 #define APDS9960_REG_GFLVL 0xae
98 #define APDS9960_REG_GSTATUS 0xaf
100 #define APDS9960_REG_IFORCE 0xe4
101 #define APDS9960_REG_PICLEAR 0xe5
102 #define APDS9960_REG_CICLEAR 0xe6
103 #define APDS9960_REG_AICLEAR 0xe7
105 #define APDS9960_DEFAULT_PERS 0x33
106 #define APDS9960_DEFAULT_GPENTH 0x50
107 #define APDS9960_DEFAULT_GEXTH 0x40
109 #define APDS9960_MAX_PXS_THRES_VAL 255
110 #define APDS9960_MAX_ALS_THRES_VAL 0xffff
111 #define APDS9960_MAX_INT_TIME_IN_US 1000000
113 enum apds9960_als_channel_idx {
114 IDX_ALS_CLEAR, IDX_ALS_RED, IDX_ALS_GREEN, IDX_ALS_BLUE,
117 #define APDS9960_REG_ALS_BASE 0x94
118 #define APDS9960_REG_ALS_CHANNEL(_colour) \
119 (APDS9960_REG_ALS_BASE + (IDX_ALS_##_colour * 2))
121 enum apds9960_gesture_channel_idx {
122 IDX_DIR_UP, IDX_DIR_DOWN, IDX_DIR_LEFT, IDX_DIR_RIGHT,
125 #define APDS9960_REG_GFIFO_BASE 0xfc
126 #define APDS9960_REG_GFIFO_DIR(_dir) \
127 (APDS9960_REG_GFIFO_BASE + IDX_DIR_##_dir)
129 struct apds9960_data {
130 struct i2c_client *client;
131 struct iio_dev *indio_dev;
135 struct regmap *regmap;
136 struct regmap_field *reg_int_als;
137 struct regmap_field *reg_int_ges;
138 struct regmap_field *reg_int_pxs;
140 struct regmap_field *reg_enable_als;
141 struct regmap_field *reg_enable_ges;
142 struct regmap_field *reg_enable_pxs;
147 int gesture_mode_running;
153 /* integration time value in us */
157 u8 buffer[4]; /* 4 8-bit channels */
160 static const struct reg_default apds9960_reg_defaults[] = {
161 /* Default ALS integration time = 2.48ms */
162 { APDS9960_REG_ATIME, 0xff },
165 static const struct regmap_range apds9960_volatile_ranges[] = {
166 regmap_reg_range(APDS9960_REG_STATUS,
168 regmap_reg_range(APDS9960_REG_GFLVL,
169 APDS9960_REG_GSTATUS),
170 regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
171 APDS9960_REG_GFIFO_DIR(RIGHT)),
172 regmap_reg_range(APDS9960_REG_IFORCE,
173 APDS9960_REG_AICLEAR),
176 static const struct regmap_access_table apds9960_volatile_table = {
177 .yes_ranges = apds9960_volatile_ranges,
178 .n_yes_ranges = ARRAY_SIZE(apds9960_volatile_ranges),
181 static const struct regmap_range apds9960_precious_ranges[] = {
182 regmap_reg_range(APDS9960_REG_RAM_START, APDS9960_REG_RAM_END),
185 static const struct regmap_access_table apds9960_precious_table = {
186 .yes_ranges = apds9960_precious_ranges,
187 .n_yes_ranges = ARRAY_SIZE(apds9960_precious_ranges),
190 static const struct regmap_range apds9960_readable_ranges[] = {
191 regmap_reg_range(APDS9960_REG_ENABLE,
192 APDS9960_REG_GSTATUS),
193 regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
194 APDS9960_REG_GFIFO_DIR(RIGHT)),
197 static const struct regmap_access_table apds9960_readable_table = {
198 .yes_ranges = apds9960_readable_ranges,
199 .n_yes_ranges = ARRAY_SIZE(apds9960_readable_ranges),
202 static const struct regmap_range apds9960_writeable_ranges[] = {
203 regmap_reg_range(APDS9960_REG_ENABLE, APDS9960_REG_CONFIG_2),
204 regmap_reg_range(APDS9960_REG_POFFSET_UR, APDS9960_REG_GCONF_4),
205 regmap_reg_range(APDS9960_REG_IFORCE, APDS9960_REG_AICLEAR),
208 static const struct regmap_access_table apds9960_writeable_table = {
209 .yes_ranges = apds9960_writeable_ranges,
210 .n_yes_ranges = ARRAY_SIZE(apds9960_writeable_ranges),
213 static const struct regmap_config apds9960_regmap_config = {
214 .name = APDS9960_REGMAP_NAME,
219 .volatile_table = &apds9960_volatile_table,
220 .precious_table = &apds9960_precious_table,
221 .rd_table = &apds9960_readable_table,
222 .wr_table = &apds9960_writeable_table,
224 .reg_defaults = apds9960_reg_defaults,
225 .num_reg_defaults = ARRAY_SIZE(apds9960_reg_defaults),
226 .max_register = APDS9960_REG_GFIFO_DIR(RIGHT),
227 .cache_type = REGCACHE_RBTREE,
230 static const struct iio_event_spec apds9960_pxs_event_spec[] = {
232 .type = IIO_EV_TYPE_THRESH,
233 .dir = IIO_EV_DIR_RISING,
234 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
235 BIT(IIO_EV_INFO_ENABLE),
238 .type = IIO_EV_TYPE_THRESH,
239 .dir = IIO_EV_DIR_FALLING,
240 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
241 BIT(IIO_EV_INFO_ENABLE),
245 static const struct iio_event_spec apds9960_als_event_spec[] = {
247 .type = IIO_EV_TYPE_THRESH,
248 .dir = IIO_EV_DIR_RISING,
249 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
250 BIT(IIO_EV_INFO_ENABLE),
253 .type = IIO_EV_TYPE_THRESH,
254 .dir = IIO_EV_DIR_FALLING,
255 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
256 BIT(IIO_EV_INFO_ENABLE),
260 #define APDS9960_GESTURE_CHANNEL(_dir, _si) { \
261 .type = IIO_PROXIMITY, \
262 .channel = _si + 1, \
272 #define APDS9960_INTENSITY_CHANNEL(_colour) { \
273 .type = IIO_INTENSITY, \
274 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
275 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
276 BIT(IIO_CHAN_INFO_INT_TIME), \
277 .channel2 = IIO_MOD_LIGHT_##_colour, \
278 .address = APDS9960_REG_ALS_CHANNEL(_colour), \
283 static const unsigned long apds9960_scan_masks[] = {0xf, 0};
285 static const struct iio_chan_spec apds9960_channels[] = {
287 .type = IIO_PROXIMITY,
288 .address = APDS9960_REG_PDATA,
289 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
290 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
295 .event_spec = apds9960_pxs_event_spec,
296 .num_event_specs = ARRAY_SIZE(apds9960_pxs_event_spec),
299 APDS9960_GESTURE_CHANNEL(UP, 0),
300 APDS9960_GESTURE_CHANNEL(DOWN, 1),
301 APDS9960_GESTURE_CHANNEL(LEFT, 2),
302 APDS9960_GESTURE_CHANNEL(RIGHT, 3),
305 .type = IIO_INTENSITY,
306 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
307 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
308 BIT(IIO_CHAN_INFO_INT_TIME),
309 .channel2 = IIO_MOD_LIGHT_CLEAR,
310 .address = APDS9960_REG_ALS_CHANNEL(CLEAR),
314 .event_spec = apds9960_als_event_spec,
315 .num_event_specs = ARRAY_SIZE(apds9960_als_event_spec),
318 APDS9960_INTENSITY_CHANNEL(RED),
319 APDS9960_INTENSITY_CHANNEL(GREEN),
320 APDS9960_INTENSITY_CHANNEL(BLUE),
323 /* integration time in us */
324 static const int apds9960_int_time[][2] =
325 { {28000, 246}, {100000, 219}, {200000, 182}, {700000, 0} };
328 static const int apds9960_pxs_gain_map[] = {1, 2, 4, 8};
329 static const int apds9960_als_gain_map[] = {1, 4, 16, 64};
331 static IIO_CONST_ATTR(proximity_scale_available, "1 2 4 8");
332 static IIO_CONST_ATTR(intensity_scale_available, "1 4 16 64");
333 static IIO_CONST_ATTR_INT_TIME_AVAIL("0.028 0.1 0.2 0.7");
335 static struct attribute *apds9960_attributes[] = {
336 &iio_const_attr_proximity_scale_available.dev_attr.attr,
337 &iio_const_attr_intensity_scale_available.dev_attr.attr,
338 &iio_const_attr_integration_time_available.dev_attr.attr,
342 static struct attribute_group apds9960_attribute_group = {
343 .attrs = apds9960_attributes,
346 static const struct reg_field apds9960_reg_field_int_als =
347 REG_FIELD(APDS9960_REG_ENABLE, 4, 4);
349 static const struct reg_field apds9960_reg_field_int_ges =
350 REG_FIELD(APDS9960_REG_GCONF_4, 1, 1);
352 static const struct reg_field apds9960_reg_field_int_pxs =
353 REG_FIELD(APDS9960_REG_ENABLE, 5, 5);
355 static const struct reg_field apds9960_reg_field_enable_als =
356 REG_FIELD(APDS9960_REG_ENABLE, 1, 1);
358 static const struct reg_field apds9960_reg_field_enable_ges =
359 REG_FIELD(APDS9960_REG_ENABLE, 6, 6);
361 static const struct reg_field apds9960_reg_field_enable_pxs =
362 REG_FIELD(APDS9960_REG_ENABLE, 2, 2);
364 static int apds9960_set_it_time(struct apds9960_data *data, int val2)
369 for (idx = 0; idx < ARRAY_SIZE(apds9960_int_time); idx++) {
370 if (apds9960_int_time[idx][0] == val2) {
371 mutex_lock(&data->lock);
372 ret = regmap_write(data->regmap, APDS9960_REG_ATIME,
373 apds9960_int_time[idx][1]);
375 data->als_adc_int_us = val2;
376 mutex_unlock(&data->lock);
384 static int apds9960_set_pxs_gain(struct apds9960_data *data, int val)
389 for (idx = 0; idx < ARRAY_SIZE(apds9960_pxs_gain_map); idx++) {
390 if (apds9960_pxs_gain_map[idx] == val) {
391 /* pxs + gesture gains are mirrored */
392 mutex_lock(&data->lock);
393 ret = regmap_update_bits(data->regmap,
394 APDS9960_REG_CONTROL,
395 APDS9960_REG_CONTROL_PGAIN_MASK,
396 idx << APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT);
398 mutex_unlock(&data->lock);
402 ret = regmap_update_bits(data->regmap,
403 APDS9960_REG_CONFIG_2,
404 APDS9960_REG_CONFIG_2_GGAIN_MASK,
405 idx << APDS9960_REG_CONFIG_2_GGAIN_MASK_SHIFT);
407 data->pxs_gain = idx;
408 mutex_unlock(&data->lock);
416 static int apds9960_set_als_gain(struct apds9960_data *data, int val)
421 for (idx = 0; idx < ARRAY_SIZE(apds9960_als_gain_map); idx++) {
422 if (apds9960_als_gain_map[idx] == val) {
423 mutex_lock(&data->lock);
424 ret = regmap_update_bits(data->regmap,
425 APDS9960_REG_CONTROL,
426 APDS9960_REG_CONTROL_AGAIN_MASK, idx);
428 data->als_gain = idx;
429 mutex_unlock(&data->lock);
438 static int apds9960_set_power_state(struct apds9960_data *data, bool on)
440 struct device *dev = &data->client->dev;
443 mutex_lock(&data->lock);
448 suspended = pm_runtime_suspended(dev);
449 ret = pm_runtime_get_sync(dev);
451 /* Allow one integration cycle before allowing a reading */
453 usleep_range(data->als_adc_int_us,
454 APDS9960_MAX_INT_TIME_IN_US);
456 ret = pm_runtime_put_autosuspend(dev);
459 mutex_unlock(&data->lock);
464 static int apds9960_set_power_state(struct apds9960_data *data, bool on)
470 static int apds9960_read_raw(struct iio_dev *indio_dev,
471 struct iio_chan_spec const *chan,
472 int *val, int *val2, long mask)
474 struct apds9960_data *data = iio_priv(indio_dev);
478 if (data->gesture_mode_running)
482 case IIO_CHAN_INFO_RAW:
483 apds9960_set_power_state(data, true);
484 switch (chan->type) {
486 ret = regmap_read(data->regmap, chan->address, val);
491 ret = regmap_bulk_read(data->regmap, chan->address,
495 *val = le16_to_cpu(buf);
500 apds9960_set_power_state(data, false);
502 case IIO_CHAN_INFO_INT_TIME:
503 /* RGB + ALS sensors only have integration time */
504 mutex_lock(&data->lock);
505 switch (chan->type) {
508 *val2 = data->als_adc_int_us;
509 ret = IIO_VAL_INT_PLUS_MICRO;
514 mutex_unlock(&data->lock);
516 case IIO_CHAN_INFO_SCALE:
517 mutex_lock(&data->lock);
518 switch (chan->type) {
520 *val = apds9960_pxs_gain_map[data->pxs_gain];
524 *val = apds9960_als_gain_map[data->als_gain];
530 mutex_unlock(&data->lock);
537 static int apds9960_write_raw(struct iio_dev *indio_dev,
538 struct iio_chan_spec const *chan,
539 int val, int val2, long mask)
541 struct apds9960_data *data = iio_priv(indio_dev);
544 case IIO_CHAN_INFO_INT_TIME:
545 /* RGB + ALS sensors only have int time */
546 switch (chan->type) {
550 return apds9960_set_it_time(data, val2);
554 case IIO_CHAN_INFO_SCALE:
557 switch (chan->type) {
559 return apds9960_set_pxs_gain(data, val);
561 return apds9960_set_als_gain(data, val);
572 static inline int apds9960_get_thres_reg(const struct iio_chan_spec *chan,
573 enum iio_event_direction dir,
577 case IIO_EV_DIR_RISING:
578 switch (chan->type) {
580 *reg = APDS9960_REG_PIHT;
583 *reg = APDS9960_REG_AIHTL;
589 case IIO_EV_DIR_FALLING:
590 switch (chan->type) {
592 *reg = APDS9960_REG_PILT;
595 *reg = APDS9960_REG_AILTL;
608 static int apds9960_read_event(struct iio_dev *indio_dev,
609 const struct iio_chan_spec *chan,
610 enum iio_event_type type,
611 enum iio_event_direction dir,
612 enum iio_event_info info,
618 struct apds9960_data *data = iio_priv(indio_dev);
620 if (info != IIO_EV_INFO_VALUE)
623 ret = apds9960_get_thres_reg(chan, dir, ®);
627 if (chan->type == IIO_PROXIMITY) {
628 ret = regmap_read(data->regmap, reg, val);
631 } else if (chan->type == IIO_INTENSITY) {
632 ret = regmap_bulk_read(data->regmap, reg, &buf, 2);
635 *val = le16_to_cpu(buf);
644 static int apds9960_write_event(struct iio_dev *indio_dev,
645 const struct iio_chan_spec *chan,
646 enum iio_event_type type,
647 enum iio_event_direction dir,
648 enum iio_event_info info,
654 struct apds9960_data *data = iio_priv(indio_dev);
656 if (info != IIO_EV_INFO_VALUE)
659 ret = apds9960_get_thres_reg(chan, dir, ®);
663 if (chan->type == IIO_PROXIMITY) {
664 if (val < 0 || val > APDS9960_MAX_PXS_THRES_VAL)
666 ret = regmap_write(data->regmap, reg, val);
669 } else if (chan->type == IIO_INTENSITY) {
670 if (val < 0 || val > APDS9960_MAX_ALS_THRES_VAL)
672 buf = cpu_to_le16(val);
673 ret = regmap_bulk_write(data->regmap, reg, &buf, 2);
682 static int apds9960_read_event_config(struct iio_dev *indio_dev,
683 const struct iio_chan_spec *chan,
684 enum iio_event_type type,
685 enum iio_event_direction dir)
687 struct apds9960_data *data = iio_priv(indio_dev);
689 switch (chan->type) {
691 return data->pxs_int;
693 return data->als_int;
701 static int apds9960_write_event_config(struct iio_dev *indio_dev,
702 const struct iio_chan_spec *chan,
703 enum iio_event_type type,
704 enum iio_event_direction dir,
707 struct apds9960_data *data = iio_priv(indio_dev);
712 switch (chan->type) {
714 if (data->pxs_int == state)
717 ret = regmap_field_write(data->reg_int_pxs, state);
720 data->pxs_int = state;
721 apds9960_set_power_state(data, state);
724 if (data->als_int == state)
727 ret = regmap_field_write(data->reg_int_als, state);
730 data->als_int = state;
731 apds9960_set_power_state(data, state);
740 static const struct iio_info apds9960_info = {
741 .driver_module = THIS_MODULE,
742 .attrs = &apds9960_attribute_group,
743 .read_raw = apds9960_read_raw,
744 .write_raw = apds9960_write_raw,
745 .read_event_value = apds9960_read_event,
746 .write_event_value = apds9960_write_event,
747 .read_event_config = apds9960_read_event_config,
748 .write_event_config = apds9960_write_event_config,
752 static inline int apds9660_fifo_is_empty(struct apds9960_data *data)
757 ret = regmap_read(data->regmap, APDS9960_REG_GFLVL, &cnt);
764 static void apds9960_read_gesture_fifo(struct apds9960_data *data)
768 mutex_lock(&data->lock);
769 data->gesture_mode_running = 1;
771 while (cnt-- || (cnt = apds9660_fifo_is_empty(data) > 0)) {
772 ret = regmap_bulk_read(data->regmap, APDS9960_REG_GFIFO_BASE,
778 iio_push_to_buffers(data->indio_dev, data->buffer);
782 data->gesture_mode_running = 0;
783 mutex_unlock(&data->lock);
786 static irqreturn_t apds9960_interrupt_handler(int irq, void *private)
788 struct iio_dev *indio_dev = private;
789 struct apds9960_data *data = iio_priv(indio_dev);
792 ret = regmap_read(data->regmap, APDS9960_REG_STATUS, &status);
794 dev_err(&data->client->dev, "irq status reg read failed\n");
798 if ((status & APDS9960_REG_STATUS_ALS_INT) && data->als_int) {
799 iio_push_event(indio_dev,
800 IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
804 regmap_write(data->regmap, APDS9960_REG_CICLEAR, 1);
807 if ((status & APDS9960_REG_STATUS_PS_INT) && data->pxs_int) {
808 iio_push_event(indio_dev,
809 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
813 regmap_write(data->regmap, APDS9960_REG_PICLEAR, 1);
816 if (status & APDS9960_REG_STATUS_GINT)
817 apds9960_read_gesture_fifo(data);
822 static int apds9960_set_powermode(struct apds9960_data *data, bool state)
824 return regmap_update_bits(data->regmap, APDS9960_REG_ENABLE, 1, state);
827 static int apds9960_buffer_postenable(struct iio_dev *indio_dev)
829 struct apds9960_data *data = iio_priv(indio_dev);
832 ret = regmap_field_write(data->reg_int_ges, 1);
836 ret = regmap_field_write(data->reg_enable_ges, 1);
840 pm_runtime_get_sync(&data->client->dev);
845 static int apds9960_buffer_predisable(struct iio_dev *indio_dev)
847 struct apds9960_data *data = iio_priv(indio_dev);
850 ret = regmap_field_write(data->reg_enable_ges, 0);
854 ret = regmap_field_write(data->reg_int_ges, 0);
858 pm_runtime_put_autosuspend(&data->client->dev);
863 static const struct iio_buffer_setup_ops apds9960_buffer_setup_ops = {
864 .postenable = apds9960_buffer_postenable,
865 .predisable = apds9960_buffer_predisable,
868 static int apds9960_regfield_init(struct apds9960_data *data)
870 struct device *dev = &data->client->dev;
871 struct regmap *regmap = data->regmap;
873 data->reg_int_als = devm_regmap_field_alloc(dev, regmap,
874 apds9960_reg_field_int_als);
875 if (IS_ERR(data->reg_int_als)) {
876 dev_err(dev, "INT ALS reg field init failed\n");
877 return PTR_ERR(data->reg_int_als);
880 data->reg_int_ges = devm_regmap_field_alloc(dev, regmap,
881 apds9960_reg_field_int_ges);
882 if (IS_ERR(data->reg_int_ges)) {
883 dev_err(dev, "INT gesture reg field init failed\n");
884 return PTR_ERR(data->reg_int_ges);
887 data->reg_int_pxs = devm_regmap_field_alloc(dev, regmap,
888 apds9960_reg_field_int_pxs);
889 if (IS_ERR(data->reg_int_pxs)) {
890 dev_err(dev, "INT pxs reg field init failed\n");
891 return PTR_ERR(data->reg_int_pxs);
894 data->reg_enable_als = devm_regmap_field_alloc(dev, regmap,
895 apds9960_reg_field_enable_als);
896 if (IS_ERR(data->reg_enable_als)) {
897 dev_err(dev, "Enable ALS reg field init failed\n");
898 return PTR_ERR(data->reg_enable_als);
901 data->reg_enable_ges = devm_regmap_field_alloc(dev, regmap,
902 apds9960_reg_field_enable_ges);
903 if (IS_ERR(data->reg_enable_ges)) {
904 dev_err(dev, "Enable gesture reg field init failed\n");
905 return PTR_ERR(data->reg_enable_ges);
908 data->reg_enable_pxs = devm_regmap_field_alloc(dev, regmap,
909 apds9960_reg_field_enable_pxs);
910 if (IS_ERR(data->reg_enable_pxs)) {
911 dev_err(dev, "Enable PXS reg field init failed\n");
912 return PTR_ERR(data->reg_enable_pxs);
918 static int apds9960_chip_init(struct apds9960_data *data)
922 /* Default IT for ALS of 28 ms */
923 ret = apds9960_set_it_time(data, 28000);
927 /* Ensure gesture interrupt is OFF */
928 ret = regmap_field_write(data->reg_int_ges, 0);
932 /* Disable gesture sensor, since polling is useless from user-space */
933 ret = regmap_field_write(data->reg_enable_ges, 0);
937 /* Ensure proximity interrupt is OFF */
938 ret = regmap_field_write(data->reg_int_pxs, 0);
942 /* Enable proximity sensor for polling */
943 ret = regmap_field_write(data->reg_enable_pxs, 1);
947 /* Ensure ALS interrupt is OFF */
948 ret = regmap_field_write(data->reg_int_als, 0);
952 /* Enable ALS sensor for polling */
953 ret = regmap_field_write(data->reg_enable_als, 1);
957 * When enabled trigger an interrupt after 3 readings
958 * outside threshold for ALS + PXS
960 ret = regmap_write(data->regmap, APDS9960_REG_PERS,
961 APDS9960_DEFAULT_PERS);
966 * Wait for 4 event outside gesture threshold to prevent interrupt
969 ret = regmap_update_bits(data->regmap, APDS9960_REG_GCONF_1,
970 APDS9960_REG_GCONF_1_GFIFO_THRES_MASK,
971 BIT(0) << APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT);
975 /* Default ENTER and EXIT thresholds for the GESTURE engine. */
976 ret = regmap_write(data->regmap, APDS9960_REG_GPENTH,
977 APDS9960_DEFAULT_GPENTH);
981 ret = regmap_write(data->regmap, APDS9960_REG_GEXTH,
982 APDS9960_DEFAULT_GEXTH);
986 return apds9960_set_powermode(data, 1);
989 static int apds9960_probe(struct i2c_client *client,
990 const struct i2c_device_id *id)
992 struct apds9960_data *data;
993 struct iio_buffer *buffer;
994 struct iio_dev *indio_dev;
997 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1001 buffer = devm_iio_kfifo_allocate(&client->dev);
1005 iio_device_attach_buffer(indio_dev, buffer);
1007 indio_dev->info = &apds9960_info;
1008 indio_dev->name = APDS9960_DRV_NAME;
1009 indio_dev->channels = apds9960_channels;
1010 indio_dev->num_channels = ARRAY_SIZE(apds9960_channels);
1011 indio_dev->available_scan_masks = apds9960_scan_masks;
1012 indio_dev->modes = (INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE);
1013 indio_dev->setup_ops = &apds9960_buffer_setup_ops;
1015 data = iio_priv(indio_dev);
1016 i2c_set_clientdata(client, indio_dev);
1018 data->regmap = devm_regmap_init_i2c(client, &apds9960_regmap_config);
1019 if (IS_ERR(data->regmap)) {
1020 dev_err(&client->dev, "regmap initialization failed.\n");
1021 return PTR_ERR(data->regmap);
1024 data->client = client;
1025 data->indio_dev = indio_dev;
1026 mutex_init(&data->lock);
1028 ret = pm_runtime_set_active(&client->dev);
1030 goto error_power_down;
1032 pm_runtime_enable(&client->dev);
1033 pm_runtime_set_autosuspend_delay(&client->dev, 5000);
1034 pm_runtime_use_autosuspend(&client->dev);
1036 apds9960_set_power_state(data, true);
1038 ret = apds9960_regfield_init(data);
1040 goto error_power_down;
1042 ret = apds9960_chip_init(data);
1044 goto error_power_down;
1046 if (client->irq <= 0) {
1047 dev_err(&client->dev, "no valid irq defined\n");
1049 goto error_power_down;
1051 ret = devm_request_threaded_irq(&client->dev, client->irq,
1052 NULL, apds9960_interrupt_handler,
1053 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1057 dev_err(&client->dev, "request irq (%d) failed\n", client->irq);
1058 goto error_power_down;
1061 ret = iio_device_register(indio_dev);
1063 goto error_power_down;
1065 apds9960_set_power_state(data, false);
1070 apds9960_set_power_state(data, false);
1075 static int apds9960_remove(struct i2c_client *client)
1077 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1078 struct apds9960_data *data = iio_priv(indio_dev);
1080 iio_device_unregister(indio_dev);
1081 pm_runtime_disable(&client->dev);
1082 pm_runtime_set_suspended(&client->dev);
1083 apds9960_set_powermode(data, 0);
1089 static int apds9960_runtime_suspend(struct device *dev)
1091 struct apds9960_data *data =
1092 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
1094 return apds9960_set_powermode(data, 0);
1097 static int apds9960_runtime_resume(struct device *dev)
1099 struct apds9960_data *data =
1100 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
1102 return apds9960_set_powermode(data, 1);
1106 static const struct dev_pm_ops apds9960_pm_ops = {
1107 SET_RUNTIME_PM_OPS(apds9960_runtime_suspend,
1108 apds9960_runtime_resume, NULL)
1111 static const struct i2c_device_id apds9960_id[] = {
1115 MODULE_DEVICE_TABLE(i2c, apds9960_id);
1117 static struct i2c_driver apds9960_driver = {
1119 .name = APDS9960_DRV_NAME,
1120 .pm = &apds9960_pm_ops,
1122 .probe = apds9960_probe,
1123 .remove = apds9960_remove,
1124 .id_table = apds9960_id,
1126 module_i2c_driver(apds9960_driver);
1128 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
1129 MODULE_DESCRIPTION("ADPS9960 Gesture/RGB/ALS/Proximity sensor");
1130 MODULE_LICENSE("GPL");