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