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