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