drivers/staging/iio/accel/adis16203_core.c

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