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