?  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 / vcnl4000.c
blobfff4b36b8b58dc04cc197b52a846d9737a95648a
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * vcnl4000.c - Support for Vishay VCNL4000/4010/4020/4040/4200 combined ambient
4 * light and proximity sensor
5 *
6 * Copyright 2012 Peter Meerwald <pmeerw@pmeerw.net>
7 * Copyright 2019 Pursim SPC
8 * Copyright 2020 Mathieu Othacehe <m.othacehe@gmail.com>
9 *
10 * IIO driver for:
11 * VCNL4000/10/20 (7-bit I2C slave address 0x13)
12 * VCNL4040 (7-bit I2C slave address 0x60)
13 * VCNL4200 (7-bit I2C slave address 0x51)
14 *
15 * TODO:
16 * allow to adjust IR current
17 * interrupts (VCNL4040, VCNL4200)
18 */
19
20 #include <linux/module.h>
21 #include <linux/i2c.h>
22 #include <linux/err.h>
23 #include <linux/delay.h>
24 #include <linux/pm_runtime.h>
25 #include <linux/interrupt.h>
26
27 #include <linux/iio/buffer.h>
28 #include <linux/iio/events.h>
29 #include <linux/iio/iio.h>
30 #include <linux/iio/sysfs.h>
31 #include <linux/iio/trigger.h>
32 #include <linux/iio/trigger_consumer.h>
33 #include <linux/iio/triggered_buffer.h>
34
35 #define VCNL4000_DRV_NAME "vcnl4000"
36 #define VCNL4000_PROD_ID 0x01
37 #define VCNL4010_PROD_ID 0x02 /* for VCNL4020, VCNL4010 */
38 #define VCNL4040_PROD_ID 0x86
39 #define VCNL4200_PROD_ID 0x58
40
41 #define VCNL4000_COMMAND 0x80 /* Command register */
42 #define VCNL4000_PROD_REV 0x81 /* Product ID and Revision ID */
43 #define VCNL4010_PROX_RATE 0x82 /* Proximity rate */
44 #define VCNL4000_LED_CURRENT 0x83 /* IR LED current for proximity mode */
45 #define VCNL4000_AL_PARAM 0x84 /* Ambient light parameter register */
46 #define VCNL4010_ALS_PARAM 0x84 /* ALS rate */
47 #define VCNL4000_AL_RESULT_HI 0x85 /* Ambient light result register, MSB */
48 #define VCNL4000_AL_RESULT_LO 0x86 /* Ambient light result register, LSB */
49 #define VCNL4000_PS_RESULT_HI 0x87 /* Proximity result register, MSB */
50 #define VCNL4000_PS_RESULT_LO 0x88 /* Proximity result register, LSB */
51 #define VCNL4000_PS_MEAS_FREQ 0x89 /* Proximity test signal frequency */
52 #define VCNL4010_INT_CTRL 0x89 /* Interrupt control */
53 #define VCNL4000_PS_MOD_ADJ 0x8a /* Proximity modulator timing adjustment */
54 #define VCNL4010_LOW_THR_HI 0x8a /* Low threshold, MSB */
55 #define VCNL4010_LOW_THR_LO 0x8b /* Low threshold, LSB */
56 #define VCNL4010_HIGH_THR_HI 0x8c /* High threshold, MSB */
57 #define VCNL4010_HIGH_THR_LO 0x8d /* High threshold, LSB */
58 #define VCNL4010_ISR 0x8e /* Interrupt status */
59
60 #define VCNL4200_AL_CONF 0x00 /* Ambient light configuration */
61 #define VCNL4200_PS_CONF1 0x03 /* Proximity configuration */
62 #define VCNL4200_PS_DATA 0x08 /* Proximity data */
63 #define VCNL4200_AL_DATA 0x09 /* Ambient light data */
64 #define VCNL4200_DEV_ID 0x0e /* Device ID, slave address and version */
65
66 #define VCNL4040_DEV_ID 0x0c /* Device ID and version */
67
68 /* Bit masks for COMMAND register */
69 #define VCNL4000_AL_RDY BIT(6) /* ALS data ready? */
70 #define VCNL4000_PS_RDY BIT(5) /* proximity data ready? */
71 #define VCNL4000_AL_OD BIT(4) /* start on-demand ALS measurement */
72 #define VCNL4000_PS_OD BIT(3) /* start on-demand proximity measurement */
73 #define VCNL4000_ALS_EN BIT(2) /* start ALS measurement */
74 #define VCNL4000_PROX_EN BIT(1) /* start proximity measurement */
75 #define VCNL4000_SELF_TIMED_EN BIT(0) /* start self-timed measurement */
76
77 /* Bit masks for interrupt registers. */
78 #define VCNL4010_INT_THR_SEL BIT(0) /* Select threshold interrupt source */
79 #define VCNL4010_INT_THR_EN BIT(1) /* Threshold interrupt type */
80 #define VCNL4010_INT_ALS_EN BIT(2) /* Enable on ALS data ready */
81 #define VCNL4010_INT_PROX_EN BIT(3) /* Enable on proximity data ready */
82
83 #define VCNL4010_INT_THR_HIGH 0 /* High threshold exceeded */
84 #define VCNL4010_INT_THR_LOW 1 /* Low threshold exceeded */
85 #define VCNL4010_INT_ALS 2 /* ALS data ready */
86 #define VCNL4010_INT_PROXIMITY 3 /* Proximity data ready */
87
88 #define VCNL4010_INT_THR \
89 (BIT(VCNL4010_INT_THR_LOW) | BIT(VCNL4010_INT_THR_HIGH))
90 #define VCNL4010_INT_DRDY \
91 (BIT(VCNL4010_INT_PROXIMITY) | BIT(VCNL4010_INT_ALS))
92
93 static const int vcnl4010_prox_sampling_frequency[][2] = {
94 {1, 950000},
95 {3, 906250},
96 {7, 812500},
97 {16, 625000},
98 {31, 250000},
99 {62, 500000},
100 {125, 0},
101 {250, 0},
102 };
103
104 #define VCNL4000_SLEEP_DELAY_MS 2000 /* before we enter pm_runtime_suspend */
105
106 enum vcnl4000_device_ids {
107 VCNL4000,
108 VCNL4010,
109 VCNL4040,
110 VCNL4200,
111 };
112
113 struct vcnl4200_channel {
114 u8 reg;
115 ktime_t last_measurement;
116 ktime_t sampling_rate;
117 struct mutex lock;
118 };
119
120 struct vcnl4000_data {
121 struct i2c_client *client;
122 enum vcnl4000_device_ids id;
123 int rev;
124 int al_scale;
125 const struct vcnl4000_chip_spec *chip_spec;
126 struct mutex vcnl4000_lock;
127 struct vcnl4200_channel vcnl4200_al;
128 struct vcnl4200_channel vcnl4200_ps;
129 uint32_t near_level;
130 };
131
132 struct vcnl4000_chip_spec {
133 const char *prod;
134 struct iio_chan_spec const *channels;
135 const int num_channels;
136 const struct iio_info *info;
137 bool irq_support;
138 int (*init)(struct vcnl4000_data *data);
139 int (*measure_light)(struct vcnl4000_data *data, int *val);
140 int (*measure_proximity)(struct vcnl4000_data *data, int *val);
141 int (*set_power_state)(struct vcnl4000_data *data, bool on);
142 };
143
144 static const struct i2c_device_id vcnl4000_id[] = {
145 { "vcnl4000", VCNL4000 },
146 { "vcnl4010", VCNL4010 },
147 { "vcnl4020", VCNL4010 },
148 { "vcnl4040", VCNL4040 },
149 { "vcnl4200", VCNL4200 },
150 { }
151 };
152 MODULE_DEVICE_TABLE(i2c, vcnl4000_id);
153
154 static int vcnl4000_set_power_state(struct vcnl4000_data *data, bool on)
155 {
156 /* no suspend op */
157 return 0;
158 }
159
160 static int vcnl4000_init(struct vcnl4000_data *data)
161 {
162 int ret, prod_id;
163
164 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_PROD_REV);
165 if (ret < 0)
166 return ret;
167
168 prod_id = ret >> 4;
169 switch (prod_id) {
170 case VCNL4000_PROD_ID:
171 if (data->id != VCNL4000)
172 dev_warn(&data->client->dev,
173 "wrong device id, use vcnl4000");
174 break;
175 case VCNL4010_PROD_ID:
176 if (data->id != VCNL4010)
177 dev_warn(&data->client->dev,
178 "wrong device id, use vcnl4010/4020");
179 break;
180 default:
181 return -ENODEV;
182 }
183
184 data->rev = ret & 0xf;
185 data->al_scale = 250000;
186 mutex_init(&data->vcnl4000_lock);
187
188 return data->chip_spec->set_power_state(data, true);
189 };
190
191 static int vcnl4200_set_power_state(struct vcnl4000_data *data, bool on)
192 {
193 u16 val = on ? 0 /* power on */ : 1 /* shut down */;
194 int ret;
195
196 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF, val);
197 if (ret < 0)
198 return ret;
199
200 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, val);
201 if (ret < 0)
202 return ret;
203
204 if (on) {
205 /* Wait at least one integration cycle before fetching data */
206 data->vcnl4200_al.last_measurement = ktime_get();
207 data->vcnl4200_ps.last_measurement = ktime_get();
208 }
209
210 return 0;
211 }
212
213 static int vcnl4200_init(struct vcnl4000_data *data)
214 {
215 int ret, id;
216
217 ret = i2c_smbus_read_word_data(data->client, VCNL4200_DEV_ID);
218 if (ret < 0)
219 return ret;
220
221 id = ret & 0xff;
222
223 if (id != VCNL4200_PROD_ID) {
224 ret = i2c_smbus_read_word_data(data->client, VCNL4040_DEV_ID);
225 if (ret < 0)
226 return ret;
227
228 id = ret & 0xff;
229
230 if (id != VCNL4040_PROD_ID)
231 return -ENODEV;
232 }
233
234 dev_dbg(&data->client->dev, "device id 0x%x", id);
235
236 data->rev = (ret >> 8) & 0xf;
237
238 data->vcnl4200_al.reg = VCNL4200_AL_DATA;
239 data->vcnl4200_ps.reg = VCNL4200_PS_DATA;
240 switch (id) {
241 case VCNL4200_PROD_ID:
242 /* Default wait time is 50ms, add 20% tolerance. */
243 data->vcnl4200_al.sampling_rate = ktime_set(0, 60000 * 1000);
244 /* Default wait time is 4.8ms, add 20% tolerance. */
245 data->vcnl4200_ps.sampling_rate = ktime_set(0, 5760 * 1000);
246 data->al_scale = 24000;
247 break;
248 case VCNL4040_PROD_ID:
249 /* Default wait time is 80ms, add 20% tolerance. */
250 data->vcnl4200_al.sampling_rate = ktime_set(0, 96000 * 1000);
251 /* Default wait time is 5ms, add 20% tolerance. */
252 data->vcnl4200_ps.sampling_rate = ktime_set(0, 6000 * 1000);
253 data->al_scale = 120000;
254 break;
255 }
256 mutex_init(&data->vcnl4200_al.lock);
257 mutex_init(&data->vcnl4200_ps.lock);
258
259 ret = data->chip_spec->set_power_state(data, true);
260 if (ret < 0)
261 return ret;
262
263 return 0;
264 };
265
266 static int vcnl4000_read_data(struct vcnl4000_data *data, u8 data_reg, int *val)
267 {
268 s32 ret;
269
270 ret = i2c_smbus_read_word_swapped(data->client, data_reg);
271 if (ret < 0)
272 return ret;
273
274 *val = ret;
275 return 0;
276 }
277
278 static int vcnl4000_write_data(struct vcnl4000_data *data, u8 data_reg, int val)
279 {
280 if (val > U16_MAX)
281 return -ERANGE;
282
283 return i2c_smbus_write_word_swapped(data->client, data_reg, val);
284 }
285
286
287 static int vcnl4000_measure(struct vcnl4000_data *data, u8 req_mask,
288 u8 rdy_mask, u8 data_reg, int *val)
289 {
290 int tries = 20;
291 int ret;
292
293 mutex_lock(&data->vcnl4000_lock);
294
295 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND,
296 req_mask);
297 if (ret < 0)
298 goto fail;
299
300 /* wait for data to become ready */
301 while (tries--) {
302 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND);
303 if (ret < 0)
304 goto fail;
305 if (ret & rdy_mask)
306 break;
307 msleep(20); /* measurement takes up to 100 ms */
308 }
309
310 if (tries < 0) {
311 dev_err(&data->client->dev,
312 "vcnl4000_measure() failed, data not ready\n");
313 ret = -EIO;
314 goto fail;
315 }
316
317 ret = vcnl4000_read_data(data, data_reg, val);
318 if (ret < 0)
319 goto fail;
320
321 mutex_unlock(&data->vcnl4000_lock);
322
323 return 0;
324
325 fail:
326 mutex_unlock(&data->vcnl4000_lock);
327 return ret;
328 }
329
330 static int vcnl4200_measure(struct vcnl4000_data *data,
331 struct vcnl4200_channel *chan, int *val)
332 {
333 int ret;
334 s64 delta;
335 ktime_t next_measurement;
336
337 mutex_lock(&chan->lock);
338
339 next_measurement = ktime_add(chan->last_measurement,
340 chan->sampling_rate);
341 delta = ktime_us_delta(next_measurement, ktime_get());
342 if (delta > 0)
343 usleep_range(delta, delta + 500);
344 chan->last_measurement = ktime_get();
345
346 mutex_unlock(&chan->lock);
347
348 ret = i2c_smbus_read_word_data(data->client, chan->reg);
349 if (ret < 0)
350 return ret;
351
352 *val = ret;
353
354 return 0;
355 }
356
357 static int vcnl4000_measure_light(struct vcnl4000_data *data, int *val)
358 {
359 return vcnl4000_measure(data,
360 VCNL4000_AL_OD, VCNL4000_AL_RDY,
361 VCNL4000_AL_RESULT_HI, val);
362 }
363
364 static int vcnl4200_measure_light(struct vcnl4000_data *data, int *val)
365 {
366 return vcnl4200_measure(data, &data->vcnl4200_al, val);
367 }
368
369 static int vcnl4000_measure_proximity(struct vcnl4000_data *data, int *val)
370 {
371 return vcnl4000_measure(data,
372 VCNL4000_PS_OD, VCNL4000_PS_RDY,
373 VCNL4000_PS_RESULT_HI, val);
374 }
375
376 static int vcnl4200_measure_proximity(struct vcnl4000_data *data, int *val)
377 {
378 return vcnl4200_measure(data, &data->vcnl4200_ps, val);
379 }
380
381 static int vcnl4010_read_proxy_samp_freq(struct vcnl4000_data *data, int *val,
382 int *val2)
383 {
384 int ret;
385
386 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_PROX_RATE);
387 if (ret < 0)
388 return ret;
389
390 if (ret >= ARRAY_SIZE(vcnl4010_prox_sampling_frequency))
391 return -EINVAL;
392
393 *val = vcnl4010_prox_sampling_frequency[ret][0];
394 *val2 = vcnl4010_prox_sampling_frequency[ret][1];
395
396 return 0;
397 }
398
399 static bool vcnl4010_is_in_periodic_mode(struct vcnl4000_data *data)
400 {
401 int ret;
402
403 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND);
404 if (ret < 0)
405 return false;
406
407 return !!(ret & VCNL4000_SELF_TIMED_EN);
408 }
409
410 static int vcnl4000_set_pm_runtime_state(struct vcnl4000_data *data, bool on)
411 {
412 struct device *dev = &data->client->dev;
413 int ret;
414
415 if (on) {
416 ret = pm_runtime_get_sync(dev);
417 if (ret < 0)
418 pm_runtime_put_noidle(dev);
419 } else {
420 pm_runtime_mark_last_busy(dev);
421 ret = pm_runtime_put_autosuspend(dev);
422 }
423
424 return ret;
425 }
426
427 static int vcnl4000_read_raw(struct iio_dev *indio_dev,
428 struct iio_chan_spec const *chan,
429 int *val, int *val2, long mask)
430 {
431 int ret;
432 struct vcnl4000_data *data = iio_priv(indio_dev);
433
434 switch (mask) {
435 case IIO_CHAN_INFO_RAW:
436 ret = vcnl4000_set_pm_runtime_state(data, true);
437 if (ret < 0)
438 return ret;
439
440 switch (chan->type) {
441 case IIO_LIGHT:
442 ret = data->chip_spec->measure_light(data, val);
443 if (!ret)
444 ret = IIO_VAL_INT;
445 break;
446 case IIO_PROXIMITY:
447 ret = data->chip_spec->measure_proximity(data, val);
448 if (!ret)
449 ret = IIO_VAL_INT;
450 break;
451 default:
452 ret = -EINVAL;
453 }
454 vcnl4000_set_pm_runtime_state(data, false);
455 return ret;
456 case IIO_CHAN_INFO_SCALE:
457 if (chan->type != IIO_LIGHT)
458 return -EINVAL;
459
460 *val = 0;
461 *val2 = data->al_scale;
462 return IIO_VAL_INT_PLUS_MICRO;
463 default:
464 return -EINVAL;
465 }
466 }
467
468 static int vcnl4010_read_raw(struct iio_dev *indio_dev,
469 struct iio_chan_spec const *chan,
470 int *val, int *val2, long mask)
471 {
472 int ret;
473 struct vcnl4000_data *data = iio_priv(indio_dev);
474
475 switch (mask) {
476 case IIO_CHAN_INFO_RAW:
477 case IIO_CHAN_INFO_SCALE:
478 ret = iio_device_claim_direct_mode(indio_dev);
479 if (ret)
480 return ret;
481
482 /* Protect against event capture. */
483 if (vcnl4010_is_in_periodic_mode(data)) {
484 ret = -EBUSY;
485 } else {
486 ret = vcnl4000_read_raw(indio_dev, chan, val, val2,
487 mask);
488 }
489
490 iio_device_release_direct_mode(indio_dev);
491 return ret;
492 case IIO_CHAN_INFO_SAMP_FREQ:
493 switch (chan->type) {
494 case IIO_PROXIMITY:
495 ret = vcnl4010_read_proxy_samp_freq(data, val, val2);
496 if (ret < 0)
497 return ret;
498 return IIO_VAL_INT_PLUS_MICRO;
499 default:
500 return -EINVAL;
501 }
502 default:
503 return -EINVAL;
504 }
505 }
506
507 static int vcnl4010_read_avail(struct iio_dev *indio_dev,
508 struct iio_chan_spec const *chan,
509 const int **vals, int *type, int *length,
510 long mask)
511 {
512 switch (mask) {
513 case IIO_CHAN_INFO_SAMP_FREQ:
514 *vals = (int *)vcnl4010_prox_sampling_frequency;
515 *type = IIO_VAL_INT_PLUS_MICRO;
516 *length = 2 * ARRAY_SIZE(vcnl4010_prox_sampling_frequency);
517 return IIO_AVAIL_LIST;
518 default:
519 return -EINVAL;
520 }
521 }
522
523 static int vcnl4010_write_proxy_samp_freq(struct vcnl4000_data *data, int val,
524 int val2)
525 {
526 unsigned int i;
527 int index = -1;
528
529 for (i = 0; i < ARRAY_SIZE(vcnl4010_prox_sampling_frequency); i++) {
530 if (val == vcnl4010_prox_sampling_frequency[i][0] &&
531 val2 == vcnl4010_prox_sampling_frequency[i][1]) {
532 index = i;
533 break;
534 }
535 }
536
537 if (index < 0)
538 return -EINVAL;
539
540 return i2c_smbus_write_byte_data(data->client, VCNL4010_PROX_RATE,
541 index);
542 }
543
544 static int vcnl4010_write_raw(struct iio_dev *indio_dev,
545 struct iio_chan_spec const *chan,
546 int val, int val2, long mask)
547 {
548 int ret;
549 struct vcnl4000_data *data = iio_priv(indio_dev);
550
551 ret = iio_device_claim_direct_mode(indio_dev);
552 if (ret)
553 return ret;
554
555 /* Protect against event capture. */
556 if (vcnl4010_is_in_periodic_mode(data)) {
557 ret = -EBUSY;
558 goto end;
559 }
560
561 switch (mask) {
562 case IIO_CHAN_INFO_SAMP_FREQ:
563 switch (chan->type) {
564 case IIO_PROXIMITY:
565 ret = vcnl4010_write_proxy_samp_freq(data, val, val2);
566 goto end;
567 default:
568 ret = -EINVAL;
569 goto end;
570 }
571 default:
572 ret = -EINVAL;
573 goto end;
574 }
575
576 end:
577 iio_device_release_direct_mode(indio_dev);
578 return ret;
579 }
580
581 static int vcnl4010_read_event(struct iio_dev *indio_dev,
582 const struct iio_chan_spec *chan,
583 enum iio_event_type type,
584 enum iio_event_direction dir,
585 enum iio_event_info info,
586 int *val, int *val2)
587 {
588 int ret;
589 struct vcnl4000_data *data = iio_priv(indio_dev);
590
591 switch (info) {
592 case IIO_EV_INFO_VALUE:
593 switch (dir) {
594 case IIO_EV_DIR_RISING:
595 ret = vcnl4000_read_data(data, VCNL4010_HIGH_THR_HI,
596 val);
597 if (ret < 0)
598 return ret;
599 return IIO_VAL_INT;
600 case IIO_EV_DIR_FALLING:
601 ret = vcnl4000_read_data(data, VCNL4010_LOW_THR_HI,
602 val);
603 if (ret < 0)
604 return ret;
605 return IIO_VAL_INT;
606 default:
607 return -EINVAL;
608 }
609 default:
610 return -EINVAL;
611 }
612 }
613
614 static int vcnl4010_write_event(struct iio_dev *indio_dev,
615 const struct iio_chan_spec *chan,
616 enum iio_event_type type,
617 enum iio_event_direction dir,
618 enum iio_event_info info,
619 int val, int val2)
620 {
621 int ret;
622 struct vcnl4000_data *data = iio_priv(indio_dev);
623
624 switch (info) {
625 case IIO_EV_INFO_VALUE:
626 switch (dir) {
627 case IIO_EV_DIR_RISING:
628 ret = vcnl4000_write_data(data, VCNL4010_HIGH_THR_HI,
629 val);
630 if (ret < 0)
631 return ret;
632 return IIO_VAL_INT;
633 case IIO_EV_DIR_FALLING:
634 ret = vcnl4000_write_data(data, VCNL4010_LOW_THR_HI,
635 val);
636 if (ret < 0)
637 return ret;
638 return IIO_VAL_INT;
639 default:
640 return -EINVAL;
641 }
642 default:
643 return -EINVAL;
644 }
645 }
646
647 static bool vcnl4010_is_thr_enabled(struct vcnl4000_data *data)
648 {
649 int ret;
650
651 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_INT_CTRL);
652 if (ret < 0)
653 return false;
654
655 return !!(ret & VCNL4010_INT_THR_EN);
656 }
657
658 static int vcnl4010_read_event_config(struct iio_dev *indio_dev,
659 const struct iio_chan_spec *chan,
660 enum iio_event_type type,
661 enum iio_event_direction dir)
662 {
663 struct vcnl4000_data *data = iio_priv(indio_dev);
664
665 switch (chan->type) {
666 case IIO_PROXIMITY:
667 return vcnl4010_is_thr_enabled(data);
668 default:
669 return -EINVAL;
670 }
671 }
672
673 static int vcnl4010_config_threshold(struct iio_dev *indio_dev, bool state)
674 {
675 struct vcnl4000_data *data = iio_priv(indio_dev);
676 int ret;
677 int icr;
678 int command;
679
680 if (state) {
681 ret = iio_device_claim_direct_mode(indio_dev);
682 if (ret)
683 return ret;
684
685 /* Enable periodic measurement of proximity data. */
686 command = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN;
687
688 /*
689 * Enable interrupts on threshold, for proximity data by
690 * default.
691 */
692 icr = VCNL4010_INT_THR_EN;
693 } else {
694 if (!vcnl4010_is_thr_enabled(data))
695 return 0;
696
697 command = 0;
698 icr = 0;
699 }
700
701 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND,
702 command);
703 if (ret < 0)
704 goto end;
705
706 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, icr);
707
708 end:
709 if (state)
710 iio_device_release_direct_mode(indio_dev);
711
712 return ret;
713 }
714
715 static int vcnl4010_write_event_config(struct iio_dev *indio_dev,
716 const struct iio_chan_spec *chan,
717 enum iio_event_type type,
718 enum iio_event_direction dir,
719 int state)
720 {
721 switch (chan->type) {
722 case IIO_PROXIMITY:
723 return vcnl4010_config_threshold(indio_dev, state);
724 default:
725 return -EINVAL;
726 }
727 }
728
729 static ssize_t vcnl4000_read_near_level(struct iio_dev *indio_dev,
730 uintptr_t priv,
731 const struct iio_chan_spec *chan,
732 char *buf)
733 {
734 struct vcnl4000_data *data = iio_priv(indio_dev);
735
736 return sprintf(buf, "%u\n", data->near_level);
737 }
738
739 static const struct iio_chan_spec_ext_info vcnl4000_ext_info[] = {
740 {
741 .name = "nearlevel",
742 .shared = IIO_SEPARATE,
743 .read = vcnl4000_read_near_level,
744 },
745 { /* sentinel */ }
746 };
747
748 static const struct iio_event_spec vcnl4000_event_spec[] = {
749 {
750 .type = IIO_EV_TYPE_THRESH,
751 .dir = IIO_EV_DIR_RISING,
752 .mask_separate = BIT(IIO_EV_INFO_VALUE),
753 }, {
754 .type = IIO_EV_TYPE_THRESH,
755 .dir = IIO_EV_DIR_FALLING,
756 .mask_separate = BIT(IIO_EV_INFO_VALUE),
757 }, {
758 .type = IIO_EV_TYPE_THRESH,
759 .dir = IIO_EV_DIR_EITHER,
760 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
761 }
762 };
763
764 static const struct iio_chan_spec vcnl4000_channels[] = {
765 {
766 .type = IIO_LIGHT,
767 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
768 BIT(IIO_CHAN_INFO_SCALE),
769 }, {
770 .type = IIO_PROXIMITY,
771 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
772 .ext_info = vcnl4000_ext_info,
773 }
774 };
775
776 static const struct iio_chan_spec vcnl4010_channels[] = {
777 {
778 .type = IIO_LIGHT,
779 .scan_index = -1,
780 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
781 BIT(IIO_CHAN_INFO_SCALE),
782 }, {
783 .type = IIO_PROXIMITY,
784 .scan_index = 0,
785 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
786 BIT(IIO_CHAN_INFO_SAMP_FREQ),
787 .info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ),
788 .event_spec = vcnl4000_event_spec,
789 .num_event_specs = ARRAY_SIZE(vcnl4000_event_spec),
790 .ext_info = vcnl4000_ext_info,
791 .scan_type = {
792 .sign = 'u',
793 .realbits = 16,
794 .storagebits = 16,
795 .endianness = IIO_CPU,
796 },
797 },
798 IIO_CHAN_SOFT_TIMESTAMP(1),
799 };
800
801 static const struct iio_info vcnl4000_info = {
802 .read_raw = vcnl4000_read_raw,
803 };
804
805 static const struct iio_info vcnl4010_info = {
806 .read_raw = vcnl4010_read_raw,
807 .read_avail = vcnl4010_read_avail,
808 .write_raw = vcnl4010_write_raw,
809 .read_event_value = vcnl4010_read_event,
810 .write_event_value = vcnl4010_write_event,
811 .read_event_config = vcnl4010_read_event_config,
812 .write_event_config = vcnl4010_write_event_config,
813 };
814
815 static const struct vcnl4000_chip_spec vcnl4000_chip_spec_cfg[] = {
816 [VCNL4000] = {
817 .prod = "VCNL4000",
818 .init = vcnl4000_init,
819 .measure_light = vcnl4000_measure_light,
820 .measure_proximity = vcnl4000_measure_proximity,
821 .set_power_state = vcnl4000_set_power_state,
822 .channels = vcnl4000_channels,
823 .num_channels = ARRAY_SIZE(vcnl4000_channels),
824 .info = &vcnl4000_info,
825 .irq_support = false,
826 },
827 [VCNL4010] = {
828 .prod = "VCNL4010/4020",
829 .init = vcnl4000_init,
830 .measure_light = vcnl4000_measure_light,
831 .measure_proximity = vcnl4000_measure_proximity,
832 .set_power_state = vcnl4000_set_power_state,
833 .channels = vcnl4010_channels,
834 .num_channels = ARRAY_SIZE(vcnl4010_channels),
835 .info = &vcnl4010_info,
836 .irq_support = true,
837 },
838 [VCNL4040] = {
839 .prod = "VCNL4040",
840 .init = vcnl4200_init,
841 .measure_light = vcnl4200_measure_light,
842 .measure_proximity = vcnl4200_measure_proximity,
843 .set_power_state = vcnl4200_set_power_state,
844 .channels = vcnl4000_channels,
845 .num_channels = ARRAY_SIZE(vcnl4000_channels),
846 .info = &vcnl4000_info,
847 .irq_support = false,
848 },
849 [VCNL4200] = {
850 .prod = "VCNL4200",
851 .init = vcnl4200_init,
852 .measure_light = vcnl4200_measure_light,
853 .measure_proximity = vcnl4200_measure_proximity,
854 .set_power_state = vcnl4200_set_power_state,
855 .channels = vcnl4000_channels,
856 .num_channels = ARRAY_SIZE(vcnl4000_channels),
857 .info = &vcnl4000_info,
858 .irq_support = false,
859 },
860 };
861
862 static irqreturn_t vcnl4010_irq_thread(int irq, void *p)
863 {
864 struct iio_dev *indio_dev = p;
865 struct vcnl4000_data *data = iio_priv(indio_dev);
866 unsigned long isr;
867 int ret;
868
869 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR);
870 if (ret < 0)
871 goto end;
872
873 isr = ret;
874
875 if (isr & VCNL4010_INT_THR) {
876 if (test_bit(VCNL4010_INT_THR_LOW, &isr)) {
877 iio_push_event(indio_dev,
878 IIO_UNMOD_EVENT_CODE(
879 IIO_PROXIMITY,
880 1,
881 IIO_EV_TYPE_THRESH,
882 IIO_EV_DIR_FALLING),
883 iio_get_time_ns(indio_dev));
884 }
885
886 if (test_bit(VCNL4010_INT_THR_HIGH, &isr)) {
887 iio_push_event(indio_dev,
888 IIO_UNMOD_EVENT_CODE(
889 IIO_PROXIMITY,
890 1,
891 IIO_EV_TYPE_THRESH,
892 IIO_EV_DIR_RISING),
893 iio_get_time_ns(indio_dev));
894 }
895
896 i2c_smbus_write_byte_data(data->client, VCNL4010_ISR,
897 isr & VCNL4010_INT_THR);
898 }
899
900 if (isr & VCNL4010_INT_DRDY && iio_buffer_enabled(indio_dev))
901 iio_trigger_poll_chained(indio_dev->trig);
902
903 end:
904 return IRQ_HANDLED;
905 }
906
907 static irqreturn_t vcnl4010_trigger_handler(int irq, void *p)
908 {
909 struct iio_poll_func *pf = p;
910 struct iio_dev *indio_dev = pf->indio_dev;
911 struct vcnl4000_data *data = iio_priv(indio_dev);
912 const unsigned long *active_scan_mask = indio_dev->active_scan_mask;
913 u16 buffer[8] = {0}; /* 1x16-bit + ts */
914 bool data_read = false;
915 unsigned long isr;
916 int val = 0;
917 int ret;
918
919 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR);
920 if (ret < 0)
921 goto end;
922
923 isr = ret;
924
925 if (test_bit(0, active_scan_mask)) {
926 if (test_bit(VCNL4010_INT_PROXIMITY, &isr)) {
927 ret = vcnl4000_read_data(data,
928 VCNL4000_PS_RESULT_HI,
929 &val);
930 if (ret < 0)
931 goto end;
932
933 buffer[0] = val;
934 data_read = true;
935 }
936 }
937
938 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_ISR,
939 isr & VCNL4010_INT_DRDY);
940 if (ret < 0)
941 goto end;
942
943 if (!data_read)
944 goto end;
945
946 iio_push_to_buffers_with_timestamp(indio_dev, buffer,
947 iio_get_time_ns(indio_dev));
948
949 end:
950 iio_trigger_notify_done(indio_dev->trig);
951 return IRQ_HANDLED;
952 }
953
954 static int vcnl4010_buffer_postenable(struct iio_dev *indio_dev)
955 {
956 struct vcnl4000_data *data = iio_priv(indio_dev);
957 int ret;
958 int cmd;
959
960 /* Do not enable the buffer if we are already capturing events. */
961 if (vcnl4010_is_in_periodic_mode(data))
962 return -EBUSY;
963
964 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL,
965 VCNL4010_INT_PROX_EN);
966 if (ret < 0)
967 return ret;
968
969 cmd = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN;
970 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, cmd);
971 }
972
973 static int vcnl4010_buffer_predisable(struct iio_dev *indio_dev)
974 {
975 struct vcnl4000_data *data = iio_priv(indio_dev);
976 int ret;
977
978 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 0);
979 if (ret < 0)
980 return ret;
981
982 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0);
983 }
984
985 static const struct iio_buffer_setup_ops vcnl4010_buffer_ops = {
986 .postenable = &vcnl4010_buffer_postenable,
987 .predisable = &vcnl4010_buffer_predisable,
988 };
989
990 static const struct iio_trigger_ops vcnl4010_trigger_ops = {
991 .validate_device = iio_trigger_validate_own_device,
992 };
993
994 static int vcnl4010_probe_trigger(struct iio_dev *indio_dev)
995 {
996 struct vcnl4000_data *data = iio_priv(indio_dev);
997 struct i2c_client *client = data->client;
998 struct iio_trigger *trigger;
999
1000 trigger = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
1001 indio_dev->name, indio_dev->id);
1002 if (!trigger)
1003 return -ENOMEM;
1004
1005 trigger->dev.parent = &client->dev;
1006 trigger->ops = &vcnl4010_trigger_ops;
1007 iio_trigger_set_drvdata(trigger, indio_dev);
1008
1009 return devm_iio_trigger_register(&client->dev, trigger);
1010 }
1011
1012 static int vcnl4000_probe(struct i2c_client *client,
1013 const struct i2c_device_id *id)
1014 {
1015 struct vcnl4000_data *data;
1016 struct iio_dev *indio_dev;
1017 int ret;
1018
1019 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1020 if (!indio_dev)
1021 return -ENOMEM;
1022
1023 data = iio_priv(indio_dev);
1024 i2c_set_clientdata(client, indio_dev);
1025 data->client = client;
1026 data->id = id->driver_data;
1027 data->chip_spec = &vcnl4000_chip_spec_cfg[data->id];
1028
1029 ret = data->chip_spec->init(data);
1030 if (ret < 0)
1031 return ret;
1032
1033 dev_dbg(&client->dev, "%s Ambient light/proximity sensor, Rev: %02x\n",
1034 data->chip_spec->prod, data->rev);
1035
1036 if (device_property_read_u32(&client->dev, "proximity-near-level",
1037 &data->near_level))
1038 data->near_level = 0;
1039
1040 indio_dev->info = data->chip_spec->info;
1041 indio_dev->channels = data->chip_spec->channels;
1042 indio_dev->num_channels = data->chip_spec->num_channels;
1043 indio_dev->name = VCNL4000_DRV_NAME;
1044 indio_dev->modes = INDIO_DIRECT_MODE;
1045
1046 if (client->irq && data->chip_spec->irq_support) {
1047 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev,
1048 NULL,
1049 vcnl4010_trigger_handler,
1050 &vcnl4010_buffer_ops);
1051 if (ret < 0) {
1052 dev_err(&client->dev,
1053 "unable to setup iio triggered buffer\n");
1054 return ret;
1055 }
1056
1057 ret = devm_request_threaded_irq(&client->dev, client->irq,
1058 NULL, vcnl4010_irq_thread,
1059 IRQF_TRIGGER_FALLING |
1060 IRQF_ONESHOT,
1061 "vcnl4010_irq",
1062 indio_dev);
1063 if (ret < 0) {
1064 dev_err(&client->dev, "irq request failed\n");
1065 return ret;
1066 }
1067
1068 ret = vcnl4010_probe_trigger(indio_dev);
1069 if (ret < 0)
1070 return ret;
1071 }
1072
1073 ret = pm_runtime_set_active(&client->dev);
1074 if (ret < 0)
1075 goto fail_poweroff;
1076
1077 ret = iio_device_register(indio_dev);
1078 if (ret < 0)
1079 goto fail_poweroff;
1080
1081 pm_runtime_enable(&client->dev);
1082 pm_runtime_set_autosuspend_delay(&client->dev, VCNL4000_SLEEP_DELAY_MS);
1083 pm_runtime_use_autosuspend(&client->dev);
1084
1085 return 0;
1086 fail_poweroff:
1087 data->chip_spec->set_power_state(data, false);
1088 return ret;
1089 }
1090
1091 static const struct of_device_id vcnl_4000_of_match[] = {
1092 {
1093 .compatible = "vishay,vcnl4000",
1094 .data = (void *)VCNL4000,
1095 },
1096 {
1097 .compatible = "vishay,vcnl4010",
1098 .data = (void *)VCNL4010,
1099 },
1100 {
1101 .compatible = "vishay,vcnl4020",
1102 .data = (void *)VCNL4010,
1103 },
1104 {
1105 .compatible = "vishay,vcnl4040",
1106 .data = (void *)VCNL4040,
1107 },
1108 {
1109 .compatible = "vishay,vcnl4200",
1110 .data = (void *)VCNL4200,
1111 },
1112 {},
1113 };
1114 MODULE_DEVICE_TABLE(of, vcnl_4000_of_match);
1115
1116 static int vcnl4000_remove(struct i2c_client *client)
1117 {
1118 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1119 struct vcnl4000_data *data = iio_priv(indio_dev);
1120
1121 pm_runtime_dont_use_autosuspend(&client->dev);
1122 pm_runtime_disable(&client->dev);
1123 iio_device_unregister(indio_dev);
1124 pm_runtime_set_suspended(&client->dev);
1125
1126 return data->chip_spec->set_power_state(data, false);
1127 }
1128
1129 static int __maybe_unused vcnl4000_runtime_suspend(struct device *dev)
1130 {
1131 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1132 struct vcnl4000_data *data = iio_priv(indio_dev);
1133
1134 return data->chip_spec->set_power_state(data, false);
1135 }
1136
1137 static int __maybe_unused vcnl4000_runtime_resume(struct device *dev)
1138 {
1139 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1140 struct vcnl4000_data *data = iio_priv(indio_dev);
1141
1142 return data->chip_spec->set_power_state(data, true);
1143 }
1144
1145 static const struct dev_pm_ops vcnl4000_pm_ops = {
1146 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1147 pm_runtime_force_resume)
1148 SET_RUNTIME_PM_OPS(vcnl4000_runtime_suspend,
1149 vcnl4000_runtime_resume, NULL)
1150 };
1151
1152 static struct i2c_driver vcnl4000_driver = {
1153 .driver = {
1154 .name = VCNL4000_DRV_NAME,
1155 .pm = &vcnl4000_pm_ops,
1156 .of_match_table = vcnl_4000_of_match,
1157 },
1158 .probe = vcnl4000_probe,
1159 .id_table = vcnl4000_id,
1160 .remove = vcnl4000_remove,
1161 };
1162
1163 module_i2c_driver(vcnl4000_driver);
1164
1165 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
1166 MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>");
1167 MODULE_DESCRIPTION("Vishay VCNL4000 proximity/ambient light sensor driver");
1168 MODULE_LICENSE("GPL");
Linux with added FPC-III support