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
adis_write_reg(struct adis * adis,unsigned int reg,unsigned int value,unsigned int size)29 int 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
116 out_unlock:
117 mutex_unlock(&adis->txrx_lock);
118
119 return ret;
120 }
121 EXPORT_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 */
adis_read_reg(struct adis * adis,unsigned int reg,unsigned int * val,unsigned int size)129 int 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
213 out_unlock:
214 mutex_unlock(&adis->txrx_lock);
215
216 return ret;
217 }
218 EXPORT_SYMBOL_GPL(adis_read_reg);
219
220 #ifdef CONFIG_DEBUG_FS
221
adis_debugfs_reg_access(struct iio_dev * indio_dev,unsigned int reg,unsigned int writeval,unsigned int * readval)222 int 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 }
239 EXPORT_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 */
adis_enable_irq(struct adis * adis,bool enable)250 int 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
271 error_ret:
272 return ret;
273 }
274 EXPORT_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 */
adis_check_status(struct adis * adis)282 int 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 }
306 EXPORT_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 */
adis_reset(struct adis * adis)314 int 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 }
325 EXPORT_SYMBOL_GPL(adis_reset);
326
adis_self_test(struct adis * adis)327 static 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 */
adis_initial_startup(struct adis * adis)358 int 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 }
376 EXPORT_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 */
adis_single_conversion(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,unsigned int error_mask,int * val)393 int 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;
419 err_unlock:
420 mutex_unlock(&indio_dev->mlock);
421 return ret;
422 }
423 EXPORT_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 */
adis_init(struct adis * adis,struct iio_dev * indio_dev,struct spi_device * spi,const struct adis_data * data)437 int 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 }
455 EXPORT_SYMBOL_GPL(adis_init);
456
457 MODULE_LICENSE("GPL");
458 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
459 MODULE_DESCRIPTION("Common library code for ADIS16XXX devices");
460
