drivers/iio/imu/adis16480.c

   1 /*
   2  * ADIS16480 and similar IMUs driver
   3  *
   4  * Copyright 2012 Analog Devices Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  */
  11
  12 #include <linux/interrupt.h>
  13 #include <linux/delay.h>
  14 #include <linux/mutex.h>
  15 #include <linux/device.h>
  16 #include <linux/kernel.h>
  17 #include <linux/spi/spi.h>
  18 #include <linux/slab.h>
  19 #include <linux/sysfs.h>
  20 #include <linux/module.h>
  21
  22 #include <linux/iio/iio.h>
  23 #include <linux/iio/sysfs.h>
  24 #include <linux/iio/buffer.h>
  25 #include <linux/iio/imu/adis.h>
  26
  27 #include <linux/debugfs.h>
  28
  29 #define ADIS16480_PAGE_SIZE 0x80
  30
  31 #define ADIS16480_REG(page, reg) ((page) * ADIS16480_PAGE_SIZE + (reg))
  32
  33 #define ADIS16480_REG_PAGE_ID 0x00 /* Same address on each page */
  34 #define ADIS16480_REG_SEQ_CNT                   ADIS16480_REG(0x00, 0x06)
  35 #define ADIS16480_REG_SYS_E_FLA                 ADIS16480_REG(0x00, 0x08)
  36 #define ADIS16480_REG_DIAG_STS                  ADIS16480_REG(0x00, 0x0A)
  37 #define ADIS16480_REG_ALM_STS                   ADIS16480_REG(0x00, 0x0C)
  38 #define ADIS16480_REG_TEMP_OUT                  ADIS16480_REG(0x00, 0x0E)
  39 #define ADIS16480_REG_X_GYRO_OUT                ADIS16480_REG(0x00, 0x10)
  40 #define ADIS16480_REG_Y_GYRO_OUT                ADIS16480_REG(0x00, 0x14)
  41 #define ADIS16480_REG_Z_GYRO_OUT                ADIS16480_REG(0x00, 0x18)
  42 #define ADIS16480_REG_X_ACCEL_OUT               ADIS16480_REG(0x00, 0x1C)
  43 #define ADIS16480_REG_Y_ACCEL_OUT               ADIS16480_REG(0x00, 0x20)
  44 #define ADIS16480_REG_Z_ACCEL_OUT               ADIS16480_REG(0x00, 0x24)
  45 #define ADIS16480_REG_X_MAGN_OUT                ADIS16480_REG(0x00, 0x28)
  46 #define ADIS16480_REG_Y_MAGN_OUT                ADIS16480_REG(0x00, 0x2A)
  47 #define ADIS16480_REG_Z_MAGN_OUT                ADIS16480_REG(0x00, 0x2C)
  48 #define ADIS16480_REG_BAROM_OUT                 ADIS16480_REG(0x00, 0x2E)
  49 #define ADIS16480_REG_X_DELTAANG_OUT            ADIS16480_REG(0x00, 0x40)
  50 #define ADIS16480_REG_Y_DELTAANG_OUT            ADIS16480_REG(0x00, 0x44)
  51 #define ADIS16480_REG_Z_DELTAANG_OUT            ADIS16480_REG(0x00, 0x48)
  52 #define ADIS16480_REG_X_DELTAVEL_OUT            ADIS16480_REG(0x00, 0x4C)
  53 #define ADIS16480_REG_Y_DELTAVEL_OUT            ADIS16480_REG(0x00, 0x50)
  54 #define ADIS16480_REG_Z_DELTAVEL_OUT            ADIS16480_REG(0x00, 0x54)
  55 #define ADIS16480_REG_PROD_ID                   ADIS16480_REG(0x00, 0x7E)
  56
  57 #define ADIS16480_REG_X_GYRO_SCALE              ADIS16480_REG(0x02, 0x04)
  58 #define ADIS16480_REG_Y_GYRO_SCALE              ADIS16480_REG(0x02, 0x06)
  59 #define ADIS16480_REG_Z_GYRO_SCALE              ADIS16480_REG(0x02, 0x08)
  60 #define ADIS16480_REG_X_ACCEL_SCALE             ADIS16480_REG(0x02, 0x0A)
  61 #define ADIS16480_REG_Y_ACCEL_SCALE             ADIS16480_REG(0x02, 0x0C)
  62 #define ADIS16480_REG_Z_ACCEL_SCALE             ADIS16480_REG(0x02, 0x0E)
  63 #define ADIS16480_REG_X_GYRO_BIAS               ADIS16480_REG(0x02, 0x10)
  64 #define ADIS16480_REG_Y_GYRO_BIAS               ADIS16480_REG(0x02, 0x14)
  65 #define ADIS16480_REG_Z_GYRO_BIAS               ADIS16480_REG(0x02, 0x18)
  66 #define ADIS16480_REG_X_ACCEL_BIAS              ADIS16480_REG(0x02, 0x1C)
  67 #define ADIS16480_REG_Y_ACCEL_BIAS              ADIS16480_REG(0x02, 0x20)
  68 #define ADIS16480_REG_Z_ACCEL_BIAS              ADIS16480_REG(0x02, 0x24)
  69 #define ADIS16480_REG_X_HARD_IRON               ADIS16480_REG(0x02, 0x28)
  70 #define ADIS16480_REG_Y_HARD_IRON               ADIS16480_REG(0x02, 0x2A)
  71 #define ADIS16480_REG_Z_HARD_IRON               ADIS16480_REG(0x02, 0x2C)
  72 #define ADIS16480_REG_BAROM_BIAS                ADIS16480_REG(0x02, 0x40)
  73 #define ADIS16480_REG_FLASH_CNT                 ADIS16480_REG(0x02, 0x7C)
  74
  75 #define ADIS16480_REG_GLOB_CMD                  ADIS16480_REG(0x03, 0x02)
  76 #define ADIS16480_REG_FNCTIO_CTRL               ADIS16480_REG(0x03, 0x06)
  77 #define ADIS16480_REG_GPIO_CTRL                 ADIS16480_REG(0x03, 0x08)
  78 #define ADIS16480_REG_CONFIG                    ADIS16480_REG(0x03, 0x0A)
  79 #define ADIS16480_REG_DEC_RATE                  ADIS16480_REG(0x03, 0x0C)
  80 #define ADIS16480_REG_SLP_CNT                   ADIS16480_REG(0x03, 0x10)
  81 #define ADIS16480_REG_FILTER_BNK0               ADIS16480_REG(0x03, 0x16)
  82 #define ADIS16480_REG_FILTER_BNK1               ADIS16480_REG(0x03, 0x18)
  83 #define ADIS16480_REG_ALM_CNFG0                 ADIS16480_REG(0x03, 0x20)
  84 #define ADIS16480_REG_ALM_CNFG1                 ADIS16480_REG(0x03, 0x22)
  85 #define ADIS16480_REG_ALM_CNFG2                 ADIS16480_REG(0x03, 0x24)
  86 #define ADIS16480_REG_XG_ALM_MAGN               ADIS16480_REG(0x03, 0x28)
  87 #define ADIS16480_REG_YG_ALM_MAGN               ADIS16480_REG(0x03, 0x2A)
  88 #define ADIS16480_REG_ZG_ALM_MAGN               ADIS16480_REG(0x03, 0x2C)
  89 #define ADIS16480_REG_XA_ALM_MAGN               ADIS16480_REG(0x03, 0x2E)
  90 #define ADIS16480_REG_YA_ALM_MAGN               ADIS16480_REG(0x03, 0x30)
  91 #define ADIS16480_REG_ZA_ALM_MAGN               ADIS16480_REG(0x03, 0x32)
  92 #define ADIS16480_REG_XM_ALM_MAGN               ADIS16480_REG(0x03, 0x34)
  93 #define ADIS16480_REG_YM_ALM_MAGN               ADIS16480_REG(0x03, 0x36)
  94 #define ADIS16480_REG_ZM_ALM_MAGN               ADIS16480_REG(0x03, 0x38)
  95 #define ADIS16480_REG_BR_ALM_MAGN               ADIS16480_REG(0x03, 0x3A)
  96 #define ADIS16480_REG_FIRM_REV                  ADIS16480_REG(0x03, 0x78)
  97 #define ADIS16480_REG_FIRM_DM                   ADIS16480_REG(0x03, 0x7A)
  98 #define ADIS16480_REG_FIRM_Y                    ADIS16480_REG(0x03, 0x7C)
  99
 100 #define ADIS16480_REG_SERIAL_NUM                ADIS16480_REG(0x04, 0x20)
 101
 102 /* Each filter coefficent bank spans two pages */
 103 #define ADIS16480_FIR_COEF(page) (x < 60 ? ADIS16480_REG(page, (x) + 8) : \
 104                 ADIS16480_REG((page) + 1, (x) - 60 + 8))
 105 #define ADIS16480_FIR_COEF_A(x)                 ADIS16480_FIR_COEF(0x05, (x))
 106 #define ADIS16480_FIR_COEF_B(x)                 ADIS16480_FIR_COEF(0x07, (x))
 107 #define ADIS16480_FIR_COEF_C(x)                 ADIS16480_FIR_COEF(0x09, (x))
 108 #define ADIS16480_FIR_COEF_D(x)                 ADIS16480_FIR_COEF(0x0B, (x))
 109
 110 struct adis16480_chip_info {
 111         unsigned int num_channels;
 112         const struct iio_chan_spec *channels;
 113         unsigned int gyro_max_val;
 114         unsigned int gyro_max_scale;
 115         unsigned int accel_max_val;
 116         unsigned int accel_max_scale;
 117 };
 118
 119 struct adis16480 {
 120         const struct adis16480_chip_info *chip_info;
 121
 122         struct adis adis;
 123 };
 124
 125 #ifdef CONFIG_DEBUG_FS
 126
 127 static ssize_t adis16480_show_firmware_revision(struct file *file,
 128                 char __user *userbuf, size_t count, loff_t *ppos)
 129 {
 130         struct adis16480 *adis16480 = file->private_data;
 131         char buf[7];
 132         size_t len;
 133         u16 rev;
 134         int ret;
 135
 136         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_FIRM_REV, &rev);
 137         if (ret < 0)
 138                 return ret;
 139
 140         len = scnprintf(buf, sizeof(buf), "%x.%x\n", rev >> 8, rev & 0xff);
 141
 142         return simple_read_from_buffer(userbuf, count, ppos, buf, len);
 143 }
 144
 145 static const struct file_operations adis16480_firmware_revision_fops = {
 146         .open = simple_open,
 147         .read = adis16480_show_firmware_revision,
 148         .llseek = default_llseek,
 149         .owner = THIS_MODULE,
 150 };
 151
 152 static ssize_t adis16480_show_firmware_date(struct file *file,
 153                 char __user *userbuf, size_t count, loff_t *ppos)
 154 {
 155         struct adis16480 *adis16480 = file->private_data;
 156         u16 md, year;
 157         char buf[12];
 158         size_t len;
 159         int ret;
 160
 161         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_FIRM_Y, &year);
 162         if (ret < 0)
 163                 return ret;
 164
 165         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_FIRM_DM, &md);
 166         if (ret < 0)
 167                 return ret;
 168
 169         len = snprintf(buf, sizeof(buf), "%.2x-%.2x-%.4x\n",
 170                         md >> 8, md & 0xff, year);
 171
 172         return simple_read_from_buffer(userbuf, count, ppos, buf, len);
 173 }
 174
 175 static const struct file_operations adis16480_firmware_date_fops = {
 176         .open = simple_open,
 177         .read = adis16480_show_firmware_date,
 178         .llseek = default_llseek,
 179         .owner = THIS_MODULE,
 180 };
 181
 182 static int adis16480_show_serial_number(void *arg, u64 *val)
 183 {
 184         struct adis16480 *adis16480 = arg;
 185         u16 serial;
 186         int ret;
 187
 188         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_SERIAL_NUM,
 189                 &serial);
 190         if (ret < 0)
 191                 return ret;
 192
 193         *val = serial;
 194
 195         return 0;
 196 }
 197 DEFINE_SIMPLE_ATTRIBUTE(adis16480_serial_number_fops,
 198         adis16480_show_serial_number, NULL, "0x%.4llx\n");
 199
 200 static int adis16480_show_product_id(void *arg, u64 *val)
 201 {
 202         struct adis16480 *adis16480 = arg;
 203         u16 prod_id;
 204         int ret;
 205
 206         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_PROD_ID,
 207                 &prod_id);
 208         if (ret < 0)
 209                 return ret;
 210
 211         *val = prod_id;
 212
 213         return 0;
 214 }
 215 DEFINE_SIMPLE_ATTRIBUTE(adis16480_product_id_fops,
 216         adis16480_show_product_id, NULL, "%llu\n");
 217
 218 static int adis16480_show_flash_count(void *arg, u64 *val)
 219 {
 220         struct adis16480 *adis16480 = arg;
 221         u32 flash_count;
 222         int ret;
 223
 224         ret = adis_read_reg_32(&adis16480->adis, ADIS16480_REG_FLASH_CNT,
 225                 &flash_count);
 226         if (ret < 0)
 227                 return ret;
 228
 229         *val = flash_count;
 230
 231         return 0;
 232 }
 233 DEFINE_SIMPLE_ATTRIBUTE(adis16480_flash_count_fops,
 234         adis16480_show_flash_count, NULL, "%lld\n");
 235
 236 static int adis16480_debugfs_init(struct iio_dev *indio_dev)
 237 {
 238         struct adis16480 *adis16480 = iio_priv(indio_dev);
 239
 240         debugfs_create_file("firmware_revision", 0400,
 241                 indio_dev->debugfs_dentry, adis16480,
 242                 &adis16480_firmware_revision_fops);
 243         debugfs_create_file("firmware_date", 0400, indio_dev->debugfs_dentry,
 244                 adis16480, &adis16480_firmware_date_fops);
 245         debugfs_create_file("serial_number", 0400, indio_dev->debugfs_dentry,
 246                 adis16480, &adis16480_serial_number_fops);
 247         debugfs_create_file("product_id", 0400, indio_dev->debugfs_dentry,
 248                 adis16480, &adis16480_product_id_fops);
 249         debugfs_create_file("flash_count", 0400, indio_dev->debugfs_dentry,
 250                 adis16480, &adis16480_flash_count_fops);
 251
 252         return 0;
 253 }
 254
 255 #else
 256
 257 static int adis16480_debugfs_init(struct iio_dev *indio_dev)
 258 {
 259         return 0;
 260 }
 261
 262 #endif
 263
 264 static int adis16480_set_freq(struct iio_dev *indio_dev, int val, int val2)
 265 {
 266         struct adis16480 *st = iio_priv(indio_dev);
 267         unsigned int t;
 268
 269         if (val < 0 || val2 < 0)
 270                 return -EINVAL;
 271
 272         t =  val * 1000 + val2 / 1000;
 273         if (t == 0)
 274                 return -EINVAL;
 275
 276         t = 2460000 / t;
 277         if (t > 2048)
 278                 t = 2048;
 279
 280         if (t != 0)
 281                 t--;
 282
 283         return adis_write_reg_16(&st->adis, ADIS16480_REG_DEC_RATE, t);
 284 }
 285
 286 static int adis16480_get_freq(struct iio_dev *indio_dev, int *val, int *val2)
 287 {
 288         struct adis16480 *st = iio_priv(indio_dev);
 289         uint16_t t;
 290         int ret;
 291         unsigned freq;
 292
 293         ret = adis_read_reg_16(&st->adis, ADIS16480_REG_DEC_RATE, &t);
 294         if (ret < 0)
 295                 return ret;
 296
 297         freq = 2460000 / (t + 1);
 298         *val = freq / 1000;
 299         *val2 = (freq % 1000) * 1000;
 300
 301         return IIO_VAL_INT_PLUS_MICRO;
 302 }
 303
 304 enum {
 305         ADIS16480_SCAN_GYRO_X,
 306         ADIS16480_SCAN_GYRO_Y,
 307         ADIS16480_SCAN_GYRO_Z,
 308         ADIS16480_SCAN_ACCEL_X,
 309         ADIS16480_SCAN_ACCEL_Y,
 310         ADIS16480_SCAN_ACCEL_Z,
 311         ADIS16480_SCAN_MAGN_X,
 312         ADIS16480_SCAN_MAGN_Y,
 313         ADIS16480_SCAN_MAGN_Z,
 314         ADIS16480_SCAN_BARO,
 315         ADIS16480_SCAN_TEMP,
 316 };
 317
 318 static const unsigned int adis16480_calibbias_regs[] = {
 319         [ADIS16480_SCAN_GYRO_X] = ADIS16480_REG_X_GYRO_BIAS,
 320         [ADIS16480_SCAN_GYRO_Y] = ADIS16480_REG_Y_GYRO_BIAS,
 321         [ADIS16480_SCAN_GYRO_Z] = ADIS16480_REG_Z_GYRO_BIAS,
 322         [ADIS16480_SCAN_ACCEL_X] = ADIS16480_REG_X_ACCEL_BIAS,
 323         [ADIS16480_SCAN_ACCEL_Y] = ADIS16480_REG_Y_ACCEL_BIAS,
 324         [ADIS16480_SCAN_ACCEL_Z] = ADIS16480_REG_Z_ACCEL_BIAS,
 325         [ADIS16480_SCAN_MAGN_X] = ADIS16480_REG_X_HARD_IRON,
 326         [ADIS16480_SCAN_MAGN_Y] = ADIS16480_REG_Y_HARD_IRON,
 327         [ADIS16480_SCAN_MAGN_Z] = ADIS16480_REG_Z_HARD_IRON,
 328         [ADIS16480_SCAN_BARO] = ADIS16480_REG_BAROM_BIAS,
 329 };
 330
 331 static const unsigned int adis16480_calibscale_regs[] = {
 332         [ADIS16480_SCAN_GYRO_X] = ADIS16480_REG_X_GYRO_SCALE,
 333         [ADIS16480_SCAN_GYRO_Y] = ADIS16480_REG_Y_GYRO_SCALE,
 334         [ADIS16480_SCAN_GYRO_Z] = ADIS16480_REG_Z_GYRO_SCALE,
 335         [ADIS16480_SCAN_ACCEL_X] = ADIS16480_REG_X_ACCEL_SCALE,
 336         [ADIS16480_SCAN_ACCEL_Y] = ADIS16480_REG_Y_ACCEL_SCALE,
 337         [ADIS16480_SCAN_ACCEL_Z] = ADIS16480_REG_Z_ACCEL_SCALE,
 338 };
 339
 340 static int adis16480_set_calibbias(struct iio_dev *indio_dev,
 341         const struct iio_chan_spec *chan, int bias)
 342 {
 343         unsigned int reg = adis16480_calibbias_regs[chan->scan_index];
 344         struct adis16480 *st = iio_priv(indio_dev);
 345
 346         switch (chan->type) {
 347         case IIO_MAGN:
 348         case IIO_PRESSURE:
 349                 if (bias < -0x8000 || bias >= 0x8000)
 350                         return -EINVAL;
 351                 return adis_write_reg_16(&st->adis, reg, bias);
 352         case IIO_ANGL_VEL:
 353         case IIO_ACCEL:
 354                 return adis_write_reg_32(&st->adis, reg, bias);
 355         default:
 356                 break;
 357         }
 358
 359         return -EINVAL;
 360 }
 361
 362 static int adis16480_get_calibbias(struct iio_dev *indio_dev,
 363         const struct iio_chan_spec *chan, int *bias)
 364 {
 365         unsigned int reg = adis16480_calibbias_regs[chan->scan_index];
 366         struct adis16480 *st = iio_priv(indio_dev);
 367         uint16_t val16;
 368         uint32_t val32;
 369         int ret;
 370
 371         switch (chan->type) {
 372         case IIO_MAGN:
 373         case IIO_PRESSURE:
 374                 ret = adis_read_reg_16(&st->adis, reg, &val16);
 375                 if (ret == 0)
 376                         *bias = sign_extend32(val16, 15);
 377                 break;
 378         case IIO_ANGL_VEL:
 379         case IIO_ACCEL:
 380                 ret = adis_read_reg_32(&st->adis, reg, &val32);
 381                 if (ret == 0)
 382                         *bias = sign_extend32(val32, 31);
 383                 break;
 384         default:
 385                         ret = -EINVAL;
 386         }
 387
 388         if (ret < 0)
 389                 return ret;
 390
 391         return IIO_VAL_INT;
 392 }
 393
 394 static int adis16480_set_calibscale(struct iio_dev *indio_dev,
 395         const struct iio_chan_spec *chan, int scale)
 396 {
 397         unsigned int reg = adis16480_calibscale_regs[chan->scan_index];
 398         struct adis16480 *st = iio_priv(indio_dev);
 399
 400         if (scale < -0x8000 || scale >= 0x8000)
 401                 return -EINVAL;
 402
 403         return adis_write_reg_16(&st->adis, reg, scale);
 404 }
 405
 406 static int adis16480_get_calibscale(struct iio_dev *indio_dev,
 407         const struct iio_chan_spec *chan, int *scale)
 408 {
 409         unsigned int reg = adis16480_calibscale_regs[chan->scan_index];
 410         struct adis16480 *st = iio_priv(indio_dev);
 411         uint16_t val16;
 412         int ret;
 413
 414         ret = adis_read_reg_16(&st->adis, reg, &val16);
 415         if (ret < 0)
 416                 return ret;
 417
 418         *scale = sign_extend32(val16, 15);
 419         return IIO_VAL_INT;
 420 }
 421
 422 static const unsigned int adis16480_def_filter_freqs[] = {
 423         310,
 424         55,
 425         275,
 426         63,
 427 };
 428
 429 static const unsigned int ad16480_filter_data[][2] = {
 430         [ADIS16480_SCAN_GYRO_X]         = { ADIS16480_REG_FILTER_BNK0, 0 },
 431         [ADIS16480_SCAN_GYRO_Y]         = { ADIS16480_REG_FILTER_BNK0, 3 },
 432         [ADIS16480_SCAN_GYRO_Z]         = { ADIS16480_REG_FILTER_BNK0, 6 },
 433         [ADIS16480_SCAN_ACCEL_X]        = { ADIS16480_REG_FILTER_BNK0, 9 },
 434         [ADIS16480_SCAN_ACCEL_Y]        = { ADIS16480_REG_FILTER_BNK0, 12 },
 435         [ADIS16480_SCAN_ACCEL_Z]        = { ADIS16480_REG_FILTER_BNK1, 0 },
 436         [ADIS16480_SCAN_MAGN_X]         = { ADIS16480_REG_FILTER_BNK1, 3 },
 437         [ADIS16480_SCAN_MAGN_Y]         = { ADIS16480_REG_FILTER_BNK1, 6 },
 438         [ADIS16480_SCAN_MAGN_Z]         = { ADIS16480_REG_FILTER_BNK1, 9 },
 439 };
 440
 441 static int adis16480_get_filter_freq(struct iio_dev *indio_dev,
 442         const struct iio_chan_spec *chan, int *freq)
 443 {
 444         struct adis16480 *st = iio_priv(indio_dev);
 445         unsigned int enable_mask, offset, reg;
 446         uint16_t val;
 447         int ret;
 448
 449         reg = ad16480_filter_data[chan->scan_index][0];
 450         offset = ad16480_filter_data[chan->scan_index][1];
 451         enable_mask = BIT(offset + 2);
 452
 453         ret = adis_read_reg_16(&st->adis, reg, &val);
 454         if (ret < 0)
 455                 return ret;
 456
 457         if (!(val & enable_mask))
 458                 *freq = 0;
 459         else
 460                 *freq = adis16480_def_filter_freqs[(val >> offset) & 0x3];
 461
 462         return IIO_VAL_INT;
 463 }
 464
 465 static int adis16480_set_filter_freq(struct iio_dev *indio_dev,
 466         const struct iio_chan_spec *chan, unsigned int freq)
 467 {
 468         struct adis16480 *st = iio_priv(indio_dev);
 469         unsigned int enable_mask, offset, reg;
 470         unsigned int diff, best_diff;
 471         unsigned int i, best_freq;
 472         uint16_t val;
 473         int ret;
 474
 475         reg = ad16480_filter_data[chan->scan_index][0];
 476         offset = ad16480_filter_data[chan->scan_index][1];
 477         enable_mask = BIT(offset + 2);
 478
 479         ret = adis_read_reg_16(&st->adis, reg, &val);
 480         if (ret < 0)
 481                 return ret;
 482
 483         if (freq == 0) {
 484                 val &= ~enable_mask;
 485         } else {
 486                 best_freq = 0;
 487                 best_diff = 310;
 488                 for (i = 0; i < ARRAY_SIZE(adis16480_def_filter_freqs); i++) {
 489                         if (adis16480_def_filter_freqs[i] >= freq) {
 490                                 diff = adis16480_def_filter_freqs[i] - freq;
 491                                 if (diff < best_diff) {
 492                                         best_diff = diff;
 493                                         best_freq = i;
 494                                 }
 495                         }
 496                 }
 497
 498                 val &= ~(0x3 << offset);
 499                 val |= best_freq << offset;
 500                 val |= enable_mask;
 501         }
 502
 503         return adis_write_reg_16(&st->adis, reg, val);
 504 }
 505
 506 static int adis16480_read_raw(struct iio_dev *indio_dev,
 507         const struct iio_chan_spec *chan, int *val, int *val2, long info)
 508 {
 509         struct adis16480 *st = iio_priv(indio_dev);
 510
 511         switch (info) {
 512         case IIO_CHAN_INFO_RAW:
 513                 return adis_single_conversion(indio_dev, chan, 0, val);
 514         case IIO_CHAN_INFO_SCALE:
 515                 switch (chan->type) {
 516                 case IIO_ANGL_VEL:
 517                         *val = st->chip_info->gyro_max_scale;
 518                         *val2 = st->chip_info->gyro_max_val;
 519                         return IIO_VAL_FRACTIONAL;
 520                 case IIO_ACCEL:
 521                         *val = st->chip_info->accel_max_scale;
 522                         *val2 = st->chip_info->accel_max_val;
 523                         return IIO_VAL_FRACTIONAL;
 524                 case IIO_MAGN:
 525                         *val = 0;
 526                         *val2 = 100; /* 0.0001 gauss */
 527                         return IIO_VAL_INT_PLUS_MICRO;
 528                 case IIO_TEMP:
 529                         *val = 5;
 530                         *val2 = 650000; /* 5.65 milli degree Celsius */
 531                         return IIO_VAL_INT_PLUS_MICRO;
 532                 case IIO_PRESSURE:
 533                         *val = 0;
 534                         *val2 = 4000; /* 40ubar = 0.004 kPa */
 535                         return IIO_VAL_INT_PLUS_MICRO;
 536                 default:
 537                         return -EINVAL;
 538                 }
 539         case IIO_CHAN_INFO_OFFSET:
 540                 /* Only the temperature channel has a offset */
 541                 *val = 4425; /* 25 degree Celsius = 0x0000 */
 542                 return IIO_VAL_INT;
 543         case IIO_CHAN_INFO_CALIBBIAS:
 544                 return adis16480_get_calibbias(indio_dev, chan, val);
 545         case IIO_CHAN_INFO_CALIBSCALE:
 546                 return adis16480_get_calibscale(indio_dev, chan, val);
 547         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 548                 return adis16480_get_filter_freq(indio_dev, chan, val);
 549         case IIO_CHAN_INFO_SAMP_FREQ:
 550                 return adis16480_get_freq(indio_dev, val, val2);
 551         default:
 552                 return -EINVAL;
 553         }
 554 }
 555
 556 static int adis16480_write_raw(struct iio_dev *indio_dev,
 557         const struct iio_chan_spec *chan, int val, int val2, long info)
 558 {
 559         switch (info) {
 560         case IIO_CHAN_INFO_CALIBBIAS:
 561                 return adis16480_set_calibbias(indio_dev, chan, val);
 562         case IIO_CHAN_INFO_CALIBSCALE:
 563                 return adis16480_set_calibscale(indio_dev, chan, val);
 564         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 565                 return adis16480_set_filter_freq(indio_dev, chan, val);
 566         case IIO_CHAN_INFO_SAMP_FREQ:
 567                 return adis16480_set_freq(indio_dev, val, val2);
 568
 569         default:
 570                 return -EINVAL;
 571         }
 572 }
 573
 574 #define ADIS16480_MOD_CHANNEL(_type, _mod, _address, _si, _info_sep, _bits) \
 575         { \
 576                 .type = (_type), \
 577                 .modified = 1, \
 578                 .channel2 = (_mod), \
 579                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
 580                         BIT(IIO_CHAN_INFO_CALIBBIAS) | \
 581                         _info_sep, \
 582                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
 583                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 584                 .address = (_address), \
 585                 .scan_index = (_si), \
 586                 .scan_type = { \
 587                         .sign = 's', \
 588                         .realbits = (_bits), \
 589                         .storagebits = (_bits), \
 590                         .endianness = IIO_BE, \
 591                 }, \
 592         }
 593
 594 #define ADIS16480_GYRO_CHANNEL(_mod) \
 595         ADIS16480_MOD_CHANNEL(IIO_ANGL_VEL, IIO_MOD_ ## _mod, \
 596         ADIS16480_REG_ ## _mod ## _GYRO_OUT, ADIS16480_SCAN_GYRO_ ## _mod, \
 597         BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \
 598         BIT(IIO_CHAN_INFO_CALIBSCALE), \
 599         32)
 600
 601 #define ADIS16480_ACCEL_CHANNEL(_mod) \
 602         ADIS16480_MOD_CHANNEL(IIO_ACCEL, IIO_MOD_ ## _mod, \
 603         ADIS16480_REG_ ## _mod ## _ACCEL_OUT, ADIS16480_SCAN_ACCEL_ ## _mod, \
 604         BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \
 605         BIT(IIO_CHAN_INFO_CALIBSCALE), \
 606         32)
 607
 608 #define ADIS16480_MAGN_CHANNEL(_mod) \
 609         ADIS16480_MOD_CHANNEL(IIO_MAGN, IIO_MOD_ ## _mod, \
 610         ADIS16480_REG_ ## _mod ## _MAGN_OUT, ADIS16480_SCAN_MAGN_ ## _mod, \
 611         BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
 612         16)
 613
 614 #define ADIS16480_PRESSURE_CHANNEL() \
 615         { \
 616                 .type = IIO_PRESSURE, \
 617                 .indexed = 1, \
 618                 .channel = 0, \
 619                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
 620                         BIT(IIO_CHAN_INFO_CALIBBIAS) | \
 621                         BIT(IIO_CHAN_INFO_SCALE), \
 622                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 623                 .address = ADIS16480_REG_BAROM_OUT, \
 624                 .scan_index = ADIS16480_SCAN_BARO, \
 625                 .scan_type = { \
 626                         .sign = 's', \
 627                         .realbits = 32, \
 628                         .storagebits = 32, \
 629                         .endianness = IIO_BE, \
 630                 }, \
 631         }
 632
 633 #define ADIS16480_TEMP_CHANNEL() { \
 634                 .type = IIO_TEMP, \
 635                 .indexed = 1, \
 636                 .channel = 0, \
 637                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
 638                         BIT(IIO_CHAN_INFO_SCALE) | \
 639                         BIT(IIO_CHAN_INFO_OFFSET), \
 640                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 641                 .address = ADIS16480_REG_TEMP_OUT, \
 642                 .scan_index = ADIS16480_SCAN_TEMP, \
 643                 .scan_type = { \
 644                         .sign = 's', \
 645                         .realbits = 16, \
 646                         .storagebits = 16, \
 647                         .endianness = IIO_BE, \
 648                 }, \
 649         }
 650
 651 static const struct iio_chan_spec adis16480_channels[] = {
 652         ADIS16480_GYRO_CHANNEL(X),
 653         ADIS16480_GYRO_CHANNEL(Y),
 654         ADIS16480_GYRO_CHANNEL(Z),
 655         ADIS16480_ACCEL_CHANNEL(X),
 656         ADIS16480_ACCEL_CHANNEL(Y),
 657         ADIS16480_ACCEL_CHANNEL(Z),
 658         ADIS16480_MAGN_CHANNEL(X),
 659         ADIS16480_MAGN_CHANNEL(Y),
 660         ADIS16480_MAGN_CHANNEL(Z),
 661         ADIS16480_PRESSURE_CHANNEL(),
 662         ADIS16480_TEMP_CHANNEL(),
 663         IIO_CHAN_SOFT_TIMESTAMP(11)
 664 };
 665
 666 static const struct iio_chan_spec adis16485_channels[] = {
 667         ADIS16480_GYRO_CHANNEL(X),
 668         ADIS16480_GYRO_CHANNEL(Y),
 669         ADIS16480_GYRO_CHANNEL(Z),
 670         ADIS16480_ACCEL_CHANNEL(X),
 671         ADIS16480_ACCEL_CHANNEL(Y),
 672         ADIS16480_ACCEL_CHANNEL(Z),
 673         ADIS16480_TEMP_CHANNEL(),
 674         IIO_CHAN_SOFT_TIMESTAMP(7)
 675 };
 676
 677 enum adis16480_variant {
 678         ADIS16375,
 679         ADIS16480,
 680         ADIS16485,
 681         ADIS16488,
 682 };
 683
 684 static const struct adis16480_chip_info adis16480_chip_info[] = {
 685         [ADIS16375] = {
 686                 .channels = adis16485_channels,
 687                 .num_channels = ARRAY_SIZE(adis16485_channels),
 688                 /*
 689                  * storing the value in rad/degree and the scale in degree
 690                  * gives us the result in rad and better precession than
 691                  * storing the scale directly in rad.
 692                  */
 693                 .gyro_max_val = IIO_RAD_TO_DEGREE(22887),
 694                 .gyro_max_scale = 300,
 695                 .accel_max_val = IIO_M_S_2_TO_G(21973),
 696                 .accel_max_scale = 18,
 697         },
 698         [ADIS16480] = {
 699                 .channels = adis16480_channels,
 700                 .num_channels = ARRAY_SIZE(adis16480_channels),
 701                 .gyro_max_val = IIO_RAD_TO_DEGREE(22500),
 702                 .gyro_max_scale = 450,
 703                 .accel_max_val = IIO_M_S_2_TO_G(12500),
 704                 .accel_max_scale = 10,
 705         },
 706         [ADIS16485] = {
 707                 .channels = adis16485_channels,
 708                 .num_channels = ARRAY_SIZE(adis16485_channels),
 709                 .gyro_max_val = IIO_RAD_TO_DEGREE(22500),
 710                 .gyro_max_scale = 450,
 711                 .accel_max_val = IIO_M_S_2_TO_G(20000),
 712                 .accel_max_scale = 5,
 713         },
 714         [ADIS16488] = {
 715                 .channels = adis16480_channels,
 716                 .num_channels = ARRAY_SIZE(adis16480_channels),
 717                 .gyro_max_val = IIO_RAD_TO_DEGREE(22500),
 718                 .gyro_max_scale = 450,
 719                 .accel_max_val = IIO_M_S_2_TO_G(22500),
 720                 .accel_max_scale = 18,
 721         },
 722 };
 723
 724 static const struct iio_info adis16480_info = {
 725         .read_raw = &adis16480_read_raw,
 726         .write_raw = &adis16480_write_raw,
 727         .update_scan_mode = adis_update_scan_mode,
 728         .driver_module = THIS_MODULE,
 729         .debugfs_reg_access = adis_debugfs_reg_access,
 730 };
 731
 732 static int adis16480_stop_device(struct iio_dev *indio_dev)
 733 {
 734         struct adis16480 *st = iio_priv(indio_dev);
 735         int ret;
 736
 737         ret = adis_write_reg_16(&st->adis, ADIS16480_REG_SLP_CNT, BIT(9));
 738         if (ret)
 739                 dev_err(&indio_dev->dev,
 740                         "Could not power down device: %d\n", ret);
 741
 742         return ret;
 743 }
 744
 745 static int adis16480_enable_irq(struct adis *adis, bool enable)
 746 {
 747         return adis_write_reg_16(adis, ADIS16480_REG_FNCTIO_CTRL,
 748                 enable ? BIT(3) : 0);
 749 }
 750
 751 static int adis16480_initial_setup(struct iio_dev *indio_dev)
 752 {
 753         struct adis16480 *st = iio_priv(indio_dev);
 754         uint16_t prod_id;
 755         unsigned int device_id;
 756         int ret;
 757
 758         adis_reset(&st->adis);
 759         msleep(70);
 760
 761         ret = adis_write_reg_16(&st->adis, ADIS16480_REG_GLOB_CMD, BIT(1));
 762         if (ret)
 763                 return ret;
 764         msleep(30);
 765
 766         ret = adis_check_status(&st->adis);
 767         if (ret)
 768                 return ret;
 769
 770         ret = adis_read_reg_16(&st->adis, ADIS16480_REG_PROD_ID, &prod_id);
 771         if (ret)
 772                 return ret;
 773
 774         ret = sscanf(indio_dev->name, "adis%u\n", &device_id);
 775         if (ret != 1)
 776                 return -EINVAL;
 777
 778         if (prod_id != device_id)
 779                 dev_warn(&indio_dev->dev, "Device ID(%u) and product ID(%u) do not match.",
 780                                 device_id, prod_id);
 781
 782         return 0;
 783 }
 784
 785 #define ADIS16480_DIAG_STAT_XGYRO_FAIL 0
 786 #define ADIS16480_DIAG_STAT_YGYRO_FAIL 1
 787 #define ADIS16480_DIAG_STAT_ZGYRO_FAIL 2
 788 #define ADIS16480_DIAG_STAT_XACCL_FAIL 3
 789 #define ADIS16480_DIAG_STAT_YACCL_FAIL 4
 790 #define ADIS16480_DIAG_STAT_ZACCL_FAIL 5
 791 #define ADIS16480_DIAG_STAT_XMAGN_FAIL 8
 792 #define ADIS16480_DIAG_STAT_YMAGN_FAIL 9
 793 #define ADIS16480_DIAG_STAT_ZMAGN_FAIL 10
 794 #define ADIS16480_DIAG_STAT_BARO_FAIL 11
 795
 796 static const char * const adis16480_status_error_msgs[] = {
 797         [ADIS16480_DIAG_STAT_XGYRO_FAIL] = "X-axis gyroscope self-test failure",
 798         [ADIS16480_DIAG_STAT_YGYRO_FAIL] = "Y-axis gyroscope self-test failure",
 799         [ADIS16480_DIAG_STAT_ZGYRO_FAIL] = "Z-axis gyroscope self-test failure",
 800         [ADIS16480_DIAG_STAT_XACCL_FAIL] = "X-axis accelerometer self-test failure",
 801         [ADIS16480_DIAG_STAT_YACCL_FAIL] = "Y-axis accelerometer self-test failure",
 802         [ADIS16480_DIAG_STAT_ZACCL_FAIL] = "Z-axis accelerometer self-test failure",
 803         [ADIS16480_DIAG_STAT_XMAGN_FAIL] = "X-axis magnetometer self-test failure",
 804         [ADIS16480_DIAG_STAT_YMAGN_FAIL] = "Y-axis magnetometer self-test failure",
 805         [ADIS16480_DIAG_STAT_ZMAGN_FAIL] = "Z-axis magnetometer self-test failure",
 806         [ADIS16480_DIAG_STAT_BARO_FAIL] = "Barometer self-test failure",
 807 };
 808
 809 static const struct adis_data adis16480_data = {
 810         .diag_stat_reg = ADIS16480_REG_DIAG_STS,
 811         .glob_cmd_reg = ADIS16480_REG_GLOB_CMD,
 812         .has_paging = true,
 813
 814         .read_delay = 5,
 815         .write_delay = 5,
 816
 817         .status_error_msgs = adis16480_status_error_msgs,
 818         .status_error_mask = BIT(ADIS16480_DIAG_STAT_XGYRO_FAIL) |
 819                 BIT(ADIS16480_DIAG_STAT_YGYRO_FAIL) |
 820                 BIT(ADIS16480_DIAG_STAT_ZGYRO_FAIL) |
 821                 BIT(ADIS16480_DIAG_STAT_XACCL_FAIL) |
 822                 BIT(ADIS16480_DIAG_STAT_YACCL_FAIL) |
 823                 BIT(ADIS16480_DIAG_STAT_ZACCL_FAIL) |
 824                 BIT(ADIS16480_DIAG_STAT_XMAGN_FAIL) |
 825                 BIT(ADIS16480_DIAG_STAT_YMAGN_FAIL) |
 826                 BIT(ADIS16480_DIAG_STAT_ZMAGN_FAIL) |
 827                 BIT(ADIS16480_DIAG_STAT_BARO_FAIL),
 828
 829         .enable_irq = adis16480_enable_irq,
 830 };
 831
 832 static int adis16480_probe(struct spi_device *spi)
 833 {
 834         const struct spi_device_id *id = spi_get_device_id(spi);
 835         struct iio_dev *indio_dev;
 836         struct adis16480 *st;
 837         int ret;
 838
 839         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 840         if (indio_dev == NULL)
 841                 return -ENOMEM;
 842
 843         spi_set_drvdata(spi, indio_dev);
 844
 845         st = iio_priv(indio_dev);
 846
 847         st->chip_info = &adis16480_chip_info[id->driver_data];
 848         indio_dev->dev.parent = &spi->dev;
 849         indio_dev->name = spi_get_device_id(spi)->name;
 850         indio_dev->channels = st->chip_info->channels;
 851         indio_dev->num_channels = st->chip_info->num_channels;
 852         indio_dev->info = &adis16480_info;
 853         indio_dev->modes = INDIO_DIRECT_MODE;
 854
 855         ret = adis_init(&st->adis, indio_dev, spi, &adis16480_data);
 856         if (ret)
 857                 return ret;
 858
 859         ret = adis_setup_buffer_and_trigger(&st->adis, indio_dev, NULL);
 860         if (ret)
 861                 return ret;
 862
 863         ret = adis16480_initial_setup(indio_dev);
 864         if (ret)
 865                 goto error_cleanup_buffer;
 866
 867         ret = iio_device_register(indio_dev);
 868         if (ret)
 869                 goto error_stop_device;
 870
 871         adis16480_debugfs_init(indio_dev);
 872
 873         return 0;
 874
 875 error_stop_device:
 876         adis16480_stop_device(indio_dev);
 877 error_cleanup_buffer:
 878         adis_cleanup_buffer_and_trigger(&st->adis, indio_dev);
 879         return ret;
 880 }
 881
 882 static int adis16480_remove(struct spi_device *spi)
 883 {
 884         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 885         struct adis16480 *st = iio_priv(indio_dev);
 886
 887         iio_device_unregister(indio_dev);
 888         adis16480_stop_device(indio_dev);
 889
 890         adis_cleanup_buffer_and_trigger(&st->adis, indio_dev);
 891
 892         return 0;
 893 }
 894
 895 static const struct spi_device_id adis16480_ids[] = {
 896         { "adis16375", ADIS16375 },
 897         { "adis16480", ADIS16480 },
 898         { "adis16485", ADIS16485 },
 899         { "adis16488", ADIS16488 },
 900         { }
 901 };
 902 MODULE_DEVICE_TABLE(spi, adis16480_ids);
 903
 904 static struct spi_driver adis16480_driver = {
 905         .driver = {
 906                 .name = "adis16480",
 907         },
 908         .id_table = adis16480_ids,
 909         .probe = adis16480_probe,
 910         .remove = adis16480_remove,
 911 };
 912 module_spi_driver(adis16480_driver);
 913
 914 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
 915 MODULE_DESCRIPTION("Analog Devices ADIS16480 IMU driver");
 916 MODULE_LICENSE("GPL v2");