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