1/* 2 * ADIS16203 Programmable Digital Vibration Sensor driver 3 * 4 * Copyright 2010 Analog Devices Inc. 5 * 6 * Licensed under the GPL-2 or later. 7 */ 8 9#include <linux/delay.h> 10#include <linux/mutex.h> 11#include <linux/device.h> 12#include <linux/kernel.h> 13#include <linux/spi/spi.h> 14#include <linux/slab.h> 15#include <linux/sysfs.h> 16#include <linux/module.h> 17 18#include "../iio.h" 19#include "../sysfs.h" 20#include "../buffer.h" 21 22#include "adis16203.h" 23 24#define DRIVER_NAME "adis16203" 25 26/** 27 * adis16203_spi_write_reg_8() - write single byte to a register 28 * @indio_dev: iio device associated with child of actual device 29 * @reg_address: the address of the register to be written 30 * @val: the value to write 31 **/ 32static int adis16203_spi_write_reg_8(struct iio_dev *indio_dev, 33 u8 reg_address, 34 u8 val) 35{ 36 int ret; 37 struct adis16203_state *st = iio_priv(indio_dev); 38 39 mutex_lock(&st->buf_lock); 40 st->tx[0] = ADIS16203_WRITE_REG(reg_address); 41 st->tx[1] = val; 42 43 ret = spi_write(st->us, st->tx, 2); 44 mutex_unlock(&st->buf_lock); 45 46 return ret; 47} 48 49/** 50 * adis16203_spi_write_reg_16() - write 2 bytes to a pair of registers 51 * @indio_dev: iio device associated with child of actual device 52 * @reg_address: the address of the lower of the two registers. Second register 53 * is assumed to have address one greater. 54 * @val: value to be written 55 **/ 56static int adis16203_spi_write_reg_16(struct iio_dev *indio_dev, 57 u8 lower_reg_address, 58 u16 value) 59{ 60 int ret; 61 struct spi_message msg; 62 struct adis16203_state *st = iio_priv(indio_dev); 63 struct spi_transfer xfers[] = { 64 { 65 .tx_buf = st->tx, 66 .bits_per_word = 8, 67 .len = 2, 68 .cs_change = 1, 69 }, { 70 .tx_buf = st->tx + 2, 71 .bits_per_word = 8, 72 .len = 2, 73 }, 74 }; 75 76 mutex_lock(&st->buf_lock); 77 st->tx[0] = ADIS16203_WRITE_REG(lower_reg_address); 78 st->tx[1] = value & 0xFF; 79 st->tx[2] = ADIS16203_WRITE_REG(lower_reg_address + 1); 80 st->tx[3] = (value >> 8) & 0xFF; 81 82 spi_message_init(&msg); 83 spi_message_add_tail(&xfers[0], &msg); 84 spi_message_add_tail(&xfers[1], &msg); 85 ret = spi_sync(st->us, &msg); 86 mutex_unlock(&st->buf_lock); 87 88 return ret; 89} 90 91/** 92 * adis16203_spi_read_reg_16() - read 2 bytes from a 16-bit register 93 * @indio_dev: iio device associated with child of actual device 94 * @reg_address: the address of the lower of the two registers. Second register 95 * is assumed to have address one greater. 96 * @val: somewhere to pass back the value read 97 **/ 98static int adis16203_spi_read_reg_16(struct iio_dev *indio_dev, 99 u8 lower_reg_address, 100 u16 *val) 101{ 102 struct spi_message msg; 103 struct adis16203_state *st = iio_priv(indio_dev); 104 int ret; 105 struct spi_transfer xfers[] = { 106 { 107 .tx_buf = st->tx, 108 .bits_per_word = 8, 109 .len = 2, 110 .cs_change = 1, 111 .delay_usecs = 20, 112 }, { 113 .rx_buf = st->rx, 114 .bits_per_word = 8, 115 .len = 2, 116 .delay_usecs = 20, 117 }, 118 }; 119 120 mutex_lock(&st->buf_lock); 121 st->tx[0] = ADIS16203_READ_REG(lower_reg_address); 122 st->tx[1] = 0; 123 124 spi_message_init(&msg); 125 spi_message_add_tail(&xfers[0], &msg); 126 spi_message_add_tail(&xfers[1], &msg); 127 ret = spi_sync(st->us, &msg); 128 if (ret) { 129 dev_err(&st->us->dev, "problem when reading 16 bit register 0x%02X", 130 lower_reg_address); 131 goto error_ret; 132 } 133 *val = (st->rx[0] << 8) | st->rx[1]; 134 135error_ret: 136 mutex_unlock(&st->buf_lock); 137 return ret; 138} 139 140static int adis16203_check_status(struct iio_dev *indio_dev) 141{ 142 u16 status; 143 int ret; 144 145 ret = adis16203_spi_read_reg_16(indio_dev, 146 ADIS16203_DIAG_STAT, 147 &status); 148 if (ret < 0) { 149 dev_err(&indio_dev->dev, "Reading status failed\n"); 150 goto error_ret; 151 } 152 ret = status & 0x1F; 153 154 if (status & ADIS16203_DIAG_STAT_SELFTEST_FAIL) 155 dev_err(&indio_dev->dev, "Self test failure\n"); 156 if (status & ADIS16203_DIAG_STAT_SPI_FAIL) 157 dev_err(&indio_dev->dev, "SPI failure\n"); 158 if (status & ADIS16203_DIAG_STAT_FLASH_UPT) 159 dev_err(&indio_dev->dev, "Flash update failed\n"); 160 if (status & ADIS16203_DIAG_STAT_POWER_HIGH) 161 dev_err(&indio_dev->dev, "Power supply above 3.625V\n"); 162 if (status & ADIS16203_DIAG_STAT_POWER_LOW) 163 dev_err(&indio_dev->dev, "Power supply below 3.15V\n"); 164 165error_ret: 166 return ret; 167} 168 169static int adis16203_reset(struct iio_dev *indio_dev) 170{ 171 int ret; 172 ret = adis16203_spi_write_reg_8(indio_dev, 173 ADIS16203_GLOB_CMD, 174 ADIS16203_GLOB_CMD_SW_RESET); 175 if (ret) 176 dev_err(&indio_dev->dev, "problem resetting device"); 177 178 return ret; 179} 180 181static ssize_t adis16203_write_reset(struct device *dev, 182 struct device_attribute *attr, 183 const char *buf, size_t len) 184{ 185 struct iio_dev *indio_dev = dev_get_drvdata(dev); 186 if (len < 1) 187 return -EINVAL; 188 switch (buf[0]) { 189 case '1': 190 case 'y': 191 case 'Y': 192 return adis16203_reset(indio_dev); 193 } 194 return -EINVAL; 195} 196 197int adis16203_set_irq(struct iio_dev *indio_dev, bool enable) 198{ 199 int ret = 0; 200 u16 msc; 201 202 ret = adis16203_spi_read_reg_16(indio_dev, ADIS16203_MSC_CTRL, &msc); 203 if (ret) 204 goto error_ret; 205 206 msc |= ADIS16203_MSC_CTRL_ACTIVE_HIGH; 207 msc &= ~ADIS16203_MSC_CTRL_DATA_RDY_DIO1; 208 if (enable) 209 msc |= ADIS16203_MSC_CTRL_DATA_RDY_EN; 210 else 211 msc &= ~ADIS16203_MSC_CTRL_DATA_RDY_EN; 212 213 ret = adis16203_spi_write_reg_16(indio_dev, ADIS16203_MSC_CTRL, msc); 214 215error_ret: 216 return ret; 217} 218 219static int adis16203_self_test(struct iio_dev *indio_dev) 220{ 221 int ret; 222 ret = adis16203_spi_write_reg_16(indio_dev, 223 ADIS16203_MSC_CTRL, 224 ADIS16203_MSC_CTRL_SELF_TEST_EN); 225 if (ret) { 226 dev_err(&indio_dev->dev, "problem starting self test"); 227 goto err_ret; 228 } 229 230 adis16203_check_status(indio_dev); 231 232err_ret: 233 return ret; 234} 235 236static int adis16203_initial_setup(struct iio_dev *indio_dev) 237{ 238 int ret; 239 240 /* Disable IRQ */ 241 ret = adis16203_set_irq(indio_dev, false); 242 if (ret) { 243 dev_err(&indio_dev->dev, "disable irq failed"); 244 goto err_ret; 245 } 246 247 /* Do self test */ 248 ret = adis16203_self_test(indio_dev); 249 if (ret) { 250 dev_err(&indio_dev->dev, "self test failure"); 251 goto err_ret; 252 } 253 254 /* Read status register to check the result */ 255 ret = adis16203_check_status(indio_dev); 256 if (ret) { 257 adis16203_reset(indio_dev); 258 dev_err(&indio_dev->dev, "device not playing ball -> reset"); 259 msleep(ADIS16203_STARTUP_DELAY); 260 ret = adis16203_check_status(indio_dev); 261 if (ret) { 262 dev_err(&indio_dev->dev, "giving up"); 263 goto err_ret; 264 } 265 } 266 267err_ret: 268 return ret; 269} 270 271enum adis16203_chan { 272 in_supply, 273 in_aux, 274 incli_x, 275 incli_y, 276 temp, 277}; 278 279static u8 adis16203_addresses[5][2] = { 280 [in_supply] = { ADIS16203_SUPPLY_OUT }, 281 [in_aux] = { ADIS16203_AUX_ADC }, 282 [incli_x] = { ADIS16203_XINCL_OUT, ADIS16203_INCL_NULL}, 283 [incli_y] = { ADIS16203_YINCL_OUT }, 284 [temp] = { ADIS16203_TEMP_OUT } 285}; 286 287static int adis16203_write_raw(struct iio_dev *indio_dev, 288 struct iio_chan_spec const *chan, 289 int val, 290 int val2, 291 long mask) 292{ 293 /* currently only one writable parameter which keeps this simple */ 294 u8 addr = adis16203_addresses[chan->address][1]; 295 return adis16203_spi_write_reg_16(indio_dev, addr, val & 0x3FFF); 296} 297 298static int adis16203_read_raw(struct iio_dev *indio_dev, 299 struct iio_chan_spec const *chan, 300 int *val, int *val2, 301 long mask) 302{ 303 int ret; 304 int bits; 305 u8 addr; 306 s16 val16; 307 switch (mask) { 308 case 0: 309 mutex_lock(&indio_dev->mlock); 310 addr = adis16203_addresses[chan->address][0]; 311 ret = adis16203_spi_read_reg_16(indio_dev, addr, &val16); 312 if (ret) { 313 mutex_unlock(&indio_dev->mlock); 314 return ret; 315 } 316 317 if (val16 & ADIS16203_ERROR_ACTIVE) { 318 ret = adis16203_check_status(indio_dev); 319 if (ret) { 320 mutex_unlock(&indio_dev->mlock); 321 return ret; 322 } 323 } 324 val16 = val16 & ((1 << chan->scan_type.realbits) - 1); 325 if (chan->scan_type.sign == 's') 326 val16 = (s16)(val16 << 327 (16 - chan->scan_type.realbits)) >> 328 (16 - chan->scan_type.realbits); 329 *val = val16; 330 mutex_unlock(&indio_dev->mlock); 331 return IIO_VAL_INT; 332 case IIO_CHAN_INFO_SCALE: 333 switch (chan->type) { 334 case IIO_VOLTAGE: 335 *val = 0; 336 if (chan->channel == 0) 337 *val2 = 1220; 338 else 339 *val2 = 610; 340 return IIO_VAL_INT_PLUS_MICRO; 341 case IIO_TEMP: 342 *val = 0; 343 *val2 = -470000; 344 return IIO_VAL_INT_PLUS_MICRO; 345 case IIO_INCLI: 346 *val = 0; 347 *val2 = 25000; 348 return IIO_VAL_INT_PLUS_MICRO; 349 default: 350 return -EINVAL; 351 } 352 case IIO_CHAN_INFO_OFFSET: 353 *val = 25; 354 return IIO_VAL_INT; 355 case IIO_CHAN_INFO_CALIBBIAS: 356 bits = 14; 357 mutex_lock(&indio_dev->mlock); 358 addr = adis16203_addresses[chan->address][1]; 359 ret = adis16203_spi_read_reg_16(indio_dev, addr, &val16); 360 if (ret) { 361 mutex_unlock(&indio_dev->mlock); 362 return ret; 363 } 364 val16 &= (1 << bits) - 1; 365 val16 = (s16)(val16 << (16 - bits)) >> (16 - bits); 366 *val = val16; 367 mutex_unlock(&indio_dev->mlock); 368 return IIO_VAL_INT; 369 default: 370 return -EINVAL; 371 } 372} 373 374static struct iio_chan_spec adis16203_channels[] = { 375 IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, "supply", 0, 0, 376 IIO_CHAN_INFO_SCALE_SEPARATE_BIT, 377 in_supply, ADIS16203_SCAN_SUPPLY, 378 IIO_ST('u', 12, 16, 0), 0), 379 IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, NULL, 1, 0, 380 IIO_CHAN_INFO_SCALE_SEPARATE_BIT, 381 in_aux, ADIS16203_SCAN_AUX_ADC, 382 IIO_ST('u', 12, 16, 0), 0), 383 IIO_CHAN(IIO_INCLI, 1, 0, 0, NULL, 0, IIO_MOD_X, 384 IIO_CHAN_INFO_SCALE_SHARED_BIT | 385 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, 386 incli_x, ADIS16203_SCAN_INCLI_X, 387 IIO_ST('s', 14, 16, 0), 0), 388 /* Fixme: Not what it appears to be - see data sheet */ 389 IIO_CHAN(IIO_INCLI, 1, 0, 0, NULL, 0, IIO_MOD_Y, 390 IIO_CHAN_INFO_SCALE_SHARED_BIT, 391 incli_y, ADIS16203_SCAN_INCLI_Y, 392 IIO_ST('s', 14, 16, 0), 0), 393 IIO_CHAN(IIO_TEMP, 0, 1, 0, NULL, 0, 0, 394 IIO_CHAN_INFO_SCALE_SEPARATE_BIT | 395 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT, 396 temp, ADIS16203_SCAN_TEMP, 397 IIO_ST('u', 12, 16, 0), 0), 398 IIO_CHAN_SOFT_TIMESTAMP(5), 399}; 400 401static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16203_write_reset, 0); 402 403static struct attribute *adis16203_attributes[] = { 404 &iio_dev_attr_reset.dev_attr.attr, 405 NULL 406}; 407 408static const struct attribute_group adis16203_attribute_group = { 409 .attrs = adis16203_attributes, 410}; 411 412static const struct iio_info adis16203_info = { 413 .attrs = &adis16203_attribute_group, 414 .read_raw = &adis16203_read_raw, 415 .write_raw = &adis16203_write_raw, 416 .driver_module = THIS_MODULE, 417}; 418 419static int __devinit adis16203_probe(struct spi_device *spi) 420{ 421 int ret; 422 struct iio_dev *indio_dev; 423 struct adis16203_state *st; 424 425 /* setup the industrialio driver allocated elements */ 426 indio_dev = iio_allocate_device(sizeof(*st)); 427 if (indio_dev == NULL) { 428 ret = -ENOMEM; 429 goto error_ret; 430 } 431 st = iio_priv(indio_dev); 432 /* this is only used for removal purposes */ 433 spi_set_drvdata(spi, indio_dev); 434 st->us = spi; 435 mutex_init(&st->buf_lock); 436 437 indio_dev->name = spi->dev.driver->name; 438 indio_dev->dev.parent = &spi->dev; 439 indio_dev->channels = adis16203_channels; 440 indio_dev->num_channels = ARRAY_SIZE(adis16203_channels); 441 indio_dev->info = &adis16203_info; 442 indio_dev->modes = INDIO_DIRECT_MODE; 443 444 ret = adis16203_configure_ring(indio_dev); 445 if (ret) 446 goto error_free_dev; 447 448 ret = iio_buffer_register(indio_dev, 449 adis16203_channels, 450 ARRAY_SIZE(adis16203_channels)); 451 if (ret) { 452 printk(KERN_ERR "failed to initialize the ring\n"); 453 goto error_unreg_ring_funcs; 454 } 455 456 if (spi->irq) { 457 ret = adis16203_probe_trigger(indio_dev); 458 if (ret) 459 goto error_uninitialize_ring; 460 } 461 462 /* Get the device into a sane initial state */ 463 ret = adis16203_initial_setup(indio_dev); 464 if (ret) 465 goto error_remove_trigger; 466 467 ret = iio_device_register(indio_dev); 468 if (ret) 469 goto error_remove_trigger; 470 471 return 0; 472 473error_remove_trigger: 474 adis16203_remove_trigger(indio_dev); 475error_uninitialize_ring: 476 iio_buffer_unregister(indio_dev); 477error_unreg_ring_funcs: 478 adis16203_unconfigure_ring(indio_dev); 479error_free_dev: 480 iio_free_device(indio_dev); 481error_ret: 482 return ret; 483} 484 485static int adis16203_remove(struct spi_device *spi) 486{ 487 struct iio_dev *indio_dev = spi_get_drvdata(spi); 488 489 iio_device_unregister(indio_dev); 490 adis16203_remove_trigger(indio_dev); 491 iio_buffer_unregister(indio_dev); 492 adis16203_unconfigure_ring(indio_dev); 493 iio_free_device(indio_dev); 494 495 return 0; 496} 497 498static struct spi_driver adis16203_driver = { 499 .driver = { 500 .name = "adis16203", 501 .owner = THIS_MODULE, 502 }, 503 .probe = adis16203_probe, 504 .remove = __devexit_p(adis16203_remove), 505}; 506module_spi_driver(adis16203_driver); 507 508MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>"); 509MODULE_DESCRIPTION("Analog Devices ADIS16203 Programmable Digital Vibration Sensor driver"); 510MODULE_LICENSE("GPL v2"); 511MODULE_ALIAS("spi:adis16203"); 512