drivers/iio/gyro/adis16260.c

   1 /*
   2  * ADIS16260/ADIS16265 Programmable Digital Gyroscope Sensor Driver
   3  *
   4  * Copyright 2010 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2 or later.
   7  */
   8
   9 #include <linux/interrupt.h>
  10 #include <linux/mutex.h>
  11 #include <linux/device.h>
  12 #include <linux/kernel.h>
  13 #include <linux/spi/spi.h>
  14 #include <linux/sysfs.h>
  15 #include <linux/module.h>
  16
  17 #include <linux/iio/iio.h>
  18 #include <linux/iio/sysfs.h>
  19 #include <linux/iio/buffer.h>
  20 #include <linux/iio/imu/adis.h>
  21
  22 #define ADIS16260_STARTUP_DELAY 220 /* ms */
  23
  24 #define ADIS16260_FLASH_CNT  0x00 /* Flash memory write count */
  25 #define ADIS16260_SUPPLY_OUT 0x02 /* Power supply measurement */
  26 #define ADIS16260_GYRO_OUT   0x04 /* X-axis gyroscope output */
  27 #define ADIS16260_AUX_ADC    0x0A /* analog input channel measurement */
  28 #define ADIS16260_TEMP_OUT   0x0C /* internal temperature measurement */
  29 #define ADIS16260_ANGL_OUT   0x0E /* angle displacement */
  30 #define ADIS16260_GYRO_OFF   0x14 /* Calibration, offset/bias adjustment */
  31 #define ADIS16260_GYRO_SCALE 0x16 /* Calibration, scale adjustment */
  32 #define ADIS16260_ALM_MAG1   0x20 /* Alarm 1 magnitude/polarity setting */
  33 #define ADIS16260_ALM_MAG2   0x22 /* Alarm 2 magnitude/polarity setting */
  34 #define ADIS16260_ALM_SMPL1  0x24 /* Alarm 1 dynamic rate of change setting */
  35 #define ADIS16260_ALM_SMPL2  0x26 /* Alarm 2 dynamic rate of change setting */
  36 #define ADIS16260_ALM_CTRL   0x28 /* Alarm control */
  37 #define ADIS16260_AUX_DAC    0x30 /* Auxiliary DAC data */
  38 #define ADIS16260_GPIO_CTRL  0x32 /* Control, digital I/O line */
  39 #define ADIS16260_MSC_CTRL   0x34 /* Control, data ready, self-test settings */
  40 #define ADIS16260_SMPL_PRD   0x36 /* Control, internal sample rate */
  41 #define ADIS16260_SENS_AVG   0x38 /* Control, dynamic range, filtering */
  42 #define ADIS16260_SLP_CNT    0x3A /* Control, sleep mode initiation */
  43 #define ADIS16260_DIAG_STAT  0x3C /* Diagnostic, error flags */
  44 #define ADIS16260_GLOB_CMD   0x3E /* Control, global commands */
  45 #define ADIS16260_LOT_ID1    0x52 /* Lot Identification Code 1 */
  46 #define ADIS16260_LOT_ID2    0x54 /* Lot Identification Code 2 */
  47 #define ADIS16260_PROD_ID    0x56 /* Product identifier;
  48                                    * convert to decimal = 16,265/16,260 */
  49 #define ADIS16260_SERIAL_NUM 0x58 /* Serial number */
  50
  51 #define ADIS16260_ERROR_ACTIVE                  (1<<14)
  52 #define ADIS16260_NEW_DATA                      (1<<15)
  53
  54 /* MSC_CTRL */
  55 #define ADIS16260_MSC_CTRL_MEM_TEST             (1<<11)
  56 /* Internal self-test enable */
  57 #define ADIS16260_MSC_CTRL_INT_SELF_TEST        (1<<10)
  58 #define ADIS16260_MSC_CTRL_NEG_SELF_TEST        (1<<9)
  59 #define ADIS16260_MSC_CTRL_POS_SELF_TEST        (1<<8)
  60 #define ADIS16260_MSC_CTRL_DATA_RDY_EN          (1<<2)
  61 #define ADIS16260_MSC_CTRL_DATA_RDY_POL_HIGH    (1<<1)
  62 #define ADIS16260_MSC_CTRL_DATA_RDY_DIO2        (1<<0)
  63
  64 /* SMPL_PRD */
  65 /* Time base (tB): 0 = 1.953 ms, 1 = 60.54 ms */
  66 #define ADIS16260_SMPL_PRD_TIME_BASE    (1<<7)
  67 #define ADIS16260_SMPL_PRD_DIV_MASK     0x7F
  68
  69 /* SLP_CNT */
  70 #define ADIS16260_SLP_CNT_POWER_OFF     0x80
  71
  72 /* DIAG_STAT */
  73 #define ADIS16260_DIAG_STAT_ALARM2      (1<<9)
  74 #define ADIS16260_DIAG_STAT_ALARM1      (1<<8)
  75 #define ADIS16260_DIAG_STAT_FLASH_CHK_BIT       6
  76 #define ADIS16260_DIAG_STAT_SELF_TEST_BIT       5
  77 #define ADIS16260_DIAG_STAT_OVERFLOW_BIT        4
  78 #define ADIS16260_DIAG_STAT_SPI_FAIL_BIT        3
  79 #define ADIS16260_DIAG_STAT_FLASH_UPT_BIT       2
  80 #define ADIS16260_DIAG_STAT_POWER_HIGH_BIT      1
  81 #define ADIS16260_DIAG_STAT_POWER_LOW_BIT       0
  82
  83 /* GLOB_CMD */
  84 #define ADIS16260_GLOB_CMD_SW_RESET     (1<<7)
  85 #define ADIS16260_GLOB_CMD_FLASH_UPD    (1<<3)
  86 #define ADIS16260_GLOB_CMD_DAC_LATCH    (1<<2)
  87 #define ADIS16260_GLOB_CMD_FAC_CALIB    (1<<1)
  88 #define ADIS16260_GLOB_CMD_AUTO_NULL    (1<<0)
  89
  90 #define ADIS16260_SPI_SLOW      (u32)(300 * 1000)
  91 #define ADIS16260_SPI_BURST     (u32)(1000 * 1000)
  92 #define ADIS16260_SPI_FAST      (u32)(2000 * 1000)
  93
  94 /* At the moment triggers are only used for ring buffer
  95  * filling. This may change!
  96  */
  97
  98 #define ADIS16260_SCAN_GYRO     0
  99 #define ADIS16260_SCAN_SUPPLY   1
 100 #define ADIS16260_SCAN_AUX_ADC  2
 101 #define ADIS16260_SCAN_TEMP     3
 102 #define ADIS16260_SCAN_ANGL     4
 103
 104 static ssize_t adis16260_read_frequency(struct device *dev,
 105                 struct device_attribute *attr,
 106                 char *buf)
 107 {
 108         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 109         struct adis *adis = iio_priv(indio_dev);
 110         int ret, len = 0;
 111         u16 t;
 112         int sps;
 113         ret = adis_read_reg_16(adis, ADIS16260_SMPL_PRD, &t);
 114         if (ret)
 115                 return ret;
 116
 117         if (spi_get_device_id(adis->spi)->driver_data) /* If an adis16251 */
 118                 sps = (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 8 : 256;
 119         else
 120                 sps = (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 66 : 2048;
 121         sps /= (t & ADIS16260_SMPL_PRD_DIV_MASK) + 1;
 122         len = sprintf(buf, "%d\n", sps);
 123         return len;
 124 }
 125
 126 static ssize_t adis16260_write_frequency(struct device *dev,
 127                 struct device_attribute *attr,
 128                 const char *buf,
 129                 size_t len)
 130 {
 131         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 132         struct adis *adis = iio_priv(indio_dev);
 133         unsigned int val;
 134         int ret;
 135         u8 t;
 136
 137         ret = kstrtouint(buf, 10, &val);
 138         if (ret)
 139                 return ret;
 140
 141         mutex_lock(&indio_dev->mlock);
 142         if (spi_get_device_id(adis->spi)->driver_data)
 143                 t = 256 / val;
 144         else
 145                 t = 2048 / val;
 146
 147         if (t > ADIS16260_SMPL_PRD_DIV_MASK)
 148                 t = ADIS16260_SMPL_PRD_DIV_MASK;
 149         else if (t > 0)
 150                 t--;
 151
 152         if (t >= 0x0A)
 153                 adis->spi->max_speed_hz = ADIS16260_SPI_SLOW;
 154         else
 155                 adis->spi->max_speed_hz = ADIS16260_SPI_FAST;
 156         ret = adis_write_reg_8(adis, ADIS16260_SMPL_PRD, t);
 157
 158         mutex_unlock(&indio_dev->mlock);
 159
 160         return ret ? ret : len;
 161 }
 162
 163 /* Power down the device */
 164 static int adis16260_stop_device(struct iio_dev *indio_dev)
 165 {
 166         struct adis *adis = iio_priv(indio_dev);
 167         int ret;
 168         u16 val = ADIS16260_SLP_CNT_POWER_OFF;
 169
 170         ret = adis_write_reg_16(adis, ADIS16260_SLP_CNT, val);
 171         if (ret)
 172                 dev_err(&indio_dev->dev, "problem with turning device off: SLP_CNT");
 173
 174         return ret;
 175 }
 176
 177 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 178                 adis16260_read_frequency,
 179                 adis16260_write_frequency);
 180
 181 static const struct iio_chan_spec adis16260_channels[] = {
 182         ADIS_GYRO_CHAN(X, ADIS16260_GYRO_OUT, ADIS16260_SCAN_GYRO,
 183                 BIT(IIO_CHAN_INFO_CALIBBIAS) |
 184                 BIT(IIO_CHAN_INFO_CALIBSCALE), 14),
 185         ADIS_INCLI_CHAN(X, ADIS16260_ANGL_OUT, ADIS16260_SCAN_ANGL, 0, 14),
 186         ADIS_TEMP_CHAN(ADIS16260_TEMP_OUT, ADIS16260_SCAN_TEMP, 12),
 187         ADIS_SUPPLY_CHAN(ADIS16260_SUPPLY_OUT, ADIS16260_SCAN_SUPPLY, 12),
 188         ADIS_AUX_ADC_CHAN(ADIS16260_AUX_ADC, ADIS16260_SCAN_AUX_ADC, 12),
 189         IIO_CHAN_SOFT_TIMESTAMP(5),
 190 };
 191
 192 static const u8 adis16260_addresses[][2] = {
 193         [ADIS16260_SCAN_GYRO] = { ADIS16260_GYRO_OFF, ADIS16260_GYRO_SCALE },
 194 };
 195
 196 static int adis16260_read_raw(struct iio_dev *indio_dev,
 197                               struct iio_chan_spec const *chan,
 198                               int *val, int *val2,
 199                               long mask)
 200 {
 201         struct adis *adis = iio_priv(indio_dev);
 202         int ret;
 203         u8 addr;
 204         s16 val16;
 205
 206         switch (mask) {
 207         case IIO_CHAN_INFO_RAW:
 208                 return adis_single_conversion(indio_dev, chan,
 209                                 ADIS16260_ERROR_ACTIVE, val);
 210         case IIO_CHAN_INFO_SCALE:
 211                 switch (chan->type) {
 212                 case IIO_ANGL_VEL:
 213                         *val = 0;
 214                         if (spi_get_device_id(adis->spi)->driver_data) {
 215                                 /* 0.01832 degree / sec */
 216                                 *val2 = IIO_DEGREE_TO_RAD(18320);
 217                         } else {
 218                                 /* 0.07326 degree / sec */
 219                                 *val2 = IIO_DEGREE_TO_RAD(73260);
 220                         }
 221                         return IIO_VAL_INT_PLUS_MICRO;
 222                 case IIO_INCLI:
 223                         *val = 0;
 224                         *val2 = IIO_DEGREE_TO_RAD(36630);
 225                         return IIO_VAL_INT_PLUS_MICRO;
 226                 case IIO_VOLTAGE:
 227                         if (chan->channel == 0) {
 228                                 *val = 1;
 229                                 *val2 = 831500; /* 1.8315 mV */
 230                         } else {
 231                                 *val = 0;
 232                                 *val2 = 610500; /* 610.5 uV */
 233                         }
 234                         return IIO_VAL_INT_PLUS_MICRO;
 235                 case IIO_TEMP:
 236                         *val = 145;
 237                         *val2 = 300000; /* 0.1453 C */
 238                         return IIO_VAL_INT_PLUS_MICRO;
 239                 default:
 240                         return -EINVAL;
 241                 }
 242                 break;
 243         case IIO_CHAN_INFO_OFFSET:
 244                 *val = 250000 / 1453; /* 25 C = 0x00 */
 245                 return IIO_VAL_INT;
 246         case IIO_CHAN_INFO_CALIBBIAS:
 247                 addr = adis16260_addresses[chan->scan_index][0];
 248                 ret = adis_read_reg_16(adis, addr, &val16);
 249                 if (ret)
 250                         return ret;
 251
 252                 *val = sign_extend32(val16, 11);
 253                 return IIO_VAL_INT;
 254         case IIO_CHAN_INFO_CALIBSCALE:
 255                 addr = adis16260_addresses[chan->scan_index][1];
 256                 ret = adis_read_reg_16(adis, addr, &val16);
 257                 if (ret)
 258                         return ret;
 259
 260                 *val = val16;
 261                 return IIO_VAL_INT;
 262         }
 263         return -EINVAL;
 264 }
 265
 266 static int adis16260_write_raw(struct iio_dev *indio_dev,
 267                                struct iio_chan_spec const *chan,
 268                                int val,
 269                                int val2,
 270                                long mask)
 271 {
 272         struct adis *adis = iio_priv(indio_dev);
 273         u8 addr;
 274
 275         switch (mask) {
 276         case IIO_CHAN_INFO_CALIBBIAS:
 277                 if (val < -2048 || val >= 2048)
 278                         return -EINVAL;
 279
 280                 addr = adis16260_addresses[chan->scan_index][0];
 281                 return adis_write_reg_16(adis, addr, val);
 282         case IIO_CHAN_INFO_CALIBSCALE:
 283                 if (val < 0 || val >= 4096)
 284                         return -EINVAL;
 285
 286                 addr = adis16260_addresses[chan->scan_index][1];
 287                 return adis_write_reg_16(adis, addr, val);
 288         }
 289         return -EINVAL;
 290 }
 291
 292 static struct attribute *adis16260_attributes[] = {
 293         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 294         NULL
 295 };
 296
 297 static const struct attribute_group adis16260_attribute_group = {
 298         .attrs = adis16260_attributes,
 299 };
 300
 301 static const struct iio_info adis16260_info = {
 302         .attrs = &adis16260_attribute_group,
 303         .read_raw = &adis16260_read_raw,
 304         .write_raw = &adis16260_write_raw,
 305         .update_scan_mode = adis_update_scan_mode,
 306         .driver_module = THIS_MODULE,
 307 };
 308
 309 static const char * const adis1620_status_error_msgs[] = {
 310         [ADIS16260_DIAG_STAT_FLASH_CHK_BIT] = "Flash checksum error",
 311         [ADIS16260_DIAG_STAT_SELF_TEST_BIT] = "Self test error",
 312         [ADIS16260_DIAG_STAT_OVERFLOW_BIT] = "Sensor overrange",
 313         [ADIS16260_DIAG_STAT_SPI_FAIL_BIT] = "SPI failure",
 314         [ADIS16260_DIAG_STAT_FLASH_UPT_BIT] = "Flash update failed",
 315         [ADIS16260_DIAG_STAT_POWER_HIGH_BIT] = "Power supply above 5.25",
 316         [ADIS16260_DIAG_STAT_POWER_LOW_BIT] = "Power supply below 4.75",
 317 };
 318
 319 static const struct adis_data adis16260_data = {
 320         .write_delay = 30,
 321         .read_delay = 30,
 322         .msc_ctrl_reg = ADIS16260_MSC_CTRL,
 323         .glob_cmd_reg = ADIS16260_GLOB_CMD,
 324         .diag_stat_reg = ADIS16260_DIAG_STAT,
 325
 326         .self_test_mask = ADIS16260_MSC_CTRL_MEM_TEST,
 327         .startup_delay = ADIS16260_STARTUP_DELAY,
 328
 329         .status_error_msgs = adis1620_status_error_msgs,
 330         .status_error_mask = BIT(ADIS16260_DIAG_STAT_FLASH_CHK_BIT) |
 331                 BIT(ADIS16260_DIAG_STAT_SELF_TEST_BIT) |
 332                 BIT(ADIS16260_DIAG_STAT_OVERFLOW_BIT) |
 333                 BIT(ADIS16260_DIAG_STAT_SPI_FAIL_BIT) |
 334                 BIT(ADIS16260_DIAG_STAT_FLASH_UPT_BIT) |
 335                 BIT(ADIS16260_DIAG_STAT_POWER_HIGH_BIT) |
 336                 BIT(ADIS16260_DIAG_STAT_POWER_LOW_BIT),
 337 };
 338
 339 static int adis16260_probe(struct spi_device *spi)
 340 {
 341         struct iio_dev *indio_dev;
 342         struct adis *adis;
 343         int ret;
 344
 345         /* setup the industrialio driver allocated elements */
 346         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adis));
 347         if (!indio_dev)
 348                 return -ENOMEM;
 349         adis = iio_priv(indio_dev);
 350         /* this is only used for removal purposes */
 351         spi_set_drvdata(spi, indio_dev);
 352
 353         indio_dev->name = spi_get_device_id(spi)->name;
 354         indio_dev->dev.parent = &spi->dev;
 355         indio_dev->info = &adis16260_info;
 356         indio_dev->channels = adis16260_channels;
 357         indio_dev->num_channels = ARRAY_SIZE(adis16260_channels);
 358         indio_dev->modes = INDIO_DIRECT_MODE;
 359
 360         ret = adis_init(adis, indio_dev, spi, &adis16260_data);
 361         if (ret)
 362                 return ret;
 363
 364         ret = adis_setup_buffer_and_trigger(adis, indio_dev, NULL);
 365         if (ret)
 366                 return ret;
 367
 368         /* Get the device into a sane initial state */
 369         ret = adis_initial_startup(adis);
 370         if (ret)
 371                 goto error_cleanup_buffer_trigger;
 372         ret = iio_device_register(indio_dev);
 373         if (ret)
 374                 goto error_cleanup_buffer_trigger;
 375
 376         return 0;
 377
 378 error_cleanup_buffer_trigger:
 379         adis_cleanup_buffer_and_trigger(adis, indio_dev);
 380         return ret;
 381 }
 382
 383 static int adis16260_remove(struct spi_device *spi)
 384 {
 385         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 386         struct adis *adis = iio_priv(indio_dev);
 387
 388         iio_device_unregister(indio_dev);
 389         adis16260_stop_device(indio_dev);
 390         adis_cleanup_buffer_and_trigger(adis, indio_dev);
 391
 392         return 0;
 393 }
 394
 395 /*
 396  * These parts do not need to be differentiated until someone adds
 397  * support for the on chip filtering.
 398  */
 399 static const struct spi_device_id adis16260_id[] = {
 400         {"adis16260", 0},
 401         {"adis16265", 0},
 402         {"adis16250", 0},
 403         {"adis16255", 0},
 404         {"adis16251", 1},
 405         {}
 406 };
 407 MODULE_DEVICE_TABLE(spi, adis16260_id);
 408
 409 static struct spi_driver adis16260_driver = {
 410         .driver = {
 411                 .name = "adis16260",
 412                 .owner = THIS_MODULE,
 413         },
 414         .probe = adis16260_probe,
 415         .remove = adis16260_remove,
 416         .id_table = adis16260_id,
 417 };
 418 module_spi_driver(adis16260_driver);
 419
 420 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
 421 MODULE_DESCRIPTION("Analog Devices ADIS16260/5 Digital Gyroscope Sensor");
 422 MODULE_LICENSE("GPL v2");