xref: /linux/drivers/iio/light/vl6180.c (revision 46e6acfe3501fa938af9c5bd730f0020235b08a2) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * vl6180.c - Support for STMicroelectronics VL6180 ALS, range and proximity
4  * sensor
5  *
6  * Copyright 2017 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
7  * Copyright 2017 Manivannan Sadhasivam <manivannanece23@gmail.com>
8  *
9  * IIO driver for VL6180 (7-bit I2C slave address 0x29)
10  *
11  * Range: 0 to 100mm
12  * ALS: < 1 Lux up to 100 kLux
13  * IR: 850nm
14  *
15  * TODO: irq, threshold events, continuous mode, hardware buffer
16  */
17 
18 #include <linux/module.h>
19 #include <linux/mod_devicetable.h>
20 #include <linux/i2c.h>
21 #include <linux/mutex.h>
22 #include <linux/err.h>
23 #include <linux/delay.h>
24 #include <linux/util_macros.h>
25 
26 #include <linux/iio/iio.h>
27 #include <linux/iio/sysfs.h>
28 
29 #define VL6180_DRV_NAME "vl6180"
30 
31 /* Device identification register and value */
32 #define VL6180_MODEL_ID	0x000
33 #define VL6180_MODEL_ID_VAL 0xb4
34 
35 /* Configuration registers */
36 #define VL6180_INTR_CONFIG 0x014
37 #define VL6180_INTR_CLEAR 0x015
38 #define VL6180_OUT_OF_RESET 0x016
39 #define VL6180_HOLD 0x017
40 #define VL6180_RANGE_START 0x018
41 #define VL6180_ALS_START 0x038
42 #define VL6180_ALS_GAIN 0x03f
43 #define VL6180_ALS_IT 0x040
44 
45 /* Status registers */
46 #define VL6180_RANGE_STATUS 0x04d
47 #define VL6180_ALS_STATUS 0x04e
48 #define VL6180_INTR_STATUS 0x04f
49 
50 /* Result value registers */
51 #define VL6180_ALS_VALUE 0x050
52 #define VL6180_RANGE_VALUE 0x062
53 #define VL6180_RANGE_RATE 0x066
54 
55 /* bits of the RANGE_START and ALS_START register */
56 #define VL6180_MODE_CONT BIT(1) /* continuous mode */
57 #define VL6180_STARTSTOP BIT(0) /* start measurement, auto-reset */
58 
59 /* bits of the INTR_STATUS and INTR_CONFIG register */
60 #define VL6180_ALS_READY BIT(5)
61 #define VL6180_RANGE_READY BIT(2)
62 
63 /* bits of the INTR_CLEAR register */
64 #define VL6180_CLEAR_ERROR BIT(2)
65 #define VL6180_CLEAR_ALS BIT(1)
66 #define VL6180_CLEAR_RANGE BIT(0)
67 
68 /* bits of the HOLD register */
69 #define VL6180_HOLD_ON BIT(0)
70 
71 /* default value for the ALS_IT register */
72 #define VL6180_ALS_IT_100 0x63 /* 100 ms */
73 
74 /* values for the ALS_GAIN register */
75 #define VL6180_ALS_GAIN_1 0x46
76 #define VL6180_ALS_GAIN_1_25 0x45
77 #define VL6180_ALS_GAIN_1_67 0x44
78 #define VL6180_ALS_GAIN_2_5 0x43
79 #define VL6180_ALS_GAIN_5 0x42
80 #define VL6180_ALS_GAIN_10 0x41
81 #define VL6180_ALS_GAIN_20 0x40
82 #define VL6180_ALS_GAIN_40 0x47
83 
84 struct vl6180_data {
85 	struct i2c_client *client;
86 	struct mutex lock;
87 	unsigned int als_gain_milli;
88 	unsigned int als_it_ms;
89 };
90 
91 enum { VL6180_ALS, VL6180_RANGE, VL6180_PROX };
92 
93 /**
94  * struct vl6180_chan_regs - Registers for accessing channels
95  * @drdy_mask:			Data ready bit in status register
96  * @start_reg:			Conversion start register
97  * @value_reg:			Result value register
98  * @word:			Register word length
99  */
100 struct vl6180_chan_regs {
101 	u8 drdy_mask;
102 	u16 start_reg, value_reg;
103 	bool word;
104 };
105 
106 static const struct vl6180_chan_regs vl6180_chan_regs_table[] = {
107 	[VL6180_ALS] = {
108 		.drdy_mask = VL6180_ALS_READY,
109 		.start_reg = VL6180_ALS_START,
110 		.value_reg = VL6180_ALS_VALUE,
111 		.word = true,
112 	},
113 	[VL6180_RANGE] = {
114 		.drdy_mask = VL6180_RANGE_READY,
115 		.start_reg = VL6180_RANGE_START,
116 		.value_reg = VL6180_RANGE_VALUE,
117 		.word = false,
118 	},
119 	[VL6180_PROX] = {
120 		.drdy_mask = VL6180_RANGE_READY,
121 		.start_reg = VL6180_RANGE_START,
122 		.value_reg = VL6180_RANGE_RATE,
123 		.word = true,
124 	},
125 };
126 
127 static int vl6180_read(struct i2c_client *client, u16 cmd, void *databuf,
128 		       u8 len)
129 {
130 	__be16 cmdbuf = cpu_to_be16(cmd);
131 	struct i2c_msg msgs[2] = {
132 		{ .addr = client->addr, .len = sizeof(cmdbuf), .buf = (u8 *) &cmdbuf },
133 		{ .addr = client->addr, .len = len, .buf = databuf,
134 		  .flags = I2C_M_RD } };
135 	int ret;
136 
137 	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
138 	if (ret < 0)
139 		dev_err(&client->dev, "failed reading register 0x%04x\n", cmd);
140 
141 	return ret;
142 }
143 
144 static int vl6180_read_byte(struct i2c_client *client, u16 cmd)
145 {
146 	u8 data;
147 	int ret;
148 
149 	ret = vl6180_read(client, cmd, &data, sizeof(data));
150 	if (ret < 0)
151 		return ret;
152 
153 	return data;
154 }
155 
156 static int vl6180_read_word(struct i2c_client *client, u16 cmd)
157 {
158 	__be16 data;
159 	int ret;
160 
161 	ret = vl6180_read(client, cmd, &data, sizeof(data));
162 	if (ret < 0)
163 		return ret;
164 
165 	return be16_to_cpu(data);
166 }
167 
168 static int vl6180_write_byte(struct i2c_client *client, u16 cmd, u8 val)
169 {
170 	u8 buf[3];
171 	struct i2c_msg msgs[1] = {
172 		{ .addr = client->addr, .len = sizeof(buf), .buf = (u8 *) &buf } };
173 	int ret;
174 
175 	buf[0] = cmd >> 8;
176 	buf[1] = cmd & 0xff;
177 	buf[2] = val;
178 
179 	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
180 	if (ret < 0) {
181 		dev_err(&client->dev, "failed writing register 0x%04x\n", cmd);
182 		return ret;
183 	}
184 
185 	return 0;
186 }
187 
188 static int vl6180_write_word(struct i2c_client *client, u16 cmd, u16 val)
189 {
190 	__be16 buf[2];
191 	struct i2c_msg msgs[1] = {
192 		{ .addr = client->addr, .len = sizeof(buf), .buf = (u8 *) &buf } };
193 	int ret;
194 
195 	buf[0] = cpu_to_be16(cmd);
196 	buf[1] = cpu_to_be16(val);
197 
198 	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
199 	if (ret < 0) {
200 		dev_err(&client->dev, "failed writing register 0x%04x\n", cmd);
201 		return ret;
202 	}
203 
204 	return 0;
205 }
206 
207 static int vl6180_measure(struct vl6180_data *data, int addr)
208 {
209 	struct i2c_client *client = data->client;
210 	int tries = 20, ret;
211 	u16 value;
212 
213 	mutex_lock(&data->lock);
214 	/* Start single shot measurement */
215 	ret = vl6180_write_byte(client,
216 		vl6180_chan_regs_table[addr].start_reg, VL6180_STARTSTOP);
217 	if (ret < 0)
218 		goto fail;
219 
220 	while (tries--) {
221 		ret = vl6180_read_byte(client, VL6180_INTR_STATUS);
222 		if (ret < 0)
223 			goto fail;
224 
225 		if (ret & vl6180_chan_regs_table[addr].drdy_mask)
226 			break;
227 		msleep(20);
228 	}
229 
230 	if (tries < 0) {
231 		ret = -EIO;
232 		goto fail;
233 	}
234 
235 	/* Read result value from appropriate registers */
236 	ret = vl6180_chan_regs_table[addr].word ?
237 		vl6180_read_word(client, vl6180_chan_regs_table[addr].value_reg) :
238 		vl6180_read_byte(client, vl6180_chan_regs_table[addr].value_reg);
239 	if (ret < 0)
240 		goto fail;
241 	value = ret;
242 
243 	/* Clear the interrupt flag after data read */
244 	ret = vl6180_write_byte(client, VL6180_INTR_CLEAR,
245 		VL6180_CLEAR_ERROR | VL6180_CLEAR_ALS | VL6180_CLEAR_RANGE);
246 	if (ret < 0)
247 		goto fail;
248 
249 	ret = value;
250 
251 fail:
252 	mutex_unlock(&data->lock);
253 
254 	return ret;
255 }
256 
257 static const struct iio_chan_spec vl6180_channels[] = {
258 	{
259 		.type = IIO_LIGHT,
260 		.address = VL6180_ALS,
261 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
262 			BIT(IIO_CHAN_INFO_INT_TIME) |
263 			BIT(IIO_CHAN_INFO_SCALE) |
264 			BIT(IIO_CHAN_INFO_HARDWAREGAIN),
265 	}, {
266 		.type = IIO_DISTANCE,
267 		.address = VL6180_RANGE,
268 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
269 			BIT(IIO_CHAN_INFO_SCALE),
270 	}, {
271 		.type = IIO_PROXIMITY,
272 		.address = VL6180_PROX,
273 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
274 	}
275 };
276 
277 /*
278  * Available Ambient Light Sensor gain settings, 1/1000th, and
279  * corresponding setting for the VL6180_ALS_GAIN register
280  */
281 static const int vl6180_als_gain_tab[8] = {
282 	1000, 1250, 1670, 2500, 5000, 10000, 20000, 40000
283 };
284 static const u8 vl6180_als_gain_tab_bits[8] = {
285 	VL6180_ALS_GAIN_1,    VL6180_ALS_GAIN_1_25,
286 	VL6180_ALS_GAIN_1_67, VL6180_ALS_GAIN_2_5,
287 	VL6180_ALS_GAIN_5,    VL6180_ALS_GAIN_10,
288 	VL6180_ALS_GAIN_20,   VL6180_ALS_GAIN_40
289 };
290 
291 static int vl6180_read_raw(struct iio_dev *indio_dev,
292 				struct iio_chan_spec const *chan,
293 				int *val, int *val2, long mask)
294 {
295 	struct vl6180_data *data = iio_priv(indio_dev);
296 	int ret;
297 
298 	switch (mask) {
299 	case IIO_CHAN_INFO_RAW:
300 		ret = vl6180_measure(data, chan->address);
301 		if (ret < 0)
302 			return ret;
303 		*val = ret;
304 
305 		return IIO_VAL_INT;
306 	case IIO_CHAN_INFO_INT_TIME:
307 		*val = data->als_it_ms;
308 		*val2 = 1000;
309 
310 		return IIO_VAL_FRACTIONAL;
311 
312 	case IIO_CHAN_INFO_SCALE:
313 		switch (chan->type) {
314 		case IIO_LIGHT:
315 			/* one ALS count is 0.32 Lux @ gain 1, IT 100 ms */
316 			*val = 32000; /* 0.32 * 1000 * 100 */
317 			*val2 = data->als_gain_milli * data->als_it_ms;
318 
319 			return IIO_VAL_FRACTIONAL;
320 
321 		case IIO_DISTANCE:
322 			*val = 0; /* sensor reports mm, scale to meter */
323 			*val2 = 1000;
324 			break;
325 		default:
326 			return -EINVAL;
327 		}
328 
329 		return IIO_VAL_INT_PLUS_MICRO;
330 	case IIO_CHAN_INFO_HARDWAREGAIN:
331 		*val = data->als_gain_milli;
332 		*val2 = 1000;
333 
334 		return IIO_VAL_FRACTIONAL;
335 
336 	default:
337 		return -EINVAL;
338 	}
339 }
340 
341 static IIO_CONST_ATTR(als_gain_available, "1 1.25 1.67 2.5 5 10 20 40");
342 
343 static struct attribute *vl6180_attributes[] = {
344 	&iio_const_attr_als_gain_available.dev_attr.attr,
345 	NULL
346 };
347 
348 static const struct attribute_group vl6180_attribute_group = {
349 	.attrs = vl6180_attributes,
350 };
351 
352 /* HOLD is needed before updating any config registers */
353 static int vl6180_hold(struct vl6180_data *data, bool hold)
354 {
355 	return vl6180_write_byte(data->client, VL6180_HOLD,
356 		hold ? VL6180_HOLD_ON : 0);
357 }
358 
359 static int vl6180_set_als_gain(struct vl6180_data *data, int val, int val2)
360 {
361 	int i, ret, gain;
362 
363 	if (val < 1 || val > 40)
364 		return -EINVAL;
365 
366 	gain = (val * 1000000 + val2) / 1000;
367 	if (gain < 1 || gain > 40000)
368 		return -EINVAL;
369 
370 	i = find_closest(gain, vl6180_als_gain_tab,
371 			 ARRAY_SIZE(vl6180_als_gain_tab));
372 
373 	mutex_lock(&data->lock);
374 	ret = vl6180_hold(data, true);
375 	if (ret < 0)
376 		goto fail;
377 
378 	ret = vl6180_write_byte(data->client, VL6180_ALS_GAIN,
379 				vl6180_als_gain_tab_bits[i]);
380 
381 	if (ret >= 0)
382 		data->als_gain_milli = vl6180_als_gain_tab[i];
383 
384 fail:
385 	vl6180_hold(data, false);
386 	mutex_unlock(&data->lock);
387 	return ret;
388 }
389 
390 static int vl6180_set_it(struct vl6180_data *data, int val, int val2)
391 {
392 	int ret, it_ms;
393 
394 	it_ms = DIV_ROUND_CLOSEST(val2, 1000); /* round to ms */
395 	if (val != 0 || it_ms < 1 || it_ms > 512)
396 		return -EINVAL;
397 
398 	mutex_lock(&data->lock);
399 	ret = vl6180_hold(data, true);
400 	if (ret < 0)
401 		goto fail;
402 
403 	ret = vl6180_write_word(data->client, VL6180_ALS_IT, it_ms - 1);
404 
405 	if (ret >= 0)
406 		data->als_it_ms = it_ms;
407 
408 fail:
409 	vl6180_hold(data, false);
410 	mutex_unlock(&data->lock);
411 
412 	return ret;
413 }
414 
415 static int vl6180_write_raw(struct iio_dev *indio_dev,
416 			     struct iio_chan_spec const *chan,
417 			     int val, int val2, long mask)
418 {
419 	struct vl6180_data *data = iio_priv(indio_dev);
420 
421 	switch (mask) {
422 	case IIO_CHAN_INFO_INT_TIME:
423 		return vl6180_set_it(data, val, val2);
424 
425 	case IIO_CHAN_INFO_HARDWAREGAIN:
426 		if (chan->type != IIO_LIGHT)
427 			return -EINVAL;
428 
429 		return vl6180_set_als_gain(data, val, val2);
430 	default:
431 		return -EINVAL;
432 	}
433 }
434 
435 static const struct iio_info vl6180_info = {
436 	.read_raw = vl6180_read_raw,
437 	.write_raw = vl6180_write_raw,
438 	.attrs = &vl6180_attribute_group,
439 };
440 
441 static int vl6180_init(struct vl6180_data *data)
442 {
443 	struct i2c_client *client = data->client;
444 	int ret;
445 
446 	ret = vl6180_read_byte(client, VL6180_MODEL_ID);
447 	if (ret < 0)
448 		return ret;
449 
450 	if (ret != VL6180_MODEL_ID_VAL) {
451 		dev_err(&client->dev, "invalid model ID %02x\n", ret);
452 		return -ENODEV;
453 	}
454 
455 	ret = vl6180_hold(data, true);
456 	if (ret < 0)
457 		return ret;
458 
459 	ret = vl6180_read_byte(client, VL6180_OUT_OF_RESET);
460 	if (ret < 0)
461 		return ret;
462 
463 	/*
464 	 * Detect false reset condition here. This bit is always set when the
465 	 * system comes out of reset.
466 	 */
467 	if (ret != 0x01)
468 		dev_info(&client->dev, "device is not fresh out of reset\n");
469 
470 	/* Enable ALS and Range ready interrupts */
471 	ret = vl6180_write_byte(client, VL6180_INTR_CONFIG,
472 				VL6180_ALS_READY | VL6180_RANGE_READY);
473 	if (ret < 0)
474 		return ret;
475 
476 	/* ALS integration time: 100ms */
477 	data->als_it_ms = 100;
478 	ret = vl6180_write_word(client, VL6180_ALS_IT, VL6180_ALS_IT_100);
479 	if (ret < 0)
480 		return ret;
481 
482 	/* ALS gain: 1 */
483 	data->als_gain_milli = 1000;
484 	ret = vl6180_write_byte(client, VL6180_ALS_GAIN, VL6180_ALS_GAIN_1);
485 	if (ret < 0)
486 		return ret;
487 
488 	ret = vl6180_write_byte(client, VL6180_OUT_OF_RESET, 0x00);
489 	if (ret < 0)
490 		return ret;
491 
492 	return vl6180_hold(data, false);
493 }
494 
495 static int vl6180_probe(struct i2c_client *client)
496 {
497 	struct vl6180_data *data;
498 	struct iio_dev *indio_dev;
499 	int ret;
500 
501 	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
502 	if (!indio_dev)
503 		return -ENOMEM;
504 
505 	data = iio_priv(indio_dev);
506 	i2c_set_clientdata(client, indio_dev);
507 	data->client = client;
508 	mutex_init(&data->lock);
509 
510 	indio_dev->info = &vl6180_info;
511 	indio_dev->channels = vl6180_channels;
512 	indio_dev->num_channels = ARRAY_SIZE(vl6180_channels);
513 	indio_dev->name = VL6180_DRV_NAME;
514 	indio_dev->modes = INDIO_DIRECT_MODE;
515 
516 	ret = vl6180_init(data);
517 	if (ret < 0)
518 		return ret;
519 
520 	return devm_iio_device_register(&client->dev, indio_dev);
521 }
522 
523 static const struct of_device_id vl6180_of_match[] = {
524 	{ .compatible = "st,vl6180", },
525 	{ },
526 };
527 MODULE_DEVICE_TABLE(of, vl6180_of_match);
528 
529 static const struct i2c_device_id vl6180_id[] = {
530 	{ "vl6180" },
531 	{ }
532 };
533 MODULE_DEVICE_TABLE(i2c, vl6180_id);
534 
535 static struct i2c_driver vl6180_driver = {
536 	.driver = {
537 		.name   = VL6180_DRV_NAME,
538 		.of_match_table = vl6180_of_match,
539 	},
540 	.probe = vl6180_probe,
541 	.id_table = vl6180_id,
542 };
543 
544 module_i2c_driver(vl6180_driver);
545 
546 MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
547 MODULE_AUTHOR("Manivannan Sadhasivam <manivannanece23@gmail.com>");
548 MODULE_DESCRIPTION("STMicro VL6180 ALS, range and proximity sensor driver");
549 MODULE_LICENSE("GPL");
550