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