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 <linux/iio/iio.h>
  30 #include <linux/iio/sysfs.h>
  31 #include <linux/iio/buffer.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 int adis16400_get_freq(struct iio_dev *indio_dev)
 165 {
 166         u16 t;
 167         int sps, ret;
 168
 169         ret = adis16400_spi_read_reg_16(indio_dev, ADIS16400_SMPL_PRD, &t);
 170         if (ret < 0)
 171                 return ret;
 172         sps =  (t & ADIS16400_SMPL_PRD_TIME_BASE) ? 53 : 1638;
 173         sps /= (t & ADIS16400_SMPL_PRD_DIV_MASK) + 1;
 174
 175         return sps;
 176 }
 177
 178 static ssize_t adis16400_read_frequency(struct device *dev,
 179                 struct device_attribute *attr,
 180                 char *buf)
 181 {
 182         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 183         int ret, len = 0;
 184         ret = adis16400_get_freq(indio_dev);
 185         if (ret < 0)
 186                 return ret;
 187         len = sprintf(buf, "%d SPS\n", ret);
 188         return len;
 189 }
 190
 191 static const unsigned adis16400_3db_divisors[] = {
 192         [0] = 2, /* Special case */
 193         [1] = 5,
 194         [2] = 10,
 195         [3] = 50,
 196         [4] = 200,
 197 };
 198
 199 static int adis16400_set_filter(struct iio_dev *indio_dev, int sps, int val)
 200 {
 201         int i, ret;
 202         u16 val16;
 203         for (i = ARRAY_SIZE(adis16400_3db_divisors) - 1; i >= 0; i--)
 204                 if (sps/adis16400_3db_divisors[i] > val)
 205                         break;
 206         if (i == -1)
 207                 ret = -EINVAL;
 208         else {
 209                 ret = adis16400_spi_read_reg_16(indio_dev,
 210                                                 ADIS16400_SENS_AVG,
 211                                                 &val16);
 212                 if (ret < 0)
 213                         goto error_ret;
 214
 215                 ret = adis16400_spi_write_reg_16(indio_dev,
 216                                                  ADIS16400_SENS_AVG,
 217                                                  (val16 & ~0x03) | i);
 218         }
 219 error_ret:
 220         return ret;
 221 }
 222
 223 static ssize_t adis16400_write_frequency(struct device *dev,
 224                 struct device_attribute *attr,
 225                 const char *buf,
 226                 size_t len)
 227 {
 228         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 229         struct adis16400_state *st = iio_priv(indio_dev);
 230         long val;
 231         int ret;
 232         u8 t;
 233
 234         ret = strict_strtol(buf, 10, &val);
 235         if (ret)
 236                 return ret;
 237
 238         mutex_lock(&indio_dev->mlock);
 239
 240         t = (1638 / val);
 241         if (t > 0)
 242                 t--;
 243         t &= ADIS16400_SMPL_PRD_DIV_MASK;
 244         if ((t & ADIS16400_SMPL_PRD_DIV_MASK) >= 0x0A)
 245                 st->us->max_speed_hz = ADIS16400_SPI_SLOW;
 246         else
 247                 st->us->max_speed_hz = ADIS16400_SPI_FAST;
 248
 249         ret = adis16400_spi_write_reg_8(indio_dev,
 250                         ADIS16400_SMPL_PRD,
 251                         t);
 252
 253         /* Also update the filter */
 254         mutex_unlock(&indio_dev->mlock);
 255
 256         return ret ? ret : len;
 257 }
 258
 259 static int adis16400_reset(struct iio_dev *indio_dev)
 260 {
 261         int ret;
 262         ret = adis16400_spi_write_reg_8(indio_dev,
 263                         ADIS16400_GLOB_CMD,
 264                         ADIS16400_GLOB_CMD_SW_RESET);
 265         if (ret)
 266                 dev_err(&indio_dev->dev, "problem resetting device");
 267
 268         return ret;
 269 }
 270
 271 int adis16400_set_irq(struct iio_dev *indio_dev, bool enable)
 272 {
 273         int ret;
 274         u16 msc;
 275
 276         ret = adis16400_spi_read_reg_16(indio_dev, ADIS16400_MSC_CTRL, &msc);
 277         if (ret)
 278                 goto error_ret;
 279
 280         msc |= ADIS16400_MSC_CTRL_DATA_RDY_POL_HIGH;
 281         if (enable)
 282                 msc |= ADIS16400_MSC_CTRL_DATA_RDY_EN;
 283         else
 284                 msc &= ~ADIS16400_MSC_CTRL_DATA_RDY_EN;
 285
 286         ret = adis16400_spi_write_reg_16(indio_dev, ADIS16400_MSC_CTRL, msc);
 287         if (ret)
 288                 goto error_ret;
 289
 290 error_ret:
 291         return ret;
 292 }
 293
 294 /* Power down the device */
 295 static int adis16400_stop_device(struct iio_dev *indio_dev)
 296 {
 297         int ret;
 298         u16 val = ADIS16400_SLP_CNT_POWER_OFF;
 299
 300         ret = adis16400_spi_write_reg_16(indio_dev, ADIS16400_SLP_CNT, val);
 301         if (ret)
 302                 dev_err(&indio_dev->dev,
 303                         "problem with turning device off: SLP_CNT");
 304
 305         return ret;
 306 }
 307
 308 static int adis16400_check_status(struct iio_dev *indio_dev)
 309 {
 310         u16 status;
 311         int ret;
 312         struct device *dev = &indio_dev->dev;
 313
 314         ret = adis16400_spi_read_reg_16(indio_dev,
 315                                         ADIS16400_DIAG_STAT, &status);
 316
 317         if (ret < 0) {
 318                 dev_err(dev, "Reading status failed\n");
 319                 goto error_ret;
 320         }
 321         ret = status;
 322         if (status & ADIS16400_DIAG_STAT_ZACCL_FAIL)
 323                 dev_err(dev, "Z-axis accelerometer self-test failure\n");
 324         if (status & ADIS16400_DIAG_STAT_YACCL_FAIL)
 325                 dev_err(dev, "Y-axis accelerometer self-test failure\n");
 326         if (status & ADIS16400_DIAG_STAT_XACCL_FAIL)
 327                 dev_err(dev, "X-axis accelerometer self-test failure\n");
 328         if (status & ADIS16400_DIAG_STAT_XGYRO_FAIL)
 329                 dev_err(dev, "X-axis gyroscope self-test failure\n");
 330         if (status & ADIS16400_DIAG_STAT_YGYRO_FAIL)
 331                 dev_err(dev, "Y-axis gyroscope self-test failure\n");
 332         if (status & ADIS16400_DIAG_STAT_ZGYRO_FAIL)
 333                 dev_err(dev, "Z-axis gyroscope self-test failure\n");
 334         if (status & ADIS16400_DIAG_STAT_ALARM2)
 335                 dev_err(dev, "Alarm 2 active\n");
 336         if (status & ADIS16400_DIAG_STAT_ALARM1)
 337                 dev_err(dev, "Alarm 1 active\n");
 338         if (status & ADIS16400_DIAG_STAT_FLASH_CHK)
 339                 dev_err(dev, "Flash checksum error\n");
 340         if (status & ADIS16400_DIAG_STAT_SELF_TEST)
 341                 dev_err(dev, "Self test error\n");
 342         if (status & ADIS16400_DIAG_STAT_OVERFLOW)
 343                 dev_err(dev, "Sensor overrange\n");
 344         if (status & ADIS16400_DIAG_STAT_SPI_FAIL)
 345                 dev_err(dev, "SPI failure\n");
 346         if (status & ADIS16400_DIAG_STAT_FLASH_UPT)
 347                 dev_err(dev, "Flash update failed\n");
 348         if (status & ADIS16400_DIAG_STAT_POWER_HIGH)
 349                 dev_err(dev, "Power supply above 5.25V\n");
 350         if (status & ADIS16400_DIAG_STAT_POWER_LOW)
 351                 dev_err(dev, "Power supply below 4.75V\n");
 352
 353 error_ret:
 354         return ret;
 355 }
 356
 357 static int adis16400_self_test(struct iio_dev *indio_dev)
 358 {
 359         int ret;
 360         ret = adis16400_spi_write_reg_16(indio_dev,
 361                         ADIS16400_MSC_CTRL,
 362                         ADIS16400_MSC_CTRL_MEM_TEST);
 363         if (ret) {
 364                 dev_err(&indio_dev->dev, "problem starting self test");
 365                 goto err_ret;
 366         }
 367
 368         msleep(ADIS16400_MTEST_DELAY);
 369         adis16400_check_status(indio_dev);
 370
 371 err_ret:
 372         return ret;
 373 }
 374
 375 static int adis16400_initial_setup(struct iio_dev *indio_dev)
 376 {
 377         int ret;
 378         u16 prod_id, smp_prd;
 379         struct adis16400_state *st = iio_priv(indio_dev);
 380
 381         /* use low spi speed for init */
 382         st->us->max_speed_hz = ADIS16400_SPI_SLOW;
 383         st->us->mode = SPI_MODE_3;
 384         spi_setup(st->us);
 385
 386         ret = adis16400_set_irq(indio_dev, false);
 387         if (ret) {
 388                 dev_err(&indio_dev->dev, "disable irq failed");
 389                 goto err_ret;
 390         }
 391
 392         ret = adis16400_self_test(indio_dev);
 393         if (ret) {
 394                 dev_err(&indio_dev->dev, "self test failure");
 395                 goto err_ret;
 396         }
 397
 398         ret = adis16400_check_status(indio_dev);
 399         if (ret) {
 400                 adis16400_reset(indio_dev);
 401                 dev_err(&indio_dev->dev, "device not playing ball -> reset");
 402                 msleep(ADIS16400_STARTUP_DELAY);
 403                 ret = adis16400_check_status(indio_dev);
 404                 if (ret) {
 405                         dev_err(&indio_dev->dev, "giving up");
 406                         goto err_ret;
 407                 }
 408         }
 409         if (st->variant->flags & ADIS16400_HAS_PROD_ID) {
 410                 ret = adis16400_spi_read_reg_16(indio_dev,
 411                                                 ADIS16400_PRODUCT_ID, &prod_id);
 412                 if (ret)
 413                         goto err_ret;
 414
 415                 if ((prod_id & 0xF000) != st->variant->product_id)
 416                         dev_warn(&indio_dev->dev, "incorrect id");
 417
 418                 dev_info(&indio_dev->dev, "%s: prod_id 0x%04x at CS%d (irq %d)\n",
 419                        indio_dev->name, prod_id,
 420                        st->us->chip_select, st->us->irq);
 421         }
 422         /* use high spi speed if possible */
 423         ret = adis16400_spi_read_reg_16(indio_dev,
 424                                         ADIS16400_SMPL_PRD, &smp_prd);
 425         if (!ret && (smp_prd & ADIS16400_SMPL_PRD_DIV_MASK) < 0x0A) {
 426                 st->us->max_speed_hz = ADIS16400_SPI_SLOW;
 427                 spi_setup(st->us);
 428         }
 429
 430 err_ret:
 431         return ret;
 432 }
 433
 434 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 435                               adis16400_read_frequency,
 436                               adis16400_write_frequency);
 437
 438 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("409 546 819 1638");
 439
 440 enum adis16400_chan {
 441         in_supply,
 442         gyro_x,
 443         gyro_y,
 444         gyro_z,
 445         accel_x,
 446         accel_y,
 447         accel_z,
 448         magn_x,
 449         magn_y,
 450         magn_z,
 451         temp,
 452         temp0, temp1, temp2,
 453         in1,
 454         in2,
 455         incli_x,
 456         incli_y,
 457 };
 458
 459 static u8 adis16400_addresses[18][2] = {
 460         [in_supply] = { ADIS16400_SUPPLY_OUT },
 461         [gyro_x] = { ADIS16400_XGYRO_OUT, ADIS16400_XGYRO_OFF },
 462         [gyro_y] = { ADIS16400_YGYRO_OUT, ADIS16400_YGYRO_OFF },
 463         [gyro_z] = { ADIS16400_ZGYRO_OUT, ADIS16400_ZGYRO_OFF },
 464         [accel_x] = { ADIS16400_XACCL_OUT, ADIS16400_XACCL_OFF },
 465         [accel_y] = { ADIS16400_YACCL_OUT, ADIS16400_YACCL_OFF },
 466         [accel_z] = { ADIS16400_ZACCL_OUT, ADIS16400_ZACCL_OFF },
 467         [magn_x] = { ADIS16400_XMAGN_OUT },
 468         [magn_y] = { ADIS16400_YMAGN_OUT },
 469         [magn_z] = { ADIS16400_ZMAGN_OUT },
 470         [temp] = { ADIS16400_TEMP_OUT },
 471         [temp0] = { ADIS16350_XTEMP_OUT },
 472         [temp1] = { ADIS16350_YTEMP_OUT },
 473         [temp2] = { ADIS16350_ZTEMP_OUT },
 474         [in1] = { ADIS16300_AUX_ADC },
 475         [in2] = { ADIS16400_AUX_ADC },
 476         [incli_x] = { ADIS16300_PITCH_OUT },
 477         [incli_y] = { ADIS16300_ROLL_OUT }
 478 };
 479
 480
 481 static int adis16400_write_raw(struct iio_dev *indio_dev,
 482                                struct iio_chan_spec const *chan,
 483                                int val,
 484                                int val2,
 485                                long mask)
 486 {
 487         struct adis16400_state *st = iio_priv(indio_dev);
 488         int ret, sps;
 489
 490         switch (mask) {
 491         case IIO_CHAN_INFO_CALIBBIAS:
 492                 mutex_lock(&indio_dev->mlock);
 493                 ret = adis16400_spi_write_reg_16(indio_dev,
 494                                 adis16400_addresses[chan->address][1],
 495                                 val);
 496                 mutex_unlock(&indio_dev->mlock);
 497                 return ret;
 498         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 499                 /* Need to cache values so we can update if the frequency
 500                    changes */
 501                 mutex_lock(&indio_dev->mlock);
 502                 st->filt_int = val;
 503                 /* Work out update to current value */
 504                 sps = adis16400_get_freq(indio_dev);
 505                 if (sps < 0) {
 506                         mutex_unlock(&indio_dev->mlock);
 507                         return sps;
 508                 }
 509
 510                 ret = adis16400_set_filter(indio_dev, sps, val);
 511                 mutex_unlock(&indio_dev->mlock);
 512                 return ret;
 513         default:
 514                 return -EINVAL;
 515         }
 516 }
 517
 518 static int adis16400_read_raw(struct iio_dev *indio_dev,
 519                               struct iio_chan_spec const *chan,
 520                               int *val,
 521                               int *val2,
 522                               long mask)
 523 {
 524         struct adis16400_state *st = iio_priv(indio_dev);
 525         int ret, shift;
 526         s16 val16;
 527
 528         switch (mask) {
 529         case IIO_CHAN_INFO_RAW:
 530                 mutex_lock(&indio_dev->mlock);
 531                 ret = adis16400_spi_read_reg_16(indio_dev,
 532                                 adis16400_addresses[chan->address][0],
 533                                 &val16);
 534                 if (ret) {
 535                         mutex_unlock(&indio_dev->mlock);
 536                         return ret;
 537                 }
 538                 val16 &= (1 << chan->scan_type.realbits) - 1;
 539                 if (chan->scan_type.sign == 's') {
 540                         shift = 16 - chan->scan_type.realbits;
 541                         val16 = (s16)(val16 << shift) >> shift;
 542                 }
 543                 *val = val16;
 544                 mutex_unlock(&indio_dev->mlock);
 545                 return IIO_VAL_INT;
 546         case IIO_CHAN_INFO_SCALE:
 547                 switch (chan->type) {
 548                 case IIO_ANGL_VEL:
 549                         *val = 0;
 550                         *val2 = st->variant->gyro_scale_micro;
 551                         return IIO_VAL_INT_PLUS_MICRO;
 552                 case IIO_VOLTAGE:
 553                         *val = 0;
 554                         if (chan->channel == 0)
 555                                 *val2 = 2418;
 556                         else
 557                                 *val2 = 806;
 558                         return IIO_VAL_INT_PLUS_MICRO;
 559                 case IIO_ACCEL:
 560                         *val = 0;
 561                         *val2 = st->variant->accel_scale_micro;
 562                         return IIO_VAL_INT_PLUS_MICRO;
 563                 case IIO_MAGN:
 564                         *val = 0;
 565                         *val2 = 500;
 566                         return IIO_VAL_INT_PLUS_MICRO;
 567                 case IIO_TEMP:
 568                         *val = 0;
 569                         *val2 = 140000;
 570                         return IIO_VAL_INT_PLUS_MICRO;
 571                 default:
 572                         return -EINVAL;
 573                 }
 574         case IIO_CHAN_INFO_CALIBBIAS:
 575                 mutex_lock(&indio_dev->mlock);
 576                 ret = adis16400_spi_read_reg_16(indio_dev,
 577                                 adis16400_addresses[chan->address][1],
 578                                 &val16);
 579                 mutex_unlock(&indio_dev->mlock);
 580                 if (ret)
 581                         return ret;
 582                 val16 = ((val16 & 0xFFF) << 4) >> 4;
 583                 *val = val16;
 584                 return IIO_VAL_INT;
 585         case IIO_CHAN_INFO_OFFSET:
 586                 /* currently only temperature */
 587                 *val = 198;
 588                 *val2 = 160000;
 589                 return IIO_VAL_INT_PLUS_MICRO;
 590         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 591                 mutex_lock(&indio_dev->mlock);
 592                 /* Need both the number of taps and the sampling frequency */
 593                 ret = adis16400_spi_read_reg_16(indio_dev,
 594                                                 ADIS16400_SENS_AVG,
 595                                                 &val16);
 596                 if (ret < 0) {
 597                         mutex_unlock(&indio_dev->mlock);
 598                         return ret;
 599                 }
 600                 ret = adis16400_get_freq(indio_dev);
 601                 if (ret > 0)
 602                         *val = ret/adis16400_3db_divisors[val16 & 0x03];
 603                 *val2 = 0;
 604                 mutex_unlock(&indio_dev->mlock);
 605                 if (ret < 0)
 606                         return ret;
 607                 return IIO_VAL_INT_PLUS_MICRO;
 608         default:
 609                 return -EINVAL;
 610         }
 611 }
 612
 613 static struct iio_chan_spec adis16400_channels[] = {
 614         {
 615                 .type = IIO_VOLTAGE,
 616                 .indexed = 1,
 617                 .channel = 0,
 618                 .extend_name = "supply",
 619                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 620                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
 621                 .address = in_supply,
 622                 .scan_index = ADIS16400_SCAN_SUPPLY,
 623                 .scan_type = IIO_ST('u', 14, 16, 0)
 624         }, {
 625                 .type = IIO_ANGL_VEL,
 626                 .modified = 1,
 627                 .channel2 = IIO_MOD_X,
 628                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 629                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 630                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 631                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 632                 .address = gyro_x,
 633                 .scan_index = ADIS16400_SCAN_GYRO_X,
 634                 .scan_type = IIO_ST('s', 14, 16, 0)
 635         }, {
 636                 .type = IIO_ANGL_VEL,
 637                 .modified = 1,
 638                 .channel2 = IIO_MOD_Y,
 639                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 640                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 641                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 642                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 643                 .address = gyro_y,
 644                 .scan_index = ADIS16400_SCAN_GYRO_Y,
 645                 .scan_type = IIO_ST('s', 14, 16, 0),
 646         }, {
 647                 .type = IIO_ANGL_VEL,
 648                 .modified = 1,
 649                 .channel2 = IIO_MOD_Z,
 650                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 651                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 652                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 653                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 654                 .address = gyro_z,
 655                 .scan_index = ADIS16400_SCAN_GYRO_Z,
 656                 .scan_type = IIO_ST('s', 14, 16, 0),
 657         }, {
 658                 .type = IIO_ACCEL,
 659                 .modified = 1,
 660                 .channel2 = IIO_MOD_X,
 661                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 662                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 663                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 664                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 665                 .address = accel_x,
 666                 .scan_index = ADIS16400_SCAN_ACC_X,
 667                 .scan_type = IIO_ST('s', 14, 16, 0),
 668         }, {
 669                 .type = IIO_ACCEL,
 670                 .modified = 1,
 671                 .channel2 = IIO_MOD_Y,
 672                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 673                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 674                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 675                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 676                 .address = accel_y,
 677                 .scan_index = ADIS16400_SCAN_ACC_Y,
 678                 .scan_type = IIO_ST('s', 14, 16, 0),
 679         }, {
 680                 .type = IIO_ACCEL,
 681                 .modified = 1,
 682                 .channel2 = IIO_MOD_Z,
 683                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 684                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 685                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 686                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 687                 .address = accel_z,
 688                 .scan_index = ADIS16400_SCAN_ACC_Z,
 689                 .scan_type = IIO_ST('s', 14, 16, 0),
 690         }, {
 691                 .type = IIO_MAGN,
 692                 .modified = 1,
 693                 .channel2 = IIO_MOD_X,
 694                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 695                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 696                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 697                 .address = magn_x,
 698                 .scan_index = ADIS16400_SCAN_MAGN_X,
 699                 .scan_type = IIO_ST('s', 14, 16, 0),
 700         }, {
 701                 .type = IIO_MAGN,
 702                 .modified = 1,
 703                 .channel2 = IIO_MOD_Y,
 704                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 705                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 706                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 707                 .address = magn_y,
 708                 .scan_index = ADIS16400_SCAN_MAGN_Y,
 709                 .scan_type = IIO_ST('s', 14, 16, 0),
 710         }, {
 711                 .type = IIO_MAGN,
 712                 .modified = 1,
 713                 .channel2 = IIO_MOD_Z,
 714                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 715                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 716                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 717                 .address = magn_z,
 718                 .scan_index = ADIS16400_SCAN_MAGN_Z,
 719                 .scan_type = IIO_ST('s', 14, 16, 0),
 720         }, {
 721                 .type = IIO_TEMP,
 722                 .indexed = 1,
 723                 .channel = 0,
 724                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 725                 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT |
 726                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
 727                 .address = temp,
 728                 .scan_index = ADIS16400_SCAN_TEMP,
 729                 .scan_type = IIO_ST('s', 12, 16, 0),
 730         }, {
 731                 .type = IIO_VOLTAGE,
 732                 .indexed = 1,
 733                 .channel = 1,
 734                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 735                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
 736                 .address = in2,
 737                 .scan_index = ADIS16400_SCAN_ADC_0,
 738                 .scan_type = IIO_ST('s', 12, 16, 0),
 739         },
 740         IIO_CHAN_SOFT_TIMESTAMP(12)
 741 };
 742
 743 static struct iio_chan_spec adis16350_channels[] = {
 744         {
 745                 .type = IIO_VOLTAGE,
 746                 .indexed = 1,
 747                 .channel = 0,
 748                 .extend_name = "supply",
 749                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 750                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
 751                 .address = in_supply,
 752                 .scan_index = ADIS16400_SCAN_SUPPLY,
 753                 .scan_type = IIO_ST('u', 12, 16, 0)
 754         }, {
 755                 .type = IIO_ANGL_VEL,
 756                 .modified = 1,
 757                 .channel2 = IIO_MOD_X,
 758                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 759                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 760                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 761                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 762                 .address = gyro_x,
 763                 .scan_index = ADIS16400_SCAN_GYRO_X,
 764                 .scan_type = IIO_ST('s', 14, 16, 0)
 765         }, {
 766                 .type = IIO_ANGL_VEL,
 767                 .modified = 1,
 768                 .channel2 = IIO_MOD_Y,
 769                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 770                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 771                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 772                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 773                 .address = gyro_y,
 774                 .scan_index = ADIS16400_SCAN_GYRO_Y,
 775                 .scan_type = IIO_ST('s', 14, 16, 0),
 776         }, {
 777                 .type = IIO_ANGL_VEL,
 778                 .modified = 1,
 779                 .channel2 = IIO_MOD_Z,
 780                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 781                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 782                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 783                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 784                 .address = gyro_z,
 785                 .scan_index = ADIS16400_SCAN_GYRO_Z,
 786                 .scan_type = IIO_ST('s', 14, 16, 0),
 787         }, {
 788                 .type = IIO_ACCEL,
 789                 .modified = 1,
 790                 .channel2 = IIO_MOD_X,
 791                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 792                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 793                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 794                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 795                 .address = accel_x,
 796                 .scan_index = ADIS16400_SCAN_ACC_X,
 797                 .scan_type = IIO_ST('s', 14, 16, 0),
 798         }, {
 799                 .type = IIO_ACCEL,
 800                 .modified = 1,
 801                 .channel2 = IIO_MOD_Y,
 802                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 803                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 804                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 805                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 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 = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 814                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 815                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 816                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 817                 .address = accel_z,
 818                 .scan_index = ADIS16400_SCAN_ACC_Z,
 819                 .scan_type = IIO_ST('s', 14, 16, 0),
 820         }, {
 821                 .type = IIO_TEMP,
 822                 .indexed = 1,
 823                 .channel = 0,
 824                 .extend_name = "x",
 825                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 826                 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT |
 827                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT |
 828                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 829                 .address = temp0,
 830                 .scan_index = ADIS16350_SCAN_TEMP_X,
 831                 .scan_type = IIO_ST('s', 12, 16, 0),
 832         }, {
 833                 .type = IIO_TEMP,
 834                 .indexed = 1,
 835                 .channel = 1,
 836                 .extend_name = "y",
 837                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 838                 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT |
 839                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT |
 840                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 841                 .address = temp1,
 842                 .scan_index = ADIS16350_SCAN_TEMP_Y,
 843                 .scan_type = IIO_ST('s', 12, 16, 0),
 844         }, {
 845                 .type = IIO_TEMP,
 846                 .indexed = 1,
 847                 .channel = 2,
 848                 .extend_name = "z",
 849                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 850                 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT |
 851                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
 852                 .address = temp2,
 853                 .scan_index = ADIS16350_SCAN_TEMP_Z,
 854                 .scan_type = IIO_ST('s', 12, 16, 0),
 855         }, {
 856                 .type = IIO_VOLTAGE,
 857                 .indexed = 1,
 858                 .channel = 1,
 859                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 860                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
 861                 .address = in1,
 862                 .scan_index = ADIS16350_SCAN_ADC_0,
 863                 .scan_type = IIO_ST('s', 12, 16, 0),
 864         },
 865         IIO_CHAN_SOFT_TIMESTAMP(11)
 866 };
 867
 868 static struct iio_chan_spec adis16300_channels[] = {
 869         {
 870                 .type = IIO_VOLTAGE,
 871                 .indexed = 1,
 872                 .channel = 0,
 873                 .extend_name = "supply",
 874                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 875                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
 876                 .address = in_supply,
 877                 .scan_index = ADIS16400_SCAN_SUPPLY,
 878                 .scan_type = IIO_ST('u', 12, 16, 0)
 879         }, {
 880                 .type = IIO_ANGL_VEL,
 881                 .modified = 1,
 882                 .channel2 = IIO_MOD_X,
 883                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 884                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 885                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 886                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 887                 .address = gyro_x,
 888                 .scan_index = ADIS16400_SCAN_GYRO_X,
 889                 .scan_type = IIO_ST('s', 14, 16, 0),
 890         }, {
 891                 .type = IIO_ACCEL,
 892                 .modified = 1,
 893                 .channel2 = IIO_MOD_X,
 894                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 895                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 896                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 897                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 898                 .address = accel_x,
 899                 .scan_index = ADIS16400_SCAN_ACC_X,
 900                 .scan_type = IIO_ST('s', 14, 16, 0),
 901         }, {
 902                 .type = IIO_ACCEL,
 903                 .modified = 1,
 904                 .channel2 = IIO_MOD_Y,
 905                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 906                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 907                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 908                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 909                 .address = accel_y,
 910                 .scan_index = ADIS16400_SCAN_ACC_Y,
 911                 .scan_type = IIO_ST('s', 14, 16, 0),
 912         }, {
 913                 .type = IIO_ACCEL,
 914                 .modified = 1,
 915                 .channel2 = IIO_MOD_Z,
 916                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 917                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 918                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 919                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 920                 .address = accel_z,
 921                 .scan_index = ADIS16400_SCAN_ACC_Z,
 922                 .scan_type = IIO_ST('s', 14, 16, 0),
 923         }, {
 924                 .type = IIO_TEMP,
 925                 .indexed = 1,
 926                 .channel = 0,
 927                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 928                 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT |
 929                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
 930                 .address = temp0,
 931                 .scan_index = ADIS16400_SCAN_TEMP,
 932                 .scan_type = IIO_ST('s', 12, 16, 0),
 933         }, {
 934                 .type = IIO_VOLTAGE,
 935                 .indexed = 1,
 936                 .channel = 1,
 937                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 938                 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
 939                 .address = in1,
 940                 .scan_index = ADIS16350_SCAN_ADC_0,
 941                 .scan_type = IIO_ST('s', 12, 16, 0),
 942         }, {
 943                 .type = IIO_INCLI,
 944                 .modified = 1,
 945                 .channel2 = IIO_MOD_X,
 946                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 947                 IIO_CHAN_INFO_SCALE_SHARED_BIT,
 948                 .address = incli_x,
 949                 .scan_index = ADIS16300_SCAN_INCLI_X,
 950                 .scan_type = IIO_ST('s', 13, 16, 0),
 951         }, {
 952                 .type = IIO_INCLI,
 953                 .modified = 1,
 954                 .channel2 = IIO_MOD_Y,
 955                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 956                 IIO_CHAN_INFO_SCALE_SHARED_BIT,
 957                 .address = incli_y,
 958                 .scan_index = ADIS16300_SCAN_INCLI_Y,
 959                 .scan_type = IIO_ST('s', 13, 16, 0),
 960         },
 961         IIO_CHAN_SOFT_TIMESTAMP(14)
 962 };
 963
 964 static const struct iio_chan_spec adis16334_channels[] = {
 965         {
 966                 .type = IIO_ANGL_VEL,
 967                 .modified = 1,
 968                 .channel2 = IIO_MOD_X,
 969                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 970                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 971                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 972                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 973                 .address = gyro_x,
 974                 .scan_index = ADIS16400_SCAN_GYRO_X,
 975                 .scan_type = IIO_ST('s', 14, 16, 0),
 976         }, {
 977                 .type = IIO_ANGL_VEL,
 978                 .modified = 1,
 979                 .channel2 = IIO_MOD_Y,
 980                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 981                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 982                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 983                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 984                 .address = gyro_y,
 985                 .scan_index = ADIS16400_SCAN_GYRO_Y,
 986                 .scan_type = IIO_ST('s', 14, 16, 0),
 987         }, {
 988                 .type = IIO_ANGL_VEL,
 989                 .modified = 1,
 990                 .channel2 = IIO_MOD_Z,
 991                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
 992                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
 993                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
 994                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
 995                 .address = gyro_z,
 996                 .scan_index = ADIS16400_SCAN_GYRO_Z,
 997                 .scan_type = IIO_ST('s', 14, 16, 0),
 998         }, {
 999                 .type = IIO_ACCEL,
1000                 .modified = 1,
1001                 .channel2 = IIO_MOD_X,
1002                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
1003                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
1004                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
1005                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
1006                 .address = accel_x,
1007                 .scan_index = ADIS16400_SCAN_ACC_X,
1008                 .scan_type = IIO_ST('s', 14, 16, 0),
1009         }, {
1010                 .type = IIO_ACCEL,
1011                 .modified = 1,
1012                 .channel2 = IIO_MOD_Y,
1013                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
1014                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
1015                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
1016                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
1017                 .address = accel_y,
1018                 .scan_index = ADIS16400_SCAN_ACC_Y,
1019                 .scan_type = IIO_ST('s', 14, 16, 0),
1020         }, {
1021                 .type = IIO_ACCEL,
1022                 .modified = 1,
1023                 .channel2 = IIO_MOD_Z,
1024                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
1025                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
1026                 IIO_CHAN_INFO_SCALE_SHARED_BIT |
1027                 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT,
1028                 .address = accel_z,
1029                 .scan_index = ADIS16400_SCAN_ACC_Z,
1030                 .scan_type = IIO_ST('s', 14, 16, 0),
1031         }, {
1032                 .type = IIO_TEMP,
1033                 .indexed = 1,
1034                 .channel = 0,
1035                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
1036                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
1037                 IIO_CHAN_INFO_SCALE_SHARED_BIT,
1038                 .address = temp0,
1039                 .scan_index = ADIS16400_SCAN_TEMP,
1040                 .scan_type = IIO_ST('s', 14, 16, 0),
1041         },
1042         IIO_CHAN_SOFT_TIMESTAMP(12)
1043 };
1044
1045 static struct attribute *adis16400_attributes[] = {
1046         &iio_dev_attr_sampling_frequency.dev_attr.attr,
1047         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
1048         NULL
1049 };
1050
1051 static const struct attribute_group adis16400_attribute_group = {
1052         .attrs = adis16400_attributes,
1053 };
1054
1055 static struct adis16400_chip_info adis16400_chips[] = {
1056         [ADIS16300] = {
1057                 .channels = adis16300_channels,
1058                 .num_channels = ARRAY_SIZE(adis16300_channels),
1059                 .gyro_scale_micro = 873,
1060                 .accel_scale_micro = 5884,
1061                 .default_scan_mask = (1 << ADIS16400_SCAN_SUPPLY) |
1062                 (1 << ADIS16400_SCAN_GYRO_X) | (1 << ADIS16400_SCAN_ACC_X) |
1063                 (1 << ADIS16400_SCAN_ACC_Y) | (1 << ADIS16400_SCAN_ACC_Z) |
1064                 (1 << ADIS16400_SCAN_TEMP) | (1 << ADIS16400_SCAN_ADC_0) |
1065                 (1 << ADIS16300_SCAN_INCLI_X) | (1 << ADIS16300_SCAN_INCLI_Y) |
1066                 (1 << 14),
1067         },
1068         [ADIS16334] = {
1069                 .channels = adis16334_channels,
1070                 .num_channels = ARRAY_SIZE(adis16334_channels),
1071                 .gyro_scale_micro = 873,
1072                 .accel_scale_micro = 981,
1073                 .default_scan_mask = (1 << ADIS16400_SCAN_GYRO_X) |
1074                 (1 << ADIS16400_SCAN_GYRO_Y) | (1 << ADIS16400_SCAN_GYRO_Z) |
1075                 (1 << ADIS16400_SCAN_ACC_X) | (1 << ADIS16400_SCAN_ACC_Y) |
1076                 (1 << ADIS16400_SCAN_ACC_Z),
1077         },
1078         [ADIS16350] = {
1079                 .channels = adis16350_channels,
1080                 .num_channels = ARRAY_SIZE(adis16350_channels),
1081                 .gyro_scale_micro = 872664,
1082                 .accel_scale_micro = 24732,
1083                 .default_scan_mask = 0x7FF,
1084                 .flags = ADIS16400_NO_BURST,
1085         },
1086         [ADIS16360] = {
1087                 .channels = adis16350_channels,
1088                 .num_channels = ARRAY_SIZE(adis16350_channels),
1089                 .flags = ADIS16400_HAS_PROD_ID,
1090                 .product_id = 0x3FE8,
1091                 .gyro_scale_micro = 1279,
1092                 .accel_scale_micro = 24732,
1093                 .default_scan_mask = 0x7FF,
1094         },
1095         [ADIS16362] = {
1096                 .channels = adis16350_channels,
1097                 .num_channels = ARRAY_SIZE(adis16350_channels),
1098                 .flags = ADIS16400_HAS_PROD_ID,
1099                 .product_id = 0x3FEA,
1100                 .gyro_scale_micro = 1279,
1101                 .accel_scale_micro = 24732,
1102                 .default_scan_mask = 0x7FF,
1103         },
1104         [ADIS16364] = {
1105                 .channels = adis16350_channels,
1106                 .num_channels = ARRAY_SIZE(adis16350_channels),
1107                 .flags = ADIS16400_HAS_PROD_ID,
1108                 .product_id = 0x3FEC,
1109                 .gyro_scale_micro = 1279,
1110                 .accel_scale_micro = 24732,
1111                 .default_scan_mask = 0x7FF,
1112         },
1113         [ADIS16365] = {
1114                 .channels = adis16350_channels,
1115                 .num_channels = ARRAY_SIZE(adis16350_channels),
1116                 .flags = ADIS16400_HAS_PROD_ID,
1117                 .product_id = 0x3FED,
1118                 .gyro_scale_micro = 1279,
1119                 .accel_scale_micro = 24732,
1120                 .default_scan_mask = 0x7FF,
1121         },
1122         [ADIS16400] = {
1123                 .channels = adis16400_channels,
1124                 .num_channels = ARRAY_SIZE(adis16400_channels),
1125                 .flags = ADIS16400_HAS_PROD_ID,
1126                 .product_id = 0x4015,
1127                 .gyro_scale_micro = 873,
1128                 .accel_scale_micro = 32656,
1129                 .default_scan_mask = 0xFFF,
1130         }
1131 };
1132
1133 static const struct iio_info adis16400_info = {
1134         .driver_module = THIS_MODULE,
1135         .read_raw = &adis16400_read_raw,
1136         .write_raw = &adis16400_write_raw,
1137         .attrs = &adis16400_attribute_group,
1138 };
1139
1140 static int __devinit adis16400_probe(struct spi_device *spi)
1141 {
1142         int ret;
1143         struct adis16400_state *st;
1144         struct iio_dev *indio_dev = iio_device_alloc(sizeof(*st));
1145         if (indio_dev == NULL) {
1146                 ret =  -ENOMEM;
1147                 goto error_ret;
1148         }
1149         st = iio_priv(indio_dev);
1150         /* this is only used for removal purposes */
1151         spi_set_drvdata(spi, indio_dev);
1152
1153         st->us = spi;
1154         mutex_init(&st->buf_lock);
1155
1156         /* setup the industrialio driver allocated elements */
1157         st->variant = &adis16400_chips[spi_get_device_id(spi)->driver_data];
1158         indio_dev->dev.parent = &spi->dev;
1159         indio_dev->name = spi_get_device_id(spi)->name;
1160         indio_dev->channels = st->variant->channels;
1161         indio_dev->num_channels = st->variant->num_channels;
1162         indio_dev->info = &adis16400_info;
1163         indio_dev->modes = INDIO_DIRECT_MODE;
1164
1165         ret = adis16400_configure_ring(indio_dev);
1166         if (ret)
1167                 goto error_free_dev;
1168
1169         ret = iio_buffer_register(indio_dev,
1170                                   st->variant->channels,
1171                                   st->variant->num_channels);
1172         if (ret) {
1173                 dev_err(&spi->dev, "failed to initialize the ring\n");
1174                 goto error_unreg_ring_funcs;
1175         }
1176
1177         if (spi->irq) {
1178                 ret = adis16400_probe_trigger(indio_dev);
1179                 if (ret)
1180                         goto error_uninitialize_ring;
1181         }
1182
1183         /* Get the device into a sane initial state */
1184         ret = adis16400_initial_setup(indio_dev);
1185         if (ret)
1186                 goto error_remove_trigger;
1187         ret = iio_device_register(indio_dev);
1188         if (ret)
1189                 goto error_remove_trigger;
1190
1191         return 0;
1192
1193 error_remove_trigger:
1194         if (spi->irq)
1195                 adis16400_remove_trigger(indio_dev);
1196 error_uninitialize_ring:
1197         iio_buffer_unregister(indio_dev);
1198 error_unreg_ring_funcs:
1199         adis16400_unconfigure_ring(indio_dev);
1200 error_free_dev:
1201         iio_device_free(indio_dev);
1202 error_ret:
1203         return ret;
1204 }
1205
1206 /* fixme, confirm ordering in this function */
1207 static int adis16400_remove(struct spi_device *spi)
1208 {
1209         int ret;
1210         struct iio_dev *indio_dev =  spi_get_drvdata(spi);
1211
1212         iio_device_unregister(indio_dev);
1213         ret = adis16400_stop_device(indio_dev);
1214         if (ret)
1215                 goto err_ret;
1216
1217         adis16400_remove_trigger(indio_dev);
1218         iio_buffer_unregister(indio_dev);
1219         adis16400_unconfigure_ring(indio_dev);
1220         iio_device_free(indio_dev);
1221
1222         return 0;
1223
1224 err_ret:
1225         return ret;
1226 }
1227
1228 static const struct spi_device_id adis16400_id[] = {
1229         {"adis16300", ADIS16300},
1230         {"adis16334", ADIS16334},
1231         {"adis16350", ADIS16350},
1232         {"adis16354", ADIS16350},
1233         {"adis16355", ADIS16350},
1234         {"adis16360", ADIS16360},
1235         {"adis16362", ADIS16362},
1236         {"adis16364", ADIS16364},
1237         {"adis16365", ADIS16365},
1238         {"adis16400", ADIS16400},
1239         {"adis16405", ADIS16400},
1240         {}
1241 };
1242 MODULE_DEVICE_TABLE(spi, adis16400_id);
1243
1244 static struct spi_driver adis16400_driver = {
1245         .driver = {
1246                 .name = "adis16400",
1247                 .owner = THIS_MODULE,
1248         },
1249         .id_table = adis16400_id,
1250         .probe = adis16400_probe,
1251         .remove = __devexit_p(adis16400_remove),
1252 };
1253 module_spi_driver(adis16400_driver);
1254
1255 MODULE_AUTHOR("Manuel Stahl <manuel.stahl@iis.fraunhofer.de>");
1256 MODULE_DESCRIPTION("Analog Devices ADIS16400/5 IMU SPI driver");
1257 MODULE_LICENSE("GPL v2");