xref: /linux/drivers/iio/proximity/vl53l0x-i2c.c (revision 68a052239fc4b351e961f698b824f7654a346091)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Support for ST VL53L0X FlightSense ToF Ranging Sensor on a i2c bus.
4  *
5  * Copyright (C) 2016 STMicroelectronics Imaging Division.
6  * Copyright (C) 2018 Song Qiang <songqiang1304521@gmail.com>
7  * Copyright (C) 2020 Ivan Drobyshevskyi <drobyshevskyi@gmail.com>
8  *
9  * Datasheet available at
10  * <https://www.st.com/resource/en/datasheet/vl53l0x.pdf>
11  *
12  * Default 7-bit i2c slave address 0x29.
13  *
14  * TODO: FIFO buffer, continuous mode, range selection, sensor ID check.
15  */
16 
17 #include <linux/delay.h>
18 #include <linux/gpio/consumer.h>
19 #include <linux/i2c.h>
20 #include <linux/irq.h>
21 #include <linux/interrupt.h>
22 #include <linux/module.h>
23 #include <linux/unaligned.h>
24 
25 #include <linux/iio/iio.h>
26 #include <linux/iio/buffer.h>
27 #include <linux/iio/trigger.h>
28 #include <linux/iio/trigger_consumer.h>
29 #include <linux/iio/triggered_buffer.h>
30 
31 #define VL_REG_SYSRANGE_START				0x00
32 
33 #define VL_REG_SYSRANGE_MODE_MASK			GENMASK(3, 0)
34 #define VL_REG_SYSRANGE_MODE_SINGLESHOT			0x00
35 #define VL_REG_SYSRANGE_MODE_START_STOP			BIT(0)
36 #define VL_REG_SYSRANGE_MODE_BACKTOBACK			BIT(1)
37 #define VL_REG_SYSRANGE_MODE_TIMED			BIT(2)
38 #define VL_REG_SYSRANGE_MODE_HISTOGRAM			BIT(3)
39 
40 #define VL_REG_SYSTEM_INTERRUPT_CONFIG_GPIO		0x0A
41 #define VL_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY	BIT(2)
42 
43 #define VL_REG_SYSTEM_INTERRUPT_CLEAR			0x0B
44 
45 #define VL_REG_RESULT_INT_STATUS			0x13
46 #define VL_REG_RESULT_RANGE_STATUS			0x14
47 #define VL_REG_IDENTIFICATION_MODEL_ID			0xC0
48 #define VL_REG_RESULT_RANGE_STATUS_COMPLETE		BIT(0)
49 
50 #define VL53L0X_MODEL_ID_VAL				0xEE
51 #define VL53L0X_CONTINUOUS_MODE				0x02
52 #define VL53L0X_SINGLE_MODE				0x01
53 
54 struct vl53l0x_data {
55 	struct i2c_client *client;
56 	struct completion completion;
57 	struct regulator *vdd_supply;
58 	struct gpio_desc *reset_gpio;
59 	struct iio_trigger *trig;
60 };
61 
62 static int vl53l0x_clear_irq(struct vl53l0x_data *data)
63 {	int ret;
64 
65 	ret = i2c_smbus_write_byte_data(data->client,
66 					VL_REG_SYSTEM_INTERRUPT_CLEAR, 1);
67 	if (ret < 0) {
68 		dev_err(&data->client->dev, "failed to clear irq: %d\n", ret);
69 		return -EINVAL;
70 	}
71 
72 	return 0;
73 }
74 
75 static irqreturn_t vl53l0x_trigger_handler(int irq, void *priv)
76 {
77 	struct iio_poll_func *pf = priv;
78 	struct iio_dev *indio_dev = pf->indio_dev;
79 	struct vl53l0x_data *data = iio_priv(indio_dev);
80 	u8 buffer[12];
81 	int ret;
82 	struct {
83 		u16 chan;
84 		aligned_s64 timestamp;
85 	} scan = { };
86 
87 	ret = i2c_smbus_read_i2c_block_data(data->client,
88 					VL_REG_RESULT_RANGE_STATUS,
89 					sizeof(buffer), buffer);
90 	if (ret < 0)
91 		return ret;
92 	else if (ret != 12)
93 		return -EREMOTEIO;
94 
95 	scan.chan = get_unaligned_be16(&buffer[10]);
96 	iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan),
97 				    iio_get_time_ns(indio_dev));
98 
99 	iio_trigger_notify_done(indio_dev->trig);
100 	vl53l0x_clear_irq(data);
101 
102 	return IRQ_HANDLED;
103 }
104 
105 static irqreturn_t vl53l0x_threaded_irq(int irq, void *priv)
106 {
107 	struct iio_dev *indio_dev = priv;
108 	struct vl53l0x_data *data = iio_priv(indio_dev);
109 
110 	if (iio_buffer_enabled(indio_dev))
111 		iio_trigger_poll_nested(indio_dev->trig);
112 	else
113 		complete(&data->completion);
114 
115 	return IRQ_HANDLED;
116 }
117 
118 static int vl53l0x_configure_irq(struct i2c_client *client,
119 				 struct iio_dev *indio_dev)
120 {
121 	int irq_flags = irq_get_trigger_type(client->irq);
122 	struct vl53l0x_data *data = iio_priv(indio_dev);
123 	int ret;
124 
125 	if (!irq_flags)
126 		irq_flags = IRQF_TRIGGER_FALLING;
127 
128 	ret = devm_request_threaded_irq(&client->dev, client->irq,
129 			NULL, vl53l0x_threaded_irq,
130 			irq_flags | IRQF_ONESHOT, indio_dev->name, indio_dev);
131 	if (ret) {
132 		dev_err(&client->dev, "devm_request_irq error: %d\n", ret);
133 		return ret;
134 	}
135 
136 	ret = i2c_smbus_write_byte_data(data->client,
137 			VL_REG_SYSTEM_INTERRUPT_CONFIG_GPIO,
138 			VL_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
139 	if (ret < 0)
140 		dev_err(&client->dev, "failed to configure IRQ: %d\n", ret);
141 
142 	return ret;
143 }
144 
145 static int vl53l0x_read_proximity(struct vl53l0x_data *data,
146 				  const struct iio_chan_spec *chan,
147 				  int *val)
148 {
149 	struct i2c_client *client = data->client;
150 	u16 tries = 20;
151 	u8 buffer[12];
152 	int ret;
153 	unsigned long time_left;
154 
155 	ret = i2c_smbus_write_byte_data(client, VL_REG_SYSRANGE_START, 1);
156 	if (ret < 0)
157 		return ret;
158 
159 	if (data->client->irq) {
160 		reinit_completion(&data->completion);
161 
162 		time_left = wait_for_completion_timeout(&data->completion, HZ/10);
163 		if (time_left == 0)
164 			return -ETIMEDOUT;
165 
166 		ret = vl53l0x_clear_irq(data);
167 		if (ret < 0)
168 			return ret;
169 	} else {
170 		do {
171 			ret = i2c_smbus_read_byte_data(client,
172 					       VL_REG_RESULT_RANGE_STATUS);
173 			if (ret < 0)
174 				return ret;
175 
176 			if (ret & VL_REG_RESULT_RANGE_STATUS_COMPLETE)
177 				break;
178 
179 			usleep_range(1000, 5000);
180 		} while (--tries);
181 		if (!tries)
182 			return -ETIMEDOUT;
183 	}
184 
185 	ret = i2c_smbus_read_i2c_block_data(client, VL_REG_RESULT_RANGE_STATUS,
186 					    12, buffer);
187 	if (ret < 0)
188 		return ret;
189 	else if (ret != 12)
190 		return -EREMOTEIO;
191 
192 	/* Values should be between 30~1200 in millimeters. */
193 	*val = get_unaligned_be16(&buffer[10]);
194 
195 	return 0;
196 }
197 
198 static const struct iio_chan_spec vl53l0x_channels[] = {
199 	{
200 		.type = IIO_DISTANCE,
201 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
202 				      BIT(IIO_CHAN_INFO_SCALE),
203 		.scan_index = 0,
204 		.scan_type = {
205 			.sign = 'u',
206 			.realbits = 12,
207 			.storagebits = 16,
208 		},
209 	},
210 	IIO_CHAN_SOFT_TIMESTAMP(1),
211 };
212 
213 static int vl53l0x_read_raw(struct iio_dev *indio_dev,
214 			    const struct iio_chan_spec *chan,
215 			    int *val, int *val2, long mask)
216 {
217 	struct vl53l0x_data *data = iio_priv(indio_dev);
218 	int ret;
219 
220 	if (chan->type != IIO_DISTANCE)
221 		return -EINVAL;
222 
223 	switch (mask) {
224 	case IIO_CHAN_INFO_RAW:
225 		ret = vl53l0x_read_proximity(data, chan, val);
226 		if (ret < 0)
227 			return ret;
228 
229 		return IIO_VAL_INT;
230 	case IIO_CHAN_INFO_SCALE:
231 		*val = 0;
232 		*val2 = 1000;
233 
234 		return IIO_VAL_INT_PLUS_MICRO;
235 	default:
236 		return -EINVAL;
237 	}
238 }
239 
240 static int vl53l0x_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig)
241 {
242 	struct vl53l0x_data *data = iio_priv(indio_dev);
243 
244 	return data->trig == trig ? 0 : -EINVAL;
245 }
246 
247 static const struct iio_info vl53l0x_info = {
248 	.read_raw = vl53l0x_read_raw,
249 	.validate_trigger = vl53l0x_validate_trigger,
250 };
251 
252 static void vl53l0x_power_off(void *_data)
253 {
254 	struct vl53l0x_data *data = _data;
255 
256 	gpiod_set_value_cansleep(data->reset_gpio, 1);
257 
258 	regulator_disable(data->vdd_supply);
259 }
260 
261 static int vl53l0x_power_on(struct vl53l0x_data *data)
262 {
263 	int ret;
264 
265 	ret = regulator_enable(data->vdd_supply);
266 	if (ret)
267 		return ret;
268 
269 	gpiod_set_value_cansleep(data->reset_gpio, 0);
270 
271 	usleep_range(3200, 5000);
272 
273 	return 0;
274 }
275 
276 static int vl53l0x_buffer_postenable(struct iio_dev *indio_dev)
277 {
278 	struct vl53l0x_data *data = iio_priv(indio_dev);
279 
280 	return i2c_smbus_write_byte_data(data->client, VL_REG_SYSRANGE_START,
281 						VL53L0X_CONTINUOUS_MODE);
282 }
283 
284 static int vl53l0x_buffer_postdisable(struct iio_dev *indio_dev)
285 {
286 	struct vl53l0x_data *data = iio_priv(indio_dev);
287 	int ret;
288 
289 	ret = i2c_smbus_write_byte_data(data->client, VL_REG_SYSRANGE_START,
290 						VL53L0X_SINGLE_MODE);
291 	if (ret < 0)
292 		return ret;
293 
294 	/* Let the ongoing reading finish */
295 	reinit_completion(&data->completion);
296 	wait_for_completion_timeout(&data->completion, HZ / 10);
297 
298 	return vl53l0x_clear_irq(data);
299 }
300 
301 static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
302 	.postenable = &vl53l0x_buffer_postenable,
303 	.postdisable = &vl53l0x_buffer_postdisable,
304 };
305 
306 static const struct iio_trigger_ops vl53l0x_trigger_ops = {
307 	.validate_device = iio_trigger_validate_own_device,
308 };
309 
310 static int vl53l0x_probe(struct i2c_client *client)
311 {
312 	struct vl53l0x_data *data;
313 	struct iio_dev *indio_dev;
314 	int ret;
315 
316 	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
317 	if (!indio_dev)
318 		return -ENOMEM;
319 
320 	data = iio_priv(indio_dev);
321 	data->client = client;
322 	i2c_set_clientdata(client, indio_dev);
323 
324 	if (!i2c_check_functionality(client->adapter,
325 				     I2C_FUNC_SMBUS_READ_I2C_BLOCK |
326 				     I2C_FUNC_SMBUS_BYTE_DATA))
327 		return -EOPNOTSUPP;
328 
329 	ret = i2c_smbus_read_byte_data(data->client, VL_REG_IDENTIFICATION_MODEL_ID);
330 	if (ret < 0)
331 		return -EINVAL;
332 
333 	if (ret != VL53L0X_MODEL_ID_VAL)
334 		dev_info(&client->dev, "Unknown model id: 0x%x", ret);
335 
336 	data->vdd_supply = devm_regulator_get(&client->dev, "vdd");
337 	if (IS_ERR(data->vdd_supply))
338 		return dev_err_probe(&client->dev, PTR_ERR(data->vdd_supply),
339 				     "Unable to get VDD regulator\n");
340 
341 	data->reset_gpio = devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_HIGH);
342 	if (IS_ERR(data->reset_gpio))
343 		return dev_err_probe(&client->dev, PTR_ERR(data->reset_gpio),
344 				     "Cannot get reset GPIO\n");
345 
346 	ret = vl53l0x_power_on(data);
347 	if (ret)
348 		return dev_err_probe(&client->dev, ret,
349 				     "Failed to power on the chip\n");
350 
351 	ret = devm_add_action_or_reset(&client->dev, vl53l0x_power_off, data);
352 	if (ret)
353 		return ret;
354 
355 	indio_dev->name = "vl53l0x";
356 	indio_dev->info = &vl53l0x_info;
357 	indio_dev->channels = vl53l0x_channels;
358 	indio_dev->num_channels = ARRAY_SIZE(vl53l0x_channels);
359 	indio_dev->modes = INDIO_DIRECT_MODE;
360 
361 	/* usage of interrupt is optional */
362 	if (client->irq) {
363 		init_completion(&data->completion);
364 
365 		data->trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
366 						indio_dev->name,
367 						iio_device_id(indio_dev));
368 		if (!data->trig)
369 			return -ENOMEM;
370 
371 		data->trig->ops = &vl53l0x_trigger_ops;
372 		iio_trigger_set_drvdata(data->trig, indio_dev);
373 		ret = devm_iio_trigger_register(&client->dev, data->trig);
374 		if (ret)
375 			return ret;
376 
377 		indio_dev->trig = iio_trigger_get(data->trig);
378 
379 		ret = vl53l0x_configure_irq(client, indio_dev);
380 		if (ret)
381 			return ret;
382 
383 		ret = devm_iio_triggered_buffer_setup(&client->dev,
384 					indio_dev,
385 					NULL,
386 					&vl53l0x_trigger_handler,
387 					&iio_triggered_buffer_setup_ops);
388 		if (ret)
389 			return ret;
390 	}
391 
392 	return devm_iio_device_register(&client->dev, indio_dev);
393 }
394 
395 static const struct i2c_device_id vl53l0x_id[] = {
396 	{ "vl53l0x" },
397 	{ }
398 };
399 MODULE_DEVICE_TABLE(i2c, vl53l0x_id);
400 
401 static const struct of_device_id st_vl53l0x_dt_match[] = {
402 	{ .compatible = "st,vl53l0x", },
403 	{ }
404 };
405 MODULE_DEVICE_TABLE(of, st_vl53l0x_dt_match);
406 
407 static struct i2c_driver vl53l0x_driver = {
408 	.driver = {
409 		.name = "vl53l0x-i2c",
410 		.of_match_table = st_vl53l0x_dt_match,
411 	},
412 	.probe = vl53l0x_probe,
413 	.id_table = vl53l0x_id,
414 };
415 module_i2c_driver(vl53l0x_driver);
416 
417 MODULE_AUTHOR("Song Qiang <songqiang1304521@gmail.com>");
418 MODULE_DESCRIPTION("ST vl53l0x ToF ranging sensor driver");
419 MODULE_LICENSE("GPL v2");
420