1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * VEML6030, VMEL6035 and VEML7700 Ambient Light Sensors
4 *
5 * Copyright (c) 2019, Rishi Gupta <[email protected]>
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
74 enum veml6030_scan {
75 VEML6030_SCAN_ALS,
76 VEML6030_SCAN_WH,
77 VEML6030_SCAN_TIMESTAMP,
78 };
79
80 struct veml6030_rf {
81 struct regmap_field *it;
82 struct regmap_field *gain;
83 };
84
85 struct 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 */
107 struct 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
122 static 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
140 static 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
153 static 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 */
167 static 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 */
in_illuminance_period_available_show(struct device * dev,struct device_attribute * attr,char * buf)180 static 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(dev_to_iio_dev(dev));
184 int ret, reg, x;
185
186 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®);
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, "%s\n", period_values[x]);
212 }
213
214 static IIO_DEVICE_ATTR_RO(in_illuminance_period_available, 0);
215
216 static struct attribute *veml6030_event_attributes[] = {
217 &iio_dev_attr_in_illuminance_period_available.dev_attr.attr,
218 NULL
219 };
220
221 static const struct attribute_group veml6030_event_attr_group = {
222 .attrs = veml6030_event_attributes,
223 };
224
veml6030_als_pwr_on(struct veml6030_data * data)225 static int veml6030_als_pwr_on(struct veml6030_data *data)
226 {
227 int ret;
228
229 ret = regmap_clear_bits(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(4000);
236
237 return 0;
238 }
239
veml6030_als_shut_down(struct veml6030_data * data)240 static int veml6030_als_shut_down(struct veml6030_data *data)
241 {
242 return regmap_set_bits(data->regmap, VEML6030_REG_ALS_CONF,
243 VEML6030_ALS_SD);
244 }
245
veml6030_als_shut_down_action(void * data)246 static void veml6030_als_shut_down_action(void *data)
247 {
248 veml6030_als_shut_down(data);
249 }
250
251 static 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 */
269 enum veml6030_chan {
270 CH_ALS,
271 CH_WHITE,
272 };
273
274 static 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
315 static 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
354 static const struct regmap_config veml6030_regmap_config = {
355 .name = "veml6030_regmap",
356 .reg_bits = 8,
357 .val_bits = 16,
358 .max_register = VEML6030_REG_ALS_INT,
359 .val_format_endian = REGMAP_ENDIAN_LITTLE,
360 };
361
veml6030_get_it(struct veml6030_data * data,int * val,int * val2)362 static int veml6030_get_it(struct veml6030_data *data, int *val, int *val2)
363 {
364 int ret, it_idx;
365
366 ret = regmap_field_read(data->rf.it, &it_idx);
367 if (ret)
368 return ret;
369
370 ret = iio_gts_find_int_time_by_sel(&data->gts, it_idx);
371 if (ret < 0)
372 return ret;
373
374 *val2 = ret;
375 *val = 0;
376
377 return IIO_VAL_INT_PLUS_MICRO;
378 }
379
veml6030_set_it(struct iio_dev * indio_dev,int val,int val2)380 static int veml6030_set_it(struct iio_dev *indio_dev, int val, int val2)
381 {
382 struct veml6030_data *data = iio_priv(indio_dev);
383 int ret, gain_idx, it_idx, new_gain, prev_gain, prev_it;
384 bool in_range;
385
386 if (val || !iio_gts_valid_time(&data->gts, val2))
387 return -EINVAL;
388
389 ret = regmap_field_read(data->rf.it, &it_idx);
390 if (ret)
391 return ret;
392
393 ret = regmap_field_read(data->rf.gain, &gain_idx);
394 if (ret)
395 return ret;
396
397 prev_it = iio_gts_find_int_time_by_sel(&data->gts, it_idx);
398 if (prev_it < 0)
399 return prev_it;
400
401 if (prev_it == val2)
402 return 0;
403
404 prev_gain = iio_gts_find_gain_by_sel(&data->gts, gain_idx);
405 if (prev_gain < 0)
406 return prev_gain;
407
408 ret = iio_gts_find_new_gain_by_gain_time_min(&data->gts, prev_gain, prev_it,
409 val2, &new_gain, &in_range);
410 if (ret)
411 return ret;
412
413 if (!in_range)
414 dev_dbg(&data->client->dev, "Optimal gain out of range\n");
415
416 ret = iio_gts_find_sel_by_int_time(&data->gts, val2);
417 if (ret < 0)
418 return ret;
419
420 ret = regmap_field_write(data->rf.it, ret);
421 if (ret)
422 return ret;
423
424 ret = iio_gts_find_sel_by_gain(&data->gts, new_gain);
425 if (ret < 0)
426 return ret;
427
428 return regmap_field_write(data->rf.gain, ret);
429 }
430
veml6030_read_persistence(struct iio_dev * indio_dev,int * val,int * val2)431 static int veml6030_read_persistence(struct iio_dev *indio_dev,
432 int *val, int *val2)
433 {
434 int ret, reg, period, x, y;
435 struct veml6030_data *data = iio_priv(indio_dev);
436
437 ret = veml6030_get_it(data, &x, &y);
438 if (ret < 0)
439 return ret;
440
441 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®);
442 if (ret) {
443 dev_err(&data->client->dev,
444 "can't read als conf register %d\n", ret);
445 }
446
447 /* integration time multiplied by 1/2/4/8 */
448 period = y * (1 << ((reg >> 4) & 0x03));
449
450 *val = period / 1000000;
451 *val2 = period % 1000000;
452
453 return IIO_VAL_INT_PLUS_MICRO;
454 }
455
veml6030_write_persistence(struct iio_dev * indio_dev,int val,int val2)456 static int veml6030_write_persistence(struct iio_dev *indio_dev,
457 int val, int val2)
458 {
459 int ret, period, x, y;
460 struct veml6030_data *data = iio_priv(indio_dev);
461
462 ret = veml6030_get_it(data, &x, &y);
463 if (ret < 0)
464 return ret;
465
466 if (!val) {
467 period = val2 / y;
468 } else {
469 if ((val == 1) && (val2 == 600000))
470 period = 1600000 / y;
471 else if ((val == 3) && (val2 == 200000))
472 period = 3200000 / y;
473 else if ((val == 6) && (val2 == 400000))
474 period = 6400000 / y;
475 else
476 period = -1;
477 }
478
479 if (period <= 0 || period > 8 || hweight8(period) != 1)
480 return -EINVAL;
481
482 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF,
483 VEML6030_ALS_PERS, (ffs(period) - 1) << 4);
484 if (ret)
485 dev_err(&data->client->dev,
486 "can't set persistence value %d\n", ret);
487
488 return ret;
489 }
490
veml6030_set_scale(struct iio_dev * indio_dev,int val,int val2)491 static int veml6030_set_scale(struct iio_dev *indio_dev, int val, int val2)
492 {
493 int ret, gain_sel, it_idx, it_sel;
494 struct veml6030_data *data = iio_priv(indio_dev);
495
496 ret = regmap_field_read(data->rf.it, &it_idx);
497 if (ret)
498 return ret;
499
500 ret = iio_gts_find_gain_time_sel_for_scale(&data->gts, val, val2,
501 &gain_sel, &it_sel);
502 if (ret)
503 return ret;
504
505 ret = regmap_field_write(data->rf.it, it_sel);
506 if (ret)
507 return ret;
508
509 ret = regmap_field_write(data->rf.gain, gain_sel);
510 if (ret)
511 return ret;
512
513 return 0;
514 }
515
veml6030_read_thresh(struct iio_dev * indio_dev,int * val,int * val2,int dir)516 static int veml6030_read_thresh(struct iio_dev *indio_dev,
517 int *val, int *val2, int dir)
518 {
519 int ret, reg;
520 struct veml6030_data *data = iio_priv(indio_dev);
521
522 if (dir == IIO_EV_DIR_RISING)
523 ret = regmap_read(data->regmap, VEML6030_REG_ALS_WH, ®);
524 else
525 ret = regmap_read(data->regmap, VEML6030_REG_ALS_WL, ®);
526 if (ret) {
527 dev_err(&data->client->dev,
528 "can't read als threshold value %d\n", ret);
529 return ret;
530 }
531
532 *val = reg & 0xffff;
533 return IIO_VAL_INT;
534 }
535
veml6030_write_thresh(struct iio_dev * indio_dev,int val,int val2,int dir)536 static int veml6030_write_thresh(struct iio_dev *indio_dev,
537 int val, int val2, int dir)
538 {
539 int ret;
540 struct veml6030_data *data = iio_priv(indio_dev);
541
542 if (val > 0xFFFF || val < 0 || val2)
543 return -EINVAL;
544
545 if (dir == IIO_EV_DIR_RISING) {
546 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, val);
547 if (ret)
548 dev_err(&data->client->dev,
549 "can't set high threshold %d\n", ret);
550 } else {
551 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, val);
552 if (ret)
553 dev_err(&data->client->dev,
554 "can't set low threshold %d\n", ret);
555 }
556
557 return ret;
558 }
559
veml6030_get_total_gain(struct veml6030_data * data)560 static int veml6030_get_total_gain(struct veml6030_data *data)
561 {
562 int gain, it, reg, ret;
563
564 ret = regmap_field_read(data->rf.gain, ®);
565 if (ret)
566 return ret;
567
568 gain = iio_gts_find_gain_by_sel(&data->gts, reg);
569 if (gain < 0)
570 return gain;
571
572 ret = regmap_field_read(data->rf.it, ®);
573 if (ret)
574 return ret;
575
576 it = iio_gts_find_int_time_by_sel(&data->gts, reg);
577 if (it < 0)
578 return it;
579
580 return iio_gts_get_total_gain(&data->gts, gain, it);
581 }
582
veml6030_get_scale(struct veml6030_data * data,int * val,int * val2)583 static int veml6030_get_scale(struct veml6030_data *data, int *val, int *val2)
584 {
585 int gain, it, reg, ret;
586
587 ret = regmap_field_read(data->rf.gain, ®);
588 if (ret)
589 return ret;
590
591 gain = iio_gts_find_gain_by_sel(&data->gts, reg);
592 if (gain < 0)
593 return gain;
594
595 ret = regmap_field_read(data->rf.it, ®);
596 if (ret)
597 return ret;
598
599 it = iio_gts_find_int_time_by_sel(&data->gts, reg);
600 if (it < 0)
601 return it;
602
603 ret = iio_gts_get_scale(&data->gts, gain, it, val, val2);
604 if (ret)
605 return ret;
606
607 return IIO_VAL_INT_PLUS_NANO;
608 }
609
veml6030_process_als(struct veml6030_data * data,int raw,int * val,int * val2)610 static int veml6030_process_als(struct veml6030_data *data, int raw,
611 int *val, int *val2)
612 {
613 int total_gain;
614
615 total_gain = veml6030_get_total_gain(data);
616 if (total_gain < 0)
617 return total_gain;
618
619 *val = raw * data->chip->max_scale / total_gain / 10000;
620 *val2 = raw * data->chip->max_scale / total_gain % 10000 * 100;
621
622 return IIO_VAL_INT_PLUS_MICRO;
623 }
624
625 /*
626 * Provide both raw as well as light reading in lux.
627 * light (in lux) = resolution * raw reading
628 */
veml6030_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)629 static int veml6030_read_raw(struct iio_dev *indio_dev,
630 struct iio_chan_spec const *chan, int *val,
631 int *val2, long mask)
632 {
633 int ret, reg;
634 struct veml6030_data *data = iio_priv(indio_dev);
635 struct regmap *regmap = data->regmap;
636 struct device *dev = &data->client->dev;
637
638 switch (mask) {
639 case IIO_CHAN_INFO_RAW:
640 case IIO_CHAN_INFO_PROCESSED:
641 switch (chan->type) {
642 case IIO_LIGHT:
643 ret = regmap_read(regmap, VEML6030_REG_ALS_DATA, ®);
644 if (ret < 0) {
645 dev_err(dev, "can't read als data %d\n", ret);
646 return ret;
647 }
648 if (mask == IIO_CHAN_INFO_PROCESSED)
649 return veml6030_process_als(data, reg, val, val2);
650
651 *val = reg;
652 return IIO_VAL_INT;
653 case IIO_INTENSITY:
654 ret = regmap_read(regmap, VEML6030_REG_WH_DATA, ®);
655 if (ret < 0) {
656 dev_err(dev, "can't read white data %d\n", ret);
657 return ret;
658 }
659 *val = reg;
660 return IIO_VAL_INT;
661 default:
662 return -EINVAL;
663 }
664 case IIO_CHAN_INFO_INT_TIME:
665 return veml6030_get_it(data, val, val2);
666 case IIO_CHAN_INFO_SCALE:
667 return veml6030_get_scale(data, val, val2);
668 default:
669 return -EINVAL;
670 }
671 }
672
veml6030_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)673 static int veml6030_read_avail(struct iio_dev *indio_dev,
674 struct iio_chan_spec const *chan,
675 const int **vals, int *type, int *length,
676 long mask)
677 {
678 struct veml6030_data *data = iio_priv(indio_dev);
679
680 switch (mask) {
681 case IIO_CHAN_INFO_INT_TIME:
682 return iio_gts_avail_times(&data->gts, vals, type, length);
683 case IIO_CHAN_INFO_SCALE:
684 return iio_gts_all_avail_scales(&data->gts, vals, type, length);
685 }
686
687 return -EINVAL;
688 }
689
veml6030_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)690 static int veml6030_write_raw(struct iio_dev *indio_dev,
691 struct iio_chan_spec const *chan,
692 int val, int val2, long mask)
693 {
694 switch (mask) {
695 case IIO_CHAN_INFO_INT_TIME:
696 return veml6030_set_it(indio_dev, val, val2);
697 case IIO_CHAN_INFO_SCALE:
698 return veml6030_set_scale(indio_dev, val, val2);
699 default:
700 return -EINVAL;
701 }
702 }
703
veml6030_write_raw_get_fmt(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,long mask)704 static int veml6030_write_raw_get_fmt(struct iio_dev *indio_dev,
705 struct iio_chan_spec const *chan,
706 long mask)
707 {
708 switch (mask) {
709 case IIO_CHAN_INFO_SCALE:
710 return IIO_VAL_INT_PLUS_NANO;
711 case IIO_CHAN_INFO_INT_TIME:
712 return IIO_VAL_INT_PLUS_MICRO;
713 default:
714 return -EINVAL;
715 }
716 }
717
veml6030_read_event_val(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)718 static int veml6030_read_event_val(struct iio_dev *indio_dev,
719 const struct iio_chan_spec *chan, enum iio_event_type type,
720 enum iio_event_direction dir, enum iio_event_info info,
721 int *val, int *val2)
722 {
723 switch (info) {
724 case IIO_EV_INFO_VALUE:
725 switch (dir) {
726 case IIO_EV_DIR_RISING:
727 case IIO_EV_DIR_FALLING:
728 return veml6030_read_thresh(indio_dev, val, val2, dir);
729 default:
730 return -EINVAL;
731 }
732 break;
733 case IIO_EV_INFO_PERIOD:
734 return veml6030_read_persistence(indio_dev, val, val2);
735 default:
736 return -EINVAL;
737 }
738 }
739
veml6030_write_event_val(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)740 static int veml6030_write_event_val(struct iio_dev *indio_dev,
741 const struct iio_chan_spec *chan, enum iio_event_type type,
742 enum iio_event_direction dir, enum iio_event_info info,
743 int val, int val2)
744 {
745 switch (info) {
746 case IIO_EV_INFO_VALUE:
747 return veml6030_write_thresh(indio_dev, val, val2, dir);
748 case IIO_EV_INFO_PERIOD:
749 return veml6030_write_persistence(indio_dev, val, val2);
750 default:
751 return -EINVAL;
752 }
753 }
754
veml6030_read_interrupt_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)755 static int veml6030_read_interrupt_config(struct iio_dev *indio_dev,
756 const struct iio_chan_spec *chan, enum iio_event_type type,
757 enum iio_event_direction dir)
758 {
759 int ret, reg;
760 struct veml6030_data *data = iio_priv(indio_dev);
761
762 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®);
763 if (ret) {
764 dev_err(&data->client->dev,
765 "can't read als conf register %d\n", ret);
766 return ret;
767 }
768
769 if (reg & VEML6030_ALS_INT_EN)
770 return 1;
771 else
772 return 0;
773 }
774
775 /*
776 * Sensor should not be measuring light when interrupt is configured.
777 * Therefore correct sequence to configure interrupt functionality is:
778 * shut down -> enable/disable interrupt -> power on
779 *
780 * state = 1 enables interrupt, state = 0 disables interrupt
781 */
veml6030_write_interrupt_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)782 static int veml6030_write_interrupt_config(struct iio_dev *indio_dev,
783 const struct iio_chan_spec *chan, enum iio_event_type type,
784 enum iio_event_direction dir, bool state)
785 {
786 int ret;
787 struct veml6030_data *data = iio_priv(indio_dev);
788
789 ret = veml6030_als_shut_down(data);
790 if (ret < 0) {
791 dev_err(&data->client->dev,
792 "can't disable als to configure interrupt %d\n", ret);
793 return ret;
794 }
795
796 /* enable interrupt + power on */
797 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF,
798 VEML6030_ALS_INT_EN | VEML6030_ALS_SD, state << 1);
799 if (ret)
800 dev_err(&data->client->dev,
801 "can't enable interrupt & poweron als %d\n", ret);
802
803 return ret;
804 }
805
806 static const struct iio_info veml6030_info = {
807 .read_raw = veml6030_read_raw,
808 .read_avail = veml6030_read_avail,
809 .write_raw = veml6030_write_raw,
810 .write_raw_get_fmt = veml6030_write_raw_get_fmt,
811 .read_event_value = veml6030_read_event_val,
812 .write_event_value = veml6030_write_event_val,
813 .read_event_config = veml6030_read_interrupt_config,
814 .write_event_config = veml6030_write_interrupt_config,
815 .event_attrs = &veml6030_event_attr_group,
816 };
817
818 static const struct iio_info veml6030_info_no_irq = {
819 .read_raw = veml6030_read_raw,
820 .read_avail = veml6030_read_avail,
821 .write_raw = veml6030_write_raw,
822 .write_raw_get_fmt = veml6030_write_raw_get_fmt,
823 };
824
veml6030_event_handler(int irq,void * private)825 static irqreturn_t veml6030_event_handler(int irq, void *private)
826 {
827 int ret, reg, evtdir;
828 struct iio_dev *indio_dev = private;
829 struct veml6030_data *data = iio_priv(indio_dev);
830
831 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, ®);
832 if (ret) {
833 dev_err(&data->client->dev,
834 "can't read als interrupt register %d\n", ret);
835 return IRQ_HANDLED;
836 }
837
838 /* Spurious interrupt handling */
839 if (!(reg & (VEML6030_INT_TH_HIGH | VEML6030_INT_TH_LOW)))
840 return IRQ_NONE;
841
842 if (reg & VEML6030_INT_TH_HIGH)
843 evtdir = IIO_EV_DIR_RISING;
844 else
845 evtdir = IIO_EV_DIR_FALLING;
846
847 iio_push_event(indio_dev, IIO_UNMOD_EVENT_CODE(IIO_INTENSITY,
848 0, IIO_EV_TYPE_THRESH, evtdir),
849 iio_get_time_ns(indio_dev));
850
851 return IRQ_HANDLED;
852 }
853
veml6030_trigger_handler(int irq,void * p)854 static irqreturn_t veml6030_trigger_handler(int irq, void *p)
855 {
856 struct iio_poll_func *pf = p;
857 struct iio_dev *iio = pf->indio_dev;
858 struct veml6030_data *data = iio_priv(iio);
859 unsigned int reg;
860 int ch, ret, i = 0;
861 struct {
862 u16 chans[2];
863 aligned_s64 timestamp;
864 } scan;
865
866 memset(&scan, 0, sizeof(scan));
867
868 iio_for_each_active_channel(iio, ch) {
869 ret = regmap_read(data->regmap, VEML6030_REG_DATA(ch),
870 ®);
871 if (ret)
872 goto done;
873
874 scan.chans[i++] = reg;
875 }
876
877 iio_push_to_buffers_with_timestamp(iio, &scan, pf->timestamp);
878
879 done:
880 iio_trigger_notify_done(iio->trig);
881
882 return IRQ_HANDLED;
883 }
884
veml6030_set_info(struct iio_dev * indio_dev)885 static int veml6030_set_info(struct iio_dev *indio_dev)
886 {
887 struct veml6030_data *data = iio_priv(indio_dev);
888 struct i2c_client *client = data->client;
889 int ret;
890
891 if (client->irq) {
892 ret = devm_request_threaded_irq(&client->dev, client->irq,
893 NULL, veml6030_event_handler,
894 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
895 indio_dev->name, indio_dev);
896 if (ret < 0)
897 return dev_err_probe(&client->dev, ret,
898 "irq %d request failed\n",
899 client->irq);
900
901 indio_dev->info = &veml6030_info;
902 } else {
903 indio_dev->info = &veml6030_info_no_irq;
904 }
905
906 return 0;
907 }
908
veml7700_set_info(struct iio_dev * indio_dev)909 static int veml7700_set_info(struct iio_dev *indio_dev)
910 {
911 indio_dev->info = &veml6030_info_no_irq;
912
913 return 0;
914 }
915
veml6030_regfield_init(struct iio_dev * indio_dev)916 static int veml6030_regfield_init(struct iio_dev *indio_dev)
917 {
918 struct veml6030_data *data = iio_priv(indio_dev);
919 struct regmap *regmap = data->regmap;
920 struct device *dev = &data->client->dev;
921 struct regmap_field *rm_field;
922 struct veml6030_rf *rf = &data->rf;
923
924 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->it_rf);
925 if (IS_ERR(rm_field))
926 return PTR_ERR(rm_field);
927 rf->it = rm_field;
928
929 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->gain_rf);
930 if (IS_ERR(rm_field))
931 return PTR_ERR(rm_field);
932 rf->gain = rm_field;
933
934 return 0;
935 }
936
937 /*
938 * Set ALS gain to 1/8, integration time to 100 ms, PSM to mode 2,
939 * persistence to 1 x integration time and the threshold
940 * interrupt disabled by default. First shutdown the sensor,
941 * update registers and then power on the sensor.
942 */
veml6030_hw_init(struct iio_dev * indio_dev,struct device * dev)943 static int veml6030_hw_init(struct iio_dev *indio_dev, struct device *dev)
944 {
945 int ret, val;
946 struct veml6030_data *data = iio_priv(indio_dev);
947
948 ret = devm_iio_init_iio_gts(dev, 2, 150400000,
949 veml6030_gain_sel, ARRAY_SIZE(veml6030_gain_sel),
950 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel),
951 &data->gts);
952 if (ret)
953 return dev_err_probe(dev, ret, "failed to init iio gts\n");
954
955 ret = veml6030_als_shut_down(data);
956 if (ret)
957 return dev_err_probe(dev, ret, "can't shutdown als\n");
958
959 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 0x1001);
960 if (ret)
961 return dev_err_probe(dev, ret, "can't setup als configs\n");
962
963 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM,
964 VEML6030_PSM | VEML6030_PSM_EN, 0x03);
965 if (ret)
966 return dev_err_probe(dev, ret, "can't setup default PSM\n");
967
968 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF);
969 if (ret)
970 return dev_err_probe(dev, ret, "can't setup high threshold\n");
971
972 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000);
973 if (ret)
974 return dev_err_probe(dev, ret, "can't setup low threshold\n");
975
976 ret = veml6030_als_pwr_on(data);
977 if (ret)
978 return dev_err_probe(dev, ret, "can't poweron als\n");
979
980 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data);
981 if (ret < 0)
982 return ret;
983
984 /* Clear stale interrupt status bits if any during start */
985 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val);
986 if (ret < 0)
987 return dev_err_probe(dev, ret,
988 "can't clear als interrupt status\n");
989
990 return ret;
991 }
992
993 /*
994 * Set ALS gain to 1/8, integration time to 100 ms, ALS and WHITE
995 * channel enabled, ALS channel interrupt, PSM enabled,
996 * PSM_WAIT = 0.8 s, persistence to 1 x integration time and the
997 * threshold interrupt disabled by default. First shutdown the sensor,
998 * update registers and then power on the sensor.
999 */
veml6035_hw_init(struct iio_dev * indio_dev,struct device * dev)1000 static int veml6035_hw_init(struct iio_dev *indio_dev, struct device *dev)
1001 {
1002 int ret, val;
1003 struct veml6030_data *data = iio_priv(indio_dev);
1004
1005 ret = devm_iio_init_iio_gts(dev, 0, 409600000,
1006 veml6035_gain_sel, ARRAY_SIZE(veml6035_gain_sel),
1007 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel),
1008 &data->gts);
1009 if (ret)
1010 return dev_err_probe(dev, ret, "failed to init iio gts\n");
1011
1012 ret = veml6030_als_shut_down(data);
1013 if (ret)
1014 return dev_err_probe(dev, ret, "can't shutdown als\n");
1015
1016 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF,
1017 VEML6035_SENS | VEML6035_CHAN_EN | VEML6030_ALS_SD);
1018 if (ret)
1019 return dev_err_probe(dev, ret, "can't setup als configs\n");
1020
1021 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM,
1022 VEML6030_PSM | VEML6030_PSM_EN, 0x03);
1023 if (ret)
1024 return dev_err_probe(dev, ret, "can't setup default PSM\n");
1025
1026 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF);
1027 if (ret)
1028 return dev_err_probe(dev, ret, "can't setup high threshold\n");
1029
1030 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000);
1031 if (ret)
1032 return dev_err_probe(dev, ret, "can't setup low threshold\n");
1033
1034 ret = veml6030_als_pwr_on(data);
1035 if (ret)
1036 return dev_err_probe(dev, ret, "can't poweron als\n");
1037
1038 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data);
1039 if (ret < 0)
1040 return ret;
1041
1042 /* Clear stale interrupt status bits if any during start */
1043 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val);
1044 if (ret < 0)
1045 return dev_err_probe(dev, ret,
1046 "can't clear als interrupt status\n");
1047
1048 return 0;
1049 }
1050
veml6030_probe(struct i2c_client * client)1051 static int veml6030_probe(struct i2c_client *client)
1052 {
1053 int ret;
1054 struct veml6030_data *data;
1055 struct iio_dev *indio_dev;
1056 struct regmap *regmap;
1057
1058 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
1059 return dev_err_probe(&client->dev, -EOPNOTSUPP,
1060 "i2c adapter doesn't support plain i2c\n");
1061
1062 regmap = devm_regmap_init_i2c(client, &veml6030_regmap_config);
1063 if (IS_ERR(regmap))
1064 return dev_err_probe(&client->dev, PTR_ERR(regmap),
1065 "can't setup regmap\n");
1066
1067 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1068 if (!indio_dev)
1069 return -ENOMEM;
1070
1071 data = iio_priv(indio_dev);
1072 i2c_set_clientdata(client, indio_dev);
1073 data->client = client;
1074 data->regmap = regmap;
1075
1076 ret = devm_regulator_get_enable(&client->dev, "vdd");
1077 if (ret)
1078 return dev_err_probe(&client->dev, ret,
1079 "failed to enable regulator\n");
1080
1081 data->chip = i2c_get_match_data(client);
1082 if (!data->chip)
1083 return -EINVAL;
1084
1085 indio_dev->name = data->chip->name;
1086 indio_dev->channels = data->chip->channels;
1087 indio_dev->num_channels = data->chip->num_channels;
1088 indio_dev->modes = INDIO_DIRECT_MODE;
1089
1090 ret = data->chip->set_info(indio_dev);
1091 if (ret < 0)
1092 return ret;
1093
1094 ret = veml6030_regfield_init(indio_dev);
1095 if (ret)
1096 return dev_err_probe(&client->dev, ret,
1097 "failed to init regfields\n");
1098
1099 ret = data->chip->hw_init(indio_dev, &client->dev);
1100 if (ret < 0)
1101 return ret;
1102
1103 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
1104 veml6030_trigger_handler, NULL);
1105 if (ret)
1106 return dev_err_probe(&client->dev, ret,
1107 "Failed to register triggered buffer");
1108
1109 return devm_iio_device_register(&client->dev, indio_dev);
1110 }
1111
veml6030_runtime_suspend(struct device * dev)1112 static int veml6030_runtime_suspend(struct device *dev)
1113 {
1114 int ret;
1115 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1116 struct veml6030_data *data = iio_priv(indio_dev);
1117
1118 ret = veml6030_als_shut_down(data);
1119 if (ret < 0)
1120 dev_err(&data->client->dev, "can't suspend als %d\n", ret);
1121
1122 return ret;
1123 }
1124
veml6030_runtime_resume(struct device * dev)1125 static int veml6030_runtime_resume(struct device *dev)
1126 {
1127 int ret;
1128 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1129 struct veml6030_data *data = iio_priv(indio_dev);
1130
1131 ret = veml6030_als_pwr_on(data);
1132 if (ret < 0)
1133 dev_err(&data->client->dev, "can't resume als %d\n", ret);
1134
1135 return ret;
1136 }
1137
1138 static DEFINE_RUNTIME_DEV_PM_OPS(veml6030_pm_ops, veml6030_runtime_suspend,
1139 veml6030_runtime_resume, NULL);
1140
1141 static const struct veml603x_chip veml6030_chip = {
1142 .name = "veml6030",
1143 .channels = veml6030_channels,
1144 .num_channels = ARRAY_SIZE(veml6030_channels),
1145 .gain_rf = VEML6030_GAIN_RF,
1146 .it_rf = VEML6030_IT_RF,
1147 .max_scale = VEML6030_MAX_SCALE,
1148 .hw_init = veml6030_hw_init,
1149 .set_info = veml6030_set_info,
1150 };
1151
1152 static const struct veml603x_chip veml6035_chip = {
1153 .name = "veml6035",
1154 .channels = veml6030_channels,
1155 .num_channels = ARRAY_SIZE(veml6030_channels),
1156 .gain_rf = VEML6035_GAIN_RF,
1157 .it_rf = VEML6030_IT_RF,
1158 .max_scale = VEML6035_MAX_SCALE,
1159 .hw_init = veml6035_hw_init,
1160 .set_info = veml6030_set_info,
1161 };
1162
1163 static const struct veml603x_chip veml7700_chip = {
1164 .name = "veml7700",
1165 .channels = veml7700_channels,
1166 .num_channels = ARRAY_SIZE(veml7700_channels),
1167 .gain_rf = VEML6030_GAIN_RF,
1168 .it_rf = VEML6030_IT_RF,
1169 .max_scale = VEML6030_MAX_SCALE,
1170 .hw_init = veml6030_hw_init,
1171 .set_info = veml7700_set_info,
1172 };
1173
1174 static const struct of_device_id veml6030_of_match[] = {
1175 {
1176 .compatible = "vishay,veml6030",
1177 .data = &veml6030_chip,
1178 },
1179 {
1180 .compatible = "vishay,veml6035",
1181 .data = &veml6035_chip,
1182 },
1183 {
1184 .compatible = "vishay,veml7700",
1185 .data = &veml7700_chip,
1186 },
1187 { }
1188 };
1189 MODULE_DEVICE_TABLE(of, veml6030_of_match);
1190
1191 static const struct i2c_device_id veml6030_id[] = {
1192 { "veml6030", (kernel_ulong_t)&veml6030_chip},
1193 { "veml6035", (kernel_ulong_t)&veml6035_chip},
1194 { "veml7700", (kernel_ulong_t)&veml7700_chip},
1195 { }
1196 };
1197 MODULE_DEVICE_TABLE(i2c, veml6030_id);
1198
1199 static struct i2c_driver veml6030_driver = {
1200 .driver = {
1201 .name = "veml6030",
1202 .of_match_table = veml6030_of_match,
1203 .pm = pm_ptr(&veml6030_pm_ops),
1204 },
1205 .probe = veml6030_probe,
1206 .id_table = veml6030_id,
1207 };
1208 module_i2c_driver(veml6030_driver);
1209
1210 MODULE_AUTHOR("Rishi Gupta <[email protected]>");
1211 MODULE_DESCRIPTION("VEML6030 Ambient Light Sensor");
1212 MODULE_LICENSE("GPL v2");
1213 MODULE_IMPORT_NS("IIO_GTS_HELPER");
1214