1 /* 2 * Common library for ADIS16XXX devices 3 * 4 * Copyright 2012 Analog Devices Inc. 5 * Author: Lars-Peter Clausen <lars@metafoo.de> 6 * 7 * Licensed under the GPL-2 or later. 8 */ 9 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 #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 int adis_write_reg(struct adis *adis, unsigned int reg, 31 unsigned int value, unsigned int size) 32 { 33 unsigned int page = reg / ADIS_PAGE_SIZE; 34 int ret, i; 35 struct spi_message msg; 36 struct spi_transfer xfers[] = { 37 { 38 .tx_buf = adis->tx, 39 .bits_per_word = 8, 40 .len = 2, 41 .cs_change = 1, 42 .delay_usecs = adis->data->write_delay, 43 }, { 44 .tx_buf = adis->tx + 2, 45 .bits_per_word = 8, 46 .len = 2, 47 .cs_change = 1, 48 .delay_usecs = adis->data->write_delay, 49 }, { 50 .tx_buf = adis->tx + 4, 51 .bits_per_word = 8, 52 .len = 2, 53 .cs_change = 1, 54 .delay_usecs = adis->data->write_delay, 55 }, { 56 .tx_buf = adis->tx + 6, 57 .bits_per_word = 8, 58 .len = 2, 59 .delay_usecs = adis->data->write_delay, 60 }, { 61 .tx_buf = adis->tx + 8, 62 .bits_per_word = 8, 63 .len = 2, 64 .delay_usecs = adis->data->write_delay, 65 }, 66 }; 67 68 mutex_lock(&adis->txrx_lock); 69 70 spi_message_init(&msg); 71 72 if (adis->current_page != page) { 73 adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID); 74 adis->tx[1] = page; 75 spi_message_add_tail(&xfers[0], &msg); 76 } 77 78 switch (size) { 79 case 4: 80 adis->tx[8] = ADIS_WRITE_REG(reg + 3); 81 adis->tx[9] = (value >> 24) & 0xff; 82 adis->tx[6] = ADIS_WRITE_REG(reg + 2); 83 adis->tx[7] = (value >> 16) & 0xff; 84 /* fall through */ 85 case 2: 86 adis->tx[4] = ADIS_WRITE_REG(reg + 1); 87 adis->tx[5] = (value >> 8) & 0xff; 88 /* fall through */ 89 case 1: 90 adis->tx[2] = ADIS_WRITE_REG(reg); 91 adis->tx[3] = value & 0xff; 92 break; 93 default: 94 ret = -EINVAL; 95 goto out_unlock; 96 } 97 98 xfers[size].cs_change = 0; 99 100 for (i = 1; i <= size; i++) 101 spi_message_add_tail(&xfers[i], &msg); 102 103 ret = spi_sync(adis->spi, &msg); 104 if (ret) { 105 dev_err(&adis->spi->dev, "Failed to write register 0x%02X: %d\n", 106 reg, ret); 107 } else { 108 adis->current_page = page; 109 } 110 111 out_unlock: 112 mutex_unlock(&adis->txrx_lock); 113 114 return ret; 115 } 116 EXPORT_SYMBOL_GPL(adis_write_reg); 117 118 /** 119 * adis_read_reg() - read 2 bytes from a 16-bit register 120 * @adis: The adis device 121 * @reg: The address of the lower of the two registers 122 * @val: The value read back from the device 123 */ 124 int adis_read_reg(struct adis *adis, unsigned int reg, 125 unsigned int *val, unsigned int size) 126 { 127 unsigned int page = reg / ADIS_PAGE_SIZE; 128 struct spi_message msg; 129 int ret; 130 struct spi_transfer xfers[] = { 131 { 132 .tx_buf = adis->tx, 133 .bits_per_word = 8, 134 .len = 2, 135 .cs_change = 1, 136 .delay_usecs = adis->data->write_delay, 137 }, { 138 .tx_buf = adis->tx + 2, 139 .bits_per_word = 8, 140 .len = 2, 141 .cs_change = 1, 142 .delay_usecs = adis->data->read_delay, 143 }, { 144 .tx_buf = adis->tx + 4, 145 .rx_buf = adis->rx, 146 .bits_per_word = 8, 147 .len = 2, 148 .cs_change = 1, 149 .delay_usecs = adis->data->read_delay, 150 }, { 151 .rx_buf = adis->rx + 2, 152 .bits_per_word = 8, 153 .len = 2, 154 .delay_usecs = adis->data->read_delay, 155 }, 156 }; 157 158 mutex_lock(&adis->txrx_lock); 159 spi_message_init(&msg); 160 161 if (adis->current_page != page) { 162 adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID); 163 adis->tx[1] = page; 164 spi_message_add_tail(&xfers[0], &msg); 165 } 166 167 switch (size) { 168 case 4: 169 adis->tx[2] = ADIS_READ_REG(reg + 2); 170 adis->tx[3] = 0; 171 spi_message_add_tail(&xfers[1], &msg); 172 /* fall through */ 173 case 2: 174 adis->tx[4] = ADIS_READ_REG(reg); 175 adis->tx[5] = 0; 176 spi_message_add_tail(&xfers[2], &msg); 177 spi_message_add_tail(&xfers[3], &msg); 178 break; 179 default: 180 ret = -EINVAL; 181 goto out_unlock; 182 } 183 184 ret = spi_sync(adis->spi, &msg); 185 if (ret) { 186 dev_err(&adis->spi->dev, "Failed to read register 0x%02X: %d\n", 187 reg, ret); 188 goto out_unlock; 189 } else { 190 adis->current_page = page; 191 } 192 193 switch (size) { 194 case 4: 195 *val = get_unaligned_be32(adis->rx); 196 break; 197 case 2: 198 *val = get_unaligned_be16(adis->rx + 2); 199 break; 200 } 201 202 out_unlock: 203 mutex_unlock(&adis->txrx_lock); 204 205 return ret; 206 } 207 EXPORT_SYMBOL_GPL(adis_read_reg); 208 209 #ifdef CONFIG_DEBUG_FS 210 211 int adis_debugfs_reg_access(struct iio_dev *indio_dev, 212 unsigned int reg, unsigned int writeval, unsigned int *readval) 213 { 214 struct adis *adis = iio_device_get_drvdata(indio_dev); 215 216 if (readval) { 217 uint16_t val16; 218 int ret; 219 220 ret = adis_read_reg_16(adis, reg, &val16); 221 *readval = val16; 222 223 return ret; 224 } else { 225 return adis_write_reg_16(adis, reg, writeval); 226 } 227 } 228 EXPORT_SYMBOL(adis_debugfs_reg_access); 229 230 #endif 231 232 /** 233 * adis_enable_irq() - Enable or disable data ready IRQ 234 * @adis: The adis device 235 * @enable: Whether to enable the IRQ 236 * 237 * Returns 0 on success, negative error code otherwise 238 */ 239 int adis_enable_irq(struct adis *adis, bool enable) 240 { 241 int ret = 0; 242 uint16_t msc; 243 244 if (adis->data->enable_irq) 245 return adis->data->enable_irq(adis, enable); 246 247 ret = adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc); 248 if (ret) 249 goto error_ret; 250 251 msc |= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH; 252 msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2; 253 if (enable) 254 msc |= ADIS_MSC_CTRL_DATA_RDY_EN; 255 else 256 msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN; 257 258 ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc); 259 260 error_ret: 261 return ret; 262 } 263 EXPORT_SYMBOL(adis_enable_irq); 264 265 /** 266 * adis_check_status() - Check the device for error conditions 267 * @adis: The adis device 268 * 269 * Returns 0 on success, a negative error code otherwise 270 */ 271 int adis_check_status(struct adis *adis) 272 { 273 uint16_t status; 274 int ret; 275 int i; 276 277 ret = adis_read_reg_16(adis, adis->data->diag_stat_reg, &status); 278 if (ret < 0) 279 return ret; 280 281 status &= adis->data->status_error_mask; 282 283 if (status == 0) 284 return 0; 285 286 for (i = 0; i < 16; ++i) { 287 if (status & BIT(i)) { 288 dev_err(&adis->spi->dev, "%s.\n", 289 adis->data->status_error_msgs[i]); 290 } 291 } 292 293 return -EIO; 294 } 295 EXPORT_SYMBOL_GPL(adis_check_status); 296 297 /** 298 * adis_reset() - Reset the device 299 * @adis: The adis device 300 * 301 * Returns 0 on success, a negative error code otherwise 302 */ 303 int adis_reset(struct adis *adis) 304 { 305 int ret; 306 307 ret = adis_write_reg_8(adis, adis->data->glob_cmd_reg, 308 ADIS_GLOB_CMD_SW_RESET); 309 if (ret) 310 dev_err(&adis->spi->dev, "Failed to reset device: %d\n", ret); 311 312 return ret; 313 } 314 EXPORT_SYMBOL_GPL(adis_reset); 315 316 static int adis_self_test(struct adis *adis) 317 { 318 int ret; 319 320 ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg, 321 adis->data->self_test_mask); 322 if (ret) { 323 dev_err(&adis->spi->dev, "Failed to initiate self test: %d\n", 324 ret); 325 return ret; 326 } 327 328 msleep(adis->data->startup_delay); 329 330 ret = adis_check_status(adis); 331 332 if (adis->data->self_test_no_autoclear) 333 adis_write_reg_16(adis, adis->data->msc_ctrl_reg, 0x00); 334 335 return ret; 336 } 337 338 /** 339 * adis_inital_startup() - Performs device self-test 340 * @adis: The adis device 341 * 342 * Returns 0 if the device is operational, a negative error code otherwise. 343 * 344 * This function should be called early on in the device initialization sequence 345 * to ensure that the device is in a sane and known state and that it is usable. 346 */ 347 int adis_initial_startup(struct adis *adis) 348 { 349 int ret; 350 351 ret = adis_self_test(adis); 352 if (ret) { 353 dev_err(&adis->spi->dev, "Self-test failed, trying reset.\n"); 354 adis_reset(adis); 355 msleep(adis->data->startup_delay); 356 ret = adis_self_test(adis); 357 if (ret) { 358 dev_err(&adis->spi->dev, "Second self-test failed, giving up.\n"); 359 return ret; 360 } 361 } 362 363 return 0; 364 } 365 EXPORT_SYMBOL_GPL(adis_initial_startup); 366 367 /** 368 * adis_single_conversion() - Performs a single sample conversion 369 * @indio_dev: The IIO device 370 * @chan: The IIO channel 371 * @error_mask: Mask for the error bit 372 * @val: Result of the conversion 373 * 374 * Returns IIO_VAL_INT on success, a negative error code otherwise. 375 * 376 * The function performs a single conversion on a given channel and post 377 * processes the value accordingly to the channel spec. If a error_mask is given 378 * the function will check if the mask is set in the returned raw value. If it 379 * is set the function will perform a self-check. If the device does not report 380 * a error bit in the channels raw value set error_mask to 0. 381 */ 382 int adis_single_conversion(struct iio_dev *indio_dev, 383 const struct iio_chan_spec *chan, unsigned int error_mask, int *val) 384 { 385 struct adis *adis = iio_device_get_drvdata(indio_dev); 386 unsigned int uval; 387 int ret; 388 389 mutex_lock(&indio_dev->mlock); 390 391 ret = adis_read_reg(adis, chan->address, &uval, 392 chan->scan_type.storagebits / 8); 393 if (ret) 394 goto err_unlock; 395 396 if (uval & error_mask) { 397 ret = adis_check_status(adis); 398 if (ret) 399 goto err_unlock; 400 } 401 402 if (chan->scan_type.sign == 's') 403 *val = sign_extend32(uval, chan->scan_type.realbits - 1); 404 else 405 *val = uval & ((1 << chan->scan_type.realbits) - 1); 406 407 ret = IIO_VAL_INT; 408 err_unlock: 409 mutex_unlock(&indio_dev->mlock); 410 return ret; 411 } 412 EXPORT_SYMBOL_GPL(adis_single_conversion); 413 414 /** 415 * adis_init() - Initialize adis device structure 416 * @adis: The adis device 417 * @indio_dev: The iio device 418 * @spi: The spi device 419 * @data: Chip specific data 420 * 421 * Returns 0 on success, a negative error code otherwise. 422 * 423 * This function must be called, before any other adis helper function may be 424 * called. 425 */ 426 int adis_init(struct adis *adis, struct iio_dev *indio_dev, 427 struct spi_device *spi, const struct adis_data *data) 428 { 429 mutex_init(&adis->txrx_lock); 430 adis->spi = spi; 431 adis->data = data; 432 iio_device_set_drvdata(indio_dev, adis); 433 434 if (data->has_paging) { 435 /* Need to set the page before first read/write */ 436 adis->current_page = -1; 437 } else { 438 /* Page will always be 0 */ 439 adis->current_page = 0; 440 } 441 442 return adis_enable_irq(adis, false); 443 } 444 EXPORT_SYMBOL_GPL(adis_init); 445 446 MODULE_LICENSE("GPL"); 447 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 448 MODULE_DESCRIPTION("Common library code for ADIS16XXX devices"); 449