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