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
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_range veml6030_readable_ranges[] = {
355 regmap_reg_range(VEML6030_REG_ALS_CONF, VEML6030_REG_ALS_INT),
356 };
357
358 static 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
363 static const struct regmap_range veml6030_writable_ranges[] = {
364 regmap_reg_range(VEML6030_REG_ALS_CONF, VEML6030_REG_ALS_PSM),
365 };
366
367 static 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
372 static const struct regmap_range veml6030_volatile_ranges[] = {
373 regmap_reg_range(VEML6030_REG_ALS_DATA, VEML6030_REG_WH_DATA),
374 };
375
376 static 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
381 static 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
veml6030_get_it(struct veml6030_data * data,int * val,int * val2)393 static int veml6030_get_it(struct veml6030_data *data, int *val, int *val2)
394 {
395 int ret, it_idx;
396
397 ret = regmap_field_read(data->rf.it, &it_idx);
398 if (ret)
399 return ret;
400
401 ret = iio_gts_find_int_time_by_sel(&data->gts, 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
veml6030_set_it(struct iio_dev * indio_dev,int val,int val2)411 static 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(&data->gts, val2))
418 return -EINVAL;
419
420 ret = regmap_field_read(data->rf.it, &it_idx);
421 if (ret)
422 return ret;
423
424 ret = regmap_field_read(data->rf.gain, &gain_idx);
425 if (ret)
426 return ret;
427
428 prev_it = iio_gts_find_int_time_by_sel(&data->gts, 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(&data->gts, gain_idx);
436 if (prev_gain < 0)
437 return prev_gain;
438
439 ret = iio_gts_find_new_gain_by_gain_time_min(&data->gts, prev_gain, prev_it,
440 val2, &new_gain, &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(&data->gts, val2);
448 if (ret < 0)
449 return ret;
450
451 ret = regmap_field_write(data->rf.it, ret);
452 if (ret)
453 return ret;
454
455 ret = iio_gts_find_sel_by_gain(&data->gts, new_gain);
456 if (ret < 0)
457 return ret;
458
459 return regmap_field_write(data->rf.gain, ret);
460 }
461
veml6030_read_persistence(struct iio_dev * indio_dev,int * val,int * val2)462 static 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, &x, &y);
469 if (ret < 0)
470 return ret;
471
472 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®);
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
veml6030_write_persistence(struct iio_dev * indio_dev,int val,int val2)487 static 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, &x, &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(data->regmap, VEML6030_REG_ALS_CONF,
514 VEML6030_ALS_PERS, (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
veml6030_set_scale(struct iio_dev * indio_dev,int val,int val2)522 static 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(data->rf.it, &it_idx);
528 if (ret)
529 return ret;
530
531 ret = iio_gts_find_gain_time_sel_for_scale(&data->gts, val, val2,
532 &gain_sel, &it_sel);
533 if (ret)
534 return ret;
535
536 ret = regmap_field_write(data->rf.it, it_sel);
537 if (ret)
538 return ret;
539
540 ret = regmap_field_write(data->rf.gain, gain_sel);
541 if (ret)
542 return ret;
543
544 return 0;
545 }
546
veml6030_read_thresh(struct iio_dev * indio_dev,int * val,int * val2,int dir)547 static 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(data->regmap, VEML6030_REG_ALS_WH, ®);
555 else
556 ret = regmap_read(data->regmap, VEML6030_REG_ALS_WL, ®);
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
veml6030_write_thresh(struct iio_dev * indio_dev,int val,int val2,int dir)567 static 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(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(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
veml6030_get_total_gain(struct veml6030_data * data)591 static int veml6030_get_total_gain(struct veml6030_data *data)
592 {
593 int gain, it, reg, ret;
594
595 ret = regmap_field_read(data->rf.gain, ®);
596 if (ret)
597 return ret;
598
599 gain = iio_gts_find_gain_by_sel(&data->gts, reg);
600 if (gain < 0)
601 return gain;
602
603 ret = regmap_field_read(data->rf.it, ®);
604 if (ret)
605 return ret;
606
607 it = iio_gts_find_int_time_by_sel(&data->gts, reg);
608 if (it < 0)
609 return it;
610
611 return iio_gts_get_total_gain(&data->gts, gain, it);
612 }
613
veml6030_get_scale(struct veml6030_data * data,int * val,int * val2)614 static 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(data->rf.gain, ®);
619 if (ret)
620 return ret;
621
622 gain = iio_gts_find_gain_by_sel(&data->gts, reg);
623 if (gain < 0)
624 return gain;
625
626 ret = regmap_field_read(data->rf.it, ®);
627 if (ret)
628 return ret;
629
630 it = iio_gts_find_int_time_by_sel(&data->gts, reg);
631 if (it < 0)
632 return it;
633
634 ret = iio_gts_get_scale(&data->gts, gain, it, val, val2);
635 if (ret)
636 return ret;
637
638 return IIO_VAL_INT_PLUS_NANO;
639 }
640
veml6030_process_als(struct veml6030_data * data,int raw,int * val,int * val2)641 static 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 */
veml6030_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)660 static 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(regmap, VEML6030_REG_ALS_DATA, ®);
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, reg, val, val2);
681
682 *val = reg;
683 return IIO_VAL_INT;
684 case IIO_INTENSITY:
685 ret = regmap_read(regmap, VEML6030_REG_WH_DATA, ®);
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
veml6030_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)704 static 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(&data->gts, vals, type, length);
714 case IIO_CHAN_INFO_SCALE:
715 return iio_gts_all_avail_scales(&data->gts, vals, type, length);
716 }
717
718 return -EINVAL;
719 }
720
veml6030_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)721 static 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
veml6030_write_raw_get_fmt(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,long mask)735 static 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
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)749 static 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
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)771 static 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
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)786 static 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(data->regmap, VEML6030_REG_ALS_CONF, ®);
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 */
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)813 static 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(data->regmap, VEML6030_REG_ALS_CONF,
829 VEML6030_ALS_INT_EN | VEML6030_ALS_SD, 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
837 static 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
849 static 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
veml6030_event_handler(int irq,void * private)856 static 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(data->regmap, VEML6030_REG_ALS_INT, ®);
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 iio_get_time_ns(indio_dev));
881
882 return IRQ_HANDLED;
883 }
884
veml6030_trigger_handler(int irq,void * p)885 static 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(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 memset(&scan, 0, sizeof(scan));
898
899 iio_for_each_active_channel(iio, ch) {
900 ret = regmap_read(data->regmap, VEML6030_REG_DATA(ch),
901 ®);
902 if (ret)
903 goto done;
904
905 scan.chans[i++] = reg;
906 }
907
908 iio_push_to_buffers_with_timestamp(iio, &scan, pf->timestamp);
909
910 done:
911 iio_trigger_notify_done(iio->trig);
912
913 return IRQ_HANDLED;
914 }
915
veml6030_set_info(struct iio_dev * indio_dev)916 static int veml6030_set_info(struct iio_dev *indio_dev)
917 {
918 struct veml6030_data *data = iio_priv(indio_dev);
919 struct i2c_client *client = data->client;
920 int ret;
921
922 if (client->irq) {
923 ret = devm_request_threaded_irq(&client->dev, client->irq,
924 NULL, veml6030_event_handler,
925 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
926 indio_dev->name, indio_dev);
927 if (ret < 0)
928 return dev_err_probe(&client->dev, ret,
929 "irq %d request failed\n",
930 client->irq);
931
932 indio_dev->info = &veml6030_info;
933 } else {
934 indio_dev->info = &veml6030_info_no_irq;
935 }
936
937 return 0;
938 }
939
veml7700_set_info(struct iio_dev * indio_dev)940 static int veml7700_set_info(struct iio_dev *indio_dev)
941 {
942 indio_dev->info = &veml6030_info_no_irq;
943
944 return 0;
945 }
946
veml6030_regfield_init(struct iio_dev * indio_dev)947 static int veml6030_regfield_init(struct iio_dev *indio_dev)
948 {
949 struct veml6030_data *data = iio_priv(indio_dev);
950 struct regmap *regmap = data->regmap;
951 struct device *dev = &data->client->dev;
952 struct regmap_field *rm_field;
953 struct veml6030_rf *rf = &data->rf;
954
955 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->it_rf);
956 if (IS_ERR(rm_field))
957 return PTR_ERR(rm_field);
958 rf->it = rm_field;
959
960 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->gain_rf);
961 if (IS_ERR(rm_field))
962 return PTR_ERR(rm_field);
963 rf->gain = rm_field;
964
965 return 0;
966 }
967
968 /*
969 * Set ALS gain to 1/8, integration time to 100 ms, PSM to mode 2,
970 * persistence to 1 x integration time and the threshold
971 * interrupt disabled by default. First shutdown the sensor,
972 * update registers and then power on the sensor.
973 */
veml6030_hw_init(struct iio_dev * indio_dev,struct device * dev)974 static int veml6030_hw_init(struct iio_dev *indio_dev, struct device *dev)
975 {
976 int ret, val;
977 struct veml6030_data *data = iio_priv(indio_dev);
978
979 ret = devm_iio_init_iio_gts(dev, 2, 150400000,
980 veml6030_gain_sel, ARRAY_SIZE(veml6030_gain_sel),
981 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel),
982 &data->gts);
983 if (ret)
984 return dev_err_probe(dev, ret, "failed to init iio gts\n");
985
986 ret = veml6030_als_shut_down(data);
987 if (ret)
988 return dev_err_probe(dev, ret, "can't shutdown als\n");
989
990 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 0x1001);
991 if (ret)
992 return dev_err_probe(dev, ret, "can't setup als configs\n");
993
994 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM,
995 VEML6030_PSM | VEML6030_PSM_EN, 0x03);
996 if (ret)
997 return dev_err_probe(dev, ret, "can't setup default PSM\n");
998
999 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF);
1000 if (ret)
1001 return dev_err_probe(dev, ret, "can't setup high threshold\n");
1002
1003 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000);
1004 if (ret)
1005 return dev_err_probe(dev, ret, "can't setup low threshold\n");
1006
1007 ret = veml6030_als_pwr_on(data);
1008 if (ret)
1009 return dev_err_probe(dev, ret, "can't poweron als\n");
1010
1011 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data);
1012 if (ret < 0)
1013 return ret;
1014
1015 /* Clear stale interrupt status bits if any during start */
1016 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val);
1017 if (ret < 0)
1018 return dev_err_probe(dev, ret,
1019 "can't clear als interrupt status\n");
1020
1021 return ret;
1022 }
1023
1024 /*
1025 * Set ALS gain to 1/8, integration time to 100 ms, ALS and WHITE
1026 * channel enabled, ALS channel interrupt, PSM enabled,
1027 * PSM_WAIT = 0.8 s, persistence to 1 x integration time and the
1028 * threshold interrupt disabled by default. First shutdown the sensor,
1029 * update registers and then power on the sensor.
1030 */
veml6035_hw_init(struct iio_dev * indio_dev,struct device * dev)1031 static int veml6035_hw_init(struct iio_dev *indio_dev, struct device *dev)
1032 {
1033 int ret, val;
1034 struct veml6030_data *data = iio_priv(indio_dev);
1035
1036 ret = devm_iio_init_iio_gts(dev, 0, 409600000,
1037 veml6035_gain_sel, ARRAY_SIZE(veml6035_gain_sel),
1038 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel),
1039 &data->gts);
1040 if (ret)
1041 return dev_err_probe(dev, ret, "failed to init iio gts\n");
1042
1043 ret = veml6030_als_shut_down(data);
1044 if (ret)
1045 return dev_err_probe(dev, ret, "can't shutdown als\n");
1046
1047 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF,
1048 VEML6035_SENS | VEML6035_CHAN_EN | VEML6030_ALS_SD);
1049 if (ret)
1050 return dev_err_probe(dev, ret, "can't setup als configs\n");
1051
1052 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM,
1053 VEML6030_PSM | VEML6030_PSM_EN, 0x03);
1054 if (ret)
1055 return dev_err_probe(dev, ret, "can't setup default PSM\n");
1056
1057 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF);
1058 if (ret)
1059 return dev_err_probe(dev, ret, "can't setup high threshold\n");
1060
1061 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000);
1062 if (ret)
1063 return dev_err_probe(dev, ret, "can't setup low threshold\n");
1064
1065 ret = veml6030_als_pwr_on(data);
1066 if (ret)
1067 return dev_err_probe(dev, ret, "can't poweron als\n");
1068
1069 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data);
1070 if (ret < 0)
1071 return ret;
1072
1073 /* Clear stale interrupt status bits if any during start */
1074 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val);
1075 if (ret < 0)
1076 return dev_err_probe(dev, ret,
1077 "can't clear als interrupt status\n");
1078
1079 return 0;
1080 }
1081
veml6030_probe(struct i2c_client * client)1082 static int veml6030_probe(struct i2c_client *client)
1083 {
1084 int ret;
1085 struct veml6030_data *data;
1086 struct iio_dev *indio_dev;
1087 struct regmap *regmap;
1088
1089 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
1090 return dev_err_probe(&client->dev, -EOPNOTSUPP,
1091 "i2c adapter doesn't support plain i2c\n");
1092
1093 regmap = devm_regmap_init_i2c(client, &veml6030_regmap_config);
1094 if (IS_ERR(regmap))
1095 return dev_err_probe(&client->dev, PTR_ERR(regmap),
1096 "can't setup regmap\n");
1097
1098 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1099 if (!indio_dev)
1100 return -ENOMEM;
1101
1102 data = iio_priv(indio_dev);
1103 i2c_set_clientdata(client, indio_dev);
1104 data->client = client;
1105 data->regmap = regmap;
1106
1107 ret = devm_regulator_get_enable(&client->dev, "vdd");
1108 if (ret)
1109 return dev_err_probe(&client->dev, ret,
1110 "failed to enable regulator\n");
1111
1112 data->chip = i2c_get_match_data(client);
1113 if (!data->chip)
1114 return -EINVAL;
1115
1116 indio_dev->name = data->chip->name;
1117 indio_dev->channels = data->chip->channels;
1118 indio_dev->num_channels = data->chip->num_channels;
1119 indio_dev->modes = INDIO_DIRECT_MODE;
1120
1121 ret = data->chip->set_info(indio_dev);
1122 if (ret < 0)
1123 return ret;
1124
1125 ret = veml6030_regfield_init(indio_dev);
1126 if (ret)
1127 return dev_err_probe(&client->dev, ret,
1128 "failed to init regfields\n");
1129
1130 ret = data->chip->hw_init(indio_dev, &client->dev);
1131 if (ret < 0)
1132 return ret;
1133
1134 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
1135 veml6030_trigger_handler, NULL);
1136 if (ret)
1137 return dev_err_probe(&client->dev, ret,
1138 "Failed to register triggered buffer");
1139
1140 return devm_iio_device_register(&client->dev, indio_dev);
1141 }
1142
veml6030_runtime_suspend(struct device * dev)1143 static int veml6030_runtime_suspend(struct device *dev)
1144 {
1145 int ret;
1146 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1147 struct veml6030_data *data = iio_priv(indio_dev);
1148
1149 ret = veml6030_als_shut_down(data);
1150 if (ret < 0)
1151 dev_err(&data->client->dev, "can't suspend als %d\n", ret);
1152
1153 return ret;
1154 }
1155
veml6030_runtime_resume(struct device * dev)1156 static int veml6030_runtime_resume(struct device *dev)
1157 {
1158 int ret;
1159 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1160 struct veml6030_data *data = iio_priv(indio_dev);
1161
1162 ret = veml6030_als_pwr_on(data);
1163 if (ret < 0)
1164 dev_err(&data->client->dev, "can't resume als %d\n", ret);
1165
1166 return ret;
1167 }
1168
1169 static DEFINE_RUNTIME_DEV_PM_OPS(veml6030_pm_ops, veml6030_runtime_suspend,
1170 veml6030_runtime_resume, NULL);
1171
1172 static const struct veml603x_chip veml6030_chip = {
1173 .name = "veml6030",
1174 .channels = veml6030_channels,
1175 .num_channels = ARRAY_SIZE(veml6030_channels),
1176 .gain_rf = VEML6030_GAIN_RF,
1177 .it_rf = VEML6030_IT_RF,
1178 .max_scale = VEML6030_MAX_SCALE,
1179 .hw_init = veml6030_hw_init,
1180 .set_info = veml6030_set_info,
1181 };
1182
1183 static const struct veml603x_chip veml6035_chip = {
1184 .name = "veml6035",
1185 .channels = veml6030_channels,
1186 .num_channels = ARRAY_SIZE(veml6030_channels),
1187 .gain_rf = VEML6035_GAIN_RF,
1188 .it_rf = VEML6030_IT_RF,
1189 .max_scale = VEML6035_MAX_SCALE,
1190 .hw_init = veml6035_hw_init,
1191 .set_info = veml6030_set_info,
1192 };
1193
1194 static const struct veml603x_chip veml7700_chip = {
1195 .name = "veml7700",
1196 .channels = veml7700_channels,
1197 .num_channels = ARRAY_SIZE(veml7700_channels),
1198 .gain_rf = VEML6030_GAIN_RF,
1199 .it_rf = VEML6030_IT_RF,
1200 .max_scale = VEML6030_MAX_SCALE,
1201 .hw_init = veml6030_hw_init,
1202 .set_info = veml7700_set_info,
1203 };
1204
1205 static const struct of_device_id veml6030_of_match[] = {
1206 {
1207 .compatible = "vishay,veml6030",
1208 .data = &veml6030_chip,
1209 },
1210 {
1211 .compatible = "vishay,veml6035",
1212 .data = &veml6035_chip,
1213 },
1214 {
1215 .compatible = "vishay,veml7700",
1216 .data = &veml7700_chip,
1217 },
1218 { }
1219 };
1220 MODULE_DEVICE_TABLE(of, veml6030_of_match);
1221
1222 static const struct i2c_device_id veml6030_id[] = {
1223 { "veml6030", (kernel_ulong_t)&veml6030_chip},
1224 { "veml6035", (kernel_ulong_t)&veml6035_chip},
1225 { "veml7700", (kernel_ulong_t)&veml7700_chip},
1226 { }
1227 };
1228 MODULE_DEVICE_TABLE(i2c, veml6030_id);
1229
1230 static struct i2c_driver veml6030_driver = {
1231 .driver = {
1232 .name = "veml6030",
1233 .of_match_table = veml6030_of_match,
1234 .pm = pm_ptr(&veml6030_pm_ops),
1235 },
1236 .probe = veml6030_probe,
1237 .id_table = veml6030_id,
1238 };
1239 module_i2c_driver(veml6030_driver);
1240
1241 MODULE_AUTHOR("Rishi Gupta <gupt21@gmail.com>");
1242 MODULE_DESCRIPTION("VEML6030 Ambient Light Sensor");
1243 MODULE_LICENSE("GPL v2");
1244 MODULE_IMPORT_NS("IIO_GTS_HELPER");
1245