1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * VEML6030, VMEL6035 and VEML7700 Ambient Light Sensors
4 *
5 * Copyright (c) 2019, Rishi Gupta <gupt21@gmail.com>
6 *
7 * VEML6030:
8 * Datasheet: https://www.vishay.com/docs/84366/veml6030.pdf
9 * Appnote-84367: https://www.vishay.com/docs/84367/designingveml6030.pdf
10 *
11 * VEML6035:
12 * Datasheet: https://www.vishay.com/docs/84889/veml6035.pdf
13 * Appnote-84944: https://www.vishay.com/docs/84944/designingveml6035.pdf
14 *
15 * VEML7700:
16 * Datasheet: https://www.vishay.com/docs/84286/veml7700.pdf
17 * Appnote-84323: https://www.vishay.com/docs/84323/designingveml7700.pdf
18 */
19
20#include <linux/bitfield.h>
21#include <linux/module.h>
22#include <linux/i2c.h>
23#include <linux/err.h>
24#include <linux/regmap.h>
25#include <linux/interrupt.h>
26#include <linux/pm_runtime.h>
27#include <linux/units.h>
28#include <linux/regulator/consumer.h>
29#include <linux/iio/iio.h>
30#include <linux/iio/sysfs.h>
31#include <linux/iio/events.h>
32#include <linux/iio/iio-gts-helper.h>
33#include <linux/iio/trigger_consumer.h>
34#include <linux/iio/triggered_buffer.h>
35
36/* Device registers */
37#define VEML6030_REG_ALS_CONF 0x00
38#define VEML6030_REG_ALS_WH 0x01
39#define VEML6030_REG_ALS_WL 0x02
40#define VEML6030_REG_ALS_PSM 0x03
41#define VEML6030_REG_ALS_DATA 0x04
42#define VEML6030_REG_WH_DATA 0x05
43#define VEML6030_REG_ALS_INT 0x06
44#define VEML6030_REG_DATA(ch) (VEML6030_REG_ALS_DATA + (ch))
45
46/* Bit masks for specific functionality */
47#define VEML6030_ALS_IT GENMASK(9, 6)
48#define VEML6030_PSM GENMASK(2, 1)
49#define VEML6030_ALS_PERS GENMASK(5, 4)
50#define VEML6030_ALS_GAIN GENMASK(12, 11)
51#define VEML6030_PSM_EN BIT(0)
52#define VEML6030_INT_TH_LOW BIT(15)
53#define VEML6030_INT_TH_HIGH BIT(14)
54#define VEML6030_ALS_INT_EN BIT(1)
55#define VEML6030_ALS_SD BIT(0)
56
57#define VEML6035_GAIN_M GENMASK(12, 10)
58#define VEML6035_GAIN BIT(10)
59#define VEML6035_DG BIT(11)
60#define VEML6035_SENS BIT(12)
61#define VEML6035_INT_CHAN BIT(3)
62#define VEML6035_CHAN_EN BIT(2)
63
64/* Regfields */
65#define VEML6030_GAIN_RF REG_FIELD(VEML6030_REG_ALS_CONF, 11, 12)
66#define VEML6030_IT_RF REG_FIELD(VEML6030_REG_ALS_CONF, 6, 9)
67
68#define VEML6035_GAIN_RF REG_FIELD(VEML6030_REG_ALS_CONF, 10, 12)
69
70/* Maximum scales x 10000 to work with integers */
71#define VEML6030_MAX_SCALE 21504
72#define VEML6035_MAX_SCALE 4096
73
74enum veml6030_scan {
75 VEML6030_SCAN_ALS,
76 VEML6030_SCAN_WH,
77 VEML6030_SCAN_TIMESTAMP,
78};
79
80struct veml6030_rf {
81 struct regmap_field *it;
82 struct regmap_field *gain;
83};
84
85struct veml603x_chip {
86 const char *name;
87 const struct iio_chan_spec *channels;
88 const int num_channels;
89 const struct reg_field gain_rf;
90 const struct reg_field it_rf;
91 const int max_scale;
92 int (*hw_init)(struct iio_dev *indio_dev, struct device *dev);
93 int (*set_info)(struct iio_dev *indio_dev);
94};
95
96/*
97 * The resolution depends on both gain and integration time. The
98 * cur_resolution stores one of the resolution mentioned in the
99 * table during startup and gets updated whenever integration time
100 * or gain is changed.
101 *
102 * Table 'resolution and maximum detection range' in the appnotes
103 * is visualized as a 2D array. The cur_gain stores index of gain
104 * in this table (0-3 for VEML6030, 0-5 for VEML6035) while the
105 * cur_integration_time holds index of integration time (0-5).
106 */
107struct veml6030_data {
108 struct i2c_client *client;
109 struct regmap *regmap;
110 struct veml6030_rf rf;
111 const struct veml603x_chip *chip;
112 struct iio_gts gts;
113
114};
115
116#define VEML6030_SEL_IT_25MS 0x0C
117#define VEML6030_SEL_IT_50MS 0x08
118#define VEML6030_SEL_IT_100MS 0x00
119#define VEML6030_SEL_IT_200MS 0x01
120#define VEML6030_SEL_IT_400MS 0x02
121#define VEML6030_SEL_IT_800MS 0x03
122static const struct iio_itime_sel_mul veml6030_it_sel[] = {
123 GAIN_SCALE_ITIME_US(25000, VEML6030_SEL_IT_25MS, 1),
124 GAIN_SCALE_ITIME_US(50000, VEML6030_SEL_IT_50MS, 2),
125 GAIN_SCALE_ITIME_US(100000, VEML6030_SEL_IT_100MS, 4),
126 GAIN_SCALE_ITIME_US(200000, VEML6030_SEL_IT_200MS, 8),
127 GAIN_SCALE_ITIME_US(400000, VEML6030_SEL_IT_400MS, 16),
128 GAIN_SCALE_ITIME_US(800000, VEML6030_SEL_IT_800MS, 32),
129};
130
131/* Gains are multiplied by 8 to work with integers. The values in the
132 * iio-gts tables don't need corrections because the maximum value of
133 * the scale refers to GAIN = x1, and the rest of the values are
134 * obtained from the resulting linear function.
135 */
136#define VEML6030_SEL_MILLI_GAIN_X125 2
137#define VEML6030_SEL_MILLI_GAIN_X250 3
138#define VEML6030_SEL_MILLI_GAIN_X1000 0
139#define VEML6030_SEL_MILLI_GAIN_X2000 1
140static const struct iio_gain_sel_pair veml6030_gain_sel[] = {
141 GAIN_SCALE_GAIN(1, VEML6030_SEL_MILLI_GAIN_X125),
142 GAIN_SCALE_GAIN(2, VEML6030_SEL_MILLI_GAIN_X250),
143 GAIN_SCALE_GAIN(8, VEML6030_SEL_MILLI_GAIN_X1000),
144 GAIN_SCALE_GAIN(16, VEML6030_SEL_MILLI_GAIN_X2000),
145};
146
147#define VEML6035_SEL_MILLI_GAIN_X125 4
148#define VEML6035_SEL_MILLI_GAIN_X250 5
149#define VEML6035_SEL_MILLI_GAIN_X500 7
150#define VEML6035_SEL_MILLI_GAIN_X1000 0
151#define VEML6035_SEL_MILLI_GAIN_X2000 1
152#define VEML6035_SEL_MILLI_GAIN_X4000 3
153static const struct iio_gain_sel_pair veml6035_gain_sel[] = {
154 GAIN_SCALE_GAIN(1, VEML6035_SEL_MILLI_GAIN_X125),
155 GAIN_SCALE_GAIN(2, VEML6035_SEL_MILLI_GAIN_X250),
156 GAIN_SCALE_GAIN(4, VEML6035_SEL_MILLI_GAIN_X500),
157 GAIN_SCALE_GAIN(8, VEML6035_SEL_MILLI_GAIN_X1000),
158 GAIN_SCALE_GAIN(16, VEML6035_SEL_MILLI_GAIN_X2000),
159 GAIN_SCALE_GAIN(32, VEML6035_SEL_MILLI_GAIN_X4000),
160};
161
162/*
163 * Persistence = 1/2/4/8 x integration time
164 * Minimum time for which light readings must stay above configured
165 * threshold to assert the interrupt.
166 */
167static const char * const period_values[] = {
168 "0.1 0.2 0.4 0.8",
169 "0.2 0.4 0.8 1.6",
170 "0.4 0.8 1.6 3.2",
171 "0.8 1.6 3.2 6.4",
172 "0.05 0.1 0.2 0.4",
173 "0.025 0.050 0.1 0.2"
174};
175
176/*
177 * Return list of valid period values in seconds corresponding to
178 * the currently active integration time.
179 */
180static ssize_t in_illuminance_period_available_show(struct device *dev,
181 struct device_attribute *attr, char *buf)
182{
183 struct veml6030_data *data = iio_priv(indio_dev: dev_to_iio_dev(dev));
184 int ret, reg, x;
185
186 ret = regmap_read(map: data->regmap, VEML6030_REG_ALS_CONF, val: &reg);
187 if (ret) {
188 dev_err(&data->client->dev,
189 "can't read als conf register %d\n", ret);
190 return ret;
191 }
192
193 ret = ((reg >> 6) & 0xF);
194 switch (ret) {
195 case 0:
196 case 1:
197 case 2:
198 case 3:
199 x = ret;
200 break;
201 case 8:
202 x = 4;
203 break;
204 case 12:
205 x = 5;
206 break;
207 default:
208 return -EINVAL;
209 }
210
211 return sysfs_emit(buf, fmt: "%s\n", period_values[x]);
212}
213
214static IIO_DEVICE_ATTR_RO(in_illuminance_period_available, 0);
215
216static struct attribute *veml6030_event_attributes[] = {
217 &iio_dev_attr_in_illuminance_period_available.dev_attr.attr,
218 NULL
219};
220
221static const struct attribute_group veml6030_event_attr_group = {
222 .attrs = veml6030_event_attributes,
223};
224
225static int veml6030_als_pwr_on(struct veml6030_data *data)
226{
227 int ret;
228
229 ret = regmap_clear_bits(map: data->regmap, VEML6030_REG_ALS_CONF,
230 VEML6030_ALS_SD);
231 if (ret)
232 return ret;
233
234 /* Wait 4 ms to let processor & oscillator start correctly */
235 fsleep(usecs: 4000);
236
237 return 0;
238}
239
240static int veml6030_als_shut_down(struct veml6030_data *data)
241{
242 return regmap_set_bits(map: data->regmap, VEML6030_REG_ALS_CONF,
243 VEML6030_ALS_SD);
244}
245
246static void veml6030_als_shut_down_action(void *data)
247{
248 veml6030_als_shut_down(data);
249}
250
251static const struct iio_event_spec veml6030_event_spec[] = {
252 {
253 .type = IIO_EV_TYPE_THRESH,
254 .dir = IIO_EV_DIR_RISING,
255 .mask_separate = BIT(IIO_EV_INFO_VALUE),
256 }, {
257 .type = IIO_EV_TYPE_THRESH,
258 .dir = IIO_EV_DIR_FALLING,
259 .mask_separate = BIT(IIO_EV_INFO_VALUE),
260 }, {
261 .type = IIO_EV_TYPE_THRESH,
262 .dir = IIO_EV_DIR_EITHER,
263 .mask_separate = BIT(IIO_EV_INFO_PERIOD) |
264 BIT(IIO_EV_INFO_ENABLE),
265 },
266};
267
268/* Channel number */
269enum veml6030_chan {
270 CH_ALS,
271 CH_WHITE,
272};
273
274static const struct iio_chan_spec veml6030_channels[] = {
275 {
276 .type = IIO_LIGHT,
277 .channel = CH_ALS,
278 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
279 BIT(IIO_CHAN_INFO_PROCESSED) |
280 BIT(IIO_CHAN_INFO_INT_TIME) |
281 BIT(IIO_CHAN_INFO_SCALE),
282 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
283 BIT(IIO_CHAN_INFO_SCALE),
284 .event_spec = veml6030_event_spec,
285 .num_event_specs = ARRAY_SIZE(veml6030_event_spec),
286 .scan_index = VEML6030_SCAN_ALS,
287 .scan_type = {
288 .sign = 'u',
289 .realbits = 16,
290 .storagebits = 16,
291 .endianness = IIO_CPU,
292 },
293 },
294 {
295 .type = IIO_INTENSITY,
296 .channel = CH_WHITE,
297 .modified = 1,
298 .channel2 = IIO_MOD_LIGHT_BOTH,
299 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
300 BIT(IIO_CHAN_INFO_INT_TIME) |
301 BIT(IIO_CHAN_INFO_SCALE),
302 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
303 BIT(IIO_CHAN_INFO_SCALE),
304 .scan_index = VEML6030_SCAN_WH,
305 .scan_type = {
306 .sign = 'u',
307 .realbits = 16,
308 .storagebits = 16,
309 .endianness = IIO_CPU,
310 },
311 },
312 IIO_CHAN_SOFT_TIMESTAMP(VEML6030_SCAN_TIMESTAMP),
313};
314
315static const struct iio_chan_spec veml7700_channels[] = {
316 {
317 .type = IIO_LIGHT,
318 .channel = CH_ALS,
319 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
320 BIT(IIO_CHAN_INFO_PROCESSED) |
321 BIT(IIO_CHAN_INFO_INT_TIME) |
322 BIT(IIO_CHAN_INFO_SCALE),
323 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
324 BIT(IIO_CHAN_INFO_SCALE),
325 .scan_index = VEML6030_SCAN_ALS,
326 .scan_type = {
327 .sign = 'u',
328 .realbits = 16,
329 .storagebits = 16,
330 .endianness = IIO_CPU,
331 },
332 },
333 {
334 .type = IIO_INTENSITY,
335 .channel = CH_WHITE,
336 .modified = 1,
337 .channel2 = IIO_MOD_LIGHT_BOTH,
338 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
339 BIT(IIO_CHAN_INFO_INT_TIME) |
340 BIT(IIO_CHAN_INFO_SCALE),
341 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
342 BIT(IIO_CHAN_INFO_SCALE),
343 .scan_index = VEML6030_SCAN_WH,
344 .scan_type = {
345 .sign = 'u',
346 .realbits = 16,
347 .storagebits = 16,
348 .endianness = IIO_CPU,
349 },
350 },
351 IIO_CHAN_SOFT_TIMESTAMP(VEML6030_SCAN_TIMESTAMP),
352};
353
354static const struct regmap_range veml6030_readable_ranges[] = {
355 regmap_reg_range(VEML6030_REG_ALS_CONF, VEML6030_REG_ALS_INT),
356};
357
358static const struct regmap_access_table veml6030_readable_table = {
359 .yes_ranges = veml6030_readable_ranges,
360 .n_yes_ranges = ARRAY_SIZE(veml6030_readable_ranges),
361};
362
363static const struct regmap_range veml6030_writable_ranges[] = {
364 regmap_reg_range(VEML6030_REG_ALS_CONF, VEML6030_REG_ALS_PSM),
365};
366
367static const struct regmap_access_table veml6030_writable_table = {
368 .yes_ranges = veml6030_writable_ranges,
369 .n_yes_ranges = ARRAY_SIZE(veml6030_writable_ranges),
370};
371
372static const struct regmap_range veml6030_volatile_ranges[] = {
373 regmap_reg_range(VEML6030_REG_ALS_DATA, VEML6030_REG_WH_DATA),
374};
375
376static const struct regmap_access_table veml6030_volatile_table = {
377 .yes_ranges = veml6030_volatile_ranges,
378 .n_yes_ranges = ARRAY_SIZE(veml6030_volatile_ranges),
379};
380
381static const struct regmap_config veml6030_regmap_config = {
382 .name = "veml6030_regmap",
383 .reg_bits = 8,
384 .val_bits = 16,
385 .max_register = VEML6030_REG_ALS_INT,
386 .val_format_endian = REGMAP_ENDIAN_LITTLE,
387 .rd_table = &veml6030_readable_table,
388 .wr_table = &veml6030_writable_table,
389 .volatile_table = &veml6030_volatile_table,
390 .cache_type = REGCACHE_RBTREE,
391};
392
393static int veml6030_get_it(struct veml6030_data *data, int *val, int *val2)
394{
395 int ret, it_idx;
396
397 ret = regmap_field_read(field: data->rf.it, val: &it_idx);
398 if (ret)
399 return ret;
400
401 ret = iio_gts_find_int_time_by_sel(gts: &data->gts, sel: it_idx);
402 if (ret < 0)
403 return ret;
404
405 *val2 = ret;
406 *val = 0;
407
408 return IIO_VAL_INT_PLUS_MICRO;
409}
410
411static int veml6030_set_it(struct iio_dev *indio_dev, int val, int val2)
412{
413 struct veml6030_data *data = iio_priv(indio_dev);
414 int ret, gain_idx, it_idx, new_gain, prev_gain, prev_it;
415 bool in_range;
416
417 if (val || !iio_gts_valid_time(gts: &data->gts, time_us: val2))
418 return -EINVAL;
419
420 ret = regmap_field_read(field: data->rf.it, val: &it_idx);
421 if (ret)
422 return ret;
423
424 ret = regmap_field_read(field: data->rf.gain, val: &gain_idx);
425 if (ret)
426 return ret;
427
428 prev_it = iio_gts_find_int_time_by_sel(gts: &data->gts, sel: it_idx);
429 if (prev_it < 0)
430 return prev_it;
431
432 if (prev_it == val2)
433 return 0;
434
435 prev_gain = iio_gts_find_gain_by_sel(gts: &data->gts, sel: gain_idx);
436 if (prev_gain < 0)
437 return prev_gain;
438
439 ret = iio_gts_find_new_gain_by_gain_time_min(gts: &data->gts, old_gain: prev_gain, old_time: prev_it,
440 new_time: val2, new_gain: &new_gain, in_range: &in_range);
441 if (ret)
442 return ret;
443
444 if (!in_range)
445 dev_dbg(&data->client->dev, "Optimal gain out of range\n");
446
447 ret = iio_gts_find_sel_by_int_time(gts: &data->gts, time: val2);
448 if (ret < 0)
449 return ret;
450
451 ret = regmap_field_write(field: data->rf.it, val: ret);
452 if (ret)
453 return ret;
454
455 ret = iio_gts_find_sel_by_gain(gts: &data->gts, gain: new_gain);
456 if (ret < 0)
457 return ret;
458
459 return regmap_field_write(field: data->rf.gain, val: ret);
460}
461
462static int veml6030_read_persistence(struct iio_dev *indio_dev,
463 int *val, int *val2)
464{
465 int ret, reg, period, x, y;
466 struct veml6030_data *data = iio_priv(indio_dev);
467
468 ret = veml6030_get_it(data, val: &x, val2: &y);
469 if (ret < 0)
470 return ret;
471
472 ret = regmap_read(map: data->regmap, VEML6030_REG_ALS_CONF, val: &reg);
473 if (ret) {
474 dev_err(&data->client->dev,
475 "can't read als conf register %d\n", ret);
476 }
477
478 /* integration time multiplied by 1/2/4/8 */
479 period = y * (1 << ((reg >> 4) & 0x03));
480
481 *val = period / 1000000;
482 *val2 = period % 1000000;
483
484 return IIO_VAL_INT_PLUS_MICRO;
485}
486
487static int veml6030_write_persistence(struct iio_dev *indio_dev,
488 int val, int val2)
489{
490 int ret, period, x, y;
491 struct veml6030_data *data = iio_priv(indio_dev);
492
493 ret = veml6030_get_it(data, val: &x, val2: &y);
494 if (ret < 0)
495 return ret;
496
497 if (!val) {
498 period = val2 / y;
499 } else {
500 if ((val == 1) && (val2 == 600000))
501 period = 1600000 / y;
502 else if ((val == 3) && (val2 == 200000))
503 period = 3200000 / y;
504 else if ((val == 6) && (val2 == 400000))
505 period = 6400000 / y;
506 else
507 period = -1;
508 }
509
510 if (period <= 0 || period > 8 || hweight8(period) != 1)
511 return -EINVAL;
512
513 ret = regmap_update_bits(map: data->regmap, VEML6030_REG_ALS_CONF,
514 VEML6030_ALS_PERS, val: (ffs(period) - 1) << 4);
515 if (ret)
516 dev_err(&data->client->dev,
517 "can't set persistence value %d\n", ret);
518
519 return ret;
520}
521
522static int veml6030_set_scale(struct iio_dev *indio_dev, int val, int val2)
523{
524 int ret, gain_sel, it_idx, it_sel;
525 struct veml6030_data *data = iio_priv(indio_dev);
526
527 ret = regmap_field_read(field: data->rf.it, val: &it_idx);
528 if (ret)
529 return ret;
530
531 ret = iio_gts_find_gain_time_sel_for_scale(gts: &data->gts, scale_int: val, scale_nano: val2,
532 gain_sel: &gain_sel, time_sel: &it_sel);
533 if (ret)
534 return ret;
535
536 ret = regmap_field_write(field: data->rf.it, val: it_sel);
537 if (ret)
538 return ret;
539
540 ret = regmap_field_write(field: data->rf.gain, val: gain_sel);
541 if (ret)
542 return ret;
543
544 return 0;
545}
546
547static int veml6030_read_thresh(struct iio_dev *indio_dev,
548 int *val, int *val2, int dir)
549{
550 int ret, reg;
551 struct veml6030_data *data = iio_priv(indio_dev);
552
553 if (dir == IIO_EV_DIR_RISING)
554 ret = regmap_read(map: data->regmap, VEML6030_REG_ALS_WH, val: &reg);
555 else
556 ret = regmap_read(map: data->regmap, VEML6030_REG_ALS_WL, val: &reg);
557 if (ret) {
558 dev_err(&data->client->dev,
559 "can't read als threshold value %d\n", ret);
560 return ret;
561 }
562
563 *val = reg & 0xffff;
564 return IIO_VAL_INT;
565}
566
567static int veml6030_write_thresh(struct iio_dev *indio_dev,
568 int val, int val2, int dir)
569{
570 int ret;
571 struct veml6030_data *data = iio_priv(indio_dev);
572
573 if (val > 0xFFFF || val < 0 || val2)
574 return -EINVAL;
575
576 if (dir == IIO_EV_DIR_RISING) {
577 ret = regmap_write(map: data->regmap, VEML6030_REG_ALS_WH, val);
578 if (ret)
579 dev_err(&data->client->dev,
580 "can't set high threshold %d\n", ret);
581 } else {
582 ret = regmap_write(map: data->regmap, VEML6030_REG_ALS_WL, val);
583 if (ret)
584 dev_err(&data->client->dev,
585 "can't set low threshold %d\n", ret);
586 }
587
588 return ret;
589}
590
591static int veml6030_get_total_gain(struct veml6030_data *data)
592{
593 int gain, it, reg, ret;
594
595 ret = regmap_field_read(field: data->rf.gain, val: &reg);
596 if (ret)
597 return ret;
598
599 gain = iio_gts_find_gain_by_sel(gts: &data->gts, sel: reg);
600 if (gain < 0)
601 return gain;
602
603 ret = regmap_field_read(field: data->rf.it, val: &reg);
604 if (ret)
605 return ret;
606
607 it = iio_gts_find_int_time_by_sel(gts: &data->gts, sel: reg);
608 if (it < 0)
609 return it;
610
611 return iio_gts_get_total_gain(gts: &data->gts, gain, time: it);
612}
613
614static int veml6030_get_scale(struct veml6030_data *data, int *val, int *val2)
615{
616 int gain, it, reg, ret;
617
618 ret = regmap_field_read(field: data->rf.gain, val: &reg);
619 if (ret)
620 return ret;
621
622 gain = iio_gts_find_gain_by_sel(gts: &data->gts, sel: reg);
623 if (gain < 0)
624 return gain;
625
626 ret = regmap_field_read(field: data->rf.it, val: &reg);
627 if (ret)
628 return ret;
629
630 it = iio_gts_find_int_time_by_sel(gts: &data->gts, sel: reg);
631 if (it < 0)
632 return it;
633
634 ret = iio_gts_get_scale(gts: &data->gts, gain, time: it, scale_int: val, scale_nano: val2);
635 if (ret)
636 return ret;
637
638 return IIO_VAL_INT_PLUS_NANO;
639}
640
641static int veml6030_process_als(struct veml6030_data *data, int raw,
642 int *val, int *val2)
643{
644 int total_gain;
645
646 total_gain = veml6030_get_total_gain(data);
647 if (total_gain < 0)
648 return total_gain;
649
650 *val = raw * data->chip->max_scale / total_gain / 10000;
651 *val2 = raw * data->chip->max_scale / total_gain % 10000 * 100;
652
653 return IIO_VAL_INT_PLUS_MICRO;
654}
655
656/*
657 * Provide both raw as well as light reading in lux.
658 * light (in lux) = resolution * raw reading
659 */
660static int veml6030_read_raw(struct iio_dev *indio_dev,
661 struct iio_chan_spec const *chan, int *val,
662 int *val2, long mask)
663{
664 int ret, reg;
665 struct veml6030_data *data = iio_priv(indio_dev);
666 struct regmap *regmap = data->regmap;
667 struct device *dev = &data->client->dev;
668
669 switch (mask) {
670 case IIO_CHAN_INFO_RAW:
671 case IIO_CHAN_INFO_PROCESSED:
672 switch (chan->type) {
673 case IIO_LIGHT:
674 ret = regmap_read(map: regmap, VEML6030_REG_ALS_DATA, val: &reg);
675 if (ret < 0) {
676 dev_err(dev, "can't read als data %d\n", ret);
677 return ret;
678 }
679 if (mask == IIO_CHAN_INFO_PROCESSED)
680 return veml6030_process_als(data, raw: reg, val, val2);
681
682 *val = reg;
683 return IIO_VAL_INT;
684 case IIO_INTENSITY:
685 ret = regmap_read(map: regmap, VEML6030_REG_WH_DATA, val: &reg);
686 if (ret < 0) {
687 dev_err(dev, "can't read white data %d\n", ret);
688 return ret;
689 }
690 *val = reg;
691 return IIO_VAL_INT;
692 default:
693 return -EINVAL;
694 }
695 case IIO_CHAN_INFO_INT_TIME:
696 return veml6030_get_it(data, val, val2);
697 case IIO_CHAN_INFO_SCALE:
698 return veml6030_get_scale(data, val, val2);
699 default:
700 return -EINVAL;
701 }
702}
703
704static int veml6030_read_avail(struct iio_dev *indio_dev,
705 struct iio_chan_spec const *chan,
706 const int **vals, int *type, int *length,
707 long mask)
708{
709 struct veml6030_data *data = iio_priv(indio_dev);
710
711 switch (mask) {
712 case IIO_CHAN_INFO_INT_TIME:
713 return iio_gts_avail_times(gts: &data->gts, vals, type, length);
714 case IIO_CHAN_INFO_SCALE:
715 return iio_gts_all_avail_scales(gts: &data->gts, vals, type, length);
716 }
717
718 return -EINVAL;
719}
720
721static int veml6030_write_raw(struct iio_dev *indio_dev,
722 struct iio_chan_spec const *chan,
723 int val, int val2, long mask)
724{
725 switch (mask) {
726 case IIO_CHAN_INFO_INT_TIME:
727 return veml6030_set_it(indio_dev, val, val2);
728 case IIO_CHAN_INFO_SCALE:
729 return veml6030_set_scale(indio_dev, val, val2);
730 default:
731 return -EINVAL;
732 }
733}
734
735static int veml6030_write_raw_get_fmt(struct iio_dev *indio_dev,
736 struct iio_chan_spec const *chan,
737 long mask)
738{
739 switch (mask) {
740 case IIO_CHAN_INFO_SCALE:
741 return IIO_VAL_INT_PLUS_NANO;
742 case IIO_CHAN_INFO_INT_TIME:
743 return IIO_VAL_INT_PLUS_MICRO;
744 default:
745 return -EINVAL;
746 }
747}
748
749static int veml6030_read_event_val(struct iio_dev *indio_dev,
750 const struct iio_chan_spec *chan, enum iio_event_type type,
751 enum iio_event_direction dir, enum iio_event_info info,
752 int *val, int *val2)
753{
754 switch (info) {
755 case IIO_EV_INFO_VALUE:
756 switch (dir) {
757 case IIO_EV_DIR_RISING:
758 case IIO_EV_DIR_FALLING:
759 return veml6030_read_thresh(indio_dev, val, val2, dir);
760 default:
761 return -EINVAL;
762 }
763 break;
764 case IIO_EV_INFO_PERIOD:
765 return veml6030_read_persistence(indio_dev, val, val2);
766 default:
767 return -EINVAL;
768 }
769}
770
771static int veml6030_write_event_val(struct iio_dev *indio_dev,
772 const struct iio_chan_spec *chan, enum iio_event_type type,
773 enum iio_event_direction dir, enum iio_event_info info,
774 int val, int val2)
775{
776 switch (info) {
777 case IIO_EV_INFO_VALUE:
778 return veml6030_write_thresh(indio_dev, val, val2, dir);
779 case IIO_EV_INFO_PERIOD:
780 return veml6030_write_persistence(indio_dev, val, val2);
781 default:
782 return -EINVAL;
783 }
784}
785
786static int veml6030_read_interrupt_config(struct iio_dev *indio_dev,
787 const struct iio_chan_spec *chan, enum iio_event_type type,
788 enum iio_event_direction dir)
789{
790 int ret, reg;
791 struct veml6030_data *data = iio_priv(indio_dev);
792
793 ret = regmap_read(map: data->regmap, VEML6030_REG_ALS_CONF, val: &reg);
794 if (ret) {
795 dev_err(&data->client->dev,
796 "can't read als conf register %d\n", ret);
797 return ret;
798 }
799
800 if (reg & VEML6030_ALS_INT_EN)
801 return 1;
802 else
803 return 0;
804}
805
806/*
807 * Sensor should not be measuring light when interrupt is configured.
808 * Therefore correct sequence to configure interrupt functionality is:
809 * shut down -> enable/disable interrupt -> power on
810 *
811 * state = 1 enables interrupt, state = 0 disables interrupt
812 */
813static int veml6030_write_interrupt_config(struct iio_dev *indio_dev,
814 const struct iio_chan_spec *chan, enum iio_event_type type,
815 enum iio_event_direction dir, bool state)
816{
817 int ret;
818 struct veml6030_data *data = iio_priv(indio_dev);
819
820 ret = veml6030_als_shut_down(data);
821 if (ret < 0) {
822 dev_err(&data->client->dev,
823 "can't disable als to configure interrupt %d\n", ret);
824 return ret;
825 }
826
827 /* enable interrupt + power on */
828 ret = regmap_update_bits(map: data->regmap, VEML6030_REG_ALS_CONF,
829 VEML6030_ALS_INT_EN | VEML6030_ALS_SD, val: state << 1);
830 if (ret)
831 dev_err(&data->client->dev,
832 "can't enable interrupt & poweron als %d\n", ret);
833
834 return ret;
835}
836
837static const struct iio_info veml6030_info = {
838 .read_raw = veml6030_read_raw,
839 .read_avail = veml6030_read_avail,
840 .write_raw = veml6030_write_raw,
841 .write_raw_get_fmt = veml6030_write_raw_get_fmt,
842 .read_event_value = veml6030_read_event_val,
843 .write_event_value = veml6030_write_event_val,
844 .read_event_config = veml6030_read_interrupt_config,
845 .write_event_config = veml6030_write_interrupt_config,
846 .event_attrs = &veml6030_event_attr_group,
847};
848
849static const struct iio_info veml6030_info_no_irq = {
850 .read_raw = veml6030_read_raw,
851 .read_avail = veml6030_read_avail,
852 .write_raw = veml6030_write_raw,
853 .write_raw_get_fmt = veml6030_write_raw_get_fmt,
854};
855
856static irqreturn_t veml6030_event_handler(int irq, void *private)
857{
858 int ret, reg, evtdir;
859 struct iio_dev *indio_dev = private;
860 struct veml6030_data *data = iio_priv(indio_dev);
861
862 ret = regmap_read(map: data->regmap, VEML6030_REG_ALS_INT, val: &reg);
863 if (ret) {
864 dev_err(&data->client->dev,
865 "can't read als interrupt register %d\n", ret);
866 return IRQ_HANDLED;
867 }
868
869 /* Spurious interrupt handling */
870 if (!(reg & (VEML6030_INT_TH_HIGH | VEML6030_INT_TH_LOW)))
871 return IRQ_NONE;
872
873 if (reg & VEML6030_INT_TH_HIGH)
874 evtdir = IIO_EV_DIR_RISING;
875 else
876 evtdir = IIO_EV_DIR_FALLING;
877
878 iio_push_event(indio_dev, IIO_UNMOD_EVENT_CODE(IIO_INTENSITY,
879 0, IIO_EV_TYPE_THRESH, evtdir),
880 timestamp: iio_get_time_ns(indio_dev));
881
882 return IRQ_HANDLED;
883}
884
885static irqreturn_t veml6030_trigger_handler(int irq, void *p)
886{
887 struct iio_poll_func *pf = p;
888 struct iio_dev *iio = pf->indio_dev;
889 struct veml6030_data *data = iio_priv(indio_dev: iio);
890 unsigned int reg;
891 int ch, ret, i = 0;
892 struct {
893 u16 chans[2];
894 aligned_s64 timestamp;
895 } scan = { };
896
897 iio_for_each_active_channel(iio, ch) {
898 ret = regmap_read(map: data->regmap, VEML6030_REG_DATA(ch),
899 val: &reg);
900 if (ret)
901 goto done;
902
903 scan.chans[i++] = reg;
904 }
905
906 iio_push_to_buffers_with_ts(indio_dev: iio, data: &scan, data_total_len: sizeof(scan), timestamp: pf->timestamp);
907
908done:
909 iio_trigger_notify_done(trig: iio->trig);
910
911 return IRQ_HANDLED;
912}
913
914static int veml6030_set_info(struct iio_dev *indio_dev)
915{
916 struct veml6030_data *data = iio_priv(indio_dev);
917 struct i2c_client *client = data->client;
918 int ret;
919
920 if (client->irq) {
921 ret = devm_request_threaded_irq(dev: &client->dev, irq: client->irq,
922 NULL, thread_fn: veml6030_event_handler,
923 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
924 devname: indio_dev->name, dev_id: indio_dev);
925 if (ret < 0)
926 return dev_err_probe(dev: &client->dev, err: ret,
927 fmt: "irq %d request failed\n",
928 client->irq);
929
930 indio_dev->info = &veml6030_info;
931 } else {
932 indio_dev->info = &veml6030_info_no_irq;
933 }
934
935 return 0;
936}
937
938static int veml7700_set_info(struct iio_dev *indio_dev)
939{
940 indio_dev->info = &veml6030_info_no_irq;
941
942 return 0;
943}
944
945static int veml6030_regfield_init(struct iio_dev *indio_dev)
946{
947 struct veml6030_data *data = iio_priv(indio_dev);
948 struct regmap *regmap = data->regmap;
949 struct device *dev = &data->client->dev;
950 struct regmap_field *rm_field;
951 struct veml6030_rf *rf = &data->rf;
952
953 rm_field = devm_regmap_field_alloc(dev, regmap, reg_field: data->chip->it_rf);
954 if (IS_ERR(ptr: rm_field))
955 return PTR_ERR(ptr: rm_field);
956 rf->it = rm_field;
957
958 rm_field = devm_regmap_field_alloc(dev, regmap, reg_field: data->chip->gain_rf);
959 if (IS_ERR(ptr: rm_field))
960 return PTR_ERR(ptr: rm_field);
961 rf->gain = rm_field;
962
963 return 0;
964}
965
966/*
967 * Set ALS gain to 1/8, integration time to 100 ms, PSM to mode 2,
968 * persistence to 1 x integration time and the threshold
969 * interrupt disabled by default. First shutdown the sensor,
970 * update registers and then power on the sensor.
971 */
972static int veml6030_hw_init(struct iio_dev *indio_dev, struct device *dev)
973{
974 int ret, val;
975 struct veml6030_data *data = iio_priv(indio_dev);
976
977 ret = devm_iio_init_iio_gts(dev, max_scale_int: 2, max_scale_nano: 150400000,
978 gain_tbl: veml6030_gain_sel, ARRAY_SIZE(veml6030_gain_sel),
979 tim_tbl: veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel),
980 gts: &data->gts);
981 if (ret)
982 return dev_err_probe(dev, err: ret, fmt: "failed to init iio gts\n");
983
984 ret = veml6030_als_shut_down(data);
985 if (ret)
986 return dev_err_probe(dev, err: ret, fmt: "can't shutdown als\n");
987
988 ret = regmap_write(map: data->regmap, VEML6030_REG_ALS_CONF, val: 0x1001);
989 if (ret)
990 return dev_err_probe(dev, err: ret, fmt: "can't setup als configs\n");
991
992 ret = regmap_update_bits(map: data->regmap, VEML6030_REG_ALS_PSM,
993 VEML6030_PSM | VEML6030_PSM_EN, val: 0x03);
994 if (ret)
995 return dev_err_probe(dev, err: ret, fmt: "can't setup default PSM\n");
996
997 ret = regmap_write(map: data->regmap, VEML6030_REG_ALS_WH, val: 0xFFFF);
998 if (ret)
999 return dev_err_probe(dev, err: ret, fmt: "can't setup high threshold\n");
1000
1001 ret = regmap_write(map: data->regmap, VEML6030_REG_ALS_WL, val: 0x0000);
1002 if (ret)
1003 return dev_err_probe(dev, err: ret, fmt: "can't setup low threshold\n");
1004
1005 ret = veml6030_als_pwr_on(data);
1006 if (ret)
1007 return dev_err_probe(dev, err: ret, fmt: "can't poweron als\n");
1008
1009 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data);
1010 if (ret < 0)
1011 return ret;
1012
1013 /* Clear stale interrupt status bits if any during start */
1014 ret = regmap_read(map: data->regmap, VEML6030_REG_ALS_INT, val: &val);
1015 if (ret < 0)
1016 return dev_err_probe(dev, err: ret,
1017 fmt: "can't clear als interrupt status\n");
1018
1019 return ret;
1020}
1021
1022/*
1023 * Set ALS gain to 1/8, integration time to 100 ms, ALS and WHITE
1024 * channel enabled, ALS channel interrupt, PSM enabled,
1025 * PSM_WAIT = 0.8 s, persistence to 1 x integration time and the
1026 * threshold interrupt disabled by default. First shutdown the sensor,
1027 * update registers and then power on the sensor.
1028 */
1029static int veml6035_hw_init(struct iio_dev *indio_dev, struct device *dev)
1030{
1031 int ret, val;
1032 struct veml6030_data *data = iio_priv(indio_dev);
1033
1034 ret = devm_iio_init_iio_gts(dev, max_scale_int: 0, max_scale_nano: 409600000,
1035 gain_tbl: veml6035_gain_sel, ARRAY_SIZE(veml6035_gain_sel),
1036 tim_tbl: veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel),
1037 gts: &data->gts);
1038 if (ret)
1039 return dev_err_probe(dev, err: ret, fmt: "failed to init iio gts\n");
1040
1041 ret = veml6030_als_shut_down(data);
1042 if (ret)
1043 return dev_err_probe(dev, err: ret, fmt: "can't shutdown als\n");
1044
1045 ret = regmap_write(map: data->regmap, VEML6030_REG_ALS_CONF,
1046 VEML6035_SENS | VEML6035_CHAN_EN | VEML6030_ALS_SD);
1047 if (ret)
1048 return dev_err_probe(dev, err: ret, fmt: "can't setup als configs\n");
1049
1050 ret = regmap_update_bits(map: data->regmap, VEML6030_REG_ALS_PSM,
1051 VEML6030_PSM | VEML6030_PSM_EN, val: 0x03);
1052 if (ret)
1053 return dev_err_probe(dev, err: ret, fmt: "can't setup default PSM\n");
1054
1055 ret = regmap_write(map: data->regmap, VEML6030_REG_ALS_WH, val: 0xFFFF);
1056 if (ret)
1057 return dev_err_probe(dev, err: ret, fmt: "can't setup high threshold\n");
1058
1059 ret = regmap_write(map: data->regmap, VEML6030_REG_ALS_WL, val: 0x0000);
1060 if (ret)
1061 return dev_err_probe(dev, err: ret, fmt: "can't setup low threshold\n");
1062
1063 ret = veml6030_als_pwr_on(data);
1064 if (ret)
1065 return dev_err_probe(dev, err: ret, fmt: "can't poweron als\n");
1066
1067 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data);
1068 if (ret < 0)
1069 return ret;
1070
1071 /* Clear stale interrupt status bits if any during start */
1072 ret = regmap_read(map: data->regmap, VEML6030_REG_ALS_INT, val: &val);
1073 if (ret < 0)
1074 return dev_err_probe(dev, err: ret,
1075 fmt: "can't clear als interrupt status\n");
1076
1077 return 0;
1078}
1079
1080static int veml6030_probe(struct i2c_client *client)
1081{
1082 int ret;
1083 struct veml6030_data *data;
1084 struct iio_dev *indio_dev;
1085 struct regmap *regmap;
1086
1087 if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C))
1088 return dev_err_probe(dev: &client->dev, err: -EOPNOTSUPP,
1089 fmt: "i2c adapter doesn't support plain i2c\n");
1090
1091 regmap = devm_regmap_init_i2c(client, &veml6030_regmap_config);
1092 if (IS_ERR(ptr: regmap))
1093 return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: regmap),
1094 fmt: "can't setup regmap\n");
1095
1096 indio_dev = devm_iio_device_alloc(parent: &client->dev, sizeof_priv: sizeof(*data));
1097 if (!indio_dev)
1098 return -ENOMEM;
1099
1100 data = iio_priv(indio_dev);
1101 i2c_set_clientdata(client, data: indio_dev);
1102 data->client = client;
1103 data->regmap = regmap;
1104
1105 ret = devm_regulator_get_enable(dev: &client->dev, id: "vdd");
1106 if (ret)
1107 return dev_err_probe(dev: &client->dev, err: ret,
1108 fmt: "failed to enable regulator\n");
1109
1110 data->chip = i2c_get_match_data(client);
1111 if (!data->chip)
1112 return -EINVAL;
1113
1114 indio_dev->name = data->chip->name;
1115 indio_dev->channels = data->chip->channels;
1116 indio_dev->num_channels = data->chip->num_channels;
1117 indio_dev->modes = INDIO_DIRECT_MODE;
1118
1119 ret = data->chip->set_info(indio_dev);
1120 if (ret < 0)
1121 return ret;
1122
1123 ret = veml6030_regfield_init(indio_dev);
1124 if (ret)
1125 return dev_err_probe(dev: &client->dev, err: ret,
1126 fmt: "failed to init regfields\n");
1127
1128 ret = data->chip->hw_init(indio_dev, &client->dev);
1129 if (ret < 0)
1130 return ret;
1131
1132 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
1133 veml6030_trigger_handler, NULL);
1134 if (ret)
1135 return dev_err_probe(dev: &client->dev, err: ret,
1136 fmt: "Failed to register triggered buffer");
1137
1138 return devm_iio_device_register(&client->dev, indio_dev);
1139}
1140
1141static int veml6030_runtime_suspend(struct device *dev)
1142{
1143 int ret;
1144 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1145 struct veml6030_data *data = iio_priv(indio_dev);
1146
1147 ret = veml6030_als_shut_down(data);
1148 if (ret < 0)
1149 dev_err(&data->client->dev, "can't suspend als %d\n", ret);
1150
1151 return ret;
1152}
1153
1154static int veml6030_runtime_resume(struct device *dev)
1155{
1156 int ret;
1157 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1158 struct veml6030_data *data = iio_priv(indio_dev);
1159
1160 ret = veml6030_als_pwr_on(data);
1161 if (ret < 0)
1162 dev_err(&data->client->dev, "can't resume als %d\n", ret);
1163
1164 return ret;
1165}
1166
1167static DEFINE_RUNTIME_DEV_PM_OPS(veml6030_pm_ops, veml6030_runtime_suspend,
1168 veml6030_runtime_resume, NULL);
1169
1170static const struct veml603x_chip veml6030_chip = {
1171 .name = "veml6030",
1172 .channels = veml6030_channels,
1173 .num_channels = ARRAY_SIZE(veml6030_channels),
1174 .gain_rf = VEML6030_GAIN_RF,
1175 .it_rf = VEML6030_IT_RF,
1176 .max_scale = VEML6030_MAX_SCALE,
1177 .hw_init = veml6030_hw_init,
1178 .set_info = veml6030_set_info,
1179};
1180
1181static const struct veml603x_chip veml6035_chip = {
1182 .name = "veml6035",
1183 .channels = veml6030_channels,
1184 .num_channels = ARRAY_SIZE(veml6030_channels),
1185 .gain_rf = VEML6035_GAIN_RF,
1186 .it_rf = VEML6030_IT_RF,
1187 .max_scale = VEML6035_MAX_SCALE,
1188 .hw_init = veml6035_hw_init,
1189 .set_info = veml6030_set_info,
1190};
1191
1192static const struct veml603x_chip veml7700_chip = {
1193 .name = "veml7700",
1194 .channels = veml7700_channels,
1195 .num_channels = ARRAY_SIZE(veml7700_channels),
1196 .gain_rf = VEML6030_GAIN_RF,
1197 .it_rf = VEML6030_IT_RF,
1198 .max_scale = VEML6030_MAX_SCALE,
1199 .hw_init = veml6030_hw_init,
1200 .set_info = veml7700_set_info,
1201};
1202
1203static const struct of_device_id veml6030_of_match[] = {
1204 {
1205 .compatible = "vishay,veml6030",
1206 .data = &veml6030_chip,
1207 },
1208 {
1209 .compatible = "vishay,veml6035",
1210 .data = &veml6035_chip,
1211 },
1212 {
1213 .compatible = "vishay,veml7700",
1214 .data = &veml7700_chip,
1215 },
1216 { }
1217};
1218MODULE_DEVICE_TABLE(of, veml6030_of_match);
1219
1220static const struct i2c_device_id veml6030_id[] = {
1221 { "veml6030", (kernel_ulong_t)&veml6030_chip},
1222 { "veml6035", (kernel_ulong_t)&veml6035_chip},
1223 { "veml7700", (kernel_ulong_t)&veml7700_chip},
1224 { }
1225};
1226MODULE_DEVICE_TABLE(i2c, veml6030_id);
1227
1228static struct i2c_driver veml6030_driver = {
1229 .driver = {
1230 .name = "veml6030",
1231 .of_match_table = veml6030_of_match,
1232 .pm = pm_ptr(&veml6030_pm_ops),
1233 },
1234 .probe = veml6030_probe,
1235 .id_table = veml6030_id,
1236};
1237module_i2c_driver(veml6030_driver);
1238
1239MODULE_AUTHOR("Rishi Gupta <gupt21@gmail.com>");
1240MODULE_DESCRIPTION("VEML6030 Ambient Light Sensor");
1241MODULE_LICENSE("GPL v2");
1242MODULE_IMPORT_NS("IIO_GTS_HELPER");
1243

source code of linux/drivers/iio/light/veml6030.c