iio/imu/adis16460.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * ADIS16460 IMU driver
0004  *
0005  * Copyright 2019 Analog Devices Inc.
0006  */
0007
0008 #include <linux/module.h>
0009 #include <linux/spi/spi.h>
0010
0011 #include <linux/iio/iio.h>
0012 #include <linux/iio/imu/adis.h>
0013
0014 #include <linux/debugfs.h>
0015
0016 #define ADIS16460_REG_FLASH_CNT     0x00
0017 #define ADIS16460_REG_DIAG_STAT     0x02
0018 #define ADIS16460_REG_X_GYRO_LOW    0x04
0019 #define ADIS16460_REG_X_GYRO_OUT    0x06
0020 #define ADIS16460_REG_Y_GYRO_LOW    0x08
0021 #define ADIS16460_REG_Y_GYRO_OUT    0x0A
0022 #define ADIS16460_REG_Z_GYRO_LOW    0x0C
0023 #define ADIS16460_REG_Z_GYRO_OUT    0x0E
0024 #define ADIS16460_REG_X_ACCL_LOW    0x10
0025 #define ADIS16460_REG_X_ACCL_OUT    0x12
0026 #define ADIS16460_REG_Y_ACCL_LOW    0x14
0027 #define ADIS16460_REG_Y_ACCL_OUT    0x16
0028 #define ADIS16460_REG_Z_ACCL_LOW    0x18
0029 #define ADIS16460_REG_Z_ACCL_OUT    0x1A
0030 #define ADIS16460_REG_SMPL_CNTR     0x1C
0031 #define ADIS16460_REG_TEMP_OUT      0x1E
0032 #define ADIS16460_REG_X_DELT_ANG    0x24
0033 #define ADIS16460_REG_Y_DELT_ANG    0x26
0034 #define ADIS16460_REG_Z_DELT_ANG    0x28
0035 #define ADIS16460_REG_X_DELT_VEL    0x2A
0036 #define ADIS16460_REG_Y_DELT_VEL    0x2C
0037 #define ADIS16460_REG_Z_DELT_VEL    0x2E
0038 #define ADIS16460_REG_MSC_CTRL      0x32
0039 #define ADIS16460_REG_SYNC_SCAL     0x34
0040 #define ADIS16460_REG_DEC_RATE      0x36
0041 #define ADIS16460_REG_FLTR_CTRL     0x38
0042 #define ADIS16460_REG_GLOB_CMD      0x3E
0043 #define ADIS16460_REG_X_GYRO_OFF    0x40
0044 #define ADIS16460_REG_Y_GYRO_OFF    0x42
0045 #define ADIS16460_REG_Z_GYRO_OFF    0x44
0046 #define ADIS16460_REG_X_ACCL_OFF    0x46
0047 #define ADIS16460_REG_Y_ACCL_OFF    0x48
0048 #define ADIS16460_REG_Z_ACCL_OFF    0x4A
0049 #define ADIS16460_REG_LOT_ID1       0x52
0050 #define ADIS16460_REG_LOT_ID2       0x54
0051 #define ADIS16460_REG_PROD_ID       0x56
0052 #define ADIS16460_REG_SERIAL_NUM    0x58
0053 #define ADIS16460_REG_CAL_SGNTR     0x60
0054 #define ADIS16460_REG_CAL_CRC       0x62
0055 #define ADIS16460_REG_CODE_SGNTR    0x64
0056 #define ADIS16460_REG_CODE_CRC      0x66
0057
0058 struct adis16460_chip_info {
0059     unsigned int num_channels;
0060     const struct iio_chan_spec *channels;
0061     unsigned int gyro_max_val;
0062     unsigned int gyro_max_scale;
0063     unsigned int accel_max_val;
0064     unsigned int accel_max_scale;
0065 };
0066
0067 struct adis16460 {
0068     const struct adis16460_chip_info *chip_info;
0069     struct adis adis;
0070 };
0071
0072 #ifdef CONFIG_DEBUG_FS
0073
0074 static int adis16460_show_serial_number(void *arg, u64 *val)
0075 {
0076     struct adis16460 *adis16460 = arg;
0077     u16 serial;
0078     int ret;
0079
0080     ret = adis_read_reg_16(&adis16460->adis, ADIS16460_REG_SERIAL_NUM,
0081         &serial);
0082     if (ret)
0083         return ret;
0084
0085     *val = serial;
0086
0087     return 0;
0088 }
0089 DEFINE_DEBUGFS_ATTRIBUTE(adis16460_serial_number_fops,
0090         adis16460_show_serial_number, NULL, "0x%.4llx\n");
0091
0092 static int adis16460_show_product_id(void *arg, u64 *val)
0093 {
0094     struct adis16460 *adis16460 = arg;
0095     u16 prod_id;
0096     int ret;
0097
0098     ret = adis_read_reg_16(&adis16460->adis, ADIS16460_REG_PROD_ID,
0099         &prod_id);
0100     if (ret)
0101         return ret;
0102
0103     *val = prod_id;
0104
0105     return 0;
0106 }
0107 DEFINE_DEBUGFS_ATTRIBUTE(adis16460_product_id_fops,
0108         adis16460_show_product_id, NULL, "%llu\n");
0109
0110 static int adis16460_show_flash_count(void *arg, u64 *val)
0111 {
0112     struct adis16460 *adis16460 = arg;
0113     u32 flash_count;
0114     int ret;
0115
0116     ret = adis_read_reg_32(&adis16460->adis, ADIS16460_REG_FLASH_CNT,
0117         &flash_count);
0118     if (ret)
0119         return ret;
0120
0121     *val = flash_count;
0122
0123     return 0;
0124 }
0125 DEFINE_DEBUGFS_ATTRIBUTE(adis16460_flash_count_fops,
0126         adis16460_show_flash_count, NULL, "%lld\n");
0127
0128 static int adis16460_debugfs_init(struct iio_dev *indio_dev)
0129 {
0130     struct adis16460 *adis16460 = iio_priv(indio_dev);
0131     struct dentry *d = iio_get_debugfs_dentry(indio_dev);
0132
0133     debugfs_create_file_unsafe("serial_number", 0400,
0134             d, adis16460, &adis16460_serial_number_fops);
0135     debugfs_create_file_unsafe("product_id", 0400,
0136             d, adis16460, &adis16460_product_id_fops);
0137     debugfs_create_file_unsafe("flash_count", 0400,
0138             d, adis16460, &adis16460_flash_count_fops);
0139
0140     return 0;
0141 }
0142
0143 #else
0144
0145 static int adis16460_debugfs_init(struct iio_dev *indio_dev)
0146 {
0147     return 0;
0148 }
0149
0150 #endif
0151
0152 static int adis16460_set_freq(struct iio_dev *indio_dev, int val, int val2)
0153 {
0154     struct adis16460 *st = iio_priv(indio_dev);
0155     int t;
0156
0157     t =  val * 1000 + val2 / 1000;
0158     if (t <= 0)
0159         return -EINVAL;
0160
0161     t = 2048000 / t;
0162     if (t > 2048)
0163         t = 2048;
0164
0165     if (t != 0)
0166         t--;
0167
0168     return adis_write_reg_16(&st->adis, ADIS16460_REG_DEC_RATE, t);
0169 }
0170
0171 static int adis16460_get_freq(struct iio_dev *indio_dev, int *val, int *val2)
0172 {
0173     struct adis16460 *st = iio_priv(indio_dev);
0174     uint16_t t;
0175     int ret;
0176     unsigned int freq;
0177
0178     ret = adis_read_reg_16(&st->adis, ADIS16460_REG_DEC_RATE, &t);
0179     if (ret)
0180         return ret;
0181
0182     freq = 2048000 / (t + 1);
0183     *val = freq / 1000;
0184     *val2 = (freq % 1000) * 1000;
0185
0186     return IIO_VAL_INT_PLUS_MICRO;
0187 }
0188
0189 static int adis16460_read_raw(struct iio_dev *indio_dev,
0190     const struct iio_chan_spec *chan, int *val, int *val2, long info)
0191 {
0192     struct adis16460 *st = iio_priv(indio_dev);
0193
0194     switch (info) {
0195     case IIO_CHAN_INFO_RAW:
0196         return adis_single_conversion(indio_dev, chan, 0, val);
0197     case IIO_CHAN_INFO_SCALE:
0198         switch (chan->type) {
0199         case IIO_ANGL_VEL:
0200             *val = st->chip_info->gyro_max_scale;
0201             *val2 = st->chip_info->gyro_max_val;
0202             return IIO_VAL_FRACTIONAL;
0203         case IIO_ACCEL:
0204             *val = st->chip_info->accel_max_scale;
0205             *val2 = st->chip_info->accel_max_val;
0206             return IIO_VAL_FRACTIONAL;
0207         case IIO_TEMP:
0208             *val = 50; /* 50 milli degrees Celsius/LSB */
0209             return IIO_VAL_INT;
0210         default:
0211             return -EINVAL;
0212         }
0213     case IIO_CHAN_INFO_OFFSET:
0214         *val = 500; /* 25 degrees Celsius = 0x0000 */
0215         return IIO_VAL_INT;
0216     case IIO_CHAN_INFO_SAMP_FREQ:
0217         return adis16460_get_freq(indio_dev, val, val2);
0218     default:
0219         return -EINVAL;
0220     }
0221 }
0222
0223 static int adis16460_write_raw(struct iio_dev *indio_dev,
0224     const struct iio_chan_spec *chan, int val, int val2, long info)
0225 {
0226     switch (info) {
0227     case IIO_CHAN_INFO_SAMP_FREQ:
0228         return adis16460_set_freq(indio_dev, val, val2);
0229     default:
0230         return -EINVAL;
0231     }
0232 }
0233
0234 enum {
0235     ADIS16460_SCAN_GYRO_X,
0236     ADIS16460_SCAN_GYRO_Y,
0237     ADIS16460_SCAN_GYRO_Z,
0238     ADIS16460_SCAN_ACCEL_X,
0239     ADIS16460_SCAN_ACCEL_Y,
0240     ADIS16460_SCAN_ACCEL_Z,
0241     ADIS16460_SCAN_TEMP,
0242 };
0243
0244 #define ADIS16460_MOD_CHANNEL(_type, _mod, _address, _si, _bits) \
0245     { \
0246         .type = (_type), \
0247         .modified = 1, \
0248         .channel2 = (_mod), \
0249         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
0250         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
0251         .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
0252         .address = (_address), \
0253         .scan_index = (_si), \
0254         .scan_type = { \
0255             .sign = 's', \
0256             .realbits = (_bits), \
0257             .storagebits = (_bits), \
0258             .endianness = IIO_BE, \
0259         }, \
0260     }
0261
0262 #define ADIS16460_GYRO_CHANNEL(_mod) \
0263     ADIS16460_MOD_CHANNEL(IIO_ANGL_VEL, IIO_MOD_ ## _mod, \
0264     ADIS16460_REG_ ## _mod ## _GYRO_LOW, ADIS16460_SCAN_GYRO_ ## _mod, \
0265     32)
0266
0267 #define ADIS16460_ACCEL_CHANNEL(_mod) \
0268     ADIS16460_MOD_CHANNEL(IIO_ACCEL, IIO_MOD_ ## _mod, \
0269     ADIS16460_REG_ ## _mod ## _ACCL_LOW, ADIS16460_SCAN_ACCEL_ ## _mod, \
0270     32)
0271
0272 #define ADIS16460_TEMP_CHANNEL() { \
0273         .type = IIO_TEMP, \
0274         .indexed = 1, \
0275         .channel = 0, \
0276         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
0277             BIT(IIO_CHAN_INFO_SCALE) | \
0278             BIT(IIO_CHAN_INFO_OFFSET), \
0279         .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
0280         .address = ADIS16460_REG_TEMP_OUT, \
0281         .scan_index = ADIS16460_SCAN_TEMP, \
0282         .scan_type = { \
0283             .sign = 's', \
0284             .realbits = 16, \
0285             .storagebits = 16, \
0286             .endianness = IIO_BE, \
0287         }, \
0288     }
0289
0290 static const struct iio_chan_spec adis16460_channels[] = {
0291     ADIS16460_GYRO_CHANNEL(X),
0292     ADIS16460_GYRO_CHANNEL(Y),
0293     ADIS16460_GYRO_CHANNEL(Z),
0294     ADIS16460_ACCEL_CHANNEL(X),
0295     ADIS16460_ACCEL_CHANNEL(Y),
0296     ADIS16460_ACCEL_CHANNEL(Z),
0297     ADIS16460_TEMP_CHANNEL(),
0298     IIO_CHAN_SOFT_TIMESTAMP(7)
0299 };
0300
0301 static const struct adis16460_chip_info adis16460_chip_info = {
0302     .channels = adis16460_channels,
0303     .num_channels = ARRAY_SIZE(adis16460_channels),
0304     /*
0305      * storing the value in rad/degree and the scale in degree
0306      * gives us the result in rad and better precession than
0307      * storing the scale directly in rad.
0308      */
0309     .gyro_max_val = IIO_RAD_TO_DEGREE(200 << 16),
0310     .gyro_max_scale = 1,
0311     .accel_max_val = IIO_M_S_2_TO_G(20000 << 16),
0312     .accel_max_scale = 5,
0313 };
0314
0315 static const struct iio_info adis16460_info = {
0316     .read_raw = &adis16460_read_raw,
0317     .write_raw = &adis16460_write_raw,
0318     .update_scan_mode = adis_update_scan_mode,
0319     .debugfs_reg_access = adis_debugfs_reg_access,
0320 };
0321
0322 #define ADIS16460_DIAG_STAT_IN_CLK_OOS  7
0323 #define ADIS16460_DIAG_STAT_FLASH_MEM   6
0324 #define ADIS16460_DIAG_STAT_SELF_TEST   5
0325 #define ADIS16460_DIAG_STAT_OVERRANGE   4
0326 #define ADIS16460_DIAG_STAT_SPI_COMM    3
0327 #define ADIS16460_DIAG_STAT_FLASH_UPT   2
0328
0329 static const char * const adis16460_status_error_msgs[] = {
0330     [ADIS16460_DIAG_STAT_IN_CLK_OOS] = "Input clock out of sync",
0331     [ADIS16460_DIAG_STAT_FLASH_MEM] = "Flash memory failure",
0332     [ADIS16460_DIAG_STAT_SELF_TEST] = "Self test diagnostic failure",
0333     [ADIS16460_DIAG_STAT_OVERRANGE] = "Sensor overrange",
0334     [ADIS16460_DIAG_STAT_SPI_COMM] = "SPI communication failure",
0335     [ADIS16460_DIAG_STAT_FLASH_UPT] = "Flash update failure",
0336 };
0337
0338 static const struct adis_timeout adis16460_timeouts = {
0339     .reset_ms = 225,
0340     .sw_reset_ms = 225,
0341     .self_test_ms = 10,
0342 };
0343
0344 static const struct adis_data adis16460_data = {
0345     .diag_stat_reg = ADIS16460_REG_DIAG_STAT,
0346     .glob_cmd_reg = ADIS16460_REG_GLOB_CMD,
0347     .prod_id_reg = ADIS16460_REG_PROD_ID,
0348     .prod_id = 16460,
0349     .self_test_mask = BIT(2),
0350     .self_test_reg = ADIS16460_REG_GLOB_CMD,
0351     .has_paging = false,
0352     .read_delay = 5,
0353     .write_delay = 5,
0354     .cs_change_delay = 16,
0355     .status_error_msgs = adis16460_status_error_msgs,
0356     .status_error_mask = BIT(ADIS16460_DIAG_STAT_IN_CLK_OOS) |
0357         BIT(ADIS16460_DIAG_STAT_FLASH_MEM) |
0358         BIT(ADIS16460_DIAG_STAT_SELF_TEST) |
0359         BIT(ADIS16460_DIAG_STAT_OVERRANGE) |
0360         BIT(ADIS16460_DIAG_STAT_SPI_COMM) |
0361         BIT(ADIS16460_DIAG_STAT_FLASH_UPT),
0362     .unmasked_drdy = true,
0363     .timeouts = &adis16460_timeouts,
0364 };
0365
0366 static int adis16460_probe(struct spi_device *spi)
0367 {
0368     struct iio_dev *indio_dev;
0369     struct adis16460 *st;
0370     int ret;
0371
0372     indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
0373     if (indio_dev == NULL)
0374         return -ENOMEM;
0375
0376     st = iio_priv(indio_dev);
0377
0378     st->chip_info = &adis16460_chip_info;
0379     indio_dev->name = spi_get_device_id(spi)->name;
0380     indio_dev->channels = st->chip_info->channels;
0381     indio_dev->num_channels = st->chip_info->num_channels;
0382     indio_dev->info = &adis16460_info;
0383     indio_dev->modes = INDIO_DIRECT_MODE;
0384
0385     ret = adis_init(&st->adis, indio_dev, spi, &adis16460_data);
0386     if (ret)
0387         return ret;
0388
0389     ret = devm_adis_setup_buffer_and_trigger(&st->adis, indio_dev, NULL);
0390     if (ret)
0391         return ret;
0392
0393     ret = __adis_initial_startup(&st->adis);
0394     if (ret)
0395         return ret;
0396
0397     ret = devm_iio_device_register(&spi->dev, indio_dev);
0398     if (ret)
0399         return ret;
0400
0401     adis16460_debugfs_init(indio_dev);
0402
0403     return 0;
0404 }
0405
0406 static const struct spi_device_id adis16460_ids[] = {
0407     { "adis16460", 0 },
0408     {}
0409 };
0410 MODULE_DEVICE_TABLE(spi, adis16460_ids);
0411
0412 static const struct of_device_id adis16460_of_match[] = {
0413     { .compatible = "adi,adis16460" },
0414     {}
0415 };
0416 MODULE_DEVICE_TABLE(of, adis16460_of_match);
0417
0418 static struct spi_driver adis16460_driver = {
0419     .driver = {
0420         .name = "adis16460",
0421         .of_match_table = adis16460_of_match,
0422     },
0423     .id_table = adis16460_ids,
0424     .probe = adis16460_probe,
0425 };
0426 module_spi_driver(adis16460_driver);
0427
0428 MODULE_AUTHOR("Dragos Bogdan <dragos.bogdan@analog.com>");
0429 MODULE_DESCRIPTION("Analog Devices ADIS16460 IMU driver");
0430 MODULE_LICENSE("GPL");
0431 MODULE_IMPORT_NS(IIO_ADISLIB);