drivers/staging/iio/accel/adis16204_core.c

   1 /*
   2  * ADIS16204 Programmable High-g Digital Impact Sensor and Recorder
   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
  21 #include "../iio.h"
  22 #include "../sysfs.h"
  23 #include "accel.h"
  24 #include "../gyro/gyro.h"
  25 #include "../adc/adc.h"
  26
  27 #include "adis16204.h"
  28
  29 #define DRIVER_NAME             "adis16204"
  30
  31 static int adis16204_check_status(struct device *dev);
  32
  33 /**
  34  * adis16204_spi_write_reg_8() - write single byte to a register
  35  * @dev: device associated with child of actual device (iio_dev or iio_trig)
  36  * @reg_address: the address of the register to be written
  37  * @val: the value to write
  38  **/
  39 static int adis16204_spi_write_reg_8(struct device *dev,
  40                 u8 reg_address,
  41                 u8 val)
  42 {
  43         int ret;
  44         struct iio_dev *indio_dev = dev_get_drvdata(dev);
  45         struct adis16204_state *st = iio_dev_get_devdata(indio_dev);
  46
  47         mutex_lock(&st->buf_lock);
  48         st->tx[0] = ADIS16204_WRITE_REG(reg_address);
  49         st->tx[1] = val;
  50
  51         ret = spi_write(st->us, st->tx, 2);
  52         mutex_unlock(&st->buf_lock);
  53
  54         return ret;
  55 }
  56
  57 /**
  58  * adis16204_spi_write_reg_16() - write 2 bytes to a pair of registers
  59  * @dev: device associated with child of actual device (iio_dev or iio_trig)
  60  * @reg_address: the address of the lower of the two registers. Second register
  61  *               is assumed to have address one greater.
  62  * @val: value to be written
  63  **/
  64 static int adis16204_spi_write_reg_16(struct device *dev,
  65                 u8 lower_reg_address,
  66                 u16 value)
  67 {
  68         int ret;
  69         struct spi_message msg;
  70         struct iio_dev *indio_dev = dev_get_drvdata(dev);
  71         struct adis16204_state *st = iio_dev_get_devdata(indio_dev);
  72         struct spi_transfer xfers[] = {
  73                 {
  74                         .tx_buf = st->tx,
  75                         .bits_per_word = 8,
  76                         .len = 2,
  77                         .cs_change = 1,
  78                 }, {
  79                         .tx_buf = st->tx + 2,
  80                         .bits_per_word = 8,
  81                         .len = 2,
  82                         .cs_change = 1,
  83                 },
  84         };
  85
  86         mutex_lock(&st->buf_lock);
  87         st->tx[0] = ADIS16204_WRITE_REG(lower_reg_address);
  88         st->tx[1] = value & 0xFF;
  89         st->tx[2] = ADIS16204_WRITE_REG(lower_reg_address + 1);
  90         st->tx[3] = (value >> 8) & 0xFF;
  91
  92         spi_message_init(&msg);
  93         spi_message_add_tail(&xfers[0], &msg);
  94         spi_message_add_tail(&xfers[1], &msg);
  95         ret = spi_sync(st->us, &msg);
  96         mutex_unlock(&st->buf_lock);
  97
  98         return ret;
  99 }
 100
 101 /**
 102  * adis16204_spi_read_reg_16() - read 2 bytes from a 16-bit register
 103  * @dev: device associated with child of actual device (iio_dev or iio_trig)
 104  * @reg_address: the address of the lower of the two registers. Second register
 105  *               is assumed to have address one greater.
 106  * @val: somewhere to pass back the value read
 107  **/
 108 static int adis16204_spi_read_reg_16(struct device *dev,
 109                 u8 lower_reg_address,
 110                 u16 *val)
 111 {
 112         struct spi_message msg;
 113         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 114         struct adis16204_state *st = iio_dev_get_devdata(indio_dev);
 115         int ret;
 116         struct spi_transfer xfers[] = {
 117                 {
 118                         .tx_buf = st->tx,
 119                         .bits_per_word = 8,
 120                         .len = 2,
 121                         .cs_change = 1,
 122                         .delay_usecs = 20,
 123                 }, {
 124                         .rx_buf = st->rx,
 125                         .bits_per_word = 8,
 126                         .len = 2,
 127                         .cs_change = 1,
 128                         .delay_usecs = 20,
 129                 },
 130         };
 131
 132         mutex_lock(&st->buf_lock);
 133         st->tx[0] = ADIS16204_READ_REG(lower_reg_address);
 134         st->tx[1] = 0;
 135
 136         spi_message_init(&msg);
 137         spi_message_add_tail(&xfers[0], &msg);
 138         spi_message_add_tail(&xfers[1], &msg);
 139         ret = spi_sync(st->us, &msg);
 140         if (ret) {
 141                 dev_err(&st->us->dev, "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
 147 error_ret:
 148         mutex_unlock(&st->buf_lock);
 149         return ret;
 150 }
 151
 152 static ssize_t adis16204_read_12bit_unsigned(struct device *dev,
 153                 struct device_attribute *attr,
 154                 char *buf)
 155 {
 156         int ret;
 157         u16 val = 0;
 158         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 159
 160         ret = adis16204_spi_read_reg_16(dev, this_attr->address, &val);
 161         if (ret)
 162                 return ret;
 163
 164         if (val & ADIS16204_ERROR_ACTIVE)
 165                 adis16204_check_status(dev);
 166
 167         return sprintf(buf, "%u\n", val & 0x0FFF);
 168 }
 169
 170 static ssize_t adis16204_read_temp(struct device *dev,
 171                 struct device_attribute *attr,
 172                 char *buf)
 173 {
 174         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 175         ssize_t ret;
 176         u16 val;
 177
 178         /* Take the iio_dev status lock */
 179         mutex_lock(&indio_dev->mlock);
 180
 181         ret = adis16204_spi_read_reg_16(dev, ADIS16204_TEMP_OUT, (u16 *)&val);
 182         if (ret)
 183                 goto error_ret;
 184
 185         if (val & ADIS16204_ERROR_ACTIVE)
 186                 adis16204_check_status(dev);
 187
 188         val &= 0xFFF;
 189         ret = sprintf(buf, "%d\n", val);
 190
 191 error_ret:
 192         mutex_unlock(&indio_dev->mlock);
 193         return ret;
 194 }
 195
 196 static ssize_t adis16204_read_12bit_signed(struct device *dev,
 197                 struct device_attribute *attr,
 198                 char *buf)
 199 {
 200         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 201         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 202         s16 val = 0;
 203         ssize_t ret;
 204
 205         mutex_lock(&indio_dev->mlock);
 206
 207         ret = adis16204_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);
 208         if (!ret) {
 209                 if (val & ADIS16204_ERROR_ACTIVE)
 210                         adis16204_check_status(dev);
 211
 212                 val = ((s16)(val << 4) >> 4);
 213                 ret = sprintf(buf, "%d\n", val);
 214         }
 215
 216         mutex_unlock(&indio_dev->mlock);
 217
 218         return ret;
 219 }
 220
 221 static ssize_t adis16204_read_14bit_signed(struct device *dev,
 222                 struct device_attribute *attr,
 223                 char *buf)
 224 {
 225         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 226         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 227         s16 val = 0;
 228         ssize_t ret;
 229
 230         mutex_lock(&indio_dev->mlock);
 231
 232         ret = adis16204_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);
 233         if (!ret) {
 234                 if (val & ADIS16204_ERROR_ACTIVE)
 235                         adis16204_check_status(dev);
 236
 237                 val = ((s16)(val << 2) >> 2);
 238                 ret = sprintf(buf, "%d\n", val);
 239         }
 240
 241         mutex_unlock(&indio_dev->mlock);
 242
 243         return ret;
 244 }
 245
 246 static ssize_t adis16204_write_16bit(struct device *dev,
 247                 struct device_attribute *attr,
 248                 const char *buf,
 249                 size_t len)
 250 {
 251         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 252         int ret;
 253         long val;
 254
 255         ret = strict_strtol(buf, 10, &val);
 256         if (ret)
 257                 goto error_ret;
 258         ret = adis16204_spi_write_reg_16(dev, this_attr->address, val);
 259
 260 error_ret:
 261         return ret ? ret : len;
 262 }
 263
 264 static int adis16204_reset(struct device *dev)
 265 {
 266         int ret;
 267         ret = adis16204_spi_write_reg_8(dev,
 268                         ADIS16204_GLOB_CMD,
 269                         ADIS16204_GLOB_CMD_SW_RESET);
 270         if (ret)
 271                 dev_err(dev, "problem resetting device");
 272
 273         return ret;
 274 }
 275
 276 static ssize_t adis16204_write_reset(struct device *dev,
 277                 struct device_attribute *attr,
 278                 const char *buf, size_t len)
 279 {
 280         if (len < 1)
 281                 return -EINVAL;
 282         switch (buf[0]) {
 283         case '1':
 284         case 'y':
 285         case 'Y':
 286                 return adis16204_reset(dev);
 287         }
 288         return -EINVAL;
 289 }
 290
 291 int adis16204_set_irq(struct device *dev, bool enable)
 292 {
 293         int ret = 0;
 294         u16 msc;
 295
 296         ret = adis16204_spi_read_reg_16(dev, ADIS16204_MSC_CTRL, &msc);
 297         if (ret)
 298                 goto error_ret;
 299
 300         msc |= ADIS16204_MSC_CTRL_ACTIVE_HIGH;
 301         msc &= ~ADIS16204_MSC_CTRL_DATA_RDY_DIO2;
 302         if (enable)
 303                 msc |= ADIS16204_MSC_CTRL_DATA_RDY_EN;
 304         else
 305                 msc &= ~ADIS16204_MSC_CTRL_DATA_RDY_EN;
 306
 307         ret = adis16204_spi_write_reg_16(dev, ADIS16204_MSC_CTRL, msc);
 308
 309 error_ret:
 310         return ret;
 311 }
 312
 313 static int adis16204_check_status(struct device *dev)
 314 {
 315         u16 status;
 316         int ret;
 317
 318         ret = adis16204_spi_read_reg_16(dev, ADIS16204_DIAG_STAT, &status);
 319         if (ret < 0) {
 320                 dev_err(dev, "Reading status failed\n");
 321                 goto error_ret;
 322         }
 323         ret = status & 0x1F;
 324
 325         if (status & ADIS16204_DIAG_STAT_SELFTEST_FAIL)
 326                 dev_err(dev, "Self test failure\n");
 327         if (status & ADIS16204_DIAG_STAT_SPI_FAIL)
 328                 dev_err(dev, "SPI failure\n");
 329         if (status & ADIS16204_DIAG_STAT_FLASH_UPT)
 330                 dev_err(dev, "Flash update failed\n");
 331         if (status & ADIS16204_DIAG_STAT_POWER_HIGH)
 332                 dev_err(dev, "Power supply above 3.625V\n");
 333         if (status & ADIS16204_DIAG_STAT_POWER_LOW)
 334                 dev_err(dev, "Power supply below 2.975V\n");
 335
 336 error_ret:
 337         return ret;
 338 }
 339
 340 static int adis16204_self_test(struct device *dev)
 341 {
 342         int ret;
 343         ret = adis16204_spi_write_reg_16(dev,
 344                         ADIS16204_MSC_CTRL,
 345                         ADIS16204_MSC_CTRL_SELF_TEST_EN);
 346         if (ret) {
 347                 dev_err(dev, "problem starting self test");
 348                 goto err_ret;
 349         }
 350
 351         adis16204_check_status(dev);
 352
 353 err_ret:
 354         return ret;
 355 }
 356
 357 static int adis16204_initial_setup(struct adis16204_state *st)
 358 {
 359         int ret;
 360         struct device *dev = &st->indio_dev->dev;
 361
 362         /* Disable IRQ */
 363         ret = adis16204_set_irq(dev, false);
 364         if (ret) {
 365                 dev_err(dev, "disable irq failed");
 366                 goto err_ret;
 367         }
 368
 369         /* Do self test */
 370         ret = adis16204_self_test(dev);
 371         if (ret) {
 372                 dev_err(dev, "self test failure");
 373                 goto err_ret;
 374         }
 375
 376         /* Read status register to check the result */
 377         ret = adis16204_check_status(dev);
 378         if (ret) {
 379                 adis16204_reset(dev);
 380                 dev_err(dev, "device not playing ball -> reset");
 381                 msleep(ADIS16204_STARTUP_DELAY);
 382                 ret = adis16204_check_status(dev);
 383                 if (ret) {
 384                         dev_err(dev, "giving up");
 385                         goto err_ret;
 386                 }
 387         }
 388
 389         printk(KERN_INFO DRIVER_NAME ": at CS%d (irq %d)\n",
 390                         st->us->chip_select, st->us->irq);
 391
 392 err_ret:
 393         return ret;
 394 }
 395
 396 static IIO_DEV_ATTR_IN_NAMED_RAW(0, supply, adis16204_read_12bit_unsigned,
 397                 ADIS16204_SUPPLY_OUT);
 398 static IIO_CONST_ATTR(in0_supply_scale, "0.00122");
 399 static IIO_DEV_ATTR_IN_RAW(1, adis16204_read_12bit_unsigned,
 400                 ADIS16204_AUX_ADC);
 401 static IIO_CONST_ATTR(in1_scale, "0.00061");
 402
 403 static IIO_DEV_ATTR_ACCEL_X(adis16204_read_14bit_signed,
 404                 ADIS16204_XACCL_OUT);
 405 static IIO_DEV_ATTR_ACCEL_Y(adis16204_read_14bit_signed,
 406                 ADIS16204_YACCL_OUT);
 407 static IIO_DEV_ATTR_ACCEL_XY(adis16204_read_14bit_signed,
 408                 ADIS16204_XY_RSS_OUT);
 409 static IIO_DEV_ATTR_ACCEL_XPEAK(adis16204_read_14bit_signed,
 410                 ADIS16204_X_PEAK_OUT);
 411 static IIO_DEV_ATTR_ACCEL_YPEAK(adis16204_read_14bit_signed,
 412                 ADIS16204_Y_PEAK_OUT);
 413 static IIO_DEV_ATTR_ACCEL_XYPEAK(adis16204_read_14bit_signed,
 414                 ADIS16204_XY_PEAK_OUT);
 415 static IIO_DEV_ATTR_ACCEL_X_OFFSET(S_IWUSR | S_IRUGO,
 416                 adis16204_read_12bit_signed,
 417                 adis16204_write_16bit,
 418                 ADIS16204_XACCL_NULL);
 419 static IIO_DEV_ATTR_ACCEL_Y_OFFSET(S_IWUSR | S_IRUGO,
 420                 adis16204_read_12bit_signed,
 421                 adis16204_write_16bit,
 422                 ADIS16204_YACCL_NULL);
 423 static IIO_CONST_ATTR(accel_x_scale, "0.017125");
 424 static IIO_CONST_ATTR(accel_y_scale, "0.008407");
 425 static IIO_CONST_ATTR(accel_xy_scale, "0.017125");
 426
 427 static IIO_DEV_ATTR_TEMP_RAW(adis16204_read_temp);
 428 static IIO_CONST_ATTR(temp_offset, "25");
 429 static IIO_CONST_ATTR(temp_scale, "-0.47");
 430
 431 static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16204_write_reset, 0);
 432
 433 static IIO_CONST_ATTR(name, "adis16204");
 434
 435 static struct attribute *adis16204_event_attributes[] = {
 436         NULL
 437 };
 438
 439 static struct attribute_group adis16204_event_attribute_group = {
 440         .attrs = adis16204_event_attributes,
 441 };
 442
 443 static struct attribute *adis16204_attributes[] = {
 444         &iio_dev_attr_in0_supply_raw.dev_attr.attr,
 445         &iio_const_attr_in0_supply_scale.dev_attr.attr,
 446         &iio_dev_attr_temp_raw.dev_attr.attr,
 447         &iio_const_attr_temp_offset.dev_attr.attr,
 448         &iio_const_attr_temp_scale.dev_attr.attr,
 449         &iio_dev_attr_reset.dev_attr.attr,
 450         &iio_const_attr_name.dev_attr.attr,
 451         &iio_dev_attr_in1_raw.dev_attr.attr,
 452         &iio_const_attr_in1_scale.dev_attr.attr,
 453         &iio_dev_attr_accel_x_raw.dev_attr.attr,
 454         &iio_dev_attr_accel_y_raw.dev_attr.attr,
 455         &iio_dev_attr_accel_xy.dev_attr.attr,
 456         &iio_dev_attr_accel_xpeak.dev_attr.attr,
 457         &iio_dev_attr_accel_ypeak.dev_attr.attr,
 458         &iio_dev_attr_accel_xypeak.dev_attr.attr,
 459         &iio_dev_attr_accel_x_offset.dev_attr.attr,
 460         &iio_dev_attr_accel_y_offset.dev_attr.attr,
 461         &iio_const_attr_accel_x_scale.dev_attr.attr,
 462         &iio_const_attr_accel_y_scale.dev_attr.attr,
 463         &iio_const_attr_accel_xy_scale.dev_attr.attr,
 464         NULL
 465 };
 466
 467 static const struct attribute_group adis16204_attribute_group = {
 468         .attrs = adis16204_attributes,
 469 };
 470
 471 static int __devinit adis16204_probe(struct spi_device *spi)
 472 {
 473         int ret, regdone = 0;
 474         struct adis16204_state *st = kzalloc(sizeof *st, GFP_KERNEL);
 475         if (!st) {
 476                 ret =  -ENOMEM;
 477                 goto error_ret;
 478         }
 479         /* this is only used for removal purposes */
 480         spi_set_drvdata(spi, st);
 481
 482         /* Allocate the comms buffers */
 483         st->rx = kzalloc(sizeof(*st->rx)*ADIS16204_MAX_RX, GFP_KERNEL);
 484         if (st->rx == NULL) {
 485                 ret = -ENOMEM;
 486                 goto error_free_st;
 487         }
 488         st->tx = kzalloc(sizeof(*st->tx)*ADIS16204_MAX_TX, GFP_KERNEL);
 489         if (st->tx == NULL) {
 490                 ret = -ENOMEM;
 491                 goto error_free_rx;
 492         }
 493         st->us = spi;
 494         mutex_init(&st->buf_lock);
 495         /* setup the industrialio driver allocated elements */
 496         st->indio_dev = iio_allocate_device();
 497         if (st->indio_dev == NULL) {
 498                 ret = -ENOMEM;
 499                 goto error_free_tx;
 500         }
 501
 502         st->indio_dev->dev.parent = &spi->dev;
 503         st->indio_dev->num_interrupt_lines = 1;
 504         st->indio_dev->event_attrs = &adis16204_event_attribute_group;
 505         st->indio_dev->attrs = &adis16204_attribute_group;
 506         st->indio_dev->dev_data = (void *)(st);
 507         st->indio_dev->driver_module = THIS_MODULE;
 508         st->indio_dev->modes = INDIO_DIRECT_MODE;
 509
 510         ret = adis16204_configure_ring(st->indio_dev);
 511         if (ret)
 512                 goto error_free_dev;
 513
 514         ret = iio_device_register(st->indio_dev);
 515         if (ret)
 516                 goto error_unreg_ring_funcs;
 517         regdone = 1;
 518
 519         ret = adis16204_initialize_ring(st->indio_dev->ring);
 520         if (ret) {
 521                 printk(KERN_ERR "failed to initialize the ring\n");
 522                 goto error_unreg_ring_funcs;
 523         }
 524
 525         if (spi->irq) {
 526                 ret = iio_register_interrupt_line(spi->irq,
 527                                 st->indio_dev,
 528                                 0,
 529                                 IRQF_TRIGGER_RISING,
 530                                 "adis16204");
 531                 if (ret)
 532                         goto error_uninitialize_ring;
 533
 534                 ret = adis16204_probe_trigger(st->indio_dev);
 535                 if (ret)
 536                         goto error_unregister_line;
 537         }
 538
 539         /* Get the device into a sane initial state */
 540         ret = adis16204_initial_setup(st);
 541         if (ret)
 542                 goto error_remove_trigger;
 543         return 0;
 544
 545 error_remove_trigger:
 546         adis16204_remove_trigger(st->indio_dev);
 547 error_unregister_line:
 548         if (spi->irq)
 549                 iio_unregister_interrupt_line(st->indio_dev, 0);
 550 error_uninitialize_ring:
 551         adis16204_uninitialize_ring(st->indio_dev->ring);
 552 error_unreg_ring_funcs:
 553         adis16204_unconfigure_ring(st->indio_dev);
 554 error_free_dev:
 555         if (regdone)
 556                 iio_device_unregister(st->indio_dev);
 557         else
 558                 iio_free_device(st->indio_dev);
 559 error_free_tx:
 560         kfree(st->tx);
 561 error_free_rx:
 562         kfree(st->rx);
 563 error_free_st:
 564         kfree(st);
 565 error_ret:
 566         return ret;
 567 }
 568
 569 static int adis16204_remove(struct spi_device *spi)
 570 {
 571         struct adis16204_state *st = spi_get_drvdata(spi);
 572         struct iio_dev *indio_dev = st->indio_dev;
 573
 574         flush_scheduled_work();
 575
 576         adis16204_remove_trigger(indio_dev);
 577         if (spi->irq)
 578                 iio_unregister_interrupt_line(indio_dev, 0);
 579
 580         adis16204_uninitialize_ring(indio_dev->ring);
 581         iio_device_unregister(indio_dev);
 582         adis16204_unconfigure_ring(indio_dev);
 583         kfree(st->tx);
 584         kfree(st->rx);
 585         kfree(st);
 586
 587         return 0;
 588 }
 589
 590 static struct spi_driver adis16204_driver = {
 591         .driver = {
 592                 .name = "adis16204",
 593                 .owner = THIS_MODULE,
 594         },
 595         .probe = adis16204_probe,
 596         .remove = __devexit_p(adis16204_remove),
 597 };
 598
 599 static __init int adis16204_init(void)
 600 {
 601         return spi_register_driver(&adis16204_driver);
 602 }
 603 module_init(adis16204_init);
 604
 605 static __exit void adis16204_exit(void)
 606 {
 607         spi_unregister_driver(&adis16204_driver);
 608 }
 609 module_exit(adis16204_exit);
 610
 611 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
 612 MODULE_DESCRIPTION("Analog Devices ADIS16204 Programmable High-g Digital Impact Sensor and Recorder");
 613 MODULE_LICENSE("GPL v2");