drivers/staging/iio/imu/adis16400_core.c

   1 /*
   2  * adis16400.c  support Analog Devices ADIS16400/5
   3  *              3d 2g Linear Accelerometers,
   4  *              3d Gyroscopes,
   5  *              3d Magnetometers via SPI
   6  *
   7  * Copyright (c) 2009 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
   8  * Copyright (c) 2007 Jonathan Cameron <jic23@cam.ac.uk>
   9  * Copyright (c) 2011 Analog Devices Inc.
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  */
  16
  17 #include <linux/interrupt.h>
  18 #include <linux/irq.h>
  19 #include <linux/gpio.h>
  20 #include <linux/delay.h>
  21 #include <linux/mutex.h>
  22 #include <linux/device.h>
  23 #include <linux/kernel.h>
  24 #include <linux/spi/spi.h>
  25 #include <linux/slab.h>
  26 #include <linux/sysfs.h>
  27 #include <linux/list.h>
  28
  29 #include "../iio.h"
  30 #include "../sysfs.h"
  31 #include "../ring_generic.h"
  32 #include "../accel/accel.h"
  33 #include "../adc/adc.h"
  34 #include "../gyro/gyro.h"
  35 #include "../magnetometer/magnet.h"
  36
  37 #include "adis16400.h"
  38
  39 #define DRIVER_NAME             "adis16400"
  40
  41 enum adis16400_chip_variant {
  42         ADIS16300,
  43         ADIS16350,
  44         ADIS16360,
  45         ADIS16362,
  46         ADIS16364,
  47         ADIS16365,
  48         ADIS16400,
  49 };
  50
  51 static int adis16400_check_status(struct iio_dev *indio_dev);
  52
  53 /* At the moment the spi framework doesn't allow global setting of cs_change.
  54  * It's in the likely to be added comment at the top of spi.h.
  55  * This means that use cannot be made of spi_write etc.
  56  */
  57
  58 /**
  59  * adis16400_spi_write_reg_8() - write single byte to a register
  60  * @dev: device associated with child of actual device (iio_dev or iio_trig)
  61  * @reg_address: the address of the register to be written
  62  * @val: the value to write
  63  **/
  64 static int adis16400_spi_write_reg_8(struct iio_dev *indio_dev,
  65                                      u8 reg_address,
  66                                      u8 val)
  67 {
  68         int ret;
  69         struct adis16400_state *st = iio_priv(indio_dev);
  70
  71         mutex_lock(&st->buf_lock);
  72         st->tx[0] = ADIS16400_WRITE_REG(reg_address);
  73         st->tx[1] = val;
  74
  75         ret = spi_write(st->us, st->tx, 2);
  76         mutex_unlock(&st->buf_lock);
  77
  78         return ret;
  79 }
  80
  81 /**
  82  * adis16400_spi_write_reg_16() - write 2 bytes to a pair of registers
  83  * @dev: device associated with child of actual device (iio_dev or iio_trig)
  84  * @reg_address: the address of the lower of the two registers. Second register
  85  *               is assumed to have address one greater.
  86  * @val: value to be written
  87  **/
  88 static int adis16400_spi_write_reg_16(struct iio_dev *indio_dev,
  89                 u8 lower_reg_address,
  90                 u16 value)
  91 {
  92         int ret;
  93         struct spi_message msg;
  94         struct adis16400_state *st = iio_priv(indio_dev);
  95         struct spi_transfer xfers[] = {
  96                 {
  97                         .tx_buf = st->tx,
  98                         .bits_per_word = 8,
  99                         .len = 2,
 100                         .cs_change = 1,
 101                 }, {
 102                         .tx_buf = st->tx + 2,
 103                         .bits_per_word = 8,
 104                         .len = 2,
 105                 },
 106         };
 107
 108         mutex_lock(&st->buf_lock);
 109         st->tx[0] = ADIS16400_WRITE_REG(lower_reg_address);
 110         st->tx[1] = value & 0xFF;
 111         st->tx[2] = ADIS16400_WRITE_REG(lower_reg_address + 1);
 112         st->tx[3] = (value >> 8) & 0xFF;
 113
 114         spi_message_init(&msg);
 115         spi_message_add_tail(&xfers[0], &msg);
 116         spi_message_add_tail(&xfers[1], &msg);
 117         ret = spi_sync(st->us, &msg);
 118         mutex_unlock(&st->buf_lock);
 119
 120         return ret;
 121 }
 122
 123 /**
 124  * adis16400_spi_read_reg_16() - read 2 bytes from a 16-bit register
 125  * @indio_dev: iio device
 126  * @reg_address: the address of the lower of the two registers. Second register
 127  *               is assumed to have address one greater.
 128  * @val: somewhere to pass back the value read
 129  **/
 130 static int adis16400_spi_read_reg_16(struct iio_dev *indio_dev,
 131                 u8 lower_reg_address,
 132                 u16 *val)
 133 {
 134         struct spi_message msg;
 135         struct adis16400_state *st = iio_priv(indio_dev);
 136         int ret;
 137         struct spi_transfer xfers[] = {
 138                 {
 139                         .tx_buf = st->tx,
 140                         .bits_per_word = 8,
 141                         .len = 2,
 142                         .cs_change = 1,
 143                 }, {
 144                         .rx_buf = st->rx,
 145                         .bits_per_word = 8,
 146                         .len = 2,
 147                 },
 148         };
 149
 150         mutex_lock(&st->buf_lock);
 151         st->tx[0] = ADIS16400_READ_REG(lower_reg_address);
 152         st->tx[1] = 0;
 153         st->tx[2] = 0;
 154         st->tx[3] = 0;
 155
 156         spi_message_init(&msg);
 157         spi_message_add_tail(&xfers[0], &msg);
 158         spi_message_add_tail(&xfers[1], &msg);
 159         ret = spi_sync(st->us, &msg);
 160         if (ret) {
 161                 dev_err(&st->us->dev,
 162                         "problem when reading 16 bit register 0x%02X",
 163                         lower_reg_address);
 164                 goto error_ret;
 165         }
 166         *val = (st->rx[0] << 8) | st->rx[1];
 167
 168 error_ret:
 169         mutex_unlock(&st->buf_lock);
 170         return ret;
 171 }
 172
 173 static ssize_t adis16400_read_frequency(struct device *dev,
 174                 struct device_attribute *attr,
 175                 char *buf)
 176 {
 177         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 178         int ret, len = 0;
 179         u16 t;
 180         int sps;
 181         ret = adis16400_spi_read_reg_16(indio_dev,
 182                         ADIS16400_SMPL_PRD,
 183                         &t);
 184         if (ret)
 185                 return ret;
 186         sps =  (t & ADIS16400_SMPL_PRD_TIME_BASE) ? 53 : 1638;
 187         sps /= (t & ADIS16400_SMPL_PRD_DIV_MASK) + 1;
 188         len = sprintf(buf, "%d SPS\n", sps);
 189         return len;
 190 }
 191
 192 static ssize_t adis16400_write_frequency(struct device *dev,
 193                 struct device_attribute *attr,
 194                 const char *buf,
 195                 size_t len)
 196 {
 197         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 198         struct adis16400_state *st = iio_priv(indio_dev);
 199         long val;
 200         int ret;
 201         u8 t;
 202
 203         ret = strict_strtol(buf, 10, &val);
 204         if (ret)
 205                 return ret;
 206
 207         mutex_lock(&indio_dev->mlock);
 208
 209         t = (1638 / val);
 210         if (t > 0)
 211                 t--;
 212         t &= ADIS16400_SMPL_PRD_DIV_MASK;
 213         if ((t & ADIS16400_SMPL_PRD_DIV_MASK) >= 0x0A)
 214                 st->us->max_speed_hz = ADIS16400_SPI_SLOW;
 215         else
 216                 st->us->max_speed_hz = ADIS16400_SPI_FAST;
 217
 218         ret = adis16400_spi_write_reg_8(indio_dev,
 219                         ADIS16400_SMPL_PRD,
 220                         t);
 221
 222         mutex_unlock(&indio_dev->mlock);
 223
 224         return ret ? ret : len;
 225 }
 226
 227 static int adis16400_reset(struct iio_dev *indio_dev)
 228 {
 229         int ret;
 230         ret = adis16400_spi_write_reg_8(indio_dev,
 231                         ADIS16400_GLOB_CMD,
 232                         ADIS16400_GLOB_CMD_SW_RESET);
 233         if (ret)
 234                 dev_err(&indio_dev->dev, "problem resetting device");
 235
 236         return ret;
 237 }
 238
 239 static ssize_t adis16400_write_reset(struct device *dev,
 240                 struct device_attribute *attr,
 241                 const char *buf, size_t len)
 242 {
 243         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 244
 245         if (len < 1)
 246                 return -1;
 247         switch (buf[0]) {
 248         case '1':
 249         case 'y':
 250         case 'Y':
 251                 return adis16400_reset(indio_dev);
 252         }
 253         return -1;
 254 }
 255
 256 int adis16400_set_irq(struct iio_dev *indio_dev, bool enable)
 257 {
 258         int ret;
 259         u16 msc;
 260         ret = adis16400_spi_read_reg_16(indio_dev, ADIS16400_MSC_CTRL, &msc);
 261         if (ret)
 262                 goto error_ret;
 263
 264         msc |= ADIS16400_MSC_CTRL_DATA_RDY_POL_HIGH;
 265         if (enable)
 266                 msc |= ADIS16400_MSC_CTRL_DATA_RDY_EN;
 267         else
 268                 msc &= ~ADIS16400_MSC_CTRL_DATA_RDY_EN;
 269
 270         ret = adis16400_spi_write_reg_16(indio_dev, ADIS16400_MSC_CTRL, msc);
 271         if (ret)
 272                 goto error_ret;
 273
 274 error_ret:
 275         return ret;
 276 }
 277
 278 /* Power down the device */
 279 static int adis16400_stop_device(struct iio_dev *indio_dev)
 280 {
 281         int ret;
 282         u16 val = ADIS16400_SLP_CNT_POWER_OFF;
 283
 284         ret = adis16400_spi_write_reg_16(indio_dev, ADIS16400_SLP_CNT, val);
 285         if (ret)
 286                 dev_err(&indio_dev->dev,
 287                         "problem with turning device off: SLP_CNT");
 288
 289         return ret;
 290 }
 291
 292 static int adis16400_self_test(struct iio_dev *indio_dev)
 293 {
 294         int ret;
 295         ret = adis16400_spi_write_reg_16(indio_dev,
 296                         ADIS16400_MSC_CTRL,
 297                         ADIS16400_MSC_CTRL_MEM_TEST);
 298         if (ret) {
 299                 dev_err(&indio_dev->dev, "problem starting self test");
 300                 goto err_ret;
 301         }
 302
 303         msleep(ADIS16400_MTEST_DELAY);
 304         adis16400_check_status(indio_dev);
 305
 306 err_ret:
 307         return ret;
 308 }
 309
 310 static int adis16400_check_status(struct iio_dev *indio_dev)
 311 {
 312         u16 status;
 313         int ret;
 314         struct device *dev = &indio_dev->dev;
 315
 316         ret = adis16400_spi_read_reg_16(indio_dev,
 317                                         ADIS16400_DIAG_STAT, &status);
 318
 319         if (ret < 0) {
 320                 dev_err(dev, "Reading status failed\n");
 321                 goto error_ret;
 322         }
 323         ret = status;
 324         if (status & ADIS16400_DIAG_STAT_ZACCL_FAIL)
 325                 dev_err(dev, "Z-axis accelerometer self-test failure\n");
 326         if (status & ADIS16400_DIAG_STAT_YACCL_FAIL)
 327                 dev_err(dev, "Y-axis accelerometer self-test failure\n");
 328         if (status & ADIS16400_DIAG_STAT_XACCL_FAIL)
 329                 dev_err(dev, "X-axis accelerometer self-test failure\n");
 330         if (status & ADIS16400_DIAG_STAT_XGYRO_FAIL)
 331                 dev_err(dev, "X-axis gyroscope self-test failure\n");
 332         if (status & ADIS16400_DIAG_STAT_YGYRO_FAIL)
 333                 dev_err(dev, "Y-axis gyroscope self-test failure\n");
 334         if (status & ADIS16400_DIAG_STAT_ZGYRO_FAIL)
 335                 dev_err(dev, "Z-axis gyroscope self-test failure\n");
 336         if (status & ADIS16400_DIAG_STAT_ALARM2)
 337                 dev_err(dev, "Alarm 2 active\n");
 338         if (status & ADIS16400_DIAG_STAT_ALARM1)
 339                 dev_err(dev, "Alarm 1 active\n");
 340         if (status & ADIS16400_DIAG_STAT_FLASH_CHK)
 341                 dev_err(dev, "Flash checksum error\n");
 342         if (status & ADIS16400_DIAG_STAT_SELF_TEST)
 343                 dev_err(dev, "Self test error\n");
 344         if (status & ADIS16400_DIAG_STAT_OVERFLOW)
 345                 dev_err(dev, "Sensor overrange\n");
 346         if (status & ADIS16400_DIAG_STAT_SPI_FAIL)
 347                 dev_err(dev, "SPI failure\n");
 348         if (status & ADIS16400_DIAG_STAT_FLASH_UPT)
 349                 dev_err(dev, "Flash update failed\n");
 350         if (status & ADIS16400_DIAG_STAT_POWER_HIGH)
 351                 dev_err(dev, "Power supply above 5.25V\n");
 352         if (status & ADIS16400_DIAG_STAT_POWER_LOW)
 353                 dev_err(dev, "Power supply below 4.75V\n");
 354
 355 error_ret:
 356         return ret;
 357 }
 358
 359 static int adis16400_initial_setup(struct iio_dev *indio_dev)
 360 {
 361         int ret;
 362         u16 prod_id, smp_prd;
 363         struct device *dev = &indio_dev->dev;
 364         struct adis16400_state *st = iio_priv(indio_dev);
 365
 366         /* use low spi speed for init */
 367         st->us->max_speed_hz = ADIS16400_SPI_SLOW;
 368         st->us->mode = SPI_MODE_3;
 369         spi_setup(st->us);
 370
 371         /* Disable IRQ */
 372         ret = adis16400_set_irq(indio_dev, false);
 373         if (ret) {
 374                 dev_err(dev, "disable irq failed");
 375                 goto err_ret;
 376         }
 377
 378         /* Do self test */
 379         ret = adis16400_self_test(indio_dev);
 380         if (ret) {
 381                 dev_err(dev, "self test failure");
 382                 goto err_ret;
 383         }
 384
 385         /* Read status register to check the result */
 386         ret = adis16400_check_status(indio_dev);
 387         if (ret) {
 388                 adis16400_reset(indio_dev);
 389                 dev_err(dev, "device not playing ball -> reset");
 390                 msleep(ADIS16400_STARTUP_DELAY);
 391                 ret = adis16400_check_status(indio_dev);
 392                 if (ret) {
 393                         dev_err(dev, "giving up");
 394                         goto err_ret;
 395                 }
 396         }
 397         if (st->variant->flags & ADIS16400_HAS_PROD_ID) {
 398                 ret = adis16400_spi_read_reg_16(indio_dev,
 399                                                 ADIS16400_PRODUCT_ID, &prod_id);
 400                 if (ret)
 401                         goto err_ret;
 402
 403                 if ((prod_id & 0xF000) != st->variant->product_id)
 404                         dev_warn(dev, "incorrect id");
 405
 406                 printk(KERN_INFO DRIVER_NAME ": prod_id 0x%04x at CS%d (irq %d)\n",
 407                        prod_id, st->us->chip_select, st->us->irq);
 408         }
 409         /* use high spi speed if possible */
 410         ret = adis16400_spi_read_reg_16(indio_dev,
 411                                         ADIS16400_SMPL_PRD, &smp_prd);
 412         if (!ret && (smp_prd & ADIS16400_SMPL_PRD_DIV_MASK) < 0x0A) {
 413                 st->us->max_speed_hz = ADIS16400_SPI_SLOW;
 414                 spi_setup(st->us);
 415         }
 416
 417
 418 err_ret:
 419
 420         return ret;
 421 }
 422
 423 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 424                 adis16400_read_frequency,
 425                 adis16400_write_frequency);
 426
 427 static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16400_write_reset, 0);
 428
 429 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("409 546 819 1638");
 430
 431 enum adis16400_chan {
 432         in_supply,
 433         gyro_x,
 434         gyro_y,
 435         gyro_z,
 436         accel_x,
 437         accel_y,
 438         accel_z,
 439         magn_x,
 440         magn_y,
 441         magn_z,
 442         temp,
 443         temp0, temp1, temp2,
 444         in1
 445 };
 446
 447 static u8 adis16400_addresses[16][2] = {
 448         [in_supply] = { ADIS16400_SUPPLY_OUT, 0 },
 449         [gyro_x] = { ADIS16400_XGYRO_OUT, ADIS16400_XGYRO_OFF },
 450         [gyro_y] = { ADIS16400_YGYRO_OUT, ADIS16400_YGYRO_OFF },
 451         [gyro_z] = { ADIS16400_ZGYRO_OUT, ADIS16400_ZGYRO_OFF },
 452         [accel_x] = { ADIS16400_XACCL_OUT, ADIS16400_XACCL_OFF },
 453         [accel_y] = { ADIS16400_YACCL_OUT, ADIS16400_YACCL_OFF },
 454         [accel_z] = { ADIS16400_ZACCL_OUT, ADIS16400_ZACCL_OFF },
 455         [magn_x] = { ADIS16400_XMAGN_OUT, 0 },
 456         [magn_y] = { ADIS16400_YMAGN_OUT, 0 },
 457         [magn_z] = { ADIS16400_ZMAGN_OUT, 0 },
 458         [temp] = { ADIS16400_TEMP_OUT, 0 },
 459         [temp0] = { ADIS16350_XTEMP_OUT },
 460         [temp1] = { ADIS16350_YTEMP_OUT },
 461         [temp2] = { ADIS16350_ZTEMP_OUT },
 462         [in1] = { ADIS16400_AUX_ADC , 0 },
 463 };
 464
 465 static int adis16400_write_raw(struct iio_dev *indio_dev,
 466                                struct iio_chan_spec const *chan,
 467                                int val,
 468                                int val2,
 469                                long mask)
 470 {
 471         int ret;
 472         switch (mask) {
 473         case (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE):
 474                 mutex_lock(&indio_dev->mlock);
 475                 ret = adis16400_spi_write_reg_16(indio_dev,
 476                                 adis16400_addresses[chan->address][1],
 477                                 val);
 478                 mutex_unlock(&indio_dev->mlock);
 479                 return ret;
 480         default:
 481                 return -EINVAL;
 482         }
 483 }
 484
 485 static int adis16400_read_raw(struct iio_dev *indio_dev,
 486                               struct iio_chan_spec const *chan,
 487                               int *val,
 488                               int *val2,
 489                               long mask)
 490 {
 491         struct adis16400_state *st = iio_priv(indio_dev);
 492         int ret;
 493         s16 val16;
 494         int shift;
 495
 496         switch (mask) {
 497         case 0:
 498                 mutex_lock(&indio_dev->mlock);
 499                 ret = adis16400_spi_read_reg_16(indio_dev,
 500                                 adis16400_addresses[chan->address][0],
 501                                 &val16);
 502                 if (ret) {
 503                         mutex_unlock(&indio_dev->mlock);
 504                         return ret;
 505                 }
 506                 val16 &= (1 << chan->scan_type.realbits) - 1;
 507                 if (chan->scan_type.sign == 's') {
 508                         shift = 16 - chan->scan_type.realbits;
 509                         val16 = (s16)(val16 << shift) >> shift;
 510                 }
 511                 *val = val16;
 512                 mutex_unlock(&indio_dev->mlock);
 513                 return IIO_VAL_INT;
 514         case (1 << IIO_CHAN_INFO_SCALE_SHARED):
 515         case (1 << IIO_CHAN_INFO_SCALE_SEPARATE):
 516                 switch (chan->type) {
 517                 case IIO_GYRO:
 518                         *val = 0;
 519                         *val2 = st->variant->gyro_scale_micro;
 520                         return IIO_VAL_INT_PLUS_MICRO;
 521                 case IIO_IN:
 522                         *val = 0;
 523                         if (chan->channel == 0)
 524                                 *val2 = 2418;
 525                         else
 526                                 *val2 = 806;
 527                         return IIO_VAL_INT_PLUS_MICRO;
 528                 case IIO_ACCEL:
 529                         *val = 0;
 530                         *val2 = st->variant->accel_scale_micro;
 531                         return IIO_VAL_INT_PLUS_MICRO;
 532                 case IIO_MAGN:
 533                         *val = 0;
 534                         *val2 = 500;
 535                         return IIO_VAL_INT_PLUS_MICRO;
 536                 case IIO_TEMP:
 537                         *val = 0;
 538                         *val2 = 140000;
 539                         return IIO_VAL_INT_PLUS_MICRO;
 540                 default:
 541                         return -EINVAL;
 542                 }
 543         case (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE):
 544                 mutex_lock(&indio_dev->mlock);
 545                 ret = adis16400_spi_read_reg_16(indio_dev,
 546                                 adis16400_addresses[chan->address][1],
 547                                 &val16);
 548                 mutex_unlock(&indio_dev->mlock);
 549                 if (ret)
 550                         return ret;
 551                 val16 = ((val16 & 0xFFF) << 4) >> 4;
 552                 *val = val16;
 553                 return IIO_VAL_INT;
 554         case (1 << IIO_CHAN_INFO_OFFSET_SEPARATE):
 555                 /* currently only temperature */
 556                 *val = 198;
 557                 *val2 = 160000;
 558                 return IIO_VAL_INT_PLUS_MICRO;
 559         default:
 560                 return -EINVAL;
 561         }
 562 }
 563
 564 static struct iio_chan_spec adis16400_channels[] = {
 565         IIO_CHAN(IIO_IN, 0, 1, 0, "supply", 0, 0,
 566                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 567                  in_supply, ADIS16400_SCAN_SUPPLY,
 568                  IIO_ST('u', 14, 16, 0), 0),
 569         IIO_CHAN(IIO_GYRO, 1, 0, 0, NULL, 0, IIO_MOD_X,
 570                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 571                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 572                  gyro_x, ADIS16400_SCAN_GYRO_X, IIO_ST('s', 14, 16, 0), 0),
 573         IIO_CHAN(IIO_GYRO, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 574                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 575                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 576                  gyro_y, ADIS16400_SCAN_GYRO_Y, IIO_ST('s', 14, 16, 0), 0),
 577         IIO_CHAN(IIO_GYRO, 1, 0, 0, NULL, 0, IIO_MOD_Z,
 578                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 579                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 580                  gyro_z, ADIS16400_SCAN_GYRO_Z, IIO_ST('s', 14, 16, 0), 0),
 581         IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_X,
 582                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 583                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 584                  accel_x, ADIS16400_SCAN_ACC_X, IIO_ST('s', 14, 16, 0), 0),
 585         IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 586                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 587                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 588                  accel_y, ADIS16400_SCAN_ACC_Y, IIO_ST('s', 14, 16, 0), 0),
 589         IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Z,
 590                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 591                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 592                  accel_z, ADIS16400_SCAN_ACC_Z, IIO_ST('s', 14, 16, 0), 0),
 593         IIO_CHAN(IIO_MAGN, 1, 0, 0, NULL, 0, IIO_MOD_X,
 594                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 595                  magn_x, ADIS16400_SCAN_MAGN_X, IIO_ST('s', 14, 16, 0), 0),
 596         IIO_CHAN(IIO_MAGN, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 597                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 598                  magn_y, ADIS16400_SCAN_MAGN_Y, IIO_ST('s', 14, 16, 0), 0),
 599         IIO_CHAN(IIO_MAGN, 1, 0, 0, NULL, 0, IIO_MOD_Z,
 600                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 601                  magn_z, ADIS16400_SCAN_MAGN_Z, IIO_ST('s', 14, 16, 0), 0),
 602         IIO_CHAN(IIO_TEMP, 0, 1, 0, NULL, 0, 0,
 603                  (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
 604                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 605                  temp, ADIS16400_SCAN_TEMP, IIO_ST('s', 12, 16, 0), 0),
 606         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 607                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 608                  in1, ADIS16400_SCAN_ADC_0, IIO_ST('s', 12, 16, 0), 0),
 609         IIO_CHAN_SOFT_TIMESTAMP(12)
 610 };
 611
 612 static struct iio_chan_spec adis16350_channels[] = {
 613         IIO_CHAN(IIO_IN, 0, 1, 0, "supply", 0, 0,
 614                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 615                  0, ADIS16400_SCAN_SUPPLY, IIO_ST('u', 12, 16, 0), 0),
 616         IIO_CHAN(IIO_GYRO, 1, 0, 0, NULL, 0, IIO_MOD_X,
 617                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 618                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 619                  1, ADIS16400_SCAN_GYRO_X, IIO_ST('s', 14, 16, 0), 0),
 620         IIO_CHAN(IIO_GYRO, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 621                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 622                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 623                  2, ADIS16400_SCAN_GYRO_Y, IIO_ST('s', 14, 16, 0), 0),
 624         IIO_CHAN(IIO_GYRO, 1, 0, 0, NULL, 0, IIO_MOD_Z,
 625                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 626                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 627                  3, ADIS16400_SCAN_GYRO_Z, IIO_ST('s', 14, 16, 0), 0),
 628         IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_X,
 629                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 630                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 631                  4, ADIS16400_SCAN_ACC_X, IIO_ST('s', 14, 16, 0), 0),
 632         IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 633                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 634                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 635                  0, ADIS16400_SCAN_ACC_Y, IIO_ST('s', 14, 16, 0), 0),
 636         IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Z,
 637                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 638                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 639                  0, ADIS16400_SCAN_ACC_Z, IIO_ST('s', 14, 16, 0), 0),
 640         IIO_CHAN(IIO_TEMP, 0, 1, 0, "x", 0, 0,
 641                  (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
 642                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 643                  0, ADIS16350_SCAN_TEMP_X, IIO_ST('s', 12, 16, 0), 0),
 644         IIO_CHAN(IIO_TEMP, 0, 1, 0, "y", 1, 0,
 645                  (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
 646                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 647                  0, ADIS16350_SCAN_TEMP_Y, IIO_ST('s', 12, 16, 0), 0),
 648         IIO_CHAN(IIO_TEMP, 0, 1, 0, "z", 2, 0,
 649                  (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
 650                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 651                  0, ADIS16350_SCAN_TEMP_Z, IIO_ST('s', 12, 16, 0), 0),
 652         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 653                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 654                  0, ADIS16350_SCAN_ADC_0, IIO_ST('s', 12, 16, 0), 0),
 655         IIO_CHAN_SOFT_TIMESTAMP(11)
 656 };
 657
 658 static struct iio_chan_spec adis16300_channels[] = {
 659         IIO_CHAN(IIO_IN, 0, 1, 0, "supply", 0, 0,
 660                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 661                  0, ADIS16400_SCAN_SUPPLY, IIO_ST('u', 12, 16, 0), 0),
 662         IIO_CHAN(IIO_GYRO, 1, 0, 0, NULL, 0, IIO_MOD_X,
 663                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 664                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 665                  1, ADIS16400_SCAN_GYRO_X, IIO_ST('s', 14, 16, 0), 0),
 666         IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_X,
 667                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 668                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 669                  4, ADIS16400_SCAN_ACC_X, IIO_ST('s', 14, 16, 0), 0),
 670         IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 671                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 672                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 673                  0, ADIS16400_SCAN_ACC_Y, IIO_ST('s', 14, 16, 0), 0),
 674         IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Z,
 675                  (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
 676                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 677                  0, ADIS16400_SCAN_ACC_Z, IIO_ST('s', 14, 16, 0), 0),
 678         IIO_CHAN(IIO_TEMP, 0, 1, 0, NULL, 0, 0,
 679                  (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
 680                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 681                  0, ADIS16400_SCAN_TEMP, IIO_ST('s', 12, 16, 0), 0),
 682         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 683                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 684                  0, ADIS16350_SCAN_ADC_0, IIO_ST('s', 12, 16, 0), 0),
 685         IIO_CHAN(IIO_INCLI, 1, 0, 0, NULL, 0, IIO_MOD_X,
 686                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 687                  0, ADIS16300_SCAN_INCLI_X, IIO_ST('s', 13, 16, 0), 0),
 688         IIO_CHAN(IIO_INCLI, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 689                  (1 << IIO_CHAN_INFO_SCALE_SHARED),
 690                  0, ADIS16300_SCAN_INCLI_Y, IIO_ST('s', 13, 16, 0), 0),
 691         IIO_CHAN_SOFT_TIMESTAMP(14)
 692 };
 693
 694 static struct attribute *adis16400_attributes[] = {
 695         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 696         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 697         &iio_dev_attr_reset.dev_attr.attr,
 698         NULL
 699 };
 700
 701 static const struct attribute_group adis16400_attribute_group = {
 702         .attrs = adis16400_attributes,
 703 };
 704
 705 static struct adis16400_chip_info adis16400_chips[] = {
 706         [ADIS16300] = {
 707                 .channels = adis16300_channels,
 708                 .num_channels = ARRAY_SIZE(adis16300_channels),
 709                 .gyro_scale_micro = 873,
 710                 .accel_scale_micro = 5884,
 711                 .default_scan_mask = (1 << ADIS16400_SCAN_SUPPLY) |
 712                 (1 << ADIS16400_SCAN_GYRO_X) | (1 << ADIS16400_SCAN_ACC_X) |
 713                 (1 << ADIS16400_SCAN_ACC_Y) | (1 << ADIS16400_SCAN_ACC_Z) |
 714                 (1 << ADIS16400_SCAN_TEMP) | (1 << ADIS16400_SCAN_ADC_0) |
 715                 (1 << ADIS16300_SCAN_INCLI_X) | (1 << ADIS16300_SCAN_INCLI_Y) |
 716                 (1 << 14),
 717         },
 718         [ADIS16350] = {
 719                 .channels = adis16350_channels,
 720                 .num_channels = ARRAY_SIZE(adis16350_channels),
 721                 .gyro_scale_micro = 872664,
 722                 .accel_scale_micro = 24732,
 723                 .default_scan_mask = 0x7FF,
 724                 .flags = ADIS16400_NO_BURST,
 725         },
 726         [ADIS16360] = {
 727                 .channels = adis16350_channels,
 728                 .num_channels = ARRAY_SIZE(adis16350_channels),
 729                 .flags = ADIS16400_HAS_PROD_ID,
 730                 .product_id = 0x3FE8,
 731                 .gyro_scale_micro = 1279,
 732                 .accel_scale_micro = 24732,
 733                 .default_scan_mask = 0x7FF,
 734         },
 735         [ADIS16362] = {
 736                 .channels = adis16350_channels,
 737                 .num_channels = ARRAY_SIZE(adis16350_channels),
 738                 .flags = ADIS16400_HAS_PROD_ID,
 739                 .product_id = 0x3FEA,
 740                 .gyro_scale_micro = 1279,
 741                 .accel_scale_micro = 24732,
 742                 .default_scan_mask = 0x7FF,
 743         },
 744         [ADIS16364] = {
 745                 .channels = adis16350_channels,
 746                 .num_channels = ARRAY_SIZE(adis16350_channels),
 747                 .flags = ADIS16400_HAS_PROD_ID,
 748                 .product_id = 0x3FEC,
 749                 .gyro_scale_micro = 1279,
 750                 .accel_scale_micro = 24732,
 751                 .default_scan_mask = 0x7FF,
 752         },
 753         [ADIS16365] = {
 754                 .channels = adis16350_channels,
 755                 .num_channels = ARRAY_SIZE(adis16350_channels),
 756                 .flags = ADIS16400_HAS_PROD_ID,
 757                 .product_id = 0x3FED,
 758                 .gyro_scale_micro = 1279,
 759                 .accel_scale_micro = 24732,
 760                 .default_scan_mask = 0x7FF,
 761         },
 762         [ADIS16400] = {
 763                 .channels = adis16400_channels,
 764                 .num_channels = ARRAY_SIZE(adis16400_channels),
 765                 .flags = ADIS16400_HAS_PROD_ID,
 766                 .product_id = 0x4015,
 767                 .gyro_scale_micro = 873,
 768                 .accel_scale_micro = 32656,
 769                 .default_scan_mask = 0xFFF,
 770         }
 771 };
 772
 773 static const struct iio_info adis16400_info = {
 774         .driver_module = THIS_MODULE,
 775         .read_raw = &adis16400_read_raw,
 776         .write_raw = &adis16400_write_raw,
 777         .attrs = &adis16400_attribute_group,
 778 };
 779
 780 static int __devinit adis16400_probe(struct spi_device *spi)
 781 {
 782         int ret, regdone = 0;
 783         struct adis16400_state *st;
 784         struct iio_dev *indio_dev = iio_allocate_device(sizeof(*st));
 785         if (indio_dev == NULL) {
 786                 ret =  -ENOMEM;
 787                 goto error_ret;
 788         }
 789         st = iio_priv(indio_dev);
 790         /* this is only used for removal purposes */
 791         spi_set_drvdata(spi, indio_dev);
 792
 793         st->us = spi;
 794         mutex_init(&st->buf_lock);
 795
 796         /* setup the industrialio driver allocated elements */
 797         st->variant = &adis16400_chips[spi_get_device_id(spi)->driver_data];
 798         indio_dev->dev.parent = &spi->dev;
 799         indio_dev->name = spi_get_device_id(spi)->name;
 800         indio_dev->channels = st->variant->channels;
 801         indio_dev->num_channels = st->variant->num_channels;
 802         indio_dev->info = &adis16400_info;
 803         indio_dev->modes = INDIO_DIRECT_MODE;
 804
 805         ret = adis16400_configure_ring(indio_dev);
 806         if (ret)
 807                 goto error_free_dev;
 808
 809         ret = iio_device_register(indio_dev);
 810         if (ret)
 811                 goto error_unreg_ring_funcs;
 812         regdone = 1;
 813
 814         ret = iio_ring_buffer_register_ex(indio_dev->ring, 0,
 815                                           st->variant->channels,
 816                                           st->variant->num_channels);
 817         if (ret) {
 818                 dev_err(&spi->dev, "failed to initialize the ring\n");
 819                 goto error_unreg_ring_funcs;
 820         }
 821
 822         if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) {
 823                 ret = adis16400_probe_trigger(indio_dev);
 824                 if (ret)
 825                         goto error_uninitialize_ring;
 826         }
 827
 828         /* Get the device into a sane initial state */
 829         ret = adis16400_initial_setup(indio_dev);
 830         if (ret)
 831                 goto error_remove_trigger;
 832         return 0;
 833
 834 error_remove_trigger:
 835         if (indio_dev->modes & INDIO_RING_TRIGGERED)
 836                 adis16400_remove_trigger(indio_dev);
 837 error_uninitialize_ring:
 838         iio_ring_buffer_unregister(indio_dev->ring);
 839 error_unreg_ring_funcs:
 840         adis16400_unconfigure_ring(indio_dev);
 841 error_free_dev:
 842         if (regdone)
 843                 iio_device_unregister(indio_dev);
 844         else
 845                 iio_free_device(indio_dev);
 846 error_ret:
 847         return ret;
 848 }
 849
 850 /* fixme, confirm ordering in this function */
 851 static int adis16400_remove(struct spi_device *spi)
 852 {
 853         int ret;
 854         struct iio_dev *indio_dev =  spi_get_drvdata(spi);
 855
 856         ret = adis16400_stop_device(indio_dev);
 857         if (ret)
 858                 goto err_ret;
 859
 860         adis16400_remove_trigger(indio_dev);
 861         iio_ring_buffer_unregister(indio_dev->ring);
 862         adis16400_unconfigure_ring(indio_dev);
 863         iio_device_unregister(indio_dev);
 864
 865         return 0;
 866
 867 err_ret:
 868         return ret;
 869 }
 870
 871 static const struct spi_device_id adis16400_id[] = {
 872         {"adis16300", ADIS16300},
 873         {"adis16350", ADIS16350},
 874         {"adis16354", ADIS16350},
 875         {"adis16355", ADIS16350},
 876         {"adis16360", ADIS16360},
 877         {"adis16362", ADIS16362},
 878         {"adis16364", ADIS16364},
 879         {"adis16365", ADIS16365},
 880         {"adis16400", ADIS16400},
 881         {"adis16405", ADIS16400},
 882         {}
 883 };
 884
 885 static struct spi_driver adis16400_driver = {
 886         .driver = {
 887                 .name = "adis16400",
 888                 .owner = THIS_MODULE,
 889         },
 890         .id_table = adis16400_id,
 891         .probe = adis16400_probe,
 892         .remove = __devexit_p(adis16400_remove),
 893 };
 894
 895 static __init int adis16400_init(void)
 896 {
 897         return spi_register_driver(&adis16400_driver);
 898 }
 899 module_init(adis16400_init);
 900
 901 static __exit void adis16400_exit(void)
 902 {
 903         spi_unregister_driver(&adis16400_driver);
 904 }
 905 module_exit(adis16400_exit);
 906
 907 MODULE_AUTHOR("Manuel Stahl <manuel.stahl@iis.fraunhofer.de>");
 908 MODULE_DESCRIPTION("Analog Devices ADIS16400/5 IMU SPI driver");
 909 MODULE_LICENSE("GPL v2");