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) 84 return ret; 85 86 ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_LOT1, &lot1); 87 if (ret) 88 return ret; 89 90 ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_LOT2, &lot2); 91 if (ret) 92 return ret; 93 94 ret = adis_read_reg_16(&adis16136->adis, ADIS16136_REG_LOT3, &lot3); 95 if (ret) 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) 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) 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) 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) 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) 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) 281 goto err_unlock; 282 283 ret = adis16136_get_freq(adis16136, &freq); 284 if (ret) 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) 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"); 586