1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Common library for ADIS16XXX devices
4  *
5  * Copyright 2012 Analog Devices Inc.
6  *   Author: Lars-Peter Clausen <lars@metafoo.de>
7  */
8 
9 #include <linux/delay.h>
10 #include <linux/gpio/consumer.h>
11 #include <linux/mutex.h>
12 #include <linux/device.h>
13 #include <linux/kernel.h>
14 #include <linux/spi/spi.h>
15 #include <linux/module.h>
16 #include <linux/unaligned.h>
17 
18 #include <linux/iio/iio.h>
19 #include <linux/iio/imu/adis.h>
20 
21 #define ADIS_MSC_CTRL_DATA_RDY_EN	BIT(2)
22 #define ADIS_MSC_CTRL_DATA_RDY_POL_HIGH	BIT(1)
23 #define ADIS_MSC_CTRL_DATA_RDY_DIO2	BIT(0)
24 #define ADIS_GLOB_CMD_SW_RESET		BIT(7)
25 
26 /**
27  * __adis_write_reg() - write N bytes to register (unlocked version)
28  * @adis: The adis device
29  * @reg: The address of the lower of the two registers
30  * @value: The value to write to device (up to 4 bytes)
31  * @size: The size of the @value (in bytes)
32  */
__adis_write_reg(struct adis * adis,unsigned int reg,unsigned int value,unsigned int size)33 int __adis_write_reg(struct adis *adis, unsigned int reg, unsigned int value,
34 		     unsigned int size)
35 {
36 	unsigned int page = reg / ADIS_PAGE_SIZE;
37 	int ret, i;
38 	struct spi_message msg;
39 	struct spi_transfer xfers[] = {
40 		{
41 			.tx_buf = adis->tx,
42 			.bits_per_word = 8,
43 			.len = 2,
44 			.cs_change = 1,
45 			.delay.value = adis->data->write_delay,
46 			.delay.unit = SPI_DELAY_UNIT_USECS,
47 		}, {
48 			.tx_buf = adis->tx + 2,
49 			.bits_per_word = 8,
50 			.len = 2,
51 			.cs_change = 1,
52 			.delay.value = adis->data->write_delay,
53 			.delay.unit = SPI_DELAY_UNIT_USECS,
54 		}, {
55 			.tx_buf = adis->tx + 4,
56 			.bits_per_word = 8,
57 			.len = 2,
58 			.cs_change = 1,
59 			.delay.value = adis->data->write_delay,
60 			.delay.unit = SPI_DELAY_UNIT_USECS,
61 		}, {
62 			.tx_buf = adis->tx + 6,
63 			.bits_per_word = 8,
64 			.len = 2,
65 			.delay.value = adis->data->write_delay,
66 			.delay.unit = SPI_DELAY_UNIT_USECS,
67 		}, {
68 			.tx_buf = adis->tx + 8,
69 			.bits_per_word = 8,
70 			.len = 2,
71 			.delay.value = adis->data->write_delay,
72 			.delay.unit = SPI_DELAY_UNIT_USECS,
73 		},
74 	};
75 
76 	spi_message_init(&msg);
77 
78 	if (adis->current_page != page) {
79 		adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID);
80 		adis->tx[1] = page;
81 		spi_message_add_tail(&xfers[0], &msg);
82 	}
83 
84 	switch (size) {
85 	case 4:
86 		adis->tx[8] = ADIS_WRITE_REG(reg + 3);
87 		adis->tx[9] = (value >> 24) & 0xff;
88 		adis->tx[6] = ADIS_WRITE_REG(reg + 2);
89 		adis->tx[7] = (value >> 16) & 0xff;
90 		fallthrough;
91 	case 2:
92 		adis->tx[4] = ADIS_WRITE_REG(reg + 1);
93 		adis->tx[5] = (value >> 8) & 0xff;
94 		fallthrough;
95 	case 1:
96 		adis->tx[2] = ADIS_WRITE_REG(reg);
97 		adis->tx[3] = value & 0xff;
98 		break;
99 	default:
100 		return -EINVAL;
101 	}
102 
103 	xfers[size].cs_change = 0;
104 
105 	for (i = 1; i <= size; i++)
106 		spi_message_add_tail(&xfers[i], &msg);
107 
108 	ret = spi_sync(adis->spi, &msg);
109 	if (ret) {
110 		dev_err(&adis->spi->dev, "Failed to write register 0x%02X: %d\n",
111 			reg, ret);
112 	} else {
113 		adis->current_page = page;
114 	}
115 
116 	return ret;
117 }
118 EXPORT_SYMBOL_NS_GPL(__adis_write_reg, "IIO_ADISLIB");
119 
120 /**
121  * __adis_read_reg() - read N bytes from register (unlocked version)
122  * @adis: The adis device
123  * @reg: The address of the lower of the two registers
124  * @val: The value read back from the device
125  * @size: The size of the @val buffer
126  */
__adis_read_reg(struct adis * adis,unsigned int reg,unsigned int * val,unsigned int size)127 int __adis_read_reg(struct adis *adis, unsigned int reg, unsigned int *val,
128 		    unsigned int size)
129 {
130 	unsigned int page = reg / ADIS_PAGE_SIZE;
131 	struct spi_message msg;
132 	int ret;
133 	struct spi_transfer xfers[] = {
134 		{
135 			.tx_buf = adis->tx,
136 			.bits_per_word = 8,
137 			.len = 2,
138 			.cs_change = 1,
139 			.delay.value = adis->data->write_delay,
140 			.delay.unit = SPI_DELAY_UNIT_USECS,
141 		}, {
142 			.tx_buf = adis->tx + 2,
143 			.bits_per_word = 8,
144 			.len = 2,
145 			.cs_change = 1,
146 			.delay.value = adis->data->read_delay,
147 			.delay.unit = SPI_DELAY_UNIT_USECS,
148 		}, {
149 			.tx_buf = adis->tx + 4,
150 			.rx_buf = adis->rx,
151 			.bits_per_word = 8,
152 			.len = 2,
153 			.cs_change = 1,
154 			.delay.value = adis->data->read_delay,
155 			.delay.unit = SPI_DELAY_UNIT_USECS,
156 		}, {
157 			.rx_buf = adis->rx + 2,
158 			.bits_per_word = 8,
159 			.len = 2,
160 			.delay.value = adis->data->read_delay,
161 			.delay.unit = SPI_DELAY_UNIT_USECS,
162 		},
163 	};
164 
165 	spi_message_init(&msg);
166 
167 	if (adis->current_page != page) {
168 		adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID);
169 		adis->tx[1] = page;
170 		spi_message_add_tail(&xfers[0], &msg);
171 	}
172 
173 	switch (size) {
174 	case 4:
175 		adis->tx[2] = ADIS_READ_REG(reg + 2);
176 		adis->tx[3] = 0;
177 		spi_message_add_tail(&xfers[1], &msg);
178 		fallthrough;
179 	case 2:
180 		adis->tx[4] = ADIS_READ_REG(reg);
181 		adis->tx[5] = 0;
182 		spi_message_add_tail(&xfers[2], &msg);
183 		spi_message_add_tail(&xfers[3], &msg);
184 		break;
185 	default:
186 		return -EINVAL;
187 	}
188 
189 	ret = spi_sync(adis->spi, &msg);
190 	if (ret) {
191 		dev_err(&adis->spi->dev, "Failed to read register 0x%02X: %d\n",
192 			reg, ret);
193 		return ret;
194 	}
195 
196 	adis->current_page = page;
197 
198 	switch (size) {
199 	case 4:
200 		*val = get_unaligned_be32(adis->rx);
201 		break;
202 	case 2:
203 		*val = get_unaligned_be16(adis->rx + 2);
204 		break;
205 	}
206 
207 	return ret;
208 }
209 EXPORT_SYMBOL_NS_GPL(__adis_read_reg, "IIO_ADISLIB");
210 /**
211  * __adis_update_bits_base() - ADIS Update bits function - Unlocked version
212  * @adis: The adis device
213  * @reg: The address of the lower of the two registers
214  * @mask: Bitmask to change
215  * @val: Value to be written
216  * @size: Size of the register to update
217  *
218  * Updates the desired bits of @reg in accordance with @mask and @val.
219  */
__adis_update_bits_base(struct adis * adis,unsigned int reg,const u32 mask,const u32 val,u8 size)220 int __adis_update_bits_base(struct adis *adis, unsigned int reg, const u32 mask,
221 			    const u32 val, u8 size)
222 {
223 	int ret;
224 	u32 __val;
225 
226 	ret = adis->ops->read(adis, reg, &__val, size);
227 	if (ret)
228 		return ret;
229 
230 	__val = (__val & ~mask) | (val & mask);
231 
232 	return adis->ops->write(adis, reg, __val, size);
233 }
234 EXPORT_SYMBOL_NS_GPL(__adis_update_bits_base, "IIO_ADISLIB");
235 
236 #ifdef CONFIG_DEBUG_FS
237 
adis_debugfs_reg_access(struct iio_dev * indio_dev,unsigned int reg,unsigned int writeval,unsigned int * readval)238 int adis_debugfs_reg_access(struct iio_dev *indio_dev, unsigned int reg,
239 			    unsigned int writeval, unsigned int *readval)
240 {
241 	struct adis *adis = iio_device_get_drvdata(indio_dev);
242 
243 	if (readval) {
244 		u16 val16;
245 		int ret;
246 
247 		ret = adis_read_reg_16(adis, reg, &val16);
248 		if (ret == 0)
249 			*readval = val16;
250 
251 		return ret;
252 	}
253 
254 	return adis_write_reg_16(adis, reg, writeval);
255 }
256 EXPORT_SYMBOL_NS(adis_debugfs_reg_access, "IIO_ADISLIB");
257 
258 #endif
259 
260 /**
261  * __adis_enable_irq() - Enable or disable data ready IRQ (unlocked)
262  * @adis: The adis device
263  * @enable: Whether to enable the IRQ
264  *
265  * Returns 0 on success, negative error code otherwise
266  */
__adis_enable_irq(struct adis * adis,bool enable)267 int __adis_enable_irq(struct adis *adis, bool enable)
268 {
269 	int ret;
270 	u16 msc;
271 
272 	if (adis->data->enable_irq)
273 		return adis->data->enable_irq(adis, enable);
274 
275 	if (adis->data->unmasked_drdy) {
276 		if (enable)
277 			enable_irq(adis->spi->irq);
278 		else
279 			disable_irq(adis->spi->irq);
280 
281 		return 0;
282 	}
283 
284 	ret = __adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc);
285 	if (ret)
286 		return ret;
287 
288 	msc |= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH;
289 	msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2;
290 	if (enable)
291 		msc |= ADIS_MSC_CTRL_DATA_RDY_EN;
292 	else
293 		msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN;
294 
295 	return __adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc);
296 }
297 EXPORT_SYMBOL_NS(__adis_enable_irq, "IIO_ADISLIB");
298 
299 /**
300  * __adis_check_status() - Check the device for error conditions (unlocked)
301  * @adis: The adis device
302  *
303  * Returns 0 on success, a negative error code otherwise
304  */
__adis_check_status(struct adis * adis)305 int __adis_check_status(struct adis *adis)
306 {
307 	unsigned int status;
308 	int diag_stat_bits;
309 	u16 status_16 = 0;
310 	int ret;
311 	int i;
312 
313 	if (adis->data->diag_stat_size) {
314 		ret = adis->ops->read(adis, adis->data->diag_stat_reg, &status,
315 				      adis->data->diag_stat_size);
316 	} else {
317 		ret = __adis_read_reg_16(adis, adis->data->diag_stat_reg,
318 					 &status_16);
319 		status = status_16;
320 	}
321 	if (ret)
322 		return ret;
323 
324 	status &= adis->data->status_error_mask;
325 
326 	if (status == 0)
327 		return 0;
328 
329 	diag_stat_bits = BITS_PER_BYTE * (adis->data->diag_stat_size ?
330 					  adis->data->diag_stat_size : 2);
331 
332 	for (i = 0; i < diag_stat_bits; ++i) {
333 		if (status & BIT(i)) {
334 			dev_err(&adis->spi->dev, "%s.\n",
335 				adis->data->status_error_msgs[i]);
336 		}
337 	}
338 
339 	return -EIO;
340 }
341 EXPORT_SYMBOL_NS_GPL(__adis_check_status, "IIO_ADISLIB");
342 
343 /**
344  * __adis_reset() - Reset the device (unlocked version)
345  * @adis: The adis device
346  *
347  * Returns 0 on success, a negative error code otherwise
348  */
__adis_reset(struct adis * adis)349 int __adis_reset(struct adis *adis)
350 {
351 	int ret;
352 	const struct adis_timeout *timeouts = adis->data->timeouts;
353 
354 	ret = __adis_write_reg_8(adis, adis->data->glob_cmd_reg,
355 				 ADIS_GLOB_CMD_SW_RESET);
356 	if (ret) {
357 		dev_err(&adis->spi->dev, "Failed to reset device: %d\n", ret);
358 		return ret;
359 	}
360 
361 	msleep(timeouts->sw_reset_ms);
362 
363 	return 0;
364 }
365 EXPORT_SYMBOL_NS_GPL(__adis_reset, "IIO_ADIS_LIB");
366 
adis_self_test(struct adis * adis)367 static int adis_self_test(struct adis *adis)
368 {
369 	int ret;
370 	const struct adis_timeout *timeouts = adis->data->timeouts;
371 
372 	ret = __adis_write_reg_16(adis, adis->data->self_test_reg,
373 				  adis->data->self_test_mask);
374 	if (ret) {
375 		dev_err(&adis->spi->dev, "Failed to initiate self test: %d\n",
376 			ret);
377 		return ret;
378 	}
379 
380 	msleep(timeouts->self_test_ms);
381 
382 	ret = __adis_check_status(adis);
383 
384 	if (adis->data->self_test_no_autoclear)
385 		__adis_write_reg_16(adis, adis->data->self_test_reg, 0x00);
386 
387 	return ret;
388 }
389 
390 /**
391  * __adis_initial_startup() - Device initial setup
392  * @adis: The adis device
393  *
394  * The function performs a HW reset via a reset pin that should be specified
395  * via GPIOLIB. If no pin is configured a SW reset will be performed.
396  * The RST pin for the ADIS devices should be configured as ACTIVE_LOW.
397  *
398  * After the self-test operation is performed, the function will also check
399  * that the product ID is as expected. This assumes that drivers providing
400  * 'prod_id_reg' will also provide the 'prod_id'.
401  *
402  * Returns 0 if the device is operational, a negative error code otherwise.
403  *
404  * This function should be called early on in the device initialization sequence
405  * to ensure that the device is in a sane and known state and that it is usable.
406  */
__adis_initial_startup(struct adis * adis)407 int __adis_initial_startup(struct adis *adis)
408 {
409 	const struct adis_timeout *timeouts = adis->data->timeouts;
410 	struct gpio_desc *gpio;
411 	u16 prod_id;
412 	int ret;
413 
414 	/* check if the device has rst pin low */
415 	gpio = devm_gpiod_get_optional(&adis->spi->dev, "reset", GPIOD_OUT_HIGH);
416 	if (IS_ERR(gpio))
417 		return PTR_ERR(gpio);
418 
419 	if (gpio) {
420 		usleep_range(10, 12);
421 		/* bring device out of reset */
422 		gpiod_set_value_cansleep(gpio, 0);
423 		msleep(timeouts->reset_ms);
424 	} else {
425 		ret = __adis_reset(adis);
426 		if (ret)
427 			return ret;
428 	}
429 
430 	ret = adis_self_test(adis);
431 	if (ret)
432 		return ret;
433 
434 	/*
435 	 * don't bother calling this if we can't unmask the IRQ as in this case
436 	 * the IRQ is most likely not yet requested and we will request it
437 	 * with 'IRQF_NO_AUTOEN' anyways.
438 	 */
439 	if (!adis->data->unmasked_drdy)
440 		__adis_enable_irq(adis, false);
441 
442 	if (!adis->data->prod_id_reg)
443 		return 0;
444 
445 	ret = adis_read_reg_16(adis, adis->data->prod_id_reg, &prod_id);
446 	if (ret)
447 		return ret;
448 
449 	if (prod_id != adis->data->prod_id)
450 		dev_warn(&adis->spi->dev,
451 			 "Device ID(%u) and product ID(%u) do not match.\n",
452 			 adis->data->prod_id, prod_id);
453 
454 	return 0;
455 }
456 EXPORT_SYMBOL_NS_GPL(__adis_initial_startup, "IIO_ADISLIB");
457 
458 /**
459  * adis_single_conversion() - Performs a single sample conversion
460  * @indio_dev: The IIO device
461  * @chan: The IIO channel
462  * @error_mask: Mask for the error bit
463  * @val: Result of the conversion
464  *
465  * Returns IIO_VAL_INT on success, a negative error code otherwise.
466  *
467  * The function performs a single conversion on a given channel and post
468  * processes the value accordingly to the channel spec. If a error_mask is given
469  * the function will check if the mask is set in the returned raw value. If it
470  * is set the function will perform a self-check. If the device does not report
471  * a error bit in the channels raw value set error_mask to 0.
472  */
adis_single_conversion(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,unsigned int error_mask,int * val)473 int adis_single_conversion(struct iio_dev *indio_dev,
474 			   const struct iio_chan_spec *chan,
475 			   unsigned int error_mask, int *val)
476 {
477 	struct adis *adis = iio_device_get_drvdata(indio_dev);
478 	unsigned int uval;
479 	int ret;
480 
481 	guard(mutex)(&adis->state_lock);
482 
483 	ret = adis->ops->read(adis, chan->address, &uval,
484 			      chan->scan_type.storagebits / 8);
485 	if (ret)
486 		return ret;
487 
488 	if (uval & error_mask) {
489 		ret = __adis_check_status(adis);
490 		if (ret)
491 			return ret;
492 	}
493 
494 	if (chan->scan_type.sign == 's')
495 		*val = sign_extend32(uval, chan->scan_type.realbits - 1);
496 	else
497 		*val = uval & ((1 << chan->scan_type.realbits) - 1);
498 
499 	return IIO_VAL_INT;
500 }
501 EXPORT_SYMBOL_NS_GPL(adis_single_conversion, "IIO_ADISLIB");
502 
503 static const struct adis_ops adis_default_ops = {
504 	.read = __adis_read_reg,
505 	.write = __adis_write_reg,
506 	.reset = __adis_reset,
507 };
508 
509 /**
510  * adis_init() - Initialize adis device structure
511  * @adis:	The adis device
512  * @indio_dev:	The iio device
513  * @spi:	The spi device
514  * @data:	Chip specific data
515  *
516  * Returns 0 on success, a negative error code otherwise.
517  *
518  * This function must be called, before any other adis helper function may be
519  * called.
520  */
adis_init(struct adis * adis,struct iio_dev * indio_dev,struct spi_device * spi,const struct adis_data * data)521 int adis_init(struct adis *adis, struct iio_dev *indio_dev,
522 	      struct spi_device *spi, const struct adis_data *data)
523 {
524 	if (!data || !data->timeouts) {
525 		dev_err(&spi->dev, "No config data or timeouts not defined!\n");
526 		return -EINVAL;
527 	}
528 
529 	mutex_init(&adis->state_lock);
530 
531 	if (!spi->cs_inactive.value) {
532 		spi->cs_inactive.value = data->cs_change_delay;
533 		spi->cs_inactive.unit = SPI_DELAY_UNIT_USECS;
534 	}
535 
536 	adis->spi = spi;
537 	adis->data = data;
538 	if (!adis->ops->write && !adis->ops->read && !adis->ops->reset)
539 		adis->ops = &adis_default_ops;
540 	else if (!adis->ops->write || !adis->ops->read || !adis->ops->reset)
541 		return -EINVAL;
542 
543 	iio_device_set_drvdata(indio_dev, adis);
544 
545 	if (data->has_paging) {
546 		/* Need to set the page before first read/write */
547 		adis->current_page = -1;
548 	} else {
549 		/* Page will always be 0 */
550 		adis->current_page = 0;
551 	}
552 
553 	return 0;
554 }
555 EXPORT_SYMBOL_NS_GPL(adis_init, "IIO_ADISLIB");
556 
557 MODULE_LICENSE("GPL");
558 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
559 MODULE_DESCRIPTION("Common library code for ADIS16XXX devices");
560