1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Common library for ADIS16XXX devices 4 * 5 * Copyright 2012 Analog Devices Inc. 6 * Author: Lars-Peter Clausen <lars@metafoo.de> 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 * __adis_write_reg() - write N bytes to register (unlocked version) 32 * @adis: The adis device 33 * @reg: The address of the lower of the two registers 34 * @value: The value to write to device (up to 4 bytes) 35 * @size: The size of the @value (in bytes) 36 */ 37int __adis_write_reg(struct adis *adis, unsigned int reg, unsigned int value, 38 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_NS_GPL(__adis_write_reg, IIO_ADISLIB); 129 130/** 131 * __adis_read_reg() - read N bytes from register (unlocked version) 132 * @adis: The adis device 133 * @reg: The address of the lower of the two registers 134 * @val: The value read back from the device 135 * @size: The size of the @val buffer 136 */ 137int __adis_read_reg(struct adis *adis, unsigned int reg, unsigned int *val, 138 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 } 211 212 adis->current_page = page; 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_NS_GPL(__adis_read_reg, IIO_ADISLIB); 226/** 227 * __adis_update_bits_base() - ADIS Update bits function - Unlocked version 228 * @adis: The adis device 229 * @reg: The address of the lower of the two registers 230 * @mask: Bitmask to change 231 * @val: Value to be written 232 * @size: Size of the register to update 233 * 234 * Updates the desired bits of @reg in accordance with @mask and @val. 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_NS_GPL(__adis_update_bits_base, IIO_ADISLIB); 251 252#ifdef CONFIG_DEBUG_FS 253 254int adis_debugfs_reg_access(struct iio_dev *indio_dev, unsigned int reg, 255 unsigned int writeval, unsigned int *readval) 256{ 257 struct adis *adis = iio_device_get_drvdata(indio_dev); 258 259 if (readval) { 260 u16 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 } 269 270 return adis_write_reg_16(adis, reg, writeval); 271} 272EXPORT_SYMBOL_NS(adis_debugfs_reg_access, IIO_ADISLIB); 273 274#endif 275 276/** 277 * __adis_enable_irq() - Enable or disable data ready IRQ (unlocked) 278 * @adis: The adis device 279 * @enable: Whether to enable the IRQ 280 * 281 * Returns 0 on success, negative error code otherwise 282 */ 283int __adis_enable_irq(struct adis *adis, bool enable) 284{ 285 int ret; 286 u16 msc; 287 288 if (adis->data->enable_irq) 289 return adis->data->enable_irq(adis, enable); 290 291 if (adis->data->unmasked_drdy) { 292 if (enable) 293 enable_irq(adis->spi->irq); 294 else 295 disable_irq(adis->spi->irq); 296 297 return 0; 298 } 299 300 ret = __adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc); 301 if (ret) 302 return ret; 303 304 msc |= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH; 305 msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2; 306 if (enable) 307 msc |= ADIS_MSC_CTRL_DATA_RDY_EN; 308 else 309 msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN; 310 311 return __adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc); 312} 313EXPORT_SYMBOL_NS(__adis_enable_irq, IIO_ADISLIB); 314 315/** 316 * __adis_check_status() - Check the device for error conditions (unlocked) 317 * @adis: The adis device 318 * 319 * Returns 0 on success, a negative error code otherwise 320 */ 321int __adis_check_status(struct adis *adis) 322{ 323 u16 status; 324 int ret; 325 int i; 326 327 ret = __adis_read_reg_16(adis, adis->data->diag_stat_reg, &status); 328 if (ret) 329 return ret; 330 331 status &= adis->data->status_error_mask; 332 333 if (status == 0) 334 return 0; 335 336 for (i = 0; i < 16; ++i) { 337 if (status & BIT(i)) { 338 dev_err(&adis->spi->dev, "%s.\n", 339 adis->data->status_error_msgs[i]); 340 } 341 } 342 343 return -EIO; 344} 345EXPORT_SYMBOL_NS_GPL(__adis_check_status, IIO_ADISLIB); 346 347/** 348 * __adis_reset() - Reset the device (unlocked version) 349 * @adis: The adis device 350 * 351 * Returns 0 on success, a negative error code otherwise 352 */ 353int __adis_reset(struct adis *adis) 354{ 355 int ret; 356 const struct adis_timeout *timeouts = adis->data->timeouts; 357 358 ret = __adis_write_reg_8(adis, adis->data->glob_cmd_reg, 359 ADIS_GLOB_CMD_SW_RESET); 360 if (ret) { 361 dev_err(&adis->spi->dev, "Failed to reset device: %d\n", ret); 362 return ret; 363 } 364 365 msleep(timeouts->sw_reset_ms); 366 367 return 0; 368} 369EXPORT_SYMBOL_NS_GPL(__adis_reset, IIO_ADIS_LIB); 370 371static int adis_self_test(struct adis *adis) 372{ 373 int ret; 374 const struct adis_timeout *timeouts = adis->data->timeouts; 375 376 ret = __adis_write_reg_16(adis, adis->data->self_test_reg, 377 adis->data->self_test_mask); 378 if (ret) { 379 dev_err(&adis->spi->dev, "Failed to initiate self test: %d\n", 380 ret); 381 return ret; 382 } 383 384 msleep(timeouts->self_test_ms); 385 386 ret = __adis_check_status(adis); 387 388 if (adis->data->self_test_no_autoclear) 389 __adis_write_reg_16(adis, adis->data->self_test_reg, 0x00); 390 391 return ret; 392} 393 394/** 395 * __adis_initial_startup() - Device initial setup 396 * @adis: The adis device 397 * 398 * The function performs a HW reset via a reset pin that should be specified 399 * via GPIOLIB. If no pin is configured a SW reset will be performed. 400 * The RST pin for the ADIS devices should be configured as ACTIVE_LOW. 401 * 402 * After the self-test operation is performed, the function will also check 403 * that the product ID is as expected. This assumes that drivers providing 404 * 'prod_id_reg' will also provide the 'prod_id'. 405 * 406 * Returns 0 if the device is operational, a negative error code otherwise. 407 * 408 * This function should be called early on in the device initialization sequence 409 * to ensure that the device is in a sane and known state and that it is usable. 410 */ 411int __adis_initial_startup(struct adis *adis) 412{ 413 const struct adis_timeout *timeouts = adis->data->timeouts; 414 struct gpio_desc *gpio; 415 u16 prod_id; 416 int ret; 417 418 /* check if the device has rst pin low */ 419 gpio = devm_gpiod_get_optional(&adis->spi->dev, "reset", GPIOD_OUT_HIGH); 420 if (IS_ERR(gpio)) 421 return PTR_ERR(gpio); 422 423 if (gpio) { 424 usleep_range(10, 12); 425 /* bring device out of reset */ 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 /* 439 * don't bother calling this if we can't unmask the IRQ as in this case 440 * the IRQ is most likely not yet requested and we will request it 441 * with 'IRQF_NO_AUTOEN' anyways. 442 */ 443 if (!adis->data->unmasked_drdy) 444 __adis_enable_irq(adis, false); 445 446 if (!adis->data->prod_id_reg) 447 return 0; 448 449 ret = adis_read_reg_16(adis, adis->data->prod_id_reg, &prod_id); 450 if (ret) 451 return ret; 452 453 if (prod_id != adis->data->prod_id) 454 dev_warn(&adis->spi->dev, 455 "Device ID(%u) and product ID(%u) do not match.\n", 456 adis->data->prod_id, prod_id); 457 458 return 0; 459} 460EXPORT_SYMBOL_NS_GPL(__adis_initial_startup, IIO_ADISLIB); 461 462/** 463 * adis_single_conversion() - Performs a single sample conversion 464 * @indio_dev: The IIO device 465 * @chan: The IIO channel 466 * @error_mask: Mask for the error bit 467 * @val: Result of the conversion 468 * 469 * Returns IIO_VAL_INT on success, a negative error code otherwise. 470 * 471 * The function performs a single conversion on a given channel and post 472 * processes the value accordingly to the channel spec. If a error_mask is given 473 * the function will check if the mask is set in the returned raw value. If it 474 * is set the function will perform a self-check. If the device does not report 475 * a error bit in the channels raw value set error_mask to 0. 476 */ 477int adis_single_conversion(struct iio_dev *indio_dev, 478 const struct iio_chan_spec *chan, 479 unsigned int error_mask, int *val) 480{ 481 struct adis *adis = iio_device_get_drvdata(indio_dev); 482 unsigned int uval; 483 int ret; 484 485 mutex_lock(&adis->state_lock); 486 487 ret = __adis_read_reg(adis, chan->address, &uval, 488 chan->scan_type.storagebits / 8); 489 if (ret) 490 goto err_unlock; 491 492 if (uval & error_mask) { 493 ret = __adis_check_status(adis); 494 if (ret) 495 goto err_unlock; 496 } 497 498 if (chan->scan_type.sign == 's') 499 *val = sign_extend32(uval, chan->scan_type.realbits - 1); 500 else 501 *val = uval & ((1 << chan->scan_type.realbits) - 1); 502 503 ret = IIO_VAL_INT; 504err_unlock: 505 mutex_unlock(&adis->state_lock); 506 return ret; 507} 508EXPORT_SYMBOL_NS_GPL(adis_single_conversion, IIO_ADISLIB); 509 510/** 511 * adis_init() - Initialize adis device structure 512 * @adis: The adis device 513 * @indio_dev: The iio device 514 * @spi: The spi device 515 * @data: Chip specific data 516 * 517 * Returns 0 on success, a negative error code otherwise. 518 * 519 * This function must be called, before any other adis helper function may be 520 * called. 521 */ 522int adis_init(struct adis *adis, struct iio_dev *indio_dev, 523 struct spi_device *spi, const struct adis_data *data) 524{ 525 if (!data || !data->timeouts) { 526 dev_err(&spi->dev, "No config data or timeouts not defined!\n"); 527 return -EINVAL; 528 } 529 530 mutex_init(&adis->state_lock); 531 adis->spi = spi; 532 adis->data = data; 533 iio_device_set_drvdata(indio_dev, adis); 534 535 if (data->has_paging) { 536 /* Need to set the page before first read/write */ 537 adis->current_page = -1; 538 } else { 539 /* Page will always be 0 */ 540 adis->current_page = 0; 541 } 542 543 return 0; 544} 545EXPORT_SYMBOL_NS_GPL(adis_init, IIO_ADISLIB); 546 547MODULE_LICENSE("GPL"); 548MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 549MODULE_DESCRIPTION("Common library code for ADIS16XXX devices"); 550