Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * apds9960.c - Support for Avago APDS9960 gesture/RGB/ALS/proximity sensor
4 *
5 * Copyright (C) 2015, 2018
6 * Author: Matt Ranostay <matt.ranostay@konsulko.com>
7 *
8 * TODO: gesture + proximity calib offsets
9 */
10
11#include <linux/acpi.h>
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/interrupt.h>
15#include <linux/delay.h>
16#include <linux/mutex.h>
17#include <linux/err.h>
18#include <linux/irq.h>
19#include <linux/i2c.h>
20#include <linux/pm_runtime.h>
21#include <linux/regmap.h>
22#include <linux/iio/iio.h>
23#include <linux/iio/buffer.h>
24#include <linux/iio/events.h>
25#include <linux/iio/kfifo_buf.h>
26#include <linux/iio/sysfs.h>
27
28#define APDS9960_REGMAP_NAME "apds9960_regmap"
29#define APDS9960_DRV_NAME "apds9960"
30
31#define APDS9960_REG_RAM_START 0x00
32#define APDS9960_REG_RAM_END 0x7f
33
34#define APDS9960_REG_ENABLE 0x80
35#define APDS9960_REG_ATIME 0x81
36#define APDS9960_REG_WTIME 0x83
37
38#define APDS9960_REG_AILTL 0x84
39#define APDS9960_REG_AILTH 0x85
40#define APDS9960_REG_AIHTL 0x86
41#define APDS9960_REG_AIHTH 0x87
42
43#define APDS9960_REG_PILT 0x89
44#define APDS9960_REG_PIHT 0x8b
45#define APDS9960_REG_PERS 0x8c
46
47#define APDS9960_REG_CONFIG_1 0x8d
48#define APDS9960_REG_PPULSE 0x8e
49
50#define APDS9960_REG_CONTROL 0x8f
51#define APDS9960_REG_CONTROL_AGAIN_MASK 0x03
52#define APDS9960_REG_CONTROL_PGAIN_MASK 0x0c
53#define APDS9960_REG_CONTROL_AGAIN_MASK_SHIFT 0
54#define APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT 2
55
56#define APDS9960_REG_CONFIG_2 0x90
57#define APDS9960_REG_ID 0x92
58
59#define APDS9960_REG_STATUS 0x93
60#define APDS9960_REG_STATUS_PS_INT BIT(5)
61#define APDS9960_REG_STATUS_ALS_INT BIT(4)
62#define APDS9960_REG_STATUS_GINT BIT(2)
63
64#define APDS9960_REG_PDATA 0x9c
65#define APDS9960_REG_POFFSET_UR 0x9d
66#define APDS9960_REG_POFFSET_DL 0x9e
67#define APDS9960_REG_CONFIG_3 0x9f
68
69#define APDS9960_REG_GPENTH 0xa0
70#define APDS9960_REG_GEXTH 0xa1
71
72#define APDS9960_REG_GCONF_1 0xa2
73#define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK 0xc0
74#define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT 6
75
76#define APDS9960_REG_GCONF_2 0xa3
77#define APDS9960_REG_GCONF_2_GGAIN_MASK 0x60
78#define APDS9960_REG_GCONF_2_GGAIN_MASK_SHIFT 5
79
80#define APDS9960_REG_GOFFSET_U 0xa4
81#define APDS9960_REG_GOFFSET_D 0xa5
82#define APDS9960_REG_GPULSE 0xa6
83#define APDS9960_REG_GOFFSET_L 0xa7
84#define APDS9960_REG_GOFFSET_R 0xa9
85#define APDS9960_REG_GCONF_3 0xaa
86
87#define APDS9960_REG_GCONF_4 0xab
88#define APDS9960_REG_GFLVL 0xae
89#define APDS9960_REG_GSTATUS 0xaf
90
91#define APDS9960_REG_IFORCE 0xe4
92#define APDS9960_REG_PICLEAR 0xe5
93#define APDS9960_REG_CICLEAR 0xe6
94#define APDS9960_REG_AICLEAR 0xe7
95
96#define APDS9960_DEFAULT_PERS 0x33
97#define APDS9960_DEFAULT_GPENTH 0x50
98#define APDS9960_DEFAULT_GEXTH 0x40
99
100#define APDS9960_MAX_PXS_THRES_VAL 255
101#define APDS9960_MAX_ALS_THRES_VAL 0xffff
102#define APDS9960_MAX_INT_TIME_IN_US 1000000
103
104enum apds9960_als_channel_idx {
105 IDX_ALS_CLEAR, IDX_ALS_RED, IDX_ALS_GREEN, IDX_ALS_BLUE,
106};
107
108#define APDS9960_REG_ALS_BASE 0x94
109#define APDS9960_REG_ALS_CHANNEL(_colour) \
110 (APDS9960_REG_ALS_BASE + (IDX_ALS_##_colour * 2))
111
112enum apds9960_gesture_channel_idx {
113 IDX_DIR_UP, IDX_DIR_DOWN, IDX_DIR_LEFT, IDX_DIR_RIGHT,
114};
115
116#define APDS9960_REG_GFIFO_BASE 0xfc
117#define APDS9960_REG_GFIFO_DIR(_dir) \
118 (APDS9960_REG_GFIFO_BASE + IDX_DIR_##_dir)
119
120struct apds9960_data {
121 struct i2c_client *client;
122 struct iio_dev *indio_dev;
123 struct mutex lock;
124
125 /* regmap fields */
126 struct regmap *regmap;
127 struct regmap_field *reg_int_als;
128 struct regmap_field *reg_int_ges;
129 struct regmap_field *reg_int_pxs;
130
131 struct regmap_field *reg_enable_als;
132 struct regmap_field *reg_enable_ges;
133 struct regmap_field *reg_enable_pxs;
134
135 /* state */
136 bool als_int;
137 bool pxs_int;
138 int gesture_mode_running;
139
140 /* gain values */
141 int als_gain;
142 int pxs_gain;
143
144 /* integration time value in us */
145 int als_adc_int_us;
146
147 /* gesture buffer */
148 u8 buffer[4]; /* 4 8-bit channels */
149
150 /* calibration value buffer */
151 int calibbias[5];
152};
153
154enum {
155 APDS9960_CHAN_PROXIMITY,
156 APDS9960_CHAN_GESTURE_UP,
157 APDS9960_CHAN_GESTURE_DOWN,
158 APDS9960_CHAN_GESTURE_LEFT,
159 APDS9960_CHAN_GESTURE_RIGHT,
160};
161
162static const unsigned int apds9960_offset_regs[][2] = {
163 [APDS9960_CHAN_PROXIMITY] = {APDS9960_REG_POFFSET_UR, APDS9960_REG_POFFSET_DL},
164 [APDS9960_CHAN_GESTURE_UP] = {APDS9960_REG_GOFFSET_U, 0},
165 [APDS9960_CHAN_GESTURE_DOWN] = {APDS9960_REG_GOFFSET_D, 0},
166 [APDS9960_CHAN_GESTURE_LEFT] = {APDS9960_REG_GOFFSET_L, 0},
167 [APDS9960_CHAN_GESTURE_RIGHT] = {APDS9960_REG_GOFFSET_R, 0},
168};
169
170static const struct reg_default apds9960_reg_defaults[] = {
171 /* Default ALS integration time = 2.48ms */
172 { APDS9960_REG_ATIME, 0xff },
173};
174
175static const struct regmap_range apds9960_volatile_ranges[] = {
176 regmap_reg_range(APDS9960_REG_STATUS,
177 APDS9960_REG_PDATA),
178 regmap_reg_range(APDS9960_REG_GFLVL,
179 APDS9960_REG_GSTATUS),
180 regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
181 APDS9960_REG_GFIFO_DIR(RIGHT)),
182 regmap_reg_range(APDS9960_REG_IFORCE,
183 APDS9960_REG_AICLEAR),
184};
185
186static const struct regmap_access_table apds9960_volatile_table = {
187 .yes_ranges = apds9960_volatile_ranges,
188 .n_yes_ranges = ARRAY_SIZE(apds9960_volatile_ranges),
189};
190
191static const struct regmap_range apds9960_precious_ranges[] = {
192 regmap_reg_range(APDS9960_REG_RAM_START, APDS9960_REG_RAM_END),
193};
194
195static const struct regmap_access_table apds9960_precious_table = {
196 .yes_ranges = apds9960_precious_ranges,
197 .n_yes_ranges = ARRAY_SIZE(apds9960_precious_ranges),
198};
199
200static const struct regmap_range apds9960_readable_ranges[] = {
201 regmap_reg_range(APDS9960_REG_ENABLE,
202 APDS9960_REG_GSTATUS),
203 regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
204 APDS9960_REG_GFIFO_DIR(RIGHT)),
205};
206
207static const struct regmap_access_table apds9960_readable_table = {
208 .yes_ranges = apds9960_readable_ranges,
209 .n_yes_ranges = ARRAY_SIZE(apds9960_readable_ranges),
210};
211
212static const struct regmap_range apds9960_writeable_ranges[] = {
213 regmap_reg_range(APDS9960_REG_ENABLE, APDS9960_REG_CONFIG_2),
214 regmap_reg_range(APDS9960_REG_POFFSET_UR, APDS9960_REG_GCONF_4),
215 regmap_reg_range(APDS9960_REG_IFORCE, APDS9960_REG_AICLEAR),
216};
217
218static const struct regmap_access_table apds9960_writeable_table = {
219 .yes_ranges = apds9960_writeable_ranges,
220 .n_yes_ranges = ARRAY_SIZE(apds9960_writeable_ranges),
221};
222
223static const struct regmap_config apds9960_regmap_config = {
224 .name = APDS9960_REGMAP_NAME,
225 .reg_bits = 8,
226 .val_bits = 8,
227 .use_single_read = true,
228 .use_single_write = true,
229
230 .volatile_table = &apds9960_volatile_table,
231 .precious_table = &apds9960_precious_table,
232 .rd_table = &apds9960_readable_table,
233 .wr_table = &apds9960_writeable_table,
234
235 .reg_defaults = apds9960_reg_defaults,
236 .num_reg_defaults = ARRAY_SIZE(apds9960_reg_defaults),
237 .max_register = APDS9960_REG_GFIFO_DIR(RIGHT),
238 .cache_type = REGCACHE_RBTREE,
239};
240
241static const struct iio_event_spec apds9960_pxs_event_spec[] = {
242 {
243 .type = IIO_EV_TYPE_THRESH,
244 .dir = IIO_EV_DIR_RISING,
245 .mask_separate = BIT(IIO_EV_INFO_VALUE),
246 },
247 {
248 .type = IIO_EV_TYPE_THRESH,
249 .dir = IIO_EV_DIR_FALLING,
250 .mask_separate = BIT(IIO_EV_INFO_VALUE),
251 },
252 {
253 .type = IIO_EV_TYPE_THRESH,
254 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
255 },
256};
257
258static const struct iio_event_spec apds9960_als_event_spec[] = {
259 {
260 .type = IIO_EV_TYPE_THRESH,
261 .dir = IIO_EV_DIR_RISING,
262 .mask_separate = BIT(IIO_EV_INFO_VALUE),
263 },
264 {
265 .type = IIO_EV_TYPE_THRESH,
266 .dir = IIO_EV_DIR_FALLING,
267 .mask_separate = BIT(IIO_EV_INFO_VALUE),
268 },
269 {
270 .type = IIO_EV_TYPE_THRESH,
271 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
272 },
273};
274
275#define APDS9960_GESTURE_CHANNEL(_dir, _si) { \
276 .type = IIO_PROXIMITY, \
277 .info_mask_separate = BIT(IIO_CHAN_INFO_CALIBBIAS), \
278 .channel = _si + 1, \
279 .scan_index = _si, \
280 .indexed = 1, \
281 .scan_type = { \
282 .sign = 'u', \
283 .realbits = 8, \
284 .storagebits = 8, \
285 }, \
286}
287
288#define APDS9960_INTENSITY_CHANNEL(_colour) { \
289 .type = IIO_INTENSITY, \
290 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
291 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
292 BIT(IIO_CHAN_INFO_INT_TIME), \
293 .channel2 = IIO_MOD_LIGHT_##_colour, \
294 .address = APDS9960_REG_ALS_CHANNEL(_colour), \
295 .modified = 1, \
296 .scan_index = -1, \
297}
298
299static const unsigned long apds9960_scan_masks[] = {0xf, 0};
300
301static const struct iio_chan_spec apds9960_channels[] = {
302 {
303 .type = IIO_PROXIMITY,
304 .address = APDS9960_REG_PDATA,
305 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
306 BIT(IIO_CHAN_INFO_CALIBBIAS),
307 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
308 .channel = 0,
309 .indexed = 0,
310 .scan_index = -1,
311
312 .event_spec = apds9960_pxs_event_spec,
313 .num_event_specs = ARRAY_SIZE(apds9960_pxs_event_spec),
314 },
315 /* Gesture Sensor */
316 APDS9960_GESTURE_CHANNEL(UP, 0),
317 APDS9960_GESTURE_CHANNEL(DOWN, 1),
318 APDS9960_GESTURE_CHANNEL(LEFT, 2),
319 APDS9960_GESTURE_CHANNEL(RIGHT, 3),
320 /* ALS */
321 {
322 .type = IIO_INTENSITY,
323 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
324 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
325 BIT(IIO_CHAN_INFO_INT_TIME),
326 .channel2 = IIO_MOD_LIGHT_CLEAR,
327 .address = APDS9960_REG_ALS_CHANNEL(CLEAR),
328 .modified = 1,
329 .scan_index = -1,
330
331 .event_spec = apds9960_als_event_spec,
332 .num_event_specs = ARRAY_SIZE(apds9960_als_event_spec),
333 },
334 /* RGB Sensor */
335 APDS9960_INTENSITY_CHANNEL(RED),
336 APDS9960_INTENSITY_CHANNEL(GREEN),
337 APDS9960_INTENSITY_CHANNEL(BLUE),
338};
339
340static int apds9960_set_calibbias(struct apds9960_data *data,
341 struct iio_chan_spec const *chan, int calibbias)
342{
343 int ret, i;
344
345 if (calibbias < S8_MIN || calibbias > S8_MAX)
346 return -EINVAL;
347
348 guard(mutex)(&data->lock);
349 for (i = 0; i < 2; i++) {
350 if (apds9960_offset_regs[chan->channel][i] == 0)
351 break;
352
353 ret = regmap_write(data->regmap, apds9960_offset_regs[chan->channel][i], calibbias);
354 if (ret < 0)
355 return ret;
356 }
357 data->calibbias[chan->channel] = calibbias;
358
359 return 0;
360}
361
362/* integration time in us */
363static const int apds9960_int_time[][2] = {
364 { 28000, 246},
365 {100000, 219},
366 {200000, 182},
367 {700000, 0}
368};
369
370/* gain mapping */
371static const int apds9960_pxs_gain_map[] = {1, 2, 4, 8};
372static const int apds9960_als_gain_map[] = {1, 4, 16, 64};
373
374static IIO_CONST_ATTR(proximity_scale_available, "1 2 4 8");
375static IIO_CONST_ATTR(intensity_scale_available, "1 4 16 64");
376static IIO_CONST_ATTR_INT_TIME_AVAIL("0.028 0.1 0.2 0.7");
377
378static struct attribute *apds9960_attributes[] = {
379 &iio_const_attr_proximity_scale_available.dev_attr.attr,
380 &iio_const_attr_intensity_scale_available.dev_attr.attr,
381 &iio_const_attr_integration_time_available.dev_attr.attr,
382 NULL,
383};
384
385static const struct attribute_group apds9960_attribute_group = {
386 .attrs = apds9960_attributes,
387};
388
389static const struct reg_field apds9960_reg_field_int_als =
390 REG_FIELD(APDS9960_REG_ENABLE, 4, 4);
391
392static const struct reg_field apds9960_reg_field_int_ges =
393 REG_FIELD(APDS9960_REG_GCONF_4, 1, 1);
394
395static const struct reg_field apds9960_reg_field_int_pxs =
396 REG_FIELD(APDS9960_REG_ENABLE, 5, 5);
397
398static const struct reg_field apds9960_reg_field_enable_als =
399 REG_FIELD(APDS9960_REG_ENABLE, 1, 1);
400
401static const struct reg_field apds9960_reg_field_enable_ges =
402 REG_FIELD(APDS9960_REG_ENABLE, 6, 6);
403
404static const struct reg_field apds9960_reg_field_enable_pxs =
405 REG_FIELD(APDS9960_REG_ENABLE, 2, 2);
406
407static int apds9960_set_it_time(struct apds9960_data *data, int val2)
408{
409 int ret = -EINVAL;
410 int idx;
411
412 for (idx = 0; idx < ARRAY_SIZE(apds9960_int_time); idx++) {
413 if (apds9960_int_time[idx][0] == val2) {
414 mutex_lock(&data->lock);
415 ret = regmap_write(data->regmap, APDS9960_REG_ATIME,
416 apds9960_int_time[idx][1]);
417 if (!ret)
418 data->als_adc_int_us = val2;
419 mutex_unlock(&data->lock);
420 break;
421 }
422 }
423
424 return ret;
425}
426
427static int apds9960_set_pxs_gain(struct apds9960_data *data, int val)
428{
429 int ret = -EINVAL;
430 int idx;
431
432 for (idx = 0; idx < ARRAY_SIZE(apds9960_pxs_gain_map); idx++) {
433 if (apds9960_pxs_gain_map[idx] == val) {
434 /* pxs + gesture gains are mirrored */
435 mutex_lock(&data->lock);
436 ret = regmap_update_bits(data->regmap,
437 APDS9960_REG_CONTROL,
438 APDS9960_REG_CONTROL_PGAIN_MASK,
439 idx << APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT);
440 if (ret) {
441 mutex_unlock(&data->lock);
442 break;
443 }
444
445 ret = regmap_update_bits(data->regmap,
446 APDS9960_REG_GCONF_2,
447 APDS9960_REG_GCONF_2_GGAIN_MASK,
448 idx << APDS9960_REG_GCONF_2_GGAIN_MASK_SHIFT);
449 if (!ret)
450 data->pxs_gain = idx;
451 mutex_unlock(&data->lock);
452 break;
453 }
454 }
455
456 return ret;
457}
458
459static int apds9960_set_als_gain(struct apds9960_data *data, int val)
460{
461 int ret = -EINVAL;
462 int idx;
463
464 for (idx = 0; idx < ARRAY_SIZE(apds9960_als_gain_map); idx++) {
465 if (apds9960_als_gain_map[idx] == val) {
466 mutex_lock(&data->lock);
467 ret = regmap_update_bits(data->regmap,
468 APDS9960_REG_CONTROL,
469 APDS9960_REG_CONTROL_AGAIN_MASK, idx);
470 if (!ret)
471 data->als_gain = idx;
472 mutex_unlock(&data->lock);
473 break;
474 }
475 }
476
477 return ret;
478}
479
480#ifdef CONFIG_PM
481static int apds9960_set_power_state(struct apds9960_data *data, bool on)
482{
483 struct device *dev = &data->client->dev;
484 int ret = 0;
485
486 mutex_lock(&data->lock);
487
488 if (on) {
489 int suspended;
490
491 suspended = pm_runtime_suspended(dev);
492 ret = pm_runtime_get_sync(dev);
493
494 /* Allow one integration cycle before allowing a reading */
495 if (suspended)
496 usleep_range(data->als_adc_int_us,
497 APDS9960_MAX_INT_TIME_IN_US);
498 } else {
499 pm_runtime_mark_last_busy(dev);
500 ret = pm_runtime_put_autosuspend(dev);
501 }
502
503 mutex_unlock(&data->lock);
504
505 return ret;
506}
507#else
508static int apds9960_set_power_state(struct apds9960_data *data, bool on)
509{
510 return 0;
511}
512#endif
513
514static int apds9960_read_raw(struct iio_dev *indio_dev,
515 struct iio_chan_spec const *chan,
516 int *val, int *val2, long mask)
517{
518 struct apds9960_data *data = iio_priv(indio_dev);
519 __le16 buf;
520 int ret = -EINVAL;
521
522 if (data->gesture_mode_running)
523 return -EBUSY;
524
525 switch (mask) {
526 case IIO_CHAN_INFO_RAW:
527 apds9960_set_power_state(data, true);
528 switch (chan->type) {
529 case IIO_PROXIMITY:
530 ret = regmap_read(data->regmap, chan->address, val);
531 if (!ret)
532 ret = IIO_VAL_INT;
533 break;
534 case IIO_INTENSITY:
535 ret = regmap_bulk_read(data->regmap, chan->address,
536 &buf, 2);
537 if (!ret) {
538 ret = IIO_VAL_INT;
539 *val = le16_to_cpu(buf);
540 }
541 break;
542 default:
543 ret = -EINVAL;
544 }
545 apds9960_set_power_state(data, false);
546 break;
547 case IIO_CHAN_INFO_INT_TIME:
548 /* RGB + ALS sensors only have integration time */
549 mutex_lock(&data->lock);
550 switch (chan->type) {
551 case IIO_INTENSITY:
552 *val = 0;
553 *val2 = data->als_adc_int_us;
554 ret = IIO_VAL_INT_PLUS_MICRO;
555 break;
556 default:
557 ret = -EINVAL;
558 }
559 mutex_unlock(&data->lock);
560 break;
561 case IIO_CHAN_INFO_SCALE:
562 mutex_lock(&data->lock);
563 switch (chan->type) {
564 case IIO_PROXIMITY:
565 *val = apds9960_pxs_gain_map[data->pxs_gain];
566 ret = IIO_VAL_INT;
567 break;
568 case IIO_INTENSITY:
569 *val = apds9960_als_gain_map[data->als_gain];
570 ret = IIO_VAL_INT;
571 break;
572 default:
573 ret = -EINVAL;
574 }
575 mutex_unlock(&data->lock);
576 break;
577 case IIO_CHAN_INFO_CALIBBIAS:
578 mutex_lock(&data->lock);
579 *val = data->calibbias[chan->channel];
580 ret = IIO_VAL_INT;
581 mutex_unlock(&data->lock);
582 break;
583 }
584
585 return ret;
586};
587
588static int apds9960_write_raw(struct iio_dev *indio_dev,
589 struct iio_chan_spec const *chan,
590 int val, int val2, long mask)
591{
592 struct apds9960_data *data = iio_priv(indio_dev);
593
594 switch (mask) {
595 case IIO_CHAN_INFO_INT_TIME:
596 /* RGB + ALS sensors only have int time */
597 switch (chan->type) {
598 case IIO_INTENSITY:
599 if (val != 0)
600 return -EINVAL;
601 return apds9960_set_it_time(data, val2);
602 default:
603 return -EINVAL;
604 }
605 case IIO_CHAN_INFO_SCALE:
606 if (val2 != 0)
607 return -EINVAL;
608 switch (chan->type) {
609 case IIO_PROXIMITY:
610 return apds9960_set_pxs_gain(data, val);
611 case IIO_INTENSITY:
612 return apds9960_set_als_gain(data, val);
613 default:
614 return -EINVAL;
615 }
616 case IIO_CHAN_INFO_CALIBBIAS:
617 if (val2 != 0)
618 return -EINVAL;
619 return apds9960_set_calibbias(data, chan, val);
620 default:
621 return -EINVAL;
622 }
623
624 return 0;
625}
626
627static inline int apds9960_get_thres_reg(const struct iio_chan_spec *chan,
628 enum iio_event_direction dir,
629 u8 *reg)
630{
631 switch (dir) {
632 case IIO_EV_DIR_RISING:
633 switch (chan->type) {
634 case IIO_PROXIMITY:
635 *reg = APDS9960_REG_PIHT;
636 break;
637 case IIO_INTENSITY:
638 *reg = APDS9960_REG_AIHTL;
639 break;
640 default:
641 return -EINVAL;
642 }
643 break;
644 case IIO_EV_DIR_FALLING:
645 switch (chan->type) {
646 case IIO_PROXIMITY:
647 *reg = APDS9960_REG_PILT;
648 break;
649 case IIO_INTENSITY:
650 *reg = APDS9960_REG_AILTL;
651 break;
652 default:
653 return -EINVAL;
654 }
655 break;
656 default:
657 return -EINVAL;
658 }
659
660 return 0;
661}
662
663static int apds9960_read_event(struct iio_dev *indio_dev,
664 const struct iio_chan_spec *chan,
665 enum iio_event_type type,
666 enum iio_event_direction dir,
667 enum iio_event_info info,
668 int *val, int *val2)
669{
670 u8 reg;
671 __le16 buf;
672 int ret = 0;
673 struct apds9960_data *data = iio_priv(indio_dev);
674
675 if (info != IIO_EV_INFO_VALUE)
676 return -EINVAL;
677
678 ret = apds9960_get_thres_reg(chan, dir, ®);
679 if (ret < 0)
680 return ret;
681
682 if (chan->type == IIO_PROXIMITY) {
683 ret = regmap_read(data->regmap, reg, val);
684 if (ret < 0)
685 return ret;
686 } else if (chan->type == IIO_INTENSITY) {
687 ret = regmap_bulk_read(data->regmap, reg, &buf, 2);
688 if (ret < 0)
689 return ret;
690 *val = le16_to_cpu(buf);
691 } else
692 return -EINVAL;
693
694 *val2 = 0;
695
696 return IIO_VAL_INT;
697}
698
699static int apds9960_write_event(struct iio_dev *indio_dev,
700 const struct iio_chan_spec *chan,
701 enum iio_event_type type,
702 enum iio_event_direction dir,
703 enum iio_event_info info,
704 int val, int val2)
705{
706 u8 reg;
707 __le16 buf;
708 int ret = 0;
709 struct apds9960_data *data = iio_priv(indio_dev);
710
711 if (info != IIO_EV_INFO_VALUE)
712 return -EINVAL;
713
714 ret = apds9960_get_thres_reg(chan, dir, ®);
715 if (ret < 0)
716 return ret;
717
718 if (chan->type == IIO_PROXIMITY) {
719 if (val < 0 || val > APDS9960_MAX_PXS_THRES_VAL)
720 return -EINVAL;
721 ret = regmap_write(data->regmap, reg, val);
722 if (ret < 0)
723 return ret;
724 } else if (chan->type == IIO_INTENSITY) {
725 if (val < 0 || val > APDS9960_MAX_ALS_THRES_VAL)
726 return -EINVAL;
727 buf = cpu_to_le16(val);
728 ret = regmap_bulk_write(data->regmap, reg, &buf, 2);
729 if (ret < 0)
730 return ret;
731 } else
732 return -EINVAL;
733
734 return 0;
735}
736
737static int apds9960_read_event_config(struct iio_dev *indio_dev,
738 const struct iio_chan_spec *chan,
739 enum iio_event_type type,
740 enum iio_event_direction dir)
741{
742 struct apds9960_data *data = iio_priv(indio_dev);
743
744 switch (chan->type) {
745 case IIO_PROXIMITY:
746 return data->pxs_int;
747 case IIO_INTENSITY:
748 return data->als_int;
749 default:
750 return -EINVAL;
751 }
752}
753
754static int apds9960_write_event_config(struct iio_dev *indio_dev,
755 const struct iio_chan_spec *chan,
756 enum iio_event_type type,
757 enum iio_event_direction dir,
758 bool state)
759{
760 struct apds9960_data *data = iio_priv(indio_dev);
761 int ret;
762
763 switch (chan->type) {
764 case IIO_PROXIMITY:
765 if (data->pxs_int == state)
766 return -EINVAL;
767
768 ret = regmap_field_write(data->reg_int_pxs, state);
769 if (ret)
770 return ret;
771 data->pxs_int = state;
772 apds9960_set_power_state(data, state);
773 break;
774 case IIO_INTENSITY:
775 if (data->als_int == state)
776 return -EINVAL;
777
778 ret = regmap_field_write(data->reg_int_als, state);
779 if (ret)
780 return ret;
781 data->als_int = state;
782 apds9960_set_power_state(data, state);
783 break;
784 default:
785 return -EINVAL;
786 }
787
788 return 0;
789}
790
791static const struct iio_info apds9960_info = {
792 .attrs = &apds9960_attribute_group,
793 .read_raw = apds9960_read_raw,
794 .write_raw = apds9960_write_raw,
795 .read_event_value = apds9960_read_event,
796 .write_event_value = apds9960_write_event,
797 .read_event_config = apds9960_read_event_config,
798 .write_event_config = apds9960_write_event_config,
799
800};
801
802static inline int apds9660_fifo_is_empty(struct apds9960_data *data)
803{
804 int cnt;
805 int ret;
806
807 ret = regmap_read(data->regmap, APDS9960_REG_GFLVL, &cnt);
808 if (ret)
809 return ret;
810
811 return cnt;
812}
813
814static void apds9960_read_gesture_fifo(struct apds9960_data *data)
815{
816 int ret, cnt = 0;
817
818 mutex_lock(&data->lock);
819 data->gesture_mode_running = 1;
820
821 while (cnt || (cnt = apds9660_fifo_is_empty(data) > 0)) {
822 ret = regmap_bulk_read(data->regmap, APDS9960_REG_GFIFO_BASE,
823 &data->buffer, 4);
824
825 if (ret)
826 goto err_read;
827
828 iio_push_to_buffers(data->indio_dev, data->buffer);
829 cnt--;
830 }
831
832err_read:
833 data->gesture_mode_running = 0;
834 mutex_unlock(&data->lock);
835}
836
837static irqreturn_t apds9960_interrupt_handler(int irq, void *private)
838{
839 struct iio_dev *indio_dev = private;
840 struct apds9960_data *data = iio_priv(indio_dev);
841 int ret, status;
842
843 ret = regmap_read(data->regmap, APDS9960_REG_STATUS, &status);
844 if (ret < 0) {
845 dev_err(&data->client->dev, "irq status reg read failed\n");
846 return IRQ_HANDLED;
847 }
848
849 if ((status & APDS9960_REG_STATUS_ALS_INT) && data->als_int) {
850 iio_push_event(indio_dev,
851 IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
852 IIO_EV_TYPE_THRESH,
853 IIO_EV_DIR_EITHER),
854 iio_get_time_ns(indio_dev));
855 regmap_write(data->regmap, APDS9960_REG_CICLEAR, 1);
856 }
857
858 if ((status & APDS9960_REG_STATUS_PS_INT) && data->pxs_int) {
859 iio_push_event(indio_dev,
860 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
861 IIO_EV_TYPE_THRESH,
862 IIO_EV_DIR_EITHER),
863 iio_get_time_ns(indio_dev));
864 regmap_write(data->regmap, APDS9960_REG_PICLEAR, 1);
865 }
866
867 if (status & APDS9960_REG_STATUS_GINT)
868 apds9960_read_gesture_fifo(data);
869
870 return IRQ_HANDLED;
871}
872
873static int apds9960_set_powermode(struct apds9960_data *data, bool state)
874{
875 return regmap_update_bits(data->regmap, APDS9960_REG_ENABLE, 1, state);
876}
877
878static int apds9960_buffer_postenable(struct iio_dev *indio_dev)
879{
880 struct apds9960_data *data = iio_priv(indio_dev);
881 int ret;
882
883 ret = regmap_field_write(data->reg_int_ges, 1);
884 if (ret)
885 return ret;
886
887 ret = regmap_field_write(data->reg_enable_ges, 1);
888 if (ret)
889 return ret;
890
891 pm_runtime_get_sync(&data->client->dev);
892
893 return 0;
894}
895
896static int apds9960_buffer_predisable(struct iio_dev *indio_dev)
897{
898 struct apds9960_data *data = iio_priv(indio_dev);
899 int ret;
900
901 ret = regmap_field_write(data->reg_enable_ges, 0);
902 if (ret)
903 return ret;
904
905 ret = regmap_field_write(data->reg_int_ges, 0);
906 if (ret)
907 return ret;
908
909 pm_runtime_put_autosuspend(&data->client->dev);
910
911 return 0;
912}
913
914static const struct iio_buffer_setup_ops apds9960_buffer_setup_ops = {
915 .postenable = apds9960_buffer_postenable,
916 .predisable = apds9960_buffer_predisable,
917};
918
919static int apds9960_regfield_init(struct apds9960_data *data)
920{
921 struct device *dev = &data->client->dev;
922 struct regmap *regmap = data->regmap;
923
924 data->reg_int_als = devm_regmap_field_alloc(dev, regmap,
925 apds9960_reg_field_int_als);
926 if (IS_ERR(data->reg_int_als)) {
927 dev_err(dev, "INT ALS reg field init failed\n");
928 return PTR_ERR(data->reg_int_als);
929 }
930
931 data->reg_int_ges = devm_regmap_field_alloc(dev, regmap,
932 apds9960_reg_field_int_ges);
933 if (IS_ERR(data->reg_int_ges)) {
934 dev_err(dev, "INT gesture reg field init failed\n");
935 return PTR_ERR(data->reg_int_ges);
936 }
937
938 data->reg_int_pxs = devm_regmap_field_alloc(dev, regmap,
939 apds9960_reg_field_int_pxs);
940 if (IS_ERR(data->reg_int_pxs)) {
941 dev_err(dev, "INT pxs reg field init failed\n");
942 return PTR_ERR(data->reg_int_pxs);
943 }
944
945 data->reg_enable_als = devm_regmap_field_alloc(dev, regmap,
946 apds9960_reg_field_enable_als);
947 if (IS_ERR(data->reg_enable_als)) {
948 dev_err(dev, "Enable ALS reg field init failed\n");
949 return PTR_ERR(data->reg_enable_als);
950 }
951
952 data->reg_enable_ges = devm_regmap_field_alloc(dev, regmap,
953 apds9960_reg_field_enable_ges);
954 if (IS_ERR(data->reg_enable_ges)) {
955 dev_err(dev, "Enable gesture reg field init failed\n");
956 return PTR_ERR(data->reg_enable_ges);
957 }
958
959 data->reg_enable_pxs = devm_regmap_field_alloc(dev, regmap,
960 apds9960_reg_field_enable_pxs);
961 if (IS_ERR(data->reg_enable_pxs)) {
962 dev_err(dev, "Enable PXS reg field init failed\n");
963 return PTR_ERR(data->reg_enable_pxs);
964 }
965
966 return 0;
967}
968
969static int apds9960_chip_init(struct apds9960_data *data)
970{
971 int ret;
972
973 /* Default IT for ALS of 28 ms */
974 ret = apds9960_set_it_time(data, 28000);
975 if (ret)
976 return ret;
977
978 /* Ensure gesture interrupt is OFF */
979 ret = regmap_field_write(data->reg_int_ges, 0);
980 if (ret)
981 return ret;
982
983 /* Disable gesture sensor, since polling is useless from user-space */
984 ret = regmap_field_write(data->reg_enable_ges, 0);
985 if (ret)
986 return ret;
987
988 /* Ensure proximity interrupt is OFF */
989 ret = regmap_field_write(data->reg_int_pxs, 0);
990 if (ret)
991 return ret;
992
993 /* Enable proximity sensor for polling */
994 ret = regmap_field_write(data->reg_enable_pxs, 1);
995 if (ret)
996 return ret;
997
998 /* Ensure ALS interrupt is OFF */
999 ret = regmap_field_write(data->reg_int_als, 0);
1000 if (ret)
1001 return ret;
1002
1003 /* Enable ALS sensor for polling */
1004 ret = regmap_field_write(data->reg_enable_als, 1);
1005 if (ret)
1006 return ret;
1007 /*
1008 * When enabled trigger an interrupt after 3 readings
1009 * outside threshold for ALS + PXS
1010 */
1011 ret = regmap_write(data->regmap, APDS9960_REG_PERS,
1012 APDS9960_DEFAULT_PERS);
1013 if (ret)
1014 return ret;
1015
1016 /*
1017 * Wait for 4 event outside gesture threshold to prevent interrupt
1018 * flooding.
1019 */
1020 ret = regmap_update_bits(data->regmap, APDS9960_REG_GCONF_1,
1021 APDS9960_REG_GCONF_1_GFIFO_THRES_MASK,
1022 BIT(0) << APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT);
1023 if (ret)
1024 return ret;
1025
1026 /* Default ENTER and EXIT thresholds for the GESTURE engine. */
1027 ret = regmap_write(data->regmap, APDS9960_REG_GPENTH,
1028 APDS9960_DEFAULT_GPENTH);
1029 if (ret)
1030 return ret;
1031
1032 ret = regmap_write(data->regmap, APDS9960_REG_GEXTH,
1033 APDS9960_DEFAULT_GEXTH);
1034 if (ret)
1035 return ret;
1036
1037 return apds9960_set_powermode(data, 1);
1038}
1039
1040static int apds9960_probe(struct i2c_client *client)
1041{
1042 struct apds9960_data *data;
1043 struct iio_dev *indio_dev;
1044 int ret;
1045
1046 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1047 if (!indio_dev)
1048 return -ENOMEM;
1049
1050 indio_dev->info = &apds9960_info;
1051 indio_dev->name = APDS9960_DRV_NAME;
1052 indio_dev->channels = apds9960_channels;
1053 indio_dev->num_channels = ARRAY_SIZE(apds9960_channels);
1054 indio_dev->available_scan_masks = apds9960_scan_masks;
1055 indio_dev->modes = INDIO_DIRECT_MODE;
1056
1057 ret = devm_iio_kfifo_buffer_setup(&client->dev, indio_dev,
1058 &apds9960_buffer_setup_ops);
1059 if (ret)
1060 return ret;
1061
1062 data = iio_priv(indio_dev);
1063 i2c_set_clientdata(client, indio_dev);
1064
1065 data->regmap = devm_regmap_init_i2c(client, &apds9960_regmap_config);
1066 if (IS_ERR(data->regmap)) {
1067 dev_err(&client->dev, "regmap initialization failed.\n");
1068 return PTR_ERR(data->regmap);
1069 }
1070
1071 data->client = client;
1072 data->indio_dev = indio_dev;
1073 mutex_init(&data->lock);
1074
1075 ret = pm_runtime_set_active(&client->dev);
1076 if (ret)
1077 goto error_power_down;
1078
1079 pm_runtime_enable(&client->dev);
1080 pm_runtime_set_autosuspend_delay(&client->dev, 5000);
1081 pm_runtime_use_autosuspend(&client->dev);
1082
1083 apds9960_set_power_state(data, true);
1084
1085 ret = apds9960_regfield_init(data);
1086 if (ret)
1087 goto error_power_down;
1088
1089 ret = apds9960_chip_init(data);
1090 if (ret)
1091 goto error_power_down;
1092
1093 if (client->irq <= 0) {
1094 dev_err(&client->dev, "no valid irq defined\n");
1095 ret = -EINVAL;
1096 goto error_power_down;
1097 }
1098 ret = devm_request_threaded_irq(&client->dev, client->irq,
1099 NULL, apds9960_interrupt_handler,
1100 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1101 "apds9960_event",
1102 indio_dev);
1103 if (ret) {
1104 dev_err(&client->dev, "request irq (%d) failed\n", client->irq);
1105 goto error_power_down;
1106 }
1107
1108 ret = iio_device_register(indio_dev);
1109 if (ret)
1110 goto error_power_down;
1111
1112 apds9960_set_power_state(data, false);
1113
1114 return 0;
1115
1116error_power_down:
1117 apds9960_set_power_state(data, false);
1118
1119 return ret;
1120}
1121
1122static void apds9960_remove(struct i2c_client *client)
1123{
1124 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1125 struct apds9960_data *data = iio_priv(indio_dev);
1126
1127 iio_device_unregister(indio_dev);
1128 pm_runtime_disable(&client->dev);
1129 pm_runtime_set_suspended(&client->dev);
1130 apds9960_set_powermode(data, 0);
1131}
1132
1133#ifdef CONFIG_PM
1134static int apds9960_runtime_suspend(struct device *dev)
1135{
1136 struct apds9960_data *data =
1137 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
1138
1139 return apds9960_set_powermode(data, 0);
1140}
1141
1142static int apds9960_runtime_resume(struct device *dev)
1143{
1144 struct apds9960_data *data =
1145 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
1146
1147 return apds9960_set_powermode(data, 1);
1148}
1149#endif
1150
1151static const struct dev_pm_ops apds9960_pm_ops = {
1152 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1153 pm_runtime_force_resume)
1154 SET_RUNTIME_PM_OPS(apds9960_runtime_suspend,
1155 apds9960_runtime_resume, NULL)
1156};
1157
1158static const struct i2c_device_id apds9960_id[] = {
1159 { "apds9960" },
1160 {}
1161};
1162MODULE_DEVICE_TABLE(i2c, apds9960_id);
1163
1164static const struct acpi_device_id apds9960_acpi_match[] = {
1165 { "MSHW0184" },
1166 { }
1167};
1168MODULE_DEVICE_TABLE(acpi, apds9960_acpi_match);
1169
1170static const struct of_device_id apds9960_of_match[] = {
1171 { .compatible = "avago,apds9960" },
1172 { }
1173};
1174MODULE_DEVICE_TABLE(of, apds9960_of_match);
1175
1176static struct i2c_driver apds9960_driver = {
1177 .driver = {
1178 .name = APDS9960_DRV_NAME,
1179 .of_match_table = apds9960_of_match,
1180 .pm = &apds9960_pm_ops,
1181 .acpi_match_table = apds9960_acpi_match,
1182 },
1183 .probe = apds9960_probe,
1184 .remove = apds9960_remove,
1185 .id_table = apds9960_id,
1186};
1187module_i2c_driver(apds9960_driver);
1188
1189MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
1190MODULE_DESCRIPTION("APDS9960 Gesture/RGB/ALS/Proximity sensor");
1191MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * apds9960.c - Support for Avago APDS9960 gesture/RGB/ALS/proximity sensor
4 *
5 * Copyright (C) 2015, 2018
6 * Author: Matt Ranostay <matt.ranostay@konsulko.com>
7 *
8 * TODO: gesture + proximity calib offsets
9 */
10
11#include <linux/acpi.h>
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/interrupt.h>
15#include <linux/delay.h>
16#include <linux/mutex.h>
17#include <linux/err.h>
18#include <linux/irq.h>
19#include <linux/i2c.h>
20#include <linux/pm_runtime.h>
21#include <linux/regmap.h>
22#include <linux/iio/iio.h>
23#include <linux/iio/buffer.h>
24#include <linux/iio/events.h>
25#include <linux/iio/kfifo_buf.h>
26#include <linux/iio/sysfs.h>
27
28#define APDS9960_REGMAP_NAME "apds9960_regmap"
29#define APDS9960_DRV_NAME "apds9960"
30
31#define APDS9960_REG_RAM_START 0x00
32#define APDS9960_REG_RAM_END 0x7f
33
34#define APDS9960_REG_ENABLE 0x80
35#define APDS9960_REG_ATIME 0x81
36#define APDS9960_REG_WTIME 0x83
37
38#define APDS9960_REG_AILTL 0x84
39#define APDS9960_REG_AILTH 0x85
40#define APDS9960_REG_AIHTL 0x86
41#define APDS9960_REG_AIHTH 0x87
42
43#define APDS9960_REG_PILT 0x89
44#define APDS9960_REG_PIHT 0x8b
45#define APDS9960_REG_PERS 0x8c
46
47#define APDS9960_REG_CONFIG_1 0x8d
48#define APDS9960_REG_PPULSE 0x8e
49
50#define APDS9960_REG_CONTROL 0x8f
51#define APDS9960_REG_CONTROL_AGAIN_MASK 0x03
52#define APDS9960_REG_CONTROL_PGAIN_MASK 0x0c
53#define APDS9960_REG_CONTROL_AGAIN_MASK_SHIFT 0
54#define APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT 2
55
56#define APDS9960_REG_CONFIG_2 0x90
57#define APDS9960_REG_ID 0x92
58
59#define APDS9960_REG_STATUS 0x93
60#define APDS9960_REG_STATUS_PS_INT BIT(5)
61#define APDS9960_REG_STATUS_ALS_INT BIT(4)
62#define APDS9960_REG_STATUS_GINT BIT(2)
63
64#define APDS9960_REG_PDATA 0x9c
65#define APDS9960_REG_POFFSET_UR 0x9d
66#define APDS9960_REG_POFFSET_DL 0x9e
67#define APDS9960_REG_CONFIG_3 0x9f
68
69#define APDS9960_REG_GPENTH 0xa0
70#define APDS9960_REG_GEXTH 0xa1
71
72#define APDS9960_REG_GCONF_1 0xa2
73#define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK 0xc0
74#define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT 6
75
76#define APDS9960_REG_GCONF_2 0xa3
77#define APDS9960_REG_GCONF_2_GGAIN_MASK 0x60
78#define APDS9960_REG_GCONF_2_GGAIN_MASK_SHIFT 5
79
80#define APDS9960_REG_GOFFSET_U 0xa4
81#define APDS9960_REG_GOFFSET_D 0xa5
82#define APDS9960_REG_GPULSE 0xa6
83#define APDS9960_REG_GOFFSET_L 0xa7
84#define APDS9960_REG_GOFFSET_R 0xa9
85#define APDS9960_REG_GCONF_3 0xaa
86
87#define APDS9960_REG_GCONF_4 0xab
88#define APDS9960_REG_GFLVL 0xae
89#define APDS9960_REG_GSTATUS 0xaf
90
91#define APDS9960_REG_IFORCE 0xe4
92#define APDS9960_REG_PICLEAR 0xe5
93#define APDS9960_REG_CICLEAR 0xe6
94#define APDS9960_REG_AICLEAR 0xe7
95
96#define APDS9960_DEFAULT_PERS 0x33
97#define APDS9960_DEFAULT_GPENTH 0x50
98#define APDS9960_DEFAULT_GEXTH 0x40
99
100#define APDS9960_MAX_PXS_THRES_VAL 255
101#define APDS9960_MAX_ALS_THRES_VAL 0xffff
102#define APDS9960_MAX_INT_TIME_IN_US 1000000
103
104enum apds9960_als_channel_idx {
105 IDX_ALS_CLEAR, IDX_ALS_RED, IDX_ALS_GREEN, IDX_ALS_BLUE,
106};
107
108#define APDS9960_REG_ALS_BASE 0x94
109#define APDS9960_REG_ALS_CHANNEL(_colour) \
110 (APDS9960_REG_ALS_BASE + (IDX_ALS_##_colour * 2))
111
112enum apds9960_gesture_channel_idx {
113 IDX_DIR_UP, IDX_DIR_DOWN, IDX_DIR_LEFT, IDX_DIR_RIGHT,
114};
115
116#define APDS9960_REG_GFIFO_BASE 0xfc
117#define APDS9960_REG_GFIFO_DIR(_dir) \
118 (APDS9960_REG_GFIFO_BASE + IDX_DIR_##_dir)
119
120struct apds9960_data {
121 struct i2c_client *client;
122 struct iio_dev *indio_dev;
123 struct mutex lock;
124
125 /* regmap fields */
126 struct regmap *regmap;
127 struct regmap_field *reg_int_als;
128 struct regmap_field *reg_int_ges;
129 struct regmap_field *reg_int_pxs;
130
131 struct regmap_field *reg_enable_als;
132 struct regmap_field *reg_enable_ges;
133 struct regmap_field *reg_enable_pxs;
134
135 /* state */
136 int als_int;
137 int pxs_int;
138 int gesture_mode_running;
139
140 /* gain values */
141 int als_gain;
142 int pxs_gain;
143
144 /* integration time value in us */
145 int als_adc_int_us;
146
147 /* gesture buffer */
148 u8 buffer[4]; /* 4 8-bit channels */
149};
150
151static const struct reg_default apds9960_reg_defaults[] = {
152 /* Default ALS integration time = 2.48ms */
153 { APDS9960_REG_ATIME, 0xff },
154};
155
156static const struct regmap_range apds9960_volatile_ranges[] = {
157 regmap_reg_range(APDS9960_REG_STATUS,
158 APDS9960_REG_PDATA),
159 regmap_reg_range(APDS9960_REG_GFLVL,
160 APDS9960_REG_GSTATUS),
161 regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
162 APDS9960_REG_GFIFO_DIR(RIGHT)),
163 regmap_reg_range(APDS9960_REG_IFORCE,
164 APDS9960_REG_AICLEAR),
165};
166
167static const struct regmap_access_table apds9960_volatile_table = {
168 .yes_ranges = apds9960_volatile_ranges,
169 .n_yes_ranges = ARRAY_SIZE(apds9960_volatile_ranges),
170};
171
172static const struct regmap_range apds9960_precious_ranges[] = {
173 regmap_reg_range(APDS9960_REG_RAM_START, APDS9960_REG_RAM_END),
174};
175
176static const struct regmap_access_table apds9960_precious_table = {
177 .yes_ranges = apds9960_precious_ranges,
178 .n_yes_ranges = ARRAY_SIZE(apds9960_precious_ranges),
179};
180
181static const struct regmap_range apds9960_readable_ranges[] = {
182 regmap_reg_range(APDS9960_REG_ENABLE,
183 APDS9960_REG_GSTATUS),
184 regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
185 APDS9960_REG_GFIFO_DIR(RIGHT)),
186};
187
188static const struct regmap_access_table apds9960_readable_table = {
189 .yes_ranges = apds9960_readable_ranges,
190 .n_yes_ranges = ARRAY_SIZE(apds9960_readable_ranges),
191};
192
193static const struct regmap_range apds9960_writeable_ranges[] = {
194 regmap_reg_range(APDS9960_REG_ENABLE, APDS9960_REG_CONFIG_2),
195 regmap_reg_range(APDS9960_REG_POFFSET_UR, APDS9960_REG_GCONF_4),
196 regmap_reg_range(APDS9960_REG_IFORCE, APDS9960_REG_AICLEAR),
197};
198
199static const struct regmap_access_table apds9960_writeable_table = {
200 .yes_ranges = apds9960_writeable_ranges,
201 .n_yes_ranges = ARRAY_SIZE(apds9960_writeable_ranges),
202};
203
204static const struct regmap_config apds9960_regmap_config = {
205 .name = APDS9960_REGMAP_NAME,
206 .reg_bits = 8,
207 .val_bits = 8,
208 .use_single_read = true,
209 .use_single_write = true,
210
211 .volatile_table = &apds9960_volatile_table,
212 .precious_table = &apds9960_precious_table,
213 .rd_table = &apds9960_readable_table,
214 .wr_table = &apds9960_writeable_table,
215
216 .reg_defaults = apds9960_reg_defaults,
217 .num_reg_defaults = ARRAY_SIZE(apds9960_reg_defaults),
218 .max_register = APDS9960_REG_GFIFO_DIR(RIGHT),
219 .cache_type = REGCACHE_RBTREE,
220};
221
222static const struct iio_event_spec apds9960_pxs_event_spec[] = {
223 {
224 .type = IIO_EV_TYPE_THRESH,
225 .dir = IIO_EV_DIR_RISING,
226 .mask_separate = BIT(IIO_EV_INFO_VALUE),
227 },
228 {
229 .type = IIO_EV_TYPE_THRESH,
230 .dir = IIO_EV_DIR_FALLING,
231 .mask_separate = BIT(IIO_EV_INFO_VALUE),
232 },
233 {
234 .type = IIO_EV_TYPE_THRESH,
235 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
236 },
237};
238
239static const struct iio_event_spec apds9960_als_event_spec[] = {
240 {
241 .type = IIO_EV_TYPE_THRESH,
242 .dir = IIO_EV_DIR_RISING,
243 .mask_separate = BIT(IIO_EV_INFO_VALUE),
244 },
245 {
246 .type = IIO_EV_TYPE_THRESH,
247 .dir = IIO_EV_DIR_FALLING,
248 .mask_separate = BIT(IIO_EV_INFO_VALUE),
249 },
250 {
251 .type = IIO_EV_TYPE_THRESH,
252 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
253 },
254};
255
256#define APDS9960_GESTURE_CHANNEL(_dir, _si) { \
257 .type = IIO_PROXIMITY, \
258 .channel = _si + 1, \
259 .scan_index = _si, \
260 .indexed = 1, \
261 .scan_type = { \
262 .sign = 'u', \
263 .realbits = 8, \
264 .storagebits = 8, \
265 }, \
266}
267
268#define APDS9960_INTENSITY_CHANNEL(_colour) { \
269 .type = IIO_INTENSITY, \
270 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
271 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
272 BIT(IIO_CHAN_INFO_INT_TIME), \
273 .channel2 = IIO_MOD_LIGHT_##_colour, \
274 .address = APDS9960_REG_ALS_CHANNEL(_colour), \
275 .modified = 1, \
276 .scan_index = -1, \
277}
278
279static const unsigned long apds9960_scan_masks[] = {0xf, 0};
280
281static const struct iio_chan_spec apds9960_channels[] = {
282 {
283 .type = IIO_PROXIMITY,
284 .address = APDS9960_REG_PDATA,
285 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
286 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
287 .channel = 0,
288 .indexed = 0,
289 .scan_index = -1,
290
291 .event_spec = apds9960_pxs_event_spec,
292 .num_event_specs = ARRAY_SIZE(apds9960_pxs_event_spec),
293 },
294 /* Gesture Sensor */
295 APDS9960_GESTURE_CHANNEL(UP, 0),
296 APDS9960_GESTURE_CHANNEL(DOWN, 1),
297 APDS9960_GESTURE_CHANNEL(LEFT, 2),
298 APDS9960_GESTURE_CHANNEL(RIGHT, 3),
299 /* ALS */
300 {
301 .type = IIO_INTENSITY,
302 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
303 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
304 BIT(IIO_CHAN_INFO_INT_TIME),
305 .channel2 = IIO_MOD_LIGHT_CLEAR,
306 .address = APDS9960_REG_ALS_CHANNEL(CLEAR),
307 .modified = 1,
308 .scan_index = -1,
309
310 .event_spec = apds9960_als_event_spec,
311 .num_event_specs = ARRAY_SIZE(apds9960_als_event_spec),
312 },
313 /* RGB Sensor */
314 APDS9960_INTENSITY_CHANNEL(RED),
315 APDS9960_INTENSITY_CHANNEL(GREEN),
316 APDS9960_INTENSITY_CHANNEL(BLUE),
317};
318
319/* integration time in us */
320static const int apds9960_int_time[][2] = {
321 { 28000, 246},
322 {100000, 219},
323 {200000, 182},
324 {700000, 0}
325};
326
327/* gain mapping */
328static const int apds9960_pxs_gain_map[] = {1, 2, 4, 8};
329static const int apds9960_als_gain_map[] = {1, 4, 16, 64};
330
331static IIO_CONST_ATTR(proximity_scale_available, "1 2 4 8");
332static IIO_CONST_ATTR(intensity_scale_available, "1 4 16 64");
333static IIO_CONST_ATTR_INT_TIME_AVAIL("0.028 0.1 0.2 0.7");
334
335static 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,
339 NULL,
340};
341
342static const struct attribute_group apds9960_attribute_group = {
343 .attrs = apds9960_attributes,
344};
345
346static const struct reg_field apds9960_reg_field_int_als =
347 REG_FIELD(APDS9960_REG_ENABLE, 4, 4);
348
349static const struct reg_field apds9960_reg_field_int_ges =
350 REG_FIELD(APDS9960_REG_GCONF_4, 1, 1);
351
352static const struct reg_field apds9960_reg_field_int_pxs =
353 REG_FIELD(APDS9960_REG_ENABLE, 5, 5);
354
355static const struct reg_field apds9960_reg_field_enable_als =
356 REG_FIELD(APDS9960_REG_ENABLE, 1, 1);
357
358static const struct reg_field apds9960_reg_field_enable_ges =
359 REG_FIELD(APDS9960_REG_ENABLE, 6, 6);
360
361static const struct reg_field apds9960_reg_field_enable_pxs =
362 REG_FIELD(APDS9960_REG_ENABLE, 2, 2);
363
364static int apds9960_set_it_time(struct apds9960_data *data, int val2)
365{
366 int ret = -EINVAL;
367 int idx;
368
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]);
374 if (!ret)
375 data->als_adc_int_us = val2;
376 mutex_unlock(&data->lock);
377 break;
378 }
379 }
380
381 return ret;
382}
383
384static int apds9960_set_pxs_gain(struct apds9960_data *data, int val)
385{
386 int ret = -EINVAL;
387 int idx;
388
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);
397 if (ret) {
398 mutex_unlock(&data->lock);
399 break;
400 }
401
402 ret = regmap_update_bits(data->regmap,
403 APDS9960_REG_GCONF_2,
404 APDS9960_REG_GCONF_2_GGAIN_MASK,
405 idx << APDS9960_REG_GCONF_2_GGAIN_MASK_SHIFT);
406 if (!ret)
407 data->pxs_gain = idx;
408 mutex_unlock(&data->lock);
409 break;
410 }
411 }
412
413 return ret;
414}
415
416static int apds9960_set_als_gain(struct apds9960_data *data, int val)
417{
418 int ret = -EINVAL;
419 int idx;
420
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);
427 if (!ret)
428 data->als_gain = idx;
429 mutex_unlock(&data->lock);
430 break;
431 }
432 }
433
434 return ret;
435}
436
437#ifdef CONFIG_PM
438static int apds9960_set_power_state(struct apds9960_data *data, bool on)
439{
440 struct device *dev = &data->client->dev;
441 int ret = 0;
442
443 mutex_lock(&data->lock);
444
445 if (on) {
446 int suspended;
447
448 suspended = pm_runtime_suspended(dev);
449 ret = pm_runtime_get_sync(dev);
450
451 /* Allow one integration cycle before allowing a reading */
452 if (suspended)
453 usleep_range(data->als_adc_int_us,
454 APDS9960_MAX_INT_TIME_IN_US);
455 } else {
456 pm_runtime_mark_last_busy(dev);
457 ret = pm_runtime_put_autosuspend(dev);
458 }
459
460 mutex_unlock(&data->lock);
461
462 return ret;
463}
464#else
465static int apds9960_set_power_state(struct apds9960_data *data, bool on)
466{
467 return 0;
468}
469#endif
470
471static int apds9960_read_raw(struct iio_dev *indio_dev,
472 struct iio_chan_spec const *chan,
473 int *val, int *val2, long mask)
474{
475 struct apds9960_data *data = iio_priv(indio_dev);
476 __le16 buf;
477 int ret = -EINVAL;
478
479 if (data->gesture_mode_running)
480 return -EBUSY;
481
482 switch (mask) {
483 case IIO_CHAN_INFO_RAW:
484 apds9960_set_power_state(data, true);
485 switch (chan->type) {
486 case IIO_PROXIMITY:
487 ret = regmap_read(data->regmap, chan->address, val);
488 if (!ret)
489 ret = IIO_VAL_INT;
490 break;
491 case IIO_INTENSITY:
492 ret = regmap_bulk_read(data->regmap, chan->address,
493 &buf, 2);
494 if (!ret) {
495 ret = IIO_VAL_INT;
496 *val = le16_to_cpu(buf);
497 }
498 break;
499 default:
500 ret = -EINVAL;
501 }
502 apds9960_set_power_state(data, false);
503 break;
504 case IIO_CHAN_INFO_INT_TIME:
505 /* RGB + ALS sensors only have integration time */
506 mutex_lock(&data->lock);
507 switch (chan->type) {
508 case IIO_INTENSITY:
509 *val = 0;
510 *val2 = data->als_adc_int_us;
511 ret = IIO_VAL_INT_PLUS_MICRO;
512 break;
513 default:
514 ret = -EINVAL;
515 }
516 mutex_unlock(&data->lock);
517 break;
518 case IIO_CHAN_INFO_SCALE:
519 mutex_lock(&data->lock);
520 switch (chan->type) {
521 case IIO_PROXIMITY:
522 *val = apds9960_pxs_gain_map[data->pxs_gain];
523 ret = IIO_VAL_INT;
524 break;
525 case IIO_INTENSITY:
526 *val = apds9960_als_gain_map[data->als_gain];
527 ret = IIO_VAL_INT;
528 break;
529 default:
530 ret = -EINVAL;
531 }
532 mutex_unlock(&data->lock);
533 break;
534 }
535
536 return ret;
537};
538
539static int apds9960_write_raw(struct iio_dev *indio_dev,
540 struct iio_chan_spec const *chan,
541 int val, int val2, long mask)
542{
543 struct apds9960_data *data = iio_priv(indio_dev);
544
545 switch (mask) {
546 case IIO_CHAN_INFO_INT_TIME:
547 /* RGB + ALS sensors only have int time */
548 switch (chan->type) {
549 case IIO_INTENSITY:
550 if (val != 0)
551 return -EINVAL;
552 return apds9960_set_it_time(data, val2);
553 default:
554 return -EINVAL;
555 }
556 case IIO_CHAN_INFO_SCALE:
557 if (val2 != 0)
558 return -EINVAL;
559 switch (chan->type) {
560 case IIO_PROXIMITY:
561 return apds9960_set_pxs_gain(data, val);
562 case IIO_INTENSITY:
563 return apds9960_set_als_gain(data, val);
564 default:
565 return -EINVAL;
566 }
567 default:
568 return -EINVAL;
569 }
570
571 return 0;
572}
573
574static inline int apds9960_get_thres_reg(const struct iio_chan_spec *chan,
575 enum iio_event_direction dir,
576 u8 *reg)
577{
578 switch (dir) {
579 case IIO_EV_DIR_RISING:
580 switch (chan->type) {
581 case IIO_PROXIMITY:
582 *reg = APDS9960_REG_PIHT;
583 break;
584 case IIO_INTENSITY:
585 *reg = APDS9960_REG_AIHTL;
586 break;
587 default:
588 return -EINVAL;
589 }
590 break;
591 case IIO_EV_DIR_FALLING:
592 switch (chan->type) {
593 case IIO_PROXIMITY:
594 *reg = APDS9960_REG_PILT;
595 break;
596 case IIO_INTENSITY:
597 *reg = APDS9960_REG_AILTL;
598 break;
599 default:
600 return -EINVAL;
601 }
602 break;
603 default:
604 return -EINVAL;
605 }
606
607 return 0;
608}
609
610static int apds9960_read_event(struct iio_dev *indio_dev,
611 const struct iio_chan_spec *chan,
612 enum iio_event_type type,
613 enum iio_event_direction dir,
614 enum iio_event_info info,
615 int *val, int *val2)
616{
617 u8 reg;
618 __le16 buf;
619 int ret = 0;
620 struct apds9960_data *data = iio_priv(indio_dev);
621
622 if (info != IIO_EV_INFO_VALUE)
623 return -EINVAL;
624
625 ret = apds9960_get_thres_reg(chan, dir, ®);
626 if (ret < 0)
627 return ret;
628
629 if (chan->type == IIO_PROXIMITY) {
630 ret = regmap_read(data->regmap, reg, val);
631 if (ret < 0)
632 return ret;
633 } else if (chan->type == IIO_INTENSITY) {
634 ret = regmap_bulk_read(data->regmap, reg, &buf, 2);
635 if (ret < 0)
636 return ret;
637 *val = le16_to_cpu(buf);
638 } else
639 return -EINVAL;
640
641 *val2 = 0;
642
643 return IIO_VAL_INT;
644}
645
646static int apds9960_write_event(struct iio_dev *indio_dev,
647 const struct iio_chan_spec *chan,
648 enum iio_event_type type,
649 enum iio_event_direction dir,
650 enum iio_event_info info,
651 int val, int val2)
652{
653 u8 reg;
654 __le16 buf;
655 int ret = 0;
656 struct apds9960_data *data = iio_priv(indio_dev);
657
658 if (info != IIO_EV_INFO_VALUE)
659 return -EINVAL;
660
661 ret = apds9960_get_thres_reg(chan, dir, ®);
662 if (ret < 0)
663 return ret;
664
665 if (chan->type == IIO_PROXIMITY) {
666 if (val < 0 || val > APDS9960_MAX_PXS_THRES_VAL)
667 return -EINVAL;
668 ret = regmap_write(data->regmap, reg, val);
669 if (ret < 0)
670 return ret;
671 } else if (chan->type == IIO_INTENSITY) {
672 if (val < 0 || val > APDS9960_MAX_ALS_THRES_VAL)
673 return -EINVAL;
674 buf = cpu_to_le16(val);
675 ret = regmap_bulk_write(data->regmap, reg, &buf, 2);
676 if (ret < 0)
677 return ret;
678 } else
679 return -EINVAL;
680
681 return 0;
682}
683
684static int apds9960_read_event_config(struct iio_dev *indio_dev,
685 const struct iio_chan_spec *chan,
686 enum iio_event_type type,
687 enum iio_event_direction dir)
688{
689 struct apds9960_data *data = iio_priv(indio_dev);
690
691 switch (chan->type) {
692 case IIO_PROXIMITY:
693 return data->pxs_int;
694 case IIO_INTENSITY:
695 return data->als_int;
696 default:
697 return -EINVAL;
698 }
699
700 return 0;
701}
702
703static int apds9960_write_event_config(struct iio_dev *indio_dev,
704 const struct iio_chan_spec *chan,
705 enum iio_event_type type,
706 enum iio_event_direction dir,
707 int state)
708{
709 struct apds9960_data *data = iio_priv(indio_dev);
710 int ret;
711
712 state = !!state;
713
714 switch (chan->type) {
715 case IIO_PROXIMITY:
716 if (data->pxs_int == state)
717 return -EINVAL;
718
719 ret = regmap_field_write(data->reg_int_pxs, state);
720 if (ret)
721 return ret;
722 data->pxs_int = state;
723 apds9960_set_power_state(data, state);
724 break;
725 case IIO_INTENSITY:
726 if (data->als_int == state)
727 return -EINVAL;
728
729 ret = regmap_field_write(data->reg_int_als, state);
730 if (ret)
731 return ret;
732 data->als_int = state;
733 apds9960_set_power_state(data, state);
734 break;
735 default:
736 return -EINVAL;
737 }
738
739 return 0;
740}
741
742static const struct iio_info apds9960_info = {
743 .attrs = &apds9960_attribute_group,
744 .read_raw = apds9960_read_raw,
745 .write_raw = apds9960_write_raw,
746 .read_event_value = apds9960_read_event,
747 .write_event_value = apds9960_write_event,
748 .read_event_config = apds9960_read_event_config,
749 .write_event_config = apds9960_write_event_config,
750
751};
752
753static inline int apds9660_fifo_is_empty(struct apds9960_data *data)
754{
755 int cnt;
756 int ret;
757
758 ret = regmap_read(data->regmap, APDS9960_REG_GFLVL, &cnt);
759 if (ret)
760 return ret;
761
762 return cnt;
763}
764
765static void apds9960_read_gesture_fifo(struct apds9960_data *data)
766{
767 int ret, cnt = 0;
768
769 mutex_lock(&data->lock);
770 data->gesture_mode_running = 1;
771
772 while (cnt || (cnt = apds9660_fifo_is_empty(data) > 0)) {
773 ret = regmap_bulk_read(data->regmap, APDS9960_REG_GFIFO_BASE,
774 &data->buffer, 4);
775
776 if (ret)
777 goto err_read;
778
779 iio_push_to_buffers(data->indio_dev, data->buffer);
780 cnt--;
781 }
782
783err_read:
784 data->gesture_mode_running = 0;
785 mutex_unlock(&data->lock);
786}
787
788static irqreturn_t apds9960_interrupt_handler(int irq, void *private)
789{
790 struct iio_dev *indio_dev = private;
791 struct apds9960_data *data = iio_priv(indio_dev);
792 int ret, status;
793
794 ret = regmap_read(data->regmap, APDS9960_REG_STATUS, &status);
795 if (ret < 0) {
796 dev_err(&data->client->dev, "irq status reg read failed\n");
797 return IRQ_HANDLED;
798 }
799
800 if ((status & APDS9960_REG_STATUS_ALS_INT) && data->als_int) {
801 iio_push_event(indio_dev,
802 IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
803 IIO_EV_TYPE_THRESH,
804 IIO_EV_DIR_EITHER),
805 iio_get_time_ns(indio_dev));
806 regmap_write(data->regmap, APDS9960_REG_CICLEAR, 1);
807 }
808
809 if ((status & APDS9960_REG_STATUS_PS_INT) && data->pxs_int) {
810 iio_push_event(indio_dev,
811 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
812 IIO_EV_TYPE_THRESH,
813 IIO_EV_DIR_EITHER),
814 iio_get_time_ns(indio_dev));
815 regmap_write(data->regmap, APDS9960_REG_PICLEAR, 1);
816 }
817
818 if (status & APDS9960_REG_STATUS_GINT)
819 apds9960_read_gesture_fifo(data);
820
821 return IRQ_HANDLED;
822}
823
824static int apds9960_set_powermode(struct apds9960_data *data, bool state)
825{
826 return regmap_update_bits(data->regmap, APDS9960_REG_ENABLE, 1, state);
827}
828
829static int apds9960_buffer_postenable(struct iio_dev *indio_dev)
830{
831 struct apds9960_data *data = iio_priv(indio_dev);
832 int ret;
833
834 ret = regmap_field_write(data->reg_int_ges, 1);
835 if (ret)
836 return ret;
837
838 ret = regmap_field_write(data->reg_enable_ges, 1);
839 if (ret)
840 return ret;
841
842 pm_runtime_get_sync(&data->client->dev);
843
844 return 0;
845}
846
847static int apds9960_buffer_predisable(struct iio_dev *indio_dev)
848{
849 struct apds9960_data *data = iio_priv(indio_dev);
850 int ret;
851
852 ret = regmap_field_write(data->reg_enable_ges, 0);
853 if (ret)
854 return ret;
855
856 ret = regmap_field_write(data->reg_int_ges, 0);
857 if (ret)
858 return ret;
859
860 pm_runtime_put_autosuspend(&data->client->dev);
861
862 return 0;
863}
864
865static const struct iio_buffer_setup_ops apds9960_buffer_setup_ops = {
866 .postenable = apds9960_buffer_postenable,
867 .predisable = apds9960_buffer_predisable,
868};
869
870static int apds9960_regfield_init(struct apds9960_data *data)
871{
872 struct device *dev = &data->client->dev;
873 struct regmap *regmap = data->regmap;
874
875 data->reg_int_als = devm_regmap_field_alloc(dev, regmap,
876 apds9960_reg_field_int_als);
877 if (IS_ERR(data->reg_int_als)) {
878 dev_err(dev, "INT ALS reg field init failed\n");
879 return PTR_ERR(data->reg_int_als);
880 }
881
882 data->reg_int_ges = devm_regmap_field_alloc(dev, regmap,
883 apds9960_reg_field_int_ges);
884 if (IS_ERR(data->reg_int_ges)) {
885 dev_err(dev, "INT gesture reg field init failed\n");
886 return PTR_ERR(data->reg_int_ges);
887 }
888
889 data->reg_int_pxs = devm_regmap_field_alloc(dev, regmap,
890 apds9960_reg_field_int_pxs);
891 if (IS_ERR(data->reg_int_pxs)) {
892 dev_err(dev, "INT pxs reg field init failed\n");
893 return PTR_ERR(data->reg_int_pxs);
894 }
895
896 data->reg_enable_als = devm_regmap_field_alloc(dev, regmap,
897 apds9960_reg_field_enable_als);
898 if (IS_ERR(data->reg_enable_als)) {
899 dev_err(dev, "Enable ALS reg field init failed\n");
900 return PTR_ERR(data->reg_enable_als);
901 }
902
903 data->reg_enable_ges = devm_regmap_field_alloc(dev, regmap,
904 apds9960_reg_field_enable_ges);
905 if (IS_ERR(data->reg_enable_ges)) {
906 dev_err(dev, "Enable gesture reg field init failed\n");
907 return PTR_ERR(data->reg_enable_ges);
908 }
909
910 data->reg_enable_pxs = devm_regmap_field_alloc(dev, regmap,
911 apds9960_reg_field_enable_pxs);
912 if (IS_ERR(data->reg_enable_pxs)) {
913 dev_err(dev, "Enable PXS reg field init failed\n");
914 return PTR_ERR(data->reg_enable_pxs);
915 }
916
917 return 0;
918}
919
920static int apds9960_chip_init(struct apds9960_data *data)
921{
922 int ret;
923
924 /* Default IT for ALS of 28 ms */
925 ret = apds9960_set_it_time(data, 28000);
926 if (ret)
927 return ret;
928
929 /* Ensure gesture interrupt is OFF */
930 ret = regmap_field_write(data->reg_int_ges, 0);
931 if (ret)
932 return ret;
933
934 /* Disable gesture sensor, since polling is useless from user-space */
935 ret = regmap_field_write(data->reg_enable_ges, 0);
936 if (ret)
937 return ret;
938
939 /* Ensure proximity interrupt is OFF */
940 ret = regmap_field_write(data->reg_int_pxs, 0);
941 if (ret)
942 return ret;
943
944 /* Enable proximity sensor for polling */
945 ret = regmap_field_write(data->reg_enable_pxs, 1);
946 if (ret)
947 return ret;
948
949 /* Ensure ALS interrupt is OFF */
950 ret = regmap_field_write(data->reg_int_als, 0);
951 if (ret)
952 return ret;
953
954 /* Enable ALS sensor for polling */
955 ret = regmap_field_write(data->reg_enable_als, 1);
956 if (ret)
957 return ret;
958 /*
959 * When enabled trigger an interrupt after 3 readings
960 * outside threshold for ALS + PXS
961 */
962 ret = regmap_write(data->regmap, APDS9960_REG_PERS,
963 APDS9960_DEFAULT_PERS);
964 if (ret)
965 return ret;
966
967 /*
968 * Wait for 4 event outside gesture threshold to prevent interrupt
969 * flooding.
970 */
971 ret = regmap_update_bits(data->regmap, APDS9960_REG_GCONF_1,
972 APDS9960_REG_GCONF_1_GFIFO_THRES_MASK,
973 BIT(0) << APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT);
974 if (ret)
975 return ret;
976
977 /* Default ENTER and EXIT thresholds for the GESTURE engine. */
978 ret = regmap_write(data->regmap, APDS9960_REG_GPENTH,
979 APDS9960_DEFAULT_GPENTH);
980 if (ret)
981 return ret;
982
983 ret = regmap_write(data->regmap, APDS9960_REG_GEXTH,
984 APDS9960_DEFAULT_GEXTH);
985 if (ret)
986 return ret;
987
988 return apds9960_set_powermode(data, 1);
989}
990
991static int apds9960_probe(struct i2c_client *client)
992{
993 struct apds9960_data *data;
994 struct iio_dev *indio_dev;
995 int ret;
996
997 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
998 if (!indio_dev)
999 return -ENOMEM;
1000
1001 indio_dev->info = &apds9960_info;
1002 indio_dev->name = APDS9960_DRV_NAME;
1003 indio_dev->channels = apds9960_channels;
1004 indio_dev->num_channels = ARRAY_SIZE(apds9960_channels);
1005 indio_dev->available_scan_masks = apds9960_scan_masks;
1006 indio_dev->modes = INDIO_DIRECT_MODE;
1007
1008 ret = devm_iio_kfifo_buffer_setup(&client->dev, indio_dev,
1009 &apds9960_buffer_setup_ops);
1010 if (ret)
1011 return ret;
1012
1013 data = iio_priv(indio_dev);
1014 i2c_set_clientdata(client, indio_dev);
1015
1016 data->regmap = devm_regmap_init_i2c(client, &apds9960_regmap_config);
1017 if (IS_ERR(data->regmap)) {
1018 dev_err(&client->dev, "regmap initialization failed.\n");
1019 return PTR_ERR(data->regmap);
1020 }
1021
1022 data->client = client;
1023 data->indio_dev = indio_dev;
1024 mutex_init(&data->lock);
1025
1026 ret = pm_runtime_set_active(&client->dev);
1027 if (ret)
1028 goto error_power_down;
1029
1030 pm_runtime_enable(&client->dev);
1031 pm_runtime_set_autosuspend_delay(&client->dev, 5000);
1032 pm_runtime_use_autosuspend(&client->dev);
1033
1034 apds9960_set_power_state(data, true);
1035
1036 ret = apds9960_regfield_init(data);
1037 if (ret)
1038 goto error_power_down;
1039
1040 ret = apds9960_chip_init(data);
1041 if (ret)
1042 goto error_power_down;
1043
1044 if (client->irq <= 0) {
1045 dev_err(&client->dev, "no valid irq defined\n");
1046 ret = -EINVAL;
1047 goto error_power_down;
1048 }
1049 ret = devm_request_threaded_irq(&client->dev, client->irq,
1050 NULL, apds9960_interrupt_handler,
1051 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1052 "apds9960_event",
1053 indio_dev);
1054 if (ret) {
1055 dev_err(&client->dev, "request irq (%d) failed\n", client->irq);
1056 goto error_power_down;
1057 }
1058
1059 ret = iio_device_register(indio_dev);
1060 if (ret)
1061 goto error_power_down;
1062
1063 apds9960_set_power_state(data, false);
1064
1065 return 0;
1066
1067error_power_down:
1068 apds9960_set_power_state(data, false);
1069
1070 return ret;
1071}
1072
1073static void apds9960_remove(struct i2c_client *client)
1074{
1075 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1076 struct apds9960_data *data = iio_priv(indio_dev);
1077
1078 iio_device_unregister(indio_dev);
1079 pm_runtime_disable(&client->dev);
1080 pm_runtime_set_suspended(&client->dev);
1081 apds9960_set_powermode(data, 0);
1082}
1083
1084#ifdef CONFIG_PM
1085static int apds9960_runtime_suspend(struct device *dev)
1086{
1087 struct apds9960_data *data =
1088 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
1089
1090 return apds9960_set_powermode(data, 0);
1091}
1092
1093static int apds9960_runtime_resume(struct device *dev)
1094{
1095 struct apds9960_data *data =
1096 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
1097
1098 return apds9960_set_powermode(data, 1);
1099}
1100#endif
1101
1102static const struct dev_pm_ops apds9960_pm_ops = {
1103 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1104 pm_runtime_force_resume)
1105 SET_RUNTIME_PM_OPS(apds9960_runtime_suspend,
1106 apds9960_runtime_resume, NULL)
1107};
1108
1109static const struct i2c_device_id apds9960_id[] = {
1110 { "apds9960", 0 },
1111 {}
1112};
1113MODULE_DEVICE_TABLE(i2c, apds9960_id);
1114
1115static const struct acpi_device_id apds9960_acpi_match[] = {
1116 { "MSHW0184" },
1117 { }
1118};
1119MODULE_DEVICE_TABLE(acpi, apds9960_acpi_match);
1120
1121static const struct of_device_id apds9960_of_match[] = {
1122 { .compatible = "avago,apds9960" },
1123 { }
1124};
1125MODULE_DEVICE_TABLE(of, apds9960_of_match);
1126
1127static struct i2c_driver apds9960_driver = {
1128 .driver = {
1129 .name = APDS9960_DRV_NAME,
1130 .of_match_table = apds9960_of_match,
1131 .pm = &apds9960_pm_ops,
1132 .acpi_match_table = apds9960_acpi_match,
1133 },
1134 .probe = apds9960_probe,
1135 .remove = apds9960_remove,
1136 .id_table = apds9960_id,
1137};
1138module_i2c_driver(apds9960_driver);
1139
1140MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
1141MODULE_DESCRIPTION("APDS9960 Gesture/RGB/ALS/Proximity sensor");
1142MODULE_LICENSE("GPL");