drivers/iio/gyro/adis16136.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ADIS16133/ADIS16135/ADIS16136 gyroscope driver
   4  *
   5  * Copyright 2012 Analog Devices Inc.
   6  *   Author: Lars-Peter Clausen <lars@metafoo.de>
   7  */
   8
   9 #include <linux/interrupt.h>
  10 #include <linux/delay.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
  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 #include <linux/debugfs.h>
  25
  26 #define ADIS16136_REG_FLASH_CNT         0x00
  27 #define ADIS16136_REG_TEMP_OUT          0x02
  28 #define ADIS16136_REG_GYRO_OUT2         0x04
  29 #define ADIS16136_REG_GYRO_OUT          0x06
  30 #define ADIS16136_REG_GYRO_OFF2         0x08
  31 #define ADIS16136_REG_GYRO_OFF          0x0A
  32 #define ADIS16136_REG_ALM_MAG1          0x10
  33 #define ADIS16136_REG_ALM_MAG2          0x12
  34 #define ADIS16136_REG_ALM_SAMPL1        0x14
  35 #define ADIS16136_REG_ALM_SAMPL2        0x16
  36 #define ADIS16136_REG_ALM_CTRL          0x18
  37 #define ADIS16136_REG_GPIO_CTRL         0x1A
  38 #define ADIS16136_REG_MSC_CTRL          0x1C
  39 #define ADIS16136_REG_SMPL_PRD          0x1E
  40 #define ADIS16136_REG_AVG_CNT           0x20
  41 #define ADIS16136_REG_DEC_RATE          0x22
  42 #define ADIS16136_REG_SLP_CTRL          0x24
  43 #define ADIS16136_REG_DIAG_STAT         0x26
  44 #define ADIS16136_REG_GLOB_CMD          0x28
  45 #define ADIS16136_REG_LOT1              0x32
  46 #define ADIS16136_REG_LOT2              0x34
  47 #define ADIS16136_REG_LOT3              0x36
  48 #define ADIS16136_REG_PROD_ID           0x38
  49 #define ADIS16136_REG_SERIAL_NUM        0x3A
  50
  51 #define ADIS16136_DIAG_STAT_FLASH_UPDATE_FAIL   2
  52 #define ADIS16136_DIAG_STAT_SPI_FAIL            3
  53 #define ADIS16136_DIAG_STAT_SELF_TEST_FAIL      5
  54 #define ADIS16136_DIAG_STAT_FLASH_CHKSUM_FAIL   6
  55
  56 #define ADIS16136_MSC_CTRL_MEMORY_TEST BIT(11)
  57 #define ADIS16136_MSC_CTRL_SELF_TEST BIT(10)
  58
  59 struct adis16136_chip_info {
  60         unsigned int precision;
  61         unsigned int fullscale;
  62 };
  63
  64 struct adis16136 {
  65         const struct adis16136_chip_info *chip_info;
  66
  67         struct adis adis;
  68 };
  69
  70 #ifdef CONFIG_DEBUG_FS
  71
  72 static ssize_t adis16136_show_serial(struct file *file,
  73                 char __user *userbuf, size_t count, loff_t *ppos)
  74 {
  75         struct adis16136 *adis16136 = file->private_data;
  76         uint16_t lot1, lot2, lot3, serial;
  77         char buf[20];
  78         size_t len;
  79         int ret;
  80
  81         ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_SERIAL_NUM,
  82                 &serial);
  83         if (ret < 0)
  84                 return ret;
  85
  86         ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_LOT1, &lot1);
  87         if (ret < 0)
  88                 return ret;
  89
  90         ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_LOT2, &lot2);
  91         if (ret < 0)
  92                 return ret;
  93
  94         ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_LOT3, &lot3);
  95         if (ret < 0)
  96                 return ret;
  97
  98         len = snprintf(buf, sizeof(buf), "%.4x%.4x%.4x-%.4x\n", lot1, lot2,
  99                 lot3, serial);
 100
 101         return simple_read_from_buffer(userbuf, count, ppos, buf, len);
 102 }
 103
 104 static const struct file_operations adis16136_serial_fops = {
 105         .open = simple_open,
 106         .read = adis16136_show_serial,
 107         .llseek = default_llseek,
 108         .owner = THIS_MODULE,
 109 };
 110
 111 static int adis16136_show_product_id(void *arg, u64 *val)
 112 {
 113         struct adis16136 *adis16136 = arg;
 114         u16 prod_id;
 115         int ret;
 116
 117         ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_PROD_ID,
 118                 &prod_id);
 119         if (ret < 0)
 120                 return ret;
 121
 122         *val = prod_id;
 123
 124         return 0;
 125 }
 126 DEFINE_DEBUGFS_ATTRIBUTE(adis16136_product_id_fops,
 127         adis16136_show_product_id, NULL, "%llu\n");
 128
 129 static int adis16136_show_flash_count(void *arg, u64 *val)
 130 {
 131         struct adis16136 *adis16136 = arg;
 132         uint16_t flash_count;
 133         int ret;
 134
 135         ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_FLASH_CNT,
 136                 &flash_count);
 137         if (ret < 0)
 138                 return ret;
 139
 140         *val = flash_count;
 141
 142         return 0;
 143 }
 144 DEFINE_DEBUGFS_ATTRIBUTE(adis16136_flash_count_fops,
 145         adis16136_show_flash_count, NULL, "%lld\n");
 146
 147 static int adis16136_debugfs_init(struct iio_dev *indio_dev)
 148 {
 149         struct adis16136 *adis16136 = iio_priv(indio_dev);
 150
 151         debugfs_create_file_unsafe("serial_number", 0400,
 152                 indio_dev->debugfs_dentry, adis16136,
 153                 &adis16136_serial_fops);
 154         debugfs_create_file_unsafe("product_id", 0400,
 155                 indio_dev->debugfs_dentry,
 156                 adis16136, &adis16136_product_id_fops);
 157         debugfs_create_file_unsafe("flash_count", 0400,
 158                 indio_dev->debugfs_dentry,
 159                 adis16136, &adis16136_flash_count_fops);
 160
 161         return 0;
 162 }
 163
 164 #else
 165
 166 static int adis16136_debugfs_init(struct iio_dev *indio_dev)
 167 {
 168         return 0;
 169 }
 170
 171 #endif
 172
 173 static int adis16136_set_freq(struct adis16136 *adis16136, unsigned int freq)
 174 {
 175         unsigned int t;
 176
 177         t = 32768 / freq;
 178         if (t < 0xf)
 179                 t = 0xf;
 180         else if (t > 0xffff)
 181                 t = 0xffff;
 182         else
 183                 t--;
 184
 185         return adis_write_reg_16(&adis16136->adis, ADIS16136_REG_SMPL_PRD, t);
 186 }
 187
 188 static int adis16136_get_freq(struct adis16136 *adis16136, unsigned int *freq)
 189 {
 190         uint16_t t;
 191         int ret;
 192
 193         ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_SMPL_PRD, &t);
 194         if (ret < 0)
 195                 return ret;
 196
 197         *freq = 32768 / (t + 1);
 198
 199         return 0;
 200 }
 201
 202 static ssize_t adis16136_write_frequency(struct device *dev,
 203         struct device_attribute *attr, const char *buf, size_t len)
 204 {
 205         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 206         struct adis16136 *adis16136 = iio_priv(indio_dev);
 207         unsigned int val;
 208         int ret;
 209
 210         ret = kstrtouint(buf, 10, &val);
 211         if (ret)
 212                 return ret;
 213
 214         if (val == 0)
 215                 return -EINVAL;
 216
 217         ret = adis16136_set_freq(adis16136, val);
 218
 219         return ret ? ret : len;
 220 }
 221
 222 static ssize_t adis16136_read_frequency(struct device *dev,
 223         struct device_attribute *attr, char *buf)
 224 {
 225         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 226         struct adis16136 *adis16136 = iio_priv(indio_dev);
 227         unsigned int freq;
 228         int ret;
 229
 230         ret = adis16136_get_freq(adis16136, &freq);
 231         if (ret < 0)
 232                 return ret;
 233
 234         return sprintf(buf, "%d\n", freq);
 235 }
 236
 237 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 238                                   adis16136_read_frequency,
 239                                   adis16136_write_frequency);
 240
 241 static const unsigned adis16136_3db_divisors[] = {
 242         [0] = 2, /* Special case */
 243         [1] = 6,
 244         [2] = 12,
 245         [3] = 25,
 246         [4] = 50,
 247         [5] = 100,
 248         [6] = 200,
 249         [7] = 200, /* Not a valid setting */
 250 };
 251
 252 static int adis16136_set_filter(struct iio_dev *indio_dev, int val)
 253 {
 254         struct adis16136 *adis16136 = iio_priv(indio_dev);
 255         unsigned int freq;
 256         int i, ret;
 257
 258         ret = adis16136_get_freq(adis16136, &freq);
 259         if (ret < 0)
 260                 return ret;
 261
 262         for (i = ARRAY_SIZE(adis16136_3db_divisors) - 1; i >= 1; i--) {
 263                 if (freq / adis16136_3db_divisors[i] >= val)
 264                         break;
 265         }
 266
 267         return adis_write_reg_16(&adis16136->adis, ADIS16136_REG_AVG_CNT, i);
 268 }
 269
 270 static int adis16136_get_filter(struct iio_dev *indio_dev, int *val)
 271 {
 272         struct adis16136 *adis16136 = iio_priv(indio_dev);
 273         unsigned int freq;
 274         uint16_t val16;
 275         int ret;
 276
 277         mutex_lock(&indio_dev->mlock);
 278
 279         ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_AVG_CNT, &val16);
 280         if (ret < 0)
 281                 goto err_unlock;
 282
 283         ret = adis16136_get_freq(adis16136, &freq);
 284         if (ret < 0)
 285                 goto err_unlock;
 286
 287         *val = freq / adis16136_3db_divisors[val16 & 0x07];
 288
 289 err_unlock:
 290         mutex_unlock(&indio_dev->mlock);
 291
 292         return ret ? ret : IIO_VAL_INT;
 293 }
 294
 295 static int adis16136_read_raw(struct iio_dev *indio_dev,
 296         const struct iio_chan_spec *chan, int *val, int *val2, long info)
 297 {
 298         struct adis16136 *adis16136 = iio_priv(indio_dev);
 299         uint32_t val32;
 300         int ret;
 301
 302         switch (info) {
 303         case IIO_CHAN_INFO_RAW:
 304                 return adis_single_conversion(indio_dev, chan, 0, val);
 305         case IIO_CHAN_INFO_SCALE:
 306                 switch (chan->type) {
 307                 case IIO_ANGL_VEL:
 308                         *val = adis16136->chip_info->precision;
 309                         *val2 = (adis16136->chip_info->fullscale << 16);
 310                         return IIO_VAL_FRACTIONAL;
 311                 case IIO_TEMP:
 312                         *val = 10;
 313                         *val2 = 697000; /* 0.010697 degree Celsius */
 314                         return IIO_VAL_INT_PLUS_MICRO;
 315                 default:
 316                         return -EINVAL;
 317                 }
 318         case IIO_CHAN_INFO_CALIBBIAS:
 319                 ret = adis_read_reg_32(&adis16136->adis,
 320                         ADIS16136_REG_GYRO_OFF2, &val32);
 321                 if (ret < 0)
 322                         return ret;
 323
 324                 *val = sign_extend32(val32, 31);
 325
 326                 return IIO_VAL_INT;
 327         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 328                 return adis16136_get_filter(indio_dev, val);
 329         default:
 330                 return -EINVAL;
 331         }
 332 }
 333
 334 static int adis16136_write_raw(struct iio_dev *indio_dev,
 335         const struct iio_chan_spec *chan, int val, int val2, long info)
 336 {
 337         struct adis16136 *adis16136 = iio_priv(indio_dev);
 338
 339         switch (info) {
 340         case IIO_CHAN_INFO_CALIBBIAS:
 341                 return adis_write_reg_32(&adis16136->adis,
 342                         ADIS16136_REG_GYRO_OFF2, val);
 343         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 344                 return adis16136_set_filter(indio_dev, val);
 345         default:
 346                 break;
 347         }
 348
 349         return -EINVAL;
 350 }
 351
 352 enum {
 353         ADIS16136_SCAN_GYRO,
 354         ADIS16136_SCAN_TEMP,
 355 };
 356
 357 static const struct iio_chan_spec adis16136_channels[] = {
 358         {
 359                 .type = IIO_ANGL_VEL,
 360                 .modified = 1,
 361                 .channel2 = IIO_MOD_X,
 362                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 363                         BIT(IIO_CHAN_INFO_CALIBBIAS) |
 364                         BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),
 365                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
 366
 367                 .address = ADIS16136_REG_GYRO_OUT2,
 368                 .scan_index = ADIS16136_SCAN_GYRO,
 369                 .scan_type = {
 370                         .sign = 's',
 371                         .realbits = 32,
 372                         .storagebits = 32,
 373                         .endianness = IIO_BE,
 374                 },
 375         }, {
 376                 .type = IIO_TEMP,
 377                 .indexed = 1,
 378                 .channel = 0,
 379                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 380                         BIT(IIO_CHAN_INFO_SCALE),
 381                 .address = ADIS16136_REG_TEMP_OUT,
 382                 .scan_index = ADIS16136_SCAN_TEMP,
 383                 .scan_type = {
 384                         .sign = 's',
 385                         .realbits = 16,
 386                         .storagebits = 16,
 387                         .endianness = IIO_BE,
 388                 },
 389         },
 390         IIO_CHAN_SOFT_TIMESTAMP(2),
 391 };
 392
 393 static struct attribute *adis16136_attributes[] = {
 394         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 395         NULL
 396 };
 397
 398 static const struct attribute_group adis16136_attribute_group = {
 399         .attrs = adis16136_attributes,
 400 };
 401
 402 static const struct iio_info adis16136_info = {
 403         .attrs = &adis16136_attribute_group,
 404         .read_raw = &adis16136_read_raw,
 405         .write_raw = &adis16136_write_raw,
 406         .update_scan_mode = adis_update_scan_mode,
 407         .debugfs_reg_access = adis_debugfs_reg_access,
 408 };
 409
 410 static int adis16136_stop_device(struct iio_dev *indio_dev)
 411 {
 412         struct adis16136 *adis16136 = iio_priv(indio_dev);
 413         int ret;
 414
 415         ret = adis_write_reg_16(&adis16136->adis, ADIS16136_REG_SLP_CTRL, 0xff);
 416         if (ret)
 417                 dev_err(&indio_dev->dev,
 418                         "Could not power down device: %d\n", ret);
 419
 420         return ret;
 421 }
 422
 423 static int adis16136_initial_setup(struct iio_dev *indio_dev)
 424 {
 425         struct adis16136 *adis16136 = iio_priv(indio_dev);
 426         unsigned int device_id;
 427         uint16_t prod_id;
 428         int ret;
 429
 430         ret = adis_initial_startup(&adis16136->adis);
 431         if (ret)
 432                 return ret;
 433
 434         ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_PROD_ID,
 435                 &prod_id);
 436         if (ret)
 437                 return ret;
 438
 439         ret = sscanf(indio_dev->name, "adis%u\n", &device_id);
 440         if (ret != 1)
 441                 return -EINVAL;
 442
 443         if (prod_id != device_id)
 444                 dev_warn(&indio_dev->dev, "Device ID(%u) and product ID(%u) do not match.",
 445                                 device_id, prod_id);
 446
 447         return 0;
 448 }
 449
 450 static const char * const adis16136_status_error_msgs[] = {
 451         [ADIS16136_DIAG_STAT_FLASH_UPDATE_FAIL] = "Flash update failed",
 452         [ADIS16136_DIAG_STAT_SPI_FAIL] = "SPI failure",
 453         [ADIS16136_DIAG_STAT_SELF_TEST_FAIL] = "Self test error",
 454         [ADIS16136_DIAG_STAT_FLASH_CHKSUM_FAIL] = "Flash checksum error",
 455 };
 456
 457 static const struct adis_data adis16136_data = {
 458         .diag_stat_reg = ADIS16136_REG_DIAG_STAT,
 459         .glob_cmd_reg = ADIS16136_REG_GLOB_CMD,
 460         .msc_ctrl_reg = ADIS16136_REG_MSC_CTRL,
 461
 462         .self_test_mask = ADIS16136_MSC_CTRL_SELF_TEST,
 463         .startup_delay = 80,
 464
 465         .read_delay = 10,
 466         .write_delay = 10,
 467
 468         .status_error_msgs = adis16136_status_error_msgs,
 469         .status_error_mask = BIT(ADIS16136_DIAG_STAT_FLASH_UPDATE_FAIL) |
 470                 BIT(ADIS16136_DIAG_STAT_SPI_FAIL) |
 471                 BIT(ADIS16136_DIAG_STAT_SELF_TEST_FAIL) |
 472                 BIT(ADIS16136_DIAG_STAT_FLASH_CHKSUM_FAIL),
 473 };
 474
 475 enum adis16136_id {
 476         ID_ADIS16133,
 477         ID_ADIS16135,
 478         ID_ADIS16136,
 479         ID_ADIS16137,
 480 };
 481
 482 static const struct adis16136_chip_info adis16136_chip_info[] = {
 483         [ID_ADIS16133] = {
 484                 .precision = IIO_DEGREE_TO_RAD(1200),
 485                 .fullscale = 24000,
 486         },
 487         [ID_ADIS16135] = {
 488                 .precision = IIO_DEGREE_TO_RAD(300),
 489                 .fullscale = 24000,
 490         },
 491         [ID_ADIS16136] = {
 492                 .precision = IIO_DEGREE_TO_RAD(450),
 493                 .fullscale = 24623,
 494         },
 495         [ID_ADIS16137] = {
 496                 .precision = IIO_DEGREE_TO_RAD(1000),
 497                 .fullscale = 24609,
 498         },
 499 };
 500
 501 static int adis16136_probe(struct spi_device *spi)
 502 {
 503         const struct spi_device_id *id = spi_get_device_id(spi);
 504         struct adis16136 *adis16136;
 505         struct iio_dev *indio_dev;
 506         int ret;
 507
 508         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adis16136));
 509         if (indio_dev == NULL)
 510                 return -ENOMEM;
 511
 512         spi_set_drvdata(spi, indio_dev);
 513
 514         adis16136 = iio_priv(indio_dev);
 515
 516         adis16136->chip_info = &adis16136_chip_info[id->driver_data];
 517         indio_dev->dev.parent = &spi->dev;
 518         indio_dev->name = spi_get_device_id(spi)->name;
 519         indio_dev->channels = adis16136_channels;
 520         indio_dev->num_channels = ARRAY_SIZE(adis16136_channels);
 521         indio_dev->info = &adis16136_info;
 522         indio_dev->modes = INDIO_DIRECT_MODE;
 523
 524         ret = adis_init(&adis16136->adis, indio_dev, spi, &adis16136_data);
 525         if (ret)
 526                 return ret;
 527
 528         ret = adis_setup_buffer_and_trigger(&adis16136->adis, indio_dev, NULL);
 529         if (ret)
 530                 return ret;
 531
 532         ret = adis16136_initial_setup(indio_dev);
 533         if (ret)
 534                 goto error_cleanup_buffer;
 535
 536         ret = iio_device_register(indio_dev);
 537         if (ret)
 538                 goto error_stop_device;
 539
 540         adis16136_debugfs_init(indio_dev);
 541
 542         return 0;
 543
 544 error_stop_device:
 545         adis16136_stop_device(indio_dev);
 546 error_cleanup_buffer:
 547         adis_cleanup_buffer_and_trigger(&adis16136->adis, indio_dev);
 548         return ret;
 549 }
 550
 551 static int adis16136_remove(struct spi_device *spi)
 552 {
 553         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 554         struct adis16136 *adis16136 = iio_priv(indio_dev);
 555
 556         iio_device_unregister(indio_dev);
 557         adis16136_stop_device(indio_dev);
 558
 559         adis_cleanup_buffer_and_trigger(&adis16136->adis, indio_dev);
 560
 561         return 0;
 562 }
 563
 564 static const struct spi_device_id adis16136_ids[] = {
 565         { "adis16133", ID_ADIS16133 },
 566         { "adis16135", ID_ADIS16135 },
 567         { "adis16136", ID_ADIS16136 },
 568         { "adis16137", ID_ADIS16137 },
 569         { }
 570 };
 571 MODULE_DEVICE_TABLE(spi, adis16136_ids);
 572
 573 static struct spi_driver adis16136_driver = {
 574         .driver = {
 575                 .name = "adis16136",
 576         },
 577         .id_table = adis16136_ids,
 578         .probe = adis16136_probe,
 579         .remove = adis16136_remove,
 580 };
 581 module_spi_driver(adis16136_driver);
 582
 583 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
 584 MODULE_DESCRIPTION("Analog Devices ADIS16133/ADIS16135/ADIS16136 gyroscope driver");
 585 MODULE_LICENSE("GPL v2");