1
2
3
4
5
6
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
32
33
34
35
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
132
133
134
135
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
228
229
230
231
232
233
234
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
278
279
280
281
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
316
317
318
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
348
349
350
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
395
396
397
398
399
400
401
402
403
404
405
406
407
408
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
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
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
456
457
458
459
460
461
462
463
464
465
466
467
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
503
504
505
506
507
508
509
510
511
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
528 adis->current_page = -1;
529 } else {
530
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");
541