Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * VEML3235 Ambient Light Sensor
4 *
5 * Copyright (c) 2024, Javier Carrasco <javier.carrasco.cruz@gmail.com>
6 *
7 * Datasheet: https://www.vishay.com/docs/80131/veml3235.pdf
8 * Appnote-80222: https://www.vishay.com/docs/80222/designingveml3235.pdf
9 */
10
11#include <linux/err.h>
12#include <linux/i2c.h>
13#include <linux/iio/iio.h>
14#include <linux/module.h>
15#include <linux/pm_runtime.h>
16#include <linux/regmap.h>
17#include <linux/regulator/consumer.h>
18
19#define VEML3235_REG_CONF 0x00
20#define VEML3235_REG_WH_DATA 0x04
21#define VEML3235_REG_ALS_DATA 0x05
22#define VEML3235_REG_ID 0x09
23
24#define VEML3235_CONF_SD BIT(0)
25#define VEML3235_CONF_SD0 BIT(15)
26
27struct veml3235_rf {
28 struct regmap_field *it;
29 struct regmap_field *gain;
30 struct regmap_field *id;
31};
32
33struct veml3235_data {
34 struct i2c_client *client;
35 struct device *dev;
36 struct regmap *regmap;
37 struct veml3235_rf rf;
38};
39
40static const int veml3235_it_times[][2] = {
41 { 0, 50000 },
42 { 0, 100000 },
43 { 0, 200000 },
44 { 0, 400000 },
45 { 0, 800000 },
46};
47
48static const int veml3235_scale_vals[] = { 1, 2, 4, 8 };
49
50static int veml3235_power_on(struct veml3235_data *data)
51{
52 int ret;
53
54 ret = regmap_clear_bits(data->regmap, VEML3235_REG_CONF,
55 VEML3235_CONF_SD | VEML3235_CONF_SD0);
56 if (ret)
57 return ret;
58
59 /* Wait 4 ms to let processor & oscillator start correctly */
60 fsleep(4000);
61
62 return 0;
63}
64
65static int veml3235_shut_down(struct veml3235_data *data)
66{
67 return regmap_set_bits(data->regmap, VEML3235_REG_CONF,
68 VEML3235_CONF_SD | VEML3235_CONF_SD0);
69}
70
71static void veml3235_shut_down_action(void *data)
72{
73 veml3235_shut_down(data);
74}
75
76enum veml3235_chan {
77 CH_ALS,
78 CH_WHITE,
79};
80
81static const struct iio_chan_spec veml3235_channels[] = {
82 {
83 .type = IIO_LIGHT,
84 .channel = CH_ALS,
85 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
86 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) |
87 BIT(IIO_CHAN_INFO_SCALE),
88 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
89 BIT(IIO_CHAN_INFO_SCALE),
90 },
91 {
92 .type = IIO_INTENSITY,
93 .channel = CH_WHITE,
94 .modified = 1,
95 .channel2 = IIO_MOD_LIGHT_BOTH,
96 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
97 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) |
98 BIT(IIO_CHAN_INFO_SCALE),
99 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
100 BIT(IIO_CHAN_INFO_SCALE),
101 },
102};
103
104static const struct regmap_config veml3235_regmap_config = {
105 .name = "veml3235_regmap",
106 .reg_bits = 8,
107 .val_bits = 16,
108 .max_register = VEML3235_REG_ID,
109 .val_format_endian = REGMAP_ENDIAN_LITTLE,
110};
111
112static int veml3235_get_it(struct veml3235_data *data, int *val, int *val2)
113{
114 int ret, reg;
115
116 ret = regmap_field_read(data->rf.it, ®);
117 if (ret)
118 return ret;
119
120 switch (reg) {
121 case 0:
122 *val2 = 50000;
123 break;
124 case 1:
125 *val2 = 100000;
126 break;
127 case 2:
128 *val2 = 200000;
129 break;
130 case 3:
131 *val2 = 400000;
132 break;
133 case 4:
134 *val2 = 800000;
135 break;
136 default:
137 return -EINVAL;
138 }
139
140 *val = 0;
141
142 return IIO_VAL_INT_PLUS_MICRO;
143}
144
145static int veml3235_set_it(struct iio_dev *indio_dev, int val, int val2)
146{
147 struct veml3235_data *data = iio_priv(indio_dev);
148 int ret, new_it;
149
150 if (val)
151 return -EINVAL;
152
153 switch (val2) {
154 case 50000:
155 new_it = 0x00;
156 break;
157 case 100000:
158 new_it = 0x01;
159 break;
160 case 200000:
161 new_it = 0x02;
162 break;
163 case 400000:
164 new_it = 0x03;
165 break;
166 case 800000:
167 new_it = 0x04;
168 break;
169 default:
170 return -EINVAL;
171 }
172
173 ret = regmap_field_write(data->rf.it, new_it);
174 if (ret) {
175 dev_err(data->dev,
176 "failed to update integration time: %d\n", ret);
177 return ret;
178 }
179
180 return 0;
181}
182
183static int veml3235_set_gain(struct iio_dev *indio_dev, int val, int val2)
184{
185 struct veml3235_data *data = iio_priv(indio_dev);
186 int ret, new_gain;
187
188 if (val2 != 0)
189 return -EINVAL;
190
191 switch (val) {
192 case 1:
193 new_gain = 0x00;
194 break;
195 case 2:
196 new_gain = 0x01;
197 break;
198 case 4:
199 new_gain = 0x03;
200 break;
201 case 8:
202 new_gain = 0x07;
203 break;
204 default:
205 return -EINVAL;
206 }
207
208 ret = regmap_field_write(data->rf.gain, new_gain);
209 if (ret) {
210 dev_err(data->dev, "failed to set gain: %d\n", ret);
211 return ret;
212 }
213
214 return 0;
215}
216
217static int veml3235_get_gain(struct veml3235_data *data, int *val)
218{
219 int ret, reg;
220
221 ret = regmap_field_read(data->rf.gain, ®);
222 if (ret) {
223 dev_err(data->dev, "failed to read gain %d\n", ret);
224 return ret;
225 }
226
227 switch (reg & 0x03) {
228 case 0:
229 *val = 1;
230 break;
231 case 1:
232 *val = 2;
233 break;
234 case 3:
235 *val = 4;
236 break;
237 default:
238 return -EINVAL;
239 }
240
241 /* Double gain */
242 if (reg & 0x04)
243 *val *= 2;
244
245 return IIO_VAL_INT;
246}
247
248static int veml3235_read_raw(struct iio_dev *indio_dev,
249 struct iio_chan_spec const *chan, int *val,
250 int *val2, long mask)
251{
252 struct veml3235_data *data = iio_priv(indio_dev);
253 struct regmap *regmap = data->regmap;
254 int ret, reg;
255
256 switch (mask) {
257 case IIO_CHAN_INFO_RAW:
258 switch (chan->type) {
259 case IIO_LIGHT:
260 ret = regmap_read(regmap, VEML3235_REG_ALS_DATA, ®);
261 if (ret < 0)
262 return ret;
263
264 *val = reg;
265 return IIO_VAL_INT;
266 case IIO_INTENSITY:
267 ret = regmap_read(regmap, VEML3235_REG_WH_DATA, ®);
268 if (ret < 0)
269 return ret;
270
271 *val = reg;
272 return IIO_VAL_INT;
273 default:
274 return -EINVAL;
275 }
276 case IIO_CHAN_INFO_INT_TIME:
277 return veml3235_get_it(data, val, val2);
278 case IIO_CHAN_INFO_SCALE:
279 return veml3235_get_gain(data, val);
280 default:
281 return -EINVAL;
282 }
283}
284
285static int veml3235_read_avail(struct iio_dev *indio_dev,
286 struct iio_chan_spec const *chan,
287 const int **vals, int *type, int *length,
288 long mask)
289{
290 switch (mask) {
291 case IIO_CHAN_INFO_INT_TIME:
292 *vals = (int *)&veml3235_it_times;
293 *length = 2 * ARRAY_SIZE(veml3235_it_times);
294 *type = IIO_VAL_INT_PLUS_MICRO;
295 return IIO_AVAIL_LIST;
296 case IIO_CHAN_INFO_SCALE:
297 *vals = (int *)&veml3235_scale_vals;
298 *length = ARRAY_SIZE(veml3235_scale_vals);
299 *type = IIO_VAL_INT;
300 return IIO_AVAIL_LIST;
301 default:
302 return -EINVAL;
303 }
304}
305
306static int veml3235_write_raw(struct iio_dev *indio_dev,
307 struct iio_chan_spec const *chan,
308 int val, int val2, long mask)
309{
310 switch (mask) {
311 case IIO_CHAN_INFO_INT_TIME:
312 return veml3235_set_it(indio_dev, val, val2);
313 case IIO_CHAN_INFO_SCALE:
314 return veml3235_set_gain(indio_dev, val, val2);
315 }
316
317 return -EINVAL;
318}
319
320static void veml3235_read_id(struct veml3235_data *data)
321{
322 int ret, reg;
323
324 ret = regmap_field_read(data->rf.id, ®);
325 if (ret) {
326 dev_info(data->dev, "failed to read ID\n");
327 return;
328 }
329
330 if (reg != 0x35)
331 dev_info(data->dev, "Unknown ID %d\n", reg);
332}
333
334static const struct reg_field veml3235_rf_it =
335 REG_FIELD(VEML3235_REG_CONF, 4, 6);
336
337static const struct reg_field veml3235_rf_gain =
338 REG_FIELD(VEML3235_REG_CONF, 11, 13);
339
340static const struct reg_field veml3235_rf_id =
341 REG_FIELD(VEML3235_REG_ID, 0, 7);
342
343static int veml3235_regfield_init(struct veml3235_data *data)
344{
345 struct regmap *regmap = data->regmap;
346 struct device *dev = data->dev;
347 struct regmap_field *rm_field;
348 struct veml3235_rf *rf = &data->rf;
349
350 rm_field = devm_regmap_field_alloc(dev, regmap, veml3235_rf_it);
351 if (IS_ERR(rm_field))
352 return PTR_ERR(rm_field);
353 rf->it = rm_field;
354
355 rm_field = devm_regmap_field_alloc(dev, regmap, veml3235_rf_gain);
356 if (IS_ERR(rm_field))
357 return PTR_ERR(rm_field);
358 rf->gain = rm_field;
359
360 rm_field = devm_regmap_field_alloc(dev, regmap, veml3235_rf_id);
361 if (IS_ERR(rm_field))
362 return PTR_ERR(rm_field);
363 rf->id = rm_field;
364
365 return 0;
366}
367
368static int veml3235_hw_init(struct iio_dev *indio_dev)
369{
370 struct veml3235_data *data = iio_priv(indio_dev);
371 struct device *dev = data->dev;
372 int ret;
373
374 /* Set gain to 1 and integration time to 100 ms */
375 ret = regmap_field_write(data->rf.gain, 0x00);
376 if (ret)
377 return dev_err_probe(data->dev, ret, "failed to set gain\n");
378
379 ret = regmap_field_write(data->rf.it, 0x01);
380 if (ret)
381 return dev_err_probe(data->dev, ret,
382 "failed to set integration time\n");
383
384 ret = veml3235_power_on(data);
385 if (ret)
386 return dev_err_probe(dev, ret, "failed to power on\n");
387
388 return devm_add_action_or_reset(dev, veml3235_shut_down_action, data);
389}
390
391static const struct iio_info veml3235_info = {
392 .read_raw = veml3235_read_raw,
393 .read_avail = veml3235_read_avail,
394 .write_raw = veml3235_write_raw,
395};
396
397static int veml3235_probe(struct i2c_client *client)
398{
399 struct device *dev = &client->dev;
400 struct veml3235_data *data;
401 struct iio_dev *indio_dev;
402 struct regmap *regmap;
403 int ret;
404
405 regmap = devm_regmap_init_i2c(client, &veml3235_regmap_config);
406 if (IS_ERR(regmap))
407 return dev_err_probe(dev, PTR_ERR(regmap),
408 "failed to setup regmap\n");
409
410 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
411 if (!indio_dev)
412 return -ENOMEM;
413
414 data = iio_priv(indio_dev);
415 i2c_set_clientdata(client, indio_dev);
416 data->client = client;
417 data->dev = dev;
418 data->regmap = regmap;
419
420 ret = veml3235_regfield_init(data);
421 if (ret)
422 return dev_err_probe(dev, ret, "failed to init regfield\n");
423
424 ret = devm_regulator_get_enable(dev, "vdd");
425 if (ret)
426 return dev_err_probe(dev, ret, "failed to enable regulator\n");
427
428 indio_dev->name = "veml3235";
429 indio_dev->channels = veml3235_channels;
430 indio_dev->num_channels = ARRAY_SIZE(veml3235_channels);
431 indio_dev->modes = INDIO_DIRECT_MODE;
432 indio_dev->info = &veml3235_info;
433
434 veml3235_read_id(data);
435
436 ret = veml3235_hw_init(indio_dev);
437 if (ret < 0)
438 return ret;
439
440 return devm_iio_device_register(dev, indio_dev);
441}
442
443static int veml3235_runtime_suspend(struct device *dev)
444{
445 struct veml3235_data *data = iio_priv(dev_get_drvdata(dev));
446 int ret;
447
448 ret = veml3235_shut_down(data);
449 if (ret < 0)
450 dev_err(data->dev, "failed to suspend: %d\n", ret);
451
452 return ret;
453}
454
455static int veml3235_runtime_resume(struct device *dev)
456{
457 struct veml3235_data *data = iio_priv(dev_get_drvdata(dev));
458 int ret;
459
460 ret = veml3235_power_on(data);
461 if (ret < 0)
462 dev_err(data->dev, "failed to resume: %d\n", ret);
463
464 return ret;
465}
466
467static DEFINE_RUNTIME_DEV_PM_OPS(veml3235_pm_ops, veml3235_runtime_suspend,
468 veml3235_runtime_resume, NULL);
469
470static const struct of_device_id veml3235_of_match[] = {
471 { .compatible = "vishay,veml3235" },
472 { }
473};
474MODULE_DEVICE_TABLE(of, veml3235_of_match);
475
476static const struct i2c_device_id veml3235_id[] = {
477 { "veml3235" },
478 { }
479};
480MODULE_DEVICE_TABLE(i2c, veml3235_id);
481
482static struct i2c_driver veml3235_driver = {
483 .driver = {
484 .name = "veml3235",
485 .of_match_table = veml3235_of_match,
486 .pm = pm_ptr(&veml3235_pm_ops),
487 },
488 .probe = veml3235_probe,
489 .id_table = veml3235_id,
490};
491module_i2c_driver(veml3235_driver);
492
493MODULE_AUTHOR("Javier Carrasco <javier.carrasco.cruz@gmail.com>");
494MODULE_DESCRIPTION("VEML3235 Ambient Light Sensor");
495MODULE_LICENSE("GPL");