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