2 * adis16400.c support Analog Devices ADIS16400/5
3 * 3d 2g Linear Accelerometers,
5 * 3d Magnetometers via SPI
7 * Copyright (c) 2009 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
8 * Copyright (c) 2007 Jonathan Cameron <jic23@kernel.org>
9 * Copyright (c) 2011 Analog Devices Inc.
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
17 #include <linux/interrupt.h>
18 #include <linux/irq.h>
19 #include <linux/delay.h>
20 #include <linux/mutex.h>
21 #include <linux/device.h>
22 #include <linux/kernel.h>
23 #include <linux/spi/spi.h>
24 #include <linux/slab.h>
25 #include <linux/sysfs.h>
26 #include <linux/list.h>
27 #include <linux/module.h>
28 #include <linux/debugfs.h>
29 #include <linux/bitops.h>
31 #include <linux/iio/iio.h>
32 #include <linux/iio/sysfs.h>
33 #include <linux/iio/buffer.h>
34 #include <linux/iio/trigger_consumer.h>
35 #include <linux/iio/imu/adis.h>
37 #define ADIS16400_STARTUP_DELAY 290 /* ms */
38 #define ADIS16400_MTEST_DELAY 90 /* ms */
40 #define ADIS16400_FLASH_CNT 0x00 /* Flash memory write count */
41 #define ADIS16400_SUPPLY_OUT 0x02 /* Power supply measurement */
42 #define ADIS16400_XGYRO_OUT 0x04 /* X-axis gyroscope output */
43 #define ADIS16400_YGYRO_OUT 0x06 /* Y-axis gyroscope output */
44 #define ADIS16400_ZGYRO_OUT 0x08 /* Z-axis gyroscope output */
45 #define ADIS16400_XACCL_OUT 0x0A /* X-axis accelerometer output */
46 #define ADIS16400_YACCL_OUT 0x0C /* Y-axis accelerometer output */
47 #define ADIS16400_ZACCL_OUT 0x0E /* Z-axis accelerometer output */
48 #define ADIS16400_XMAGN_OUT 0x10 /* X-axis magnetometer measurement */
49 #define ADIS16400_YMAGN_OUT 0x12 /* Y-axis magnetometer measurement */
50 #define ADIS16400_ZMAGN_OUT 0x14 /* Z-axis magnetometer measurement */
51 #define ADIS16400_TEMP_OUT 0x16 /* Temperature output */
52 #define ADIS16400_AUX_ADC 0x18 /* Auxiliary ADC measurement */
54 #define ADIS16350_XTEMP_OUT 0x10 /* X-axis gyroscope temperature measurement */
55 #define ADIS16350_YTEMP_OUT 0x12 /* Y-axis gyroscope temperature measurement */
56 #define ADIS16350_ZTEMP_OUT 0x14 /* Z-axis gyroscope temperature measurement */
58 #define ADIS16300_PITCH_OUT 0x12 /* X axis inclinometer output measurement */
59 #define ADIS16300_ROLL_OUT 0x14 /* Y axis inclinometer output measurement */
60 #define ADIS16300_AUX_ADC 0x16 /* Auxiliary ADC measurement */
62 #define ADIS16448_BARO_OUT 0x16 /* Barometric pressure output */
63 #define ADIS16448_TEMP_OUT 0x18 /* Temperature output */
65 /* Calibration parameters */
66 #define ADIS16400_XGYRO_OFF 0x1A /* X-axis gyroscope bias offset factor */
67 #define ADIS16400_YGYRO_OFF 0x1C /* Y-axis gyroscope bias offset factor */
68 #define ADIS16400_ZGYRO_OFF 0x1E /* Z-axis gyroscope bias offset factor */
69 #define ADIS16400_XACCL_OFF 0x20 /* X-axis acceleration bias offset factor */
70 #define ADIS16400_YACCL_OFF 0x22 /* Y-axis acceleration bias offset factor */
71 #define ADIS16400_ZACCL_OFF 0x24 /* Z-axis acceleration bias offset factor */
72 #define ADIS16400_XMAGN_HIF 0x26 /* X-axis magnetometer, hard-iron factor */
73 #define ADIS16400_YMAGN_HIF 0x28 /* Y-axis magnetometer, hard-iron factor */
74 #define ADIS16400_ZMAGN_HIF 0x2A /* Z-axis magnetometer, hard-iron factor */
75 #define ADIS16400_XMAGN_SIF 0x2C /* X-axis magnetometer, soft-iron factor */
76 #define ADIS16400_YMAGN_SIF 0x2E /* Y-axis magnetometer, soft-iron factor */
77 #define ADIS16400_ZMAGN_SIF 0x30 /* Z-axis magnetometer, soft-iron factor */
79 #define ADIS16400_GPIO_CTRL 0x32 /* Auxiliary digital input/output control */
80 #define ADIS16400_MSC_CTRL 0x34 /* Miscellaneous control */
81 #define ADIS16400_SMPL_PRD 0x36 /* Internal sample period (rate) control */
82 #define ADIS16400_SENS_AVG 0x38 /* Dynamic range and digital filter control */
83 #define ADIS16400_SLP_CNT 0x3A /* Sleep mode control */
84 #define ADIS16400_DIAG_STAT 0x3C /* System status */
87 #define ADIS16400_GLOB_CMD 0x3E /* System command */
88 #define ADIS16400_ALM_MAG1 0x40 /* Alarm 1 amplitude threshold */
89 #define ADIS16400_ALM_MAG2 0x42 /* Alarm 2 amplitude threshold */
90 #define ADIS16400_ALM_SMPL1 0x44 /* Alarm 1 sample size */
91 #define ADIS16400_ALM_SMPL2 0x46 /* Alarm 2 sample size */
92 #define ADIS16400_ALM_CTRL 0x48 /* Alarm control */
93 #define ADIS16400_AUX_DAC 0x4A /* Auxiliary DAC data */
95 #define ADIS16334_LOT_ID1 0x52 /* Lot identification code 1 */
96 #define ADIS16334_LOT_ID2 0x54 /* Lot identification code 2 */
97 #define ADIS16400_PRODUCT_ID 0x56 /* Product identifier */
98 #define ADIS16334_SERIAL_NUMBER 0x58 /* Serial number, lot specific */
100 #define ADIS16400_ERROR_ACTIVE (1<<14)
101 #define ADIS16400_NEW_DATA (1<<14)
104 #define ADIS16400_MSC_CTRL_MEM_TEST (1<<11)
105 #define ADIS16400_MSC_CTRL_INT_SELF_TEST (1<<10)
106 #define ADIS16400_MSC_CTRL_NEG_SELF_TEST (1<<9)
107 #define ADIS16400_MSC_CTRL_POS_SELF_TEST (1<<8)
108 #define ADIS16400_MSC_CTRL_GYRO_BIAS (1<<7)
109 #define ADIS16400_MSC_CTRL_ACCL_ALIGN (1<<6)
110 #define ADIS16400_MSC_CTRL_DATA_RDY_EN (1<<2)
111 #define ADIS16400_MSC_CTRL_DATA_RDY_POL_HIGH (1<<1)
112 #define ADIS16400_MSC_CTRL_DATA_RDY_DIO2 (1<<0)
115 #define ADIS16400_SMPL_PRD_TIME_BASE (1<<7)
116 #define ADIS16400_SMPL_PRD_DIV_MASK 0x7F
119 #define ADIS16400_DIAG_STAT_ZACCL_FAIL 15
120 #define ADIS16400_DIAG_STAT_YACCL_FAIL 14
121 #define ADIS16400_DIAG_STAT_XACCL_FAIL 13
122 #define ADIS16400_DIAG_STAT_XGYRO_FAIL 12
123 #define ADIS16400_DIAG_STAT_YGYRO_FAIL 11
124 #define ADIS16400_DIAG_STAT_ZGYRO_FAIL 10
125 #define ADIS16400_DIAG_STAT_ALARM2 9
126 #define ADIS16400_DIAG_STAT_ALARM1 8
127 #define ADIS16400_DIAG_STAT_FLASH_CHK 6
128 #define ADIS16400_DIAG_STAT_SELF_TEST 5
129 #define ADIS16400_DIAG_STAT_OVERFLOW 4
130 #define ADIS16400_DIAG_STAT_SPI_FAIL 3
131 #define ADIS16400_DIAG_STAT_FLASH_UPT 2
132 #define ADIS16400_DIAG_STAT_POWER_HIGH 1
133 #define ADIS16400_DIAG_STAT_POWER_LOW 0
136 #define ADIS16400_GLOB_CMD_SW_RESET (1<<7)
137 #define ADIS16400_GLOB_CMD_P_AUTO_NULL (1<<4)
138 #define ADIS16400_GLOB_CMD_FLASH_UPD (1<<3)
139 #define ADIS16400_GLOB_CMD_DAC_LATCH (1<<2)
140 #define ADIS16400_GLOB_CMD_FAC_CALIB (1<<1)
141 #define ADIS16400_GLOB_CMD_AUTO_NULL (1<<0)
144 #define ADIS16400_SLP_CNT_POWER_OFF (1<<8)
146 #define ADIS16334_RATE_DIV_SHIFT 8
147 #define ADIS16334_RATE_INT_CLK BIT(0)
149 #define ADIS16400_SPI_SLOW (u32)(300 * 1000)
150 #define ADIS16400_SPI_BURST (u32)(1000 * 1000)
151 #define ADIS16400_SPI_FAST (u32)(2000 * 1000)
153 #define ADIS16400_HAS_PROD_ID BIT(0)
154 #define ADIS16400_NO_BURST BIT(1)
155 #define ADIS16400_HAS_SLOW_MODE BIT(2)
156 #define ADIS16400_HAS_SERIAL_NUMBER BIT(3)
157 #define ADIS16400_BURST_DIAG_STAT BIT(4)
159 struct adis16400_state
;
161 struct adis16400_chip_info
{
162 const struct iio_chan_spec
*channels
;
163 const int num_channels
;
165 unsigned int gyro_scale_micro
;
166 unsigned int accel_scale_micro
;
169 int (*set_freq
)(struct adis16400_state
*st
, unsigned int freq
);
170 int (*get_freq
)(struct adis16400_state
*st
);
174 * struct adis16400_state - device instance specific data
175 * @variant: chip variant info
176 * @filt_int: integer part of requested filter frequency
179 struct adis16400_state
{
180 struct adis16400_chip_info
*variant
;
184 unsigned long avail_scan_mask
[2];
187 /* At the moment triggers are only used for ring buffer
188 * filling. This may change!
192 ADIS16400_SCAN_SUPPLY
,
193 ADIS16400_SCAN_GYRO_X
,
194 ADIS16400_SCAN_GYRO_Y
,
195 ADIS16400_SCAN_GYRO_Z
,
196 ADIS16400_SCAN_ACC_X
,
197 ADIS16400_SCAN_ACC_Y
,
198 ADIS16400_SCAN_ACC_Z
,
199 ADIS16400_SCAN_MAGN_X
,
200 ADIS16400_SCAN_MAGN_Y
,
201 ADIS16400_SCAN_MAGN_Z
,
203 ADIS16350_SCAN_TEMP_X
,
204 ADIS16350_SCAN_TEMP_Y
,
205 ADIS16350_SCAN_TEMP_Z
,
206 ADIS16300_SCAN_INCLI_X
,
207 ADIS16300_SCAN_INCLI_Y
,
209 ADIS16400_SCAN_TIMESTAMP
,
212 #ifdef CONFIG_DEBUG_FS
214 static ssize_t
adis16400_show_serial_number(struct file
*file
,
215 char __user
*userbuf
, size_t count
, loff_t
*ppos
)
217 struct adis16400_state
*st
= file
->private_data
;
218 u16 lot1
, lot2
, serial_number
;
223 ret
= adis_read_reg_16(&st
->adis
, ADIS16334_LOT_ID1
, &lot1
);
227 ret
= adis_read_reg_16(&st
->adis
, ADIS16334_LOT_ID2
, &lot2
);
231 ret
= adis_read_reg_16(&st
->adis
, ADIS16334_SERIAL_NUMBER
,
236 len
= snprintf(buf
, sizeof(buf
), "%.4x-%.4x-%.4x\n", lot1
, lot2
,
239 return simple_read_from_buffer(userbuf
, count
, ppos
, buf
, len
);
242 static const struct file_operations adis16400_serial_number_fops
= {
244 .read
= adis16400_show_serial_number
,
245 .llseek
= default_llseek
,
246 .owner
= THIS_MODULE
,
249 static int adis16400_show_product_id(void *arg
, u64
*val
)
251 struct adis16400_state
*st
= arg
;
255 ret
= adis_read_reg_16(&st
->adis
, ADIS16400_PRODUCT_ID
, &prod_id
);
263 DEFINE_SIMPLE_ATTRIBUTE(adis16400_product_id_fops
,
264 adis16400_show_product_id
, NULL
, "%lld\n");
266 static int adis16400_show_flash_count(void *arg
, u64
*val
)
268 struct adis16400_state
*st
= arg
;
269 uint16_t flash_count
;
272 ret
= adis_read_reg_16(&st
->adis
, ADIS16400_FLASH_CNT
, &flash_count
);
280 DEFINE_SIMPLE_ATTRIBUTE(adis16400_flash_count_fops
,
281 adis16400_show_flash_count
, NULL
, "%lld\n");
283 static int adis16400_debugfs_init(struct iio_dev
*indio_dev
)
285 struct adis16400_state
*st
= iio_priv(indio_dev
);
287 if (st
->variant
->flags
& ADIS16400_HAS_SERIAL_NUMBER
)
288 debugfs_create_file("serial_number", 0400,
289 indio_dev
->debugfs_dentry
, st
,
290 &adis16400_serial_number_fops
);
291 if (st
->variant
->flags
& ADIS16400_HAS_PROD_ID
)
292 debugfs_create_file("product_id", 0400,
293 indio_dev
->debugfs_dentry
, st
,
294 &adis16400_product_id_fops
);
295 debugfs_create_file("flash_count", 0400, indio_dev
->debugfs_dentry
,
296 st
, &adis16400_flash_count_fops
);
303 static int adis16400_debugfs_init(struct iio_dev
*indio_dev
)
310 enum adis16400_chip_variant
{
323 static struct adis_burst adis16400_burst
= {
325 .reg_cmd
= ADIS16400_GLOB_CMD
,
328 static int adis16334_get_freq(struct adis16400_state
*st
)
333 ret
= adis_read_reg_16(&st
->adis
, ADIS16400_SMPL_PRD
, &t
);
337 t
>>= ADIS16334_RATE_DIV_SHIFT
;
342 static int adis16334_set_freq(struct adis16400_state
*st
, unsigned int freq
)
347 t
= ilog2(819200 / freq
);
354 t
<<= ADIS16334_RATE_DIV_SHIFT
;
355 t
|= ADIS16334_RATE_INT_CLK
;
357 return adis_write_reg_16(&st
->adis
, ADIS16400_SMPL_PRD
, t
);
360 static int adis16400_get_freq(struct adis16400_state
*st
)
365 ret
= adis_read_reg_16(&st
->adis
, ADIS16400_SMPL_PRD
, &t
);
369 sps
= (t
& ADIS16400_SMPL_PRD_TIME_BASE
) ? 52851 : 1638404;
370 sps
/= (t
& ADIS16400_SMPL_PRD_DIV_MASK
) + 1;
375 static int adis16400_set_freq(struct adis16400_state
*st
, unsigned int freq
)
382 val
|= ADIS16400_SMPL_PRD_TIME_BASE
;
392 if (t
>= 0x0A || (val
& ADIS16400_SMPL_PRD_TIME_BASE
))
393 st
->adis
.spi
->max_speed_hz
= ADIS16400_SPI_SLOW
;
395 st
->adis
.spi
->max_speed_hz
= ADIS16400_SPI_FAST
;
397 return adis_write_reg_8(&st
->adis
, ADIS16400_SMPL_PRD
, val
);
400 static const unsigned int adis16400_3db_divisors
[] = {
401 [0] = 2, /* Special case */
408 [7] = 200, /* Not a valid setting */
411 static int adis16400_set_filter(struct iio_dev
*indio_dev
, int sps
, int val
)
413 struct adis16400_state
*st
= iio_priv(indio_dev
);
417 for (i
= ARRAY_SIZE(adis16400_3db_divisors
) - 1; i
>= 1; i
--) {
418 if (sps
/ adis16400_3db_divisors
[i
] >= val
)
422 ret
= adis_read_reg_16(&st
->adis
, ADIS16400_SENS_AVG
, &val16
);
426 ret
= adis_write_reg_16(&st
->adis
, ADIS16400_SENS_AVG
,
427 (val16
& ~0x07) | i
);
431 /* Power down the device */
432 static int adis16400_stop_device(struct iio_dev
*indio_dev
)
434 struct adis16400_state
*st
= iio_priv(indio_dev
);
437 ret
= adis_write_reg_16(&st
->adis
, ADIS16400_SLP_CNT
,
438 ADIS16400_SLP_CNT_POWER_OFF
);
440 dev_err(&indio_dev
->dev
,
441 "problem with turning device off: SLP_CNT");
446 static int adis16400_initial_setup(struct iio_dev
*indio_dev
)
448 struct adis16400_state
*st
= iio_priv(indio_dev
);
449 uint16_t prod_id
, smp_prd
;
450 unsigned int device_id
;
453 /* use low spi speed for init if the device has a slow mode */
454 if (st
->variant
->flags
& ADIS16400_HAS_SLOW_MODE
)
455 st
->adis
.spi
->max_speed_hz
= ADIS16400_SPI_SLOW
;
457 st
->adis
.spi
->max_speed_hz
= ADIS16400_SPI_FAST
;
458 st
->adis
.spi
->mode
= SPI_MODE_3
;
459 spi_setup(st
->adis
.spi
);
461 ret
= adis_initial_startup(&st
->adis
);
465 if (st
->variant
->flags
& ADIS16400_HAS_PROD_ID
) {
466 ret
= adis_read_reg_16(&st
->adis
,
467 ADIS16400_PRODUCT_ID
, &prod_id
);
471 ret
= sscanf(indio_dev
->name
, "adis%u\n", &device_id
);
477 if (prod_id
!= device_id
)
478 dev_warn(&indio_dev
->dev
, "Device ID(%u) and product ID(%u) do not match.",
481 dev_info(&indio_dev
->dev
, "%s: prod_id 0x%04x at CS%d (irq %d)\n",
482 indio_dev
->name
, prod_id
,
483 st
->adis
.spi
->chip_select
, st
->adis
.spi
->irq
);
485 /* use high spi speed if possible */
486 if (st
->variant
->flags
& ADIS16400_HAS_SLOW_MODE
) {
487 ret
= adis_read_reg_16(&st
->adis
, ADIS16400_SMPL_PRD
, &smp_prd
);
491 if ((smp_prd
& ADIS16400_SMPL_PRD_DIV_MASK
) < 0x0A) {
492 st
->adis
.spi
->max_speed_hz
= ADIS16400_SPI_FAST
;
493 spi_setup(st
->adis
.spi
);
501 static const uint8_t adis16400_addresses
[] = {
502 [ADIS16400_SCAN_GYRO_X
] = ADIS16400_XGYRO_OFF
,
503 [ADIS16400_SCAN_GYRO_Y
] = ADIS16400_YGYRO_OFF
,
504 [ADIS16400_SCAN_GYRO_Z
] = ADIS16400_ZGYRO_OFF
,
505 [ADIS16400_SCAN_ACC_X
] = ADIS16400_XACCL_OFF
,
506 [ADIS16400_SCAN_ACC_Y
] = ADIS16400_YACCL_OFF
,
507 [ADIS16400_SCAN_ACC_Z
] = ADIS16400_ZACCL_OFF
,
510 static int adis16400_write_raw(struct iio_dev
*indio_dev
,
511 struct iio_chan_spec
const *chan
, int val
, int val2
, long info
)
513 struct adis16400_state
*st
= iio_priv(indio_dev
);
517 case IIO_CHAN_INFO_CALIBBIAS
:
518 mutex_lock(&indio_dev
->mlock
);
519 ret
= adis_write_reg_16(&st
->adis
,
520 adis16400_addresses
[chan
->scan_index
], val
);
521 mutex_unlock(&indio_dev
->mlock
);
523 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY
:
525 * Need to cache values so we can update if the frequency
528 mutex_lock(&indio_dev
->mlock
);
530 /* Work out update to current value */
531 sps
= st
->variant
->get_freq(st
);
533 mutex_unlock(&indio_dev
->mlock
);
537 ret
= adis16400_set_filter(indio_dev
, sps
,
538 val
* 1000 + val2
/ 1000);
539 mutex_unlock(&indio_dev
->mlock
);
541 case IIO_CHAN_INFO_SAMP_FREQ
:
542 sps
= val
* 1000 + val2
/ 1000;
547 mutex_lock(&indio_dev
->mlock
);
548 ret
= st
->variant
->set_freq(st
, sps
);
549 mutex_unlock(&indio_dev
->mlock
);
556 static int adis16400_read_raw(struct iio_dev
*indio_dev
,
557 struct iio_chan_spec
const *chan
, int *val
, int *val2
, long info
)
559 struct adis16400_state
*st
= iio_priv(indio_dev
);
564 case IIO_CHAN_INFO_RAW
:
565 return adis_single_conversion(indio_dev
, chan
, 0, val
);
566 case IIO_CHAN_INFO_SCALE
:
567 switch (chan
->type
) {
570 *val2
= st
->variant
->gyro_scale_micro
;
571 return IIO_VAL_INT_PLUS_MICRO
;
574 if (chan
->channel
== 0) {
576 *val2
= 418000; /* 2.418 mV */
579 *val2
= 805800; /* 805.8 uV */
581 return IIO_VAL_INT_PLUS_MICRO
;
584 *val2
= st
->variant
->accel_scale_micro
;
585 return IIO_VAL_INT_PLUS_MICRO
;
588 *val2
= 500; /* 0.5 mgauss */
589 return IIO_VAL_INT_PLUS_MICRO
;
591 *val
= st
->variant
->temp_scale_nano
/ 1000000;
592 *val2
= (st
->variant
->temp_scale_nano
% 1000000);
593 return IIO_VAL_INT_PLUS_MICRO
;
595 /* 20 uBar = 0.002kPascal */
598 return IIO_VAL_INT_PLUS_MICRO
;
602 case IIO_CHAN_INFO_CALIBBIAS
:
603 mutex_lock(&indio_dev
->mlock
);
604 ret
= adis_read_reg_16(&st
->adis
,
605 adis16400_addresses
[chan
->scan_index
], &val16
);
606 mutex_unlock(&indio_dev
->mlock
);
609 val16
= sign_extend32(val16
, 11);
612 case IIO_CHAN_INFO_OFFSET
:
613 /* currently only temperature */
614 *val
= st
->variant
->temp_offset
;
616 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY
:
617 mutex_lock(&indio_dev
->mlock
);
618 /* Need both the number of taps and the sampling frequency */
619 ret
= adis_read_reg_16(&st
->adis
,
623 mutex_unlock(&indio_dev
->mlock
);
626 ret
= st
->variant
->get_freq(st
);
628 ret
/= adis16400_3db_divisors
[val16
& 0x07];
630 *val2
= (ret
% 1000) * 1000;
632 mutex_unlock(&indio_dev
->mlock
);
635 return IIO_VAL_INT_PLUS_MICRO
;
636 case IIO_CHAN_INFO_SAMP_FREQ
:
637 ret
= st
->variant
->get_freq(st
);
641 *val2
= (ret
% 1000) * 1000;
642 return IIO_VAL_INT_PLUS_MICRO
;
648 #if IS_ENABLED(CONFIG_IIO_BUFFER)
649 static irqreturn_t
adis16400_trigger_handler(int irq
, void *p
)
651 struct iio_poll_func
*pf
= p
;
652 struct iio_dev
*indio_dev
= pf
->indio_dev
;
653 struct adis16400_state
*st
= iio_priv(indio_dev
);
654 struct adis
*adis
= &st
->adis
;
655 u32 old_speed_hz
= st
->adis
.spi
->max_speed_hz
;
662 if (!(st
->variant
->flags
& ADIS16400_NO_BURST
) &&
663 st
->adis
.spi
->max_speed_hz
> ADIS16400_SPI_BURST
) {
664 st
->adis
.spi
->max_speed_hz
= ADIS16400_SPI_BURST
;
665 spi_setup(st
->adis
.spi
);
668 ret
= spi_sync(adis
->spi
, &adis
->msg
);
670 dev_err(&adis
->spi
->dev
, "Failed to read data: %d\n", ret
);
672 if (!(st
->variant
->flags
& ADIS16400_NO_BURST
)) {
673 st
->adis
.spi
->max_speed_hz
= old_speed_hz
;
674 spi_setup(st
->adis
.spi
);
677 if (st
->variant
->flags
& ADIS16400_BURST_DIAG_STAT
)
678 buffer
= adis
->buffer
+ sizeof(u16
);
680 buffer
= adis
->buffer
;
682 iio_push_to_buffers_with_timestamp(indio_dev
, buffer
,
685 iio_trigger_notify_done(indio_dev
->trig
);
690 #define adis16400_trigger_handler NULL
691 #endif /* IS_ENABLED(CONFIG_IIO_BUFFER) */
693 #define ADIS16400_VOLTAGE_CHAN(addr, bits, name, si, chn) { \
694 .type = IIO_VOLTAGE, \
697 .extend_name = name, \
698 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
699 BIT(IIO_CHAN_INFO_SCALE), \
700 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
702 .scan_index = (si), \
705 .realbits = (bits), \
708 .endianness = IIO_BE, \
712 #define ADIS16400_SUPPLY_CHAN(addr, bits) \
713 ADIS16400_VOLTAGE_CHAN(addr, bits, "supply", ADIS16400_SCAN_SUPPLY, 0)
715 #define ADIS16400_AUX_ADC_CHAN(addr, bits) \
716 ADIS16400_VOLTAGE_CHAN(addr, bits, NULL, ADIS16400_SCAN_ADC, 1)
718 #define ADIS16400_GYRO_CHAN(mod, addr, bits) { \
719 .type = IIO_ANGL_VEL, \
721 .channel2 = IIO_MOD_ ## mod, \
722 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
723 BIT(IIO_CHAN_INFO_CALIBBIAS), \
724 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
725 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
726 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
728 .scan_index = ADIS16400_SCAN_GYRO_ ## mod, \
731 .realbits = (bits), \
734 .endianness = IIO_BE, \
738 #define ADIS16400_ACCEL_CHAN(mod, addr, bits) { \
741 .channel2 = IIO_MOD_ ## mod, \
742 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
743 BIT(IIO_CHAN_INFO_CALIBBIAS), \
744 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
745 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
746 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
748 .scan_index = ADIS16400_SCAN_ACC_ ## mod, \
751 .realbits = (bits), \
754 .endianness = IIO_BE, \
758 #define ADIS16400_MAGN_CHAN(mod, addr, bits) { \
761 .channel2 = IIO_MOD_ ## mod, \
762 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
763 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
764 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
765 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
767 .scan_index = ADIS16400_SCAN_MAGN_ ## mod, \
770 .realbits = (bits), \
773 .endianness = IIO_BE, \
777 #define ADIS16400_MOD_TEMP_NAME_X "x"
778 #define ADIS16400_MOD_TEMP_NAME_Y "y"
779 #define ADIS16400_MOD_TEMP_NAME_Z "z"
781 #define ADIS16400_MOD_TEMP_CHAN(mod, addr, bits) { \
785 .extend_name = ADIS16400_MOD_TEMP_NAME_ ## mod, \
786 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
787 BIT(IIO_CHAN_INFO_OFFSET) | \
788 BIT(IIO_CHAN_INFO_SCALE), \
789 .info_mask_shared_by_type = \
790 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
791 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
793 .scan_index = ADIS16350_SCAN_TEMP_ ## mod, \
796 .realbits = (bits), \
799 .endianness = IIO_BE, \
803 #define ADIS16400_TEMP_CHAN(addr, bits) { \
807 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
808 BIT(IIO_CHAN_INFO_OFFSET) | \
809 BIT(IIO_CHAN_INFO_SCALE), \
810 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
812 .scan_index = ADIS16350_SCAN_TEMP_X, \
815 .realbits = (bits), \
818 .endianness = IIO_BE, \
822 #define ADIS16400_INCLI_CHAN(mod, addr, bits) { \
825 .channel2 = IIO_MOD_ ## mod, \
826 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
827 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
828 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
830 .scan_index = ADIS16300_SCAN_INCLI_ ## mod, \
833 .realbits = (bits), \
836 .endianness = IIO_BE, \
840 static const struct iio_chan_spec adis16400_channels
[] = {
841 ADIS16400_SUPPLY_CHAN(ADIS16400_SUPPLY_OUT
, 14),
842 ADIS16400_GYRO_CHAN(X
, ADIS16400_XGYRO_OUT
, 14),
843 ADIS16400_GYRO_CHAN(Y
, ADIS16400_YGYRO_OUT
, 14),
844 ADIS16400_GYRO_CHAN(Z
, ADIS16400_ZGYRO_OUT
, 14),
845 ADIS16400_ACCEL_CHAN(X
, ADIS16400_XACCL_OUT
, 14),
846 ADIS16400_ACCEL_CHAN(Y
, ADIS16400_YACCL_OUT
, 14),
847 ADIS16400_ACCEL_CHAN(Z
, ADIS16400_ZACCL_OUT
, 14),
848 ADIS16400_MAGN_CHAN(X
, ADIS16400_XMAGN_OUT
, 14),
849 ADIS16400_MAGN_CHAN(Y
, ADIS16400_YMAGN_OUT
, 14),
850 ADIS16400_MAGN_CHAN(Z
, ADIS16400_ZMAGN_OUT
, 14),
851 ADIS16400_TEMP_CHAN(ADIS16400_TEMP_OUT
, 12),
852 ADIS16400_AUX_ADC_CHAN(ADIS16400_AUX_ADC
, 12),
853 IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP
),
856 static const struct iio_chan_spec adis16445_channels
[] = {
857 ADIS16400_GYRO_CHAN(X
, ADIS16400_XGYRO_OUT
, 16),
858 ADIS16400_GYRO_CHAN(Y
, ADIS16400_YGYRO_OUT
, 16),
859 ADIS16400_GYRO_CHAN(Z
, ADIS16400_ZGYRO_OUT
, 16),
860 ADIS16400_ACCEL_CHAN(X
, ADIS16400_XACCL_OUT
, 16),
861 ADIS16400_ACCEL_CHAN(Y
, ADIS16400_YACCL_OUT
, 16),
862 ADIS16400_ACCEL_CHAN(Z
, ADIS16400_ZACCL_OUT
, 16),
863 ADIS16400_TEMP_CHAN(ADIS16448_TEMP_OUT
, 12),
864 IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP
),
867 static const struct iio_chan_spec adis16448_channels
[] = {
868 ADIS16400_GYRO_CHAN(X
, ADIS16400_XGYRO_OUT
, 16),
869 ADIS16400_GYRO_CHAN(Y
, ADIS16400_YGYRO_OUT
, 16),
870 ADIS16400_GYRO_CHAN(Z
, ADIS16400_ZGYRO_OUT
, 16),
871 ADIS16400_ACCEL_CHAN(X
, ADIS16400_XACCL_OUT
, 16),
872 ADIS16400_ACCEL_CHAN(Y
, ADIS16400_YACCL_OUT
, 16),
873 ADIS16400_ACCEL_CHAN(Z
, ADIS16400_ZACCL_OUT
, 16),
874 ADIS16400_MAGN_CHAN(X
, ADIS16400_XMAGN_OUT
, 16),
875 ADIS16400_MAGN_CHAN(Y
, ADIS16400_YMAGN_OUT
, 16),
876 ADIS16400_MAGN_CHAN(Z
, ADIS16400_ZMAGN_OUT
, 16),
878 .type
= IIO_PRESSURE
,
879 .info_mask_separate
= BIT(IIO_CHAN_INFO_RAW
),
880 .info_mask_shared_by_type
= BIT(IIO_CHAN_INFO_SCALE
),
881 .info_mask_shared_by_all
= BIT(IIO_CHAN_INFO_SAMP_FREQ
),
882 .address
= ADIS16448_BARO_OUT
,
883 .scan_index
= ADIS16400_SCAN_BARO
,
888 .endianness
= IIO_BE
,
891 ADIS16400_TEMP_CHAN(ADIS16448_TEMP_OUT
, 12),
892 IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP
),
895 static const struct iio_chan_spec adis16350_channels
[] = {
896 ADIS16400_SUPPLY_CHAN(ADIS16400_SUPPLY_OUT
, 12),
897 ADIS16400_GYRO_CHAN(X
, ADIS16400_XGYRO_OUT
, 14),
898 ADIS16400_GYRO_CHAN(Y
, ADIS16400_YGYRO_OUT
, 14),
899 ADIS16400_GYRO_CHAN(Z
, ADIS16400_ZGYRO_OUT
, 14),
900 ADIS16400_ACCEL_CHAN(X
, ADIS16400_XACCL_OUT
, 14),
901 ADIS16400_ACCEL_CHAN(Y
, ADIS16400_YACCL_OUT
, 14),
902 ADIS16400_ACCEL_CHAN(Z
, ADIS16400_ZACCL_OUT
, 14),
903 ADIS16400_MAGN_CHAN(X
, ADIS16400_XMAGN_OUT
, 14),
904 ADIS16400_MAGN_CHAN(Y
, ADIS16400_YMAGN_OUT
, 14),
905 ADIS16400_MAGN_CHAN(Z
, ADIS16400_ZMAGN_OUT
, 14),
906 ADIS16400_AUX_ADC_CHAN(ADIS16300_AUX_ADC
, 12),
907 ADIS16400_MOD_TEMP_CHAN(X
, ADIS16350_XTEMP_OUT
, 12),
908 ADIS16400_MOD_TEMP_CHAN(Y
, ADIS16350_YTEMP_OUT
, 12),
909 ADIS16400_MOD_TEMP_CHAN(Z
, ADIS16350_ZTEMP_OUT
, 12),
910 IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP
),
913 static const struct iio_chan_spec adis16300_channels
[] = {
914 ADIS16400_SUPPLY_CHAN(ADIS16400_SUPPLY_OUT
, 12),
915 ADIS16400_GYRO_CHAN(X
, ADIS16400_XGYRO_OUT
, 14),
916 ADIS16400_ACCEL_CHAN(X
, ADIS16400_XACCL_OUT
, 14),
917 ADIS16400_ACCEL_CHAN(Y
, ADIS16400_YACCL_OUT
, 14),
918 ADIS16400_ACCEL_CHAN(Z
, ADIS16400_ZACCL_OUT
, 14),
919 ADIS16400_TEMP_CHAN(ADIS16350_XTEMP_OUT
, 12),
920 ADIS16400_AUX_ADC_CHAN(ADIS16300_AUX_ADC
, 12),
921 ADIS16400_INCLI_CHAN(X
, ADIS16300_PITCH_OUT
, 13),
922 ADIS16400_INCLI_CHAN(Y
, ADIS16300_ROLL_OUT
, 13),
923 IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP
),
926 static const struct iio_chan_spec adis16334_channels
[] = {
927 ADIS16400_GYRO_CHAN(X
, ADIS16400_XGYRO_OUT
, 14),
928 ADIS16400_GYRO_CHAN(Y
, ADIS16400_YGYRO_OUT
, 14),
929 ADIS16400_GYRO_CHAN(Z
, ADIS16400_ZGYRO_OUT
, 14),
930 ADIS16400_ACCEL_CHAN(X
, ADIS16400_XACCL_OUT
, 14),
931 ADIS16400_ACCEL_CHAN(Y
, ADIS16400_YACCL_OUT
, 14),
932 ADIS16400_ACCEL_CHAN(Z
, ADIS16400_ZACCL_OUT
, 14),
933 ADIS16400_TEMP_CHAN(ADIS16350_XTEMP_OUT
, 12),
934 IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP
),
937 static struct adis16400_chip_info adis16400_chips
[] = {
939 .channels
= adis16300_channels
,
940 .num_channels
= ARRAY_SIZE(adis16300_channels
),
941 .flags
= ADIS16400_HAS_PROD_ID
| ADIS16400_HAS_SLOW_MODE
|
942 ADIS16400_HAS_SERIAL_NUMBER
,
943 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
944 .accel_scale_micro
= 5884,
945 .temp_scale_nano
= 140000000, /* 0.14 C */
946 .temp_offset
= 25000000 / 140000, /* 25 C = 0x00 */
947 .set_freq
= adis16400_set_freq
,
948 .get_freq
= adis16400_get_freq
,
951 .channels
= adis16334_channels
,
952 .num_channels
= ARRAY_SIZE(adis16334_channels
),
953 .flags
= ADIS16400_HAS_PROD_ID
| ADIS16400_NO_BURST
|
954 ADIS16400_HAS_SERIAL_NUMBER
,
955 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
956 .accel_scale_micro
= IIO_G_TO_M_S_2(1000), /* 1 mg */
957 .temp_scale_nano
= 67850000, /* 0.06785 C */
958 .temp_offset
= 25000000 / 67850, /* 25 C = 0x00 */
959 .set_freq
= adis16334_set_freq
,
960 .get_freq
= adis16334_get_freq
,
963 .channels
= adis16350_channels
,
964 .num_channels
= ARRAY_SIZE(adis16350_channels
),
965 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(73260), /* 0.07326 deg/s */
966 .accel_scale_micro
= IIO_G_TO_M_S_2(2522), /* 0.002522 g */
967 .temp_scale_nano
= 145300000, /* 0.1453 C */
968 .temp_offset
= 25000000 / 145300, /* 25 C = 0x00 */
969 .flags
= ADIS16400_NO_BURST
| ADIS16400_HAS_SLOW_MODE
,
970 .set_freq
= adis16400_set_freq
,
971 .get_freq
= adis16400_get_freq
,
974 .channels
= adis16350_channels
,
975 .num_channels
= ARRAY_SIZE(adis16350_channels
),
976 .flags
= ADIS16400_HAS_PROD_ID
| ADIS16400_HAS_SLOW_MODE
|
977 ADIS16400_HAS_SERIAL_NUMBER
,
978 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
979 .accel_scale_micro
= IIO_G_TO_M_S_2(3333), /* 3.333 mg */
980 .temp_scale_nano
= 136000000, /* 0.136 C */
981 .temp_offset
= 25000000 / 136000, /* 25 C = 0x00 */
982 .set_freq
= adis16400_set_freq
,
983 .get_freq
= adis16400_get_freq
,
986 .channels
= adis16350_channels
,
987 .num_channels
= ARRAY_SIZE(adis16350_channels
),
988 .flags
= ADIS16400_HAS_PROD_ID
| ADIS16400_HAS_SLOW_MODE
|
989 ADIS16400_HAS_SERIAL_NUMBER
,
990 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
991 .accel_scale_micro
= IIO_G_TO_M_S_2(333), /* 0.333 mg */
992 .temp_scale_nano
= 136000000, /* 0.136 C */
993 .temp_offset
= 25000000 / 136000, /* 25 C = 0x00 */
994 .set_freq
= adis16400_set_freq
,
995 .get_freq
= adis16400_get_freq
,
998 .channels
= adis16350_channels
,
999 .num_channels
= ARRAY_SIZE(adis16350_channels
),
1000 .flags
= ADIS16400_HAS_PROD_ID
| ADIS16400_HAS_SLOW_MODE
|
1001 ADIS16400_HAS_SERIAL_NUMBER
,
1002 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
1003 .accel_scale_micro
= IIO_G_TO_M_S_2(1000), /* 1 mg */
1004 .temp_scale_nano
= 136000000, /* 0.136 C */
1005 .temp_offset
= 25000000 / 136000, /* 25 C = 0x00 */
1006 .set_freq
= adis16400_set_freq
,
1007 .get_freq
= adis16400_get_freq
,
1010 .channels
= adis16350_channels
,
1011 .num_channels
= ARRAY_SIZE(adis16350_channels
),
1012 .flags
= ADIS16400_HAS_PROD_ID
| ADIS16400_HAS_SLOW_MODE
|
1013 ADIS16400_HAS_SERIAL_NUMBER
,
1014 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(2000), /* 0.2 deg/s */
1015 .accel_scale_micro
= IIO_G_TO_M_S_2(3333), /* 3.333 mg */
1016 .temp_scale_nano
= 136000000, /* 0.136 C */
1017 .temp_offset
= 25000000 / 136000, /* 25 C = 0x00 */
1018 .set_freq
= adis16400_set_freq
,
1019 .get_freq
= adis16400_get_freq
,
1022 .channels
= adis16400_channels
,
1023 .num_channels
= ARRAY_SIZE(adis16400_channels
),
1024 .flags
= ADIS16400_HAS_PROD_ID
| ADIS16400_HAS_SLOW_MODE
,
1025 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
1026 .accel_scale_micro
= IIO_G_TO_M_S_2(3333), /* 3.333 mg */
1027 .temp_scale_nano
= 140000000, /* 0.14 C */
1028 .temp_offset
= 25000000 / 140000, /* 25 C = 0x00 */
1029 .set_freq
= adis16400_set_freq
,
1030 .get_freq
= adis16400_get_freq
,
1033 .channels
= adis16445_channels
,
1034 .num_channels
= ARRAY_SIZE(adis16445_channels
),
1035 .flags
= ADIS16400_HAS_PROD_ID
|
1036 ADIS16400_HAS_SERIAL_NUMBER
|
1037 ADIS16400_BURST_DIAG_STAT
,
1038 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(10000), /* 0.01 deg/s */
1039 .accel_scale_micro
= IIO_G_TO_M_S_2(250), /* 1/4000 g */
1040 .temp_scale_nano
= 73860000, /* 0.07386 C */
1041 .temp_offset
= 31000000 / 73860, /* 31 C = 0x00 */
1042 .set_freq
= adis16334_set_freq
,
1043 .get_freq
= adis16334_get_freq
,
1046 .channels
= adis16448_channels
,
1047 .num_channels
= ARRAY_SIZE(adis16448_channels
),
1048 .flags
= ADIS16400_HAS_PROD_ID
|
1049 ADIS16400_HAS_SERIAL_NUMBER
|
1050 ADIS16400_BURST_DIAG_STAT
,
1051 .gyro_scale_micro
= IIO_DEGREE_TO_RAD(40000), /* 0.04 deg/s */
1052 .accel_scale_micro
= IIO_G_TO_M_S_2(833), /* 1/1200 g */
1053 .temp_scale_nano
= 73860000, /* 0.07386 C */
1054 .temp_offset
= 31000000 / 73860, /* 31 C = 0x00 */
1055 .set_freq
= adis16334_set_freq
,
1056 .get_freq
= adis16334_get_freq
,
1060 static const struct iio_info adis16400_info
= {
1061 .read_raw
= &adis16400_read_raw
,
1062 .write_raw
= &adis16400_write_raw
,
1063 .update_scan_mode
= adis_update_scan_mode
,
1064 .debugfs_reg_access
= adis_debugfs_reg_access
,
1067 static const char * const adis16400_status_error_msgs
[] = {
1068 [ADIS16400_DIAG_STAT_ZACCL_FAIL
] = "Z-axis accelerometer self-test failure",
1069 [ADIS16400_DIAG_STAT_YACCL_FAIL
] = "Y-axis accelerometer self-test failure",
1070 [ADIS16400_DIAG_STAT_XACCL_FAIL
] = "X-axis accelerometer self-test failure",
1071 [ADIS16400_DIAG_STAT_XGYRO_FAIL
] = "X-axis gyroscope self-test failure",
1072 [ADIS16400_DIAG_STAT_YGYRO_FAIL
] = "Y-axis gyroscope self-test failure",
1073 [ADIS16400_DIAG_STAT_ZGYRO_FAIL
] = "Z-axis gyroscope self-test failure",
1074 [ADIS16400_DIAG_STAT_ALARM2
] = "Alarm 2 active",
1075 [ADIS16400_DIAG_STAT_ALARM1
] = "Alarm 1 active",
1076 [ADIS16400_DIAG_STAT_FLASH_CHK
] = "Flash checksum error",
1077 [ADIS16400_DIAG_STAT_SELF_TEST
] = "Self test error",
1078 [ADIS16400_DIAG_STAT_OVERFLOW
] = "Sensor overrange",
1079 [ADIS16400_DIAG_STAT_SPI_FAIL
] = "SPI failure",
1080 [ADIS16400_DIAG_STAT_FLASH_UPT
] = "Flash update failed",
1081 [ADIS16400_DIAG_STAT_POWER_HIGH
] = "Power supply above 5.25V",
1082 [ADIS16400_DIAG_STAT_POWER_LOW
] = "Power supply below 4.75V",
1085 static const struct adis_data adis16400_data
= {
1086 .msc_ctrl_reg
= ADIS16400_MSC_CTRL
,
1087 .glob_cmd_reg
= ADIS16400_GLOB_CMD
,
1088 .diag_stat_reg
= ADIS16400_DIAG_STAT
,
1093 .self_test_mask
= ADIS16400_MSC_CTRL_MEM_TEST
,
1094 .startup_delay
= ADIS16400_STARTUP_DELAY
,
1096 .status_error_msgs
= adis16400_status_error_msgs
,
1097 .status_error_mask
= BIT(ADIS16400_DIAG_STAT_ZACCL_FAIL
) |
1098 BIT(ADIS16400_DIAG_STAT_YACCL_FAIL
) |
1099 BIT(ADIS16400_DIAG_STAT_XACCL_FAIL
) |
1100 BIT(ADIS16400_DIAG_STAT_XGYRO_FAIL
) |
1101 BIT(ADIS16400_DIAG_STAT_YGYRO_FAIL
) |
1102 BIT(ADIS16400_DIAG_STAT_ZGYRO_FAIL
) |
1103 BIT(ADIS16400_DIAG_STAT_ALARM2
) |
1104 BIT(ADIS16400_DIAG_STAT_ALARM1
) |
1105 BIT(ADIS16400_DIAG_STAT_FLASH_CHK
) |
1106 BIT(ADIS16400_DIAG_STAT_SELF_TEST
) |
1107 BIT(ADIS16400_DIAG_STAT_OVERFLOW
) |
1108 BIT(ADIS16400_DIAG_STAT_SPI_FAIL
) |
1109 BIT(ADIS16400_DIAG_STAT_FLASH_UPT
) |
1110 BIT(ADIS16400_DIAG_STAT_POWER_HIGH
) |
1111 BIT(ADIS16400_DIAG_STAT_POWER_LOW
),
1114 static void adis16400_setup_chan_mask(struct adis16400_state
*st
)
1116 const struct adis16400_chip_info
*chip_info
= st
->variant
;
1119 for (i
= 0; i
< chip_info
->num_channels
; i
++) {
1120 const struct iio_chan_spec
*ch
= &chip_info
->channels
[i
];
1122 if (ch
->scan_index
>= 0 &&
1123 ch
->scan_index
!= ADIS16400_SCAN_TIMESTAMP
)
1124 st
->avail_scan_mask
[0] |= BIT(ch
->scan_index
);
1128 static int adis16400_probe(struct spi_device
*spi
)
1130 struct adis16400_state
*st
;
1131 struct iio_dev
*indio_dev
;
1134 indio_dev
= devm_iio_device_alloc(&spi
->dev
, sizeof(*st
));
1135 if (indio_dev
== NULL
)
1138 st
= iio_priv(indio_dev
);
1139 /* this is only used for removal purposes */
1140 spi_set_drvdata(spi
, indio_dev
);
1142 /* setup the industrialio driver allocated elements */
1143 st
->variant
= &adis16400_chips
[spi_get_device_id(spi
)->driver_data
];
1144 indio_dev
->dev
.parent
= &spi
->dev
;
1145 indio_dev
->name
= spi_get_device_id(spi
)->name
;
1146 indio_dev
->channels
= st
->variant
->channels
;
1147 indio_dev
->num_channels
= st
->variant
->num_channels
;
1148 indio_dev
->info
= &adis16400_info
;
1149 indio_dev
->modes
= INDIO_DIRECT_MODE
;
1151 if (!(st
->variant
->flags
& ADIS16400_NO_BURST
)) {
1152 adis16400_setup_chan_mask(st
);
1153 indio_dev
->available_scan_masks
= st
->avail_scan_mask
;
1154 st
->adis
.burst
= &adis16400_burst
;
1155 if (st
->variant
->flags
& ADIS16400_BURST_DIAG_STAT
)
1156 st
->adis
.burst
->extra_len
= sizeof(u16
);
1159 ret
= adis_init(&st
->adis
, indio_dev
, spi
, &adis16400_data
);
1163 ret
= adis_setup_buffer_and_trigger(&st
->adis
, indio_dev
,
1164 adis16400_trigger_handler
);
1168 /* Get the device into a sane initial state */
1169 ret
= adis16400_initial_setup(indio_dev
);
1171 goto error_cleanup_buffer
;
1172 ret
= iio_device_register(indio_dev
);
1174 goto error_cleanup_buffer
;
1176 adis16400_debugfs_init(indio_dev
);
1179 error_cleanup_buffer
:
1180 adis_cleanup_buffer_and_trigger(&st
->adis
, indio_dev
);
1184 static int adis16400_remove(struct spi_device
*spi
)
1186 struct iio_dev
*indio_dev
= spi_get_drvdata(spi
);
1187 struct adis16400_state
*st
= iio_priv(indio_dev
);
1189 iio_device_unregister(indio_dev
);
1190 adis16400_stop_device(indio_dev
);
1192 adis_cleanup_buffer_and_trigger(&st
->adis
, indio_dev
);
1197 static const struct spi_device_id adis16400_id
[] = {
1198 {"adis16300", ADIS16300
},
1199 {"adis16305", ADIS16300
},
1200 {"adis16334", ADIS16334
},
1201 {"adis16350", ADIS16350
},
1202 {"adis16354", ADIS16350
},
1203 {"adis16355", ADIS16350
},
1204 {"adis16360", ADIS16360
},
1205 {"adis16362", ADIS16362
},
1206 {"adis16364", ADIS16364
},
1207 {"adis16365", ADIS16360
},
1208 {"adis16367", ADIS16367
},
1209 {"adis16400", ADIS16400
},
1210 {"adis16405", ADIS16400
},
1211 {"adis16445", ADIS16445
},
1212 {"adis16448", ADIS16448
},
1215 MODULE_DEVICE_TABLE(spi
, adis16400_id
);
1217 static struct spi_driver adis16400_driver
= {
1219 .name
= "adis16400",
1221 .id_table
= adis16400_id
,
1222 .probe
= adis16400_probe
,
1223 .remove
= adis16400_remove
,
1225 module_spi_driver(adis16400_driver
);
1227 MODULE_AUTHOR("Manuel Stahl <manuel.stahl@iis.fraunhofer.de>");
1228 MODULE_DESCRIPTION("Analog Devices ADIS16400/5 IMU SPI driver");
1229 MODULE_LICENSE("GPL v2");