1/* 2 * ADIS16240 Programmable Impact Sensor and Recorder driver 3 * 4 * Copyright 2010 Analog Devices Inc. 5 * 6 * Licensed under the GPL-2 or later. 7 */ 8 9#include <linux/interrupt.h> 10#include <linux/irq.h> 11#include <linux/gpio.h> 12#include <linux/delay.h> 13#include <linux/mutex.h> 14#include <linux/device.h> 15#include <linux/kernel.h> 16#include <linux/spi/spi.h> 17#include <linux/slab.h> 18#include <linux/sysfs.h> 19#include <linux/list.h> 20#include <linux/module.h> 21 22#include "../iio.h" 23#include "../sysfs.h" 24#include "../buffer.h" 25 26#include "adis16240.h" 27 28#define DRIVER_NAME "adis16240" 29 30static int adis16240_check_status(struct iio_dev *indio_dev); 31 32/** 33 * adis16240_spi_write_reg_8() - write single byte to a register 34 * @indio_dev: iio_dev associated with device 35 * @reg_address: the address of the register to be written 36 * @val: the value to write 37 **/ 38static int adis16240_spi_write_reg_8(struct iio_dev *indio_dev, 39 u8 reg_address, 40 u8 val) 41{ 42 int ret; 43 struct adis16240_state *st = iio_priv(indio_dev); 44 45 mutex_lock(&st->buf_lock); 46 st->tx[0] = ADIS16240_WRITE_REG(reg_address); 47 st->tx[1] = val; 48 49 ret = spi_write(st->us, st->tx, 2); 50 mutex_unlock(&st->buf_lock); 51 52 return ret; 53} 54 55/** 56 * adis16240_spi_write_reg_16() - write 2 bytes to a pair of registers 57 * @indio_dev: iio_dev for this device 58 * @reg_address: the address of the lower of the two registers. Second register 59 * is assumed to have address one greater. 60 * @val: value to be written 61 **/ 62static int adis16240_spi_write_reg_16(struct iio_dev *indio_dev, 63 u8 lower_reg_address, 64 u16 value) 65{ 66 int ret; 67 struct spi_message msg; 68 struct adis16240_state *st = iio_priv(indio_dev); 69 struct spi_transfer xfers[] = { 70 { 71 .tx_buf = st->tx, 72 .bits_per_word = 8, 73 .len = 2, 74 .cs_change = 1, 75 .delay_usecs = 35, 76 }, { 77 .tx_buf = st->tx + 2, 78 .bits_per_word = 8, 79 .len = 2, 80 .delay_usecs = 35, 81 }, 82 }; 83 84 mutex_lock(&st->buf_lock); 85 st->tx[0] = ADIS16240_WRITE_REG(lower_reg_address); 86 st->tx[1] = value & 0xFF; 87 st->tx[2] = ADIS16240_WRITE_REG(lower_reg_address + 1); 88 st->tx[3] = (value >> 8) & 0xFF; 89 90 spi_message_init(&msg); 91 spi_message_add_tail(&xfers[0], &msg); 92 spi_message_add_tail(&xfers[1], &msg); 93 ret = spi_sync(st->us, &msg); 94 mutex_unlock(&st->buf_lock); 95 96 return ret; 97} 98 99/** 100 * adis16240_spi_read_reg_16() - read 2 bytes from a 16-bit register 101 * @indio_dev: iio_dev for this device 102 * @reg_address: the address of the lower of the two registers. Second register 103 * is assumed to have address one greater. 104 * @val: somewhere to pass back the value read 105 **/ 106static int adis16240_spi_read_reg_16(struct iio_dev *indio_dev, 107 u8 lower_reg_address, 108 u16 *val) 109{ 110 struct spi_message msg; 111 struct adis16240_state *st = iio_priv(indio_dev); 112 int ret; 113 struct spi_transfer xfers[] = { 114 { 115 .tx_buf = st->tx, 116 .bits_per_word = 8, 117 .len = 2, 118 .cs_change = 1, 119 .delay_usecs = 35, 120 }, { 121 .rx_buf = st->rx, 122 .bits_per_word = 8, 123 .len = 2, 124 .cs_change = 1, 125 .delay_usecs = 35, 126 }, 127 }; 128 129 mutex_lock(&st->buf_lock); 130 st->tx[0] = ADIS16240_READ_REG(lower_reg_address); 131 st->tx[1] = 0; 132 st->tx[2] = 0; 133 st->tx[3] = 0; 134 135 spi_message_init(&msg); 136 spi_message_add_tail(&xfers[0], &msg); 137 spi_message_add_tail(&xfers[1], &msg); 138 ret = spi_sync(st->us, &msg); 139 if (ret) { 140 dev_err(&st->us->dev, 141 "problem when reading 16 bit register 0x%02X", 142 lower_reg_address); 143 goto error_ret; 144 } 145 *val = (st->rx[0] << 8) | st->rx[1]; 146 147error_ret: 148 mutex_unlock(&st->buf_lock); 149 return ret; 150} 151 152static ssize_t adis16240_spi_read_signed(struct device *dev, 153 struct device_attribute *attr, 154 char *buf, 155 unsigned bits) 156{ 157 struct iio_dev *indio_dev = dev_get_drvdata(dev); 158 int ret; 159 s16 val = 0; 160 unsigned shift = 16 - bits; 161 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 162 163 ret = adis16240_spi_read_reg_16(indio_dev, 164 this_attr->address, (u16 *)&val); 165 if (ret) 166 return ret; 167 168 if (val & ADIS16240_ERROR_ACTIVE) 169 adis16240_check_status(indio_dev); 170 171 val = ((s16)(val << shift) >> shift); 172 return sprintf(buf, "%d\n", val); 173} 174 175static ssize_t adis16240_read_12bit_signed(struct device *dev, 176 struct device_attribute *attr, 177 char *buf) 178{ 179 ssize_t ret; 180 struct iio_dev *indio_dev = dev_get_drvdata(dev); 181 182 /* Take the iio_dev status lock */ 183 mutex_lock(&indio_dev->mlock); 184 ret = adis16240_spi_read_signed(dev, attr, buf, 12); 185 mutex_unlock(&indio_dev->mlock); 186 187 return ret; 188} 189 190static int adis16240_reset(struct iio_dev *indio_dev) 191{ 192 int ret; 193 ret = adis16240_spi_write_reg_8(indio_dev, 194 ADIS16240_GLOB_CMD, 195 ADIS16240_GLOB_CMD_SW_RESET); 196 if (ret) 197 dev_err(&indio_dev->dev, "problem resetting device"); 198 199 return ret; 200} 201 202static ssize_t adis16240_write_reset(struct device *dev, 203 struct device_attribute *attr, 204 const char *buf, size_t len) 205{ 206 struct iio_dev *indio_dev = dev_get_drvdata(dev); 207 208 if (len < 1) 209 return -EINVAL; 210 switch (buf[0]) { 211 case '1': 212 case 'y': 213 case 'Y': 214 return adis16240_reset(indio_dev); 215 } 216 return -EINVAL; 217} 218 219int adis16240_set_irq(struct iio_dev *indio_dev, bool enable) 220{ 221 int ret = 0; 222 u16 msc; 223 224 ret = adis16240_spi_read_reg_16(indio_dev, 225 ADIS16240_MSC_CTRL, &msc); 226 if (ret) 227 goto error_ret; 228 229 msc |= ADIS16240_MSC_CTRL_ACTIVE_HIGH; 230 msc &= ~ADIS16240_MSC_CTRL_DATA_RDY_DIO2; 231 if (enable) 232 msc |= ADIS16240_MSC_CTRL_DATA_RDY_EN; 233 else 234 msc &= ~ADIS16240_MSC_CTRL_DATA_RDY_EN; 235 236 ret = adis16240_spi_write_reg_16(indio_dev, 237 ADIS16240_MSC_CTRL, msc); 238 239error_ret: 240 return ret; 241} 242 243static int adis16240_self_test(struct iio_dev *indio_dev) 244{ 245 int ret; 246 ret = adis16240_spi_write_reg_16(indio_dev, 247 ADIS16240_MSC_CTRL, 248 ADIS16240_MSC_CTRL_SELF_TEST_EN); 249 if (ret) { 250 dev_err(&indio_dev->dev, "problem starting self test"); 251 goto err_ret; 252 } 253 254 msleep(ADIS16240_STARTUP_DELAY); 255 256 adis16240_check_status(indio_dev); 257 258err_ret: 259 return ret; 260} 261 262static int adis16240_check_status(struct iio_dev *indio_dev) 263{ 264 u16 status; 265 int ret; 266 struct device *dev = &indio_dev->dev; 267 268 ret = adis16240_spi_read_reg_16(indio_dev, 269 ADIS16240_DIAG_STAT, &status); 270 271 if (ret < 0) { 272 dev_err(dev, "Reading status failed\n"); 273 goto error_ret; 274 } 275 276 ret = status & 0x2F; 277 if (status & ADIS16240_DIAG_STAT_PWRON_FAIL) 278 dev_err(dev, "Power-on, self-test fail\n"); 279 if (status & ADIS16240_DIAG_STAT_SPI_FAIL) 280 dev_err(dev, "SPI failure\n"); 281 if (status & ADIS16240_DIAG_STAT_FLASH_UPT) 282 dev_err(dev, "Flash update failed\n"); 283 if (status & ADIS16240_DIAG_STAT_POWER_HIGH) 284 dev_err(dev, "Power supply above 3.625V\n"); 285 if (status & ADIS16240_DIAG_STAT_POWER_LOW) 286 dev_err(dev, "Power supply below 2.225V\n"); 287 288error_ret: 289 return ret; 290} 291 292static int adis16240_initial_setup(struct iio_dev *indio_dev) 293{ 294 int ret; 295 struct device *dev = &indio_dev->dev; 296 297 /* Disable IRQ */ 298 ret = adis16240_set_irq(indio_dev, false); 299 if (ret) { 300 dev_err(dev, "disable irq failed"); 301 goto err_ret; 302 } 303 304 /* Do self test */ 305 ret = adis16240_self_test(indio_dev); 306 if (ret) { 307 dev_err(dev, "self test failure"); 308 goto err_ret; 309 } 310 311 /* Read status register to check the result */ 312 ret = adis16240_check_status(indio_dev); 313 if (ret) { 314 adis16240_reset(indio_dev); 315 dev_err(dev, "device not playing ball -> reset"); 316 msleep(ADIS16240_STARTUP_DELAY); 317 ret = adis16240_check_status(indio_dev); 318 if (ret) { 319 dev_err(dev, "giving up"); 320 goto err_ret; 321 } 322 } 323 324err_ret: 325 return ret; 326} 327 328static IIO_DEVICE_ATTR(in_accel_xyz_squared_peak_raw, S_IRUGO, 329 adis16240_read_12bit_signed, NULL, 330 ADIS16240_XYZPEAK_OUT); 331 332static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16240_write_reset, 0); 333 334static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("4096"); 335 336enum adis16240_chan { 337 in_supply, 338 in_aux, 339 accel_x, 340 accel_y, 341 accel_z, 342 temp, 343}; 344 345static const u8 adis16240_addresses[6][3] = { 346 [in_supply] = { ADIS16240_SUPPLY_OUT }, 347 [in_aux] = { ADIS16240_AUX_ADC }, 348 [accel_x] = { ADIS16240_XACCL_OUT, ADIS16240_XACCL_OFF, 349 ADIS16240_XPEAK_OUT }, 350 [accel_y] = { ADIS16240_YACCL_OUT, ADIS16240_YACCL_OFF, 351 ADIS16240_YPEAK_OUT }, 352 [accel_z] = { ADIS16240_ZACCL_OUT, ADIS16240_ZACCL_OFF, 353 ADIS16240_ZPEAK_OUT }, 354 [temp] = { ADIS16240_TEMP_OUT }, 355}; 356 357static int adis16240_read_raw(struct iio_dev *indio_dev, 358 struct iio_chan_spec const *chan, 359 int *val, int *val2, 360 long mask) 361{ 362 int ret; 363 int bits; 364 u8 addr; 365 s16 val16; 366 367 switch (mask) { 368 case 0: 369 mutex_lock(&indio_dev->mlock); 370 addr = adis16240_addresses[chan->address][0]; 371 ret = adis16240_spi_read_reg_16(indio_dev, addr, &val16); 372 if (ret) { 373 mutex_unlock(&indio_dev->mlock); 374 return ret; 375 } 376 377 if (val16 & ADIS16240_ERROR_ACTIVE) { 378 ret = adis16240_check_status(indio_dev); 379 if (ret) { 380 mutex_unlock(&indio_dev->mlock); 381 return ret; 382 } 383 } 384 val16 = val16 & ((1 << chan->scan_type.realbits) - 1); 385 if (chan->scan_type.sign == 's') 386 val16 = (s16)(val16 << 387 (16 - chan->scan_type.realbits)) >> 388 (16 - chan->scan_type.realbits); 389 *val = val16; 390 mutex_unlock(&indio_dev->mlock); 391 return IIO_VAL_INT; 392 case IIO_CHAN_INFO_SCALE: 393 switch (chan->type) { 394 case IIO_VOLTAGE: 395 *val = 0; 396 if (chan->channel == 0) 397 *val2 = 4880; 398 else 399 return -EINVAL; 400 return IIO_VAL_INT_PLUS_MICRO; 401 case IIO_TEMP: 402 *val = 0; 403 *val2 = 244000; 404 return IIO_VAL_INT_PLUS_MICRO; 405 case IIO_ACCEL: 406 *val = 0; 407 *val2 = 504062; 408 return IIO_VAL_INT_PLUS_MICRO; 409 default: 410 return -EINVAL; 411 } 412 break; 413 case IIO_CHAN_INFO_PEAK_SCALE: 414 *val = 6; 415 *val2 = 629295; 416 return IIO_VAL_INT_PLUS_MICRO; 417 case IIO_CHAN_INFO_OFFSET: 418 *val = 25; 419 return IIO_VAL_INT; 420 case IIO_CHAN_INFO_CALIBBIAS: 421 bits = 10; 422 mutex_lock(&indio_dev->mlock); 423 addr = adis16240_addresses[chan->address][1]; 424 ret = adis16240_spi_read_reg_16(indio_dev, addr, &val16); 425 if (ret) { 426 mutex_unlock(&indio_dev->mlock); 427 return ret; 428 } 429 val16 &= (1 << bits) - 1; 430 val16 = (s16)(val16 << (16 - bits)) >> (16 - bits); 431 *val = val16; 432 mutex_unlock(&indio_dev->mlock); 433 return IIO_VAL_INT; 434 case IIO_CHAN_INFO_PEAK: 435 bits = 10; 436 mutex_lock(&indio_dev->mlock); 437 addr = adis16240_addresses[chan->address][2]; 438 ret = adis16240_spi_read_reg_16(indio_dev, addr, &val16); 439 if (ret) { 440 mutex_unlock(&indio_dev->mlock); 441 return ret; 442 } 443 val16 &= (1 << bits) - 1; 444 val16 = (s16)(val16 << (16 - bits)) >> (16 - bits); 445 *val = val16; 446 mutex_unlock(&indio_dev->mlock); 447 return IIO_VAL_INT; 448 } 449 return -EINVAL; 450} 451 452static int adis16240_write_raw(struct iio_dev *indio_dev, 453 struct iio_chan_spec const *chan, 454 int val, 455 int val2, 456 long mask) 457{ 458 int bits = 10; 459 s16 val16; 460 u8 addr; 461 switch (mask) { 462 case IIO_CHAN_INFO_CALIBBIAS: 463 val16 = val & ((1 << bits) - 1); 464 addr = adis16240_addresses[chan->address][1]; 465 return adis16240_spi_write_reg_16(indio_dev, addr, val16); 466 } 467 return -EINVAL; 468} 469 470static struct iio_chan_spec adis16240_channels[] = { 471 IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, "supply", 0, 0, 472 IIO_CHAN_INFO_SCALE_SEPARATE_BIT, 473 in_supply, ADIS16240_SCAN_SUPPLY, 474 IIO_ST('u', 10, 16, 0), 0), 475 IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, NULL, 1, 0, 476 0, 477 in_aux, ADIS16240_SCAN_AUX_ADC, 478 IIO_ST('u', 10, 16, 0), 0), 479 IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_X, 480 IIO_CHAN_INFO_SCALE_SHARED_BIT | 481 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, 482 accel_x, ADIS16240_SCAN_ACC_X, 483 IIO_ST('s', 10, 16, 0), 0), 484 IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Y, 485 IIO_CHAN_INFO_SCALE_SHARED_BIT | 486 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, 487 accel_y, ADIS16240_SCAN_ACC_Y, 488 IIO_ST('s', 10, 16, 0), 0), 489 IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Z, 490 IIO_CHAN_INFO_SCALE_SHARED_BIT | 491 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, 492 accel_z, ADIS16240_SCAN_ACC_Z, 493 IIO_ST('s', 10, 16, 0), 0), 494 IIO_CHAN(IIO_TEMP, 0, 1, 0, NULL, 0, 0, 495 IIO_CHAN_INFO_SCALE_SEPARATE_BIT, 496 temp, ADIS16240_SCAN_TEMP, 497 IIO_ST('u', 10, 16, 0), 0), 498 IIO_CHAN_SOFT_TIMESTAMP(6) 499}; 500 501static struct attribute *adis16240_attributes[] = { 502 &iio_dev_attr_in_accel_xyz_squared_peak_raw.dev_attr.attr, 503 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 504 &iio_dev_attr_reset.dev_attr.attr, 505 NULL 506}; 507 508static const struct attribute_group adis16240_attribute_group = { 509 .attrs = adis16240_attributes, 510}; 511 512static const struct iio_info adis16240_info = { 513 .attrs = &adis16240_attribute_group, 514 .read_raw = &adis16240_read_raw, 515 .write_raw = &adis16240_write_raw, 516 .driver_module = THIS_MODULE, 517}; 518 519static int __devinit adis16240_probe(struct spi_device *spi) 520{ 521 int ret; 522 struct adis16240_state *st; 523 struct iio_dev *indio_dev; 524 525 /* setup the industrialio driver allocated elements */ 526 indio_dev = iio_allocate_device(sizeof(*st)); 527 if (indio_dev == NULL) { 528 ret = -ENOMEM; 529 goto error_ret; 530 } 531 st = iio_priv(indio_dev); 532 /* this is only used for removal purposes */ 533 spi_set_drvdata(spi, indio_dev); 534 535 st->us = spi; 536 mutex_init(&st->buf_lock); 537 538 indio_dev->name = spi->dev.driver->name; 539 indio_dev->dev.parent = &spi->dev; 540 indio_dev->info = &adis16240_info; 541 indio_dev->channels = adis16240_channels; 542 indio_dev->num_channels = ARRAY_SIZE(adis16240_channels); 543 indio_dev->modes = INDIO_DIRECT_MODE; 544 545 ret = adis16240_configure_ring(indio_dev); 546 if (ret) 547 goto error_free_dev; 548 549 ret = iio_buffer_register(indio_dev, 550 adis16240_channels, 551 ARRAY_SIZE(adis16240_channels)); 552 if (ret) { 553 printk(KERN_ERR "failed to initialize the ring\n"); 554 goto error_unreg_ring_funcs; 555 } 556 557 if (spi->irq) { 558 ret = adis16240_probe_trigger(indio_dev); 559 if (ret) 560 goto error_uninitialize_ring; 561 } 562 563 /* Get the device into a sane initial state */ 564 ret = adis16240_initial_setup(indio_dev); 565 if (ret) 566 goto error_remove_trigger; 567 ret = iio_device_register(indio_dev); 568 if (ret) 569 goto error_remove_trigger; 570 return 0; 571 572error_remove_trigger: 573 adis16240_remove_trigger(indio_dev); 574error_uninitialize_ring: 575 iio_buffer_unregister(indio_dev); 576error_unreg_ring_funcs: 577 adis16240_unconfigure_ring(indio_dev); 578error_free_dev: 579 iio_free_device(indio_dev); 580error_ret: 581 return ret; 582} 583 584static int adis16240_remove(struct spi_device *spi) 585{ 586 587 struct iio_dev *indio_dev = spi_get_drvdata(spi); 588 589 flush_scheduled_work(); 590 591 iio_device_unregister(indio_dev); 592 adis16240_remove_trigger(indio_dev); 593 iio_buffer_unregister(indio_dev); 594 adis16240_unconfigure_ring(indio_dev); 595 iio_free_device(indio_dev); 596 597 return 0; 598} 599 600static struct spi_driver adis16240_driver = { 601 .driver = { 602 .name = "adis16240", 603 .owner = THIS_MODULE, 604 }, 605 .probe = adis16240_probe, 606 .remove = __devexit_p(adis16240_remove), 607}; 608module_spi_driver(adis16240_driver); 609 610MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>"); 611MODULE_DESCRIPTION("Analog Devices Programmable Impact Sensor and Recorder"); 612MODULE_LICENSE("GPL v2"); 613MODULE_ALIAS("spi:adis16240"); 614