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