drivers/iio/imu/adis.c

   1 /*
   2  * Common library for ADIS16XXX devices
   3  *
   4  * Copyright 2012 Analog Devices Inc.
   5  *   Author: Lars-Peter Clausen <lars@metafoo.de>
   6  *
   7  * Licensed under the GPL-2 or later.
   8  */
   9
  10 #include <linux/delay.h>
  11 #include <linux/mutex.h>
  12 #include <linux/device.h>
  13 #include <linux/kernel.h>
  14 #include <linux/spi/spi.h>
  15 #include <linux/slab.h>
  16 #include <linux/sysfs.h>
  17 #include <linux/module.h>
  18 #include <asm/unaligned.h>
  19
  20 #include <linux/iio/iio.h>
  21 #include <linux/iio/sysfs.h>
  22 #include <linux/iio/buffer.h>
  23 #include <linux/iio/imu/adis.h>
  24
  25 #define ADIS_MSC_CTRL_DATA_RDY_EN       BIT(2)
  26 #define ADIS_MSC_CTRL_DATA_RDY_POL_HIGH BIT(1)
  27 #define ADIS_MSC_CTRL_DATA_RDY_DIO2     BIT(0)
  28 #define ADIS_GLOB_CMD_SW_RESET          BIT(7)
  29
  30 int adis_write_reg(struct adis *adis, unsigned int reg,
  31         unsigned int value, unsigned int size)
  32 {
  33         int ret, i;
  34         struct spi_message msg;
  35         struct spi_transfer xfers[] = {
  36                 {
  37                         .tx_buf = adis->tx,
  38                         .bits_per_word = 8,
  39                         .len = 2,
  40                         .cs_change = 1,
  41                         .delay_usecs = adis->data->write_delay,
  42                 }, {
  43                         .tx_buf = adis->tx + 2,
  44                         .bits_per_word = 8,
  45                         .len = 2,
  46                         .cs_change = 1,
  47                         .delay_usecs = adis->data->write_delay,
  48                 }, {
  49                         .tx_buf = adis->tx + 4,
  50                         .bits_per_word = 8,
  51                         .len = 2,
  52                         .cs_change = 1,
  53                         .delay_usecs = adis->data->write_delay,
  54                 }, {
  55                         .tx_buf = adis->tx + 6,
  56                         .bits_per_word = 8,
  57                         .len = 2,
  58                         .delay_usecs = adis->data->write_delay,
  59                 },
  60         };
  61
  62         mutex_lock(&adis->txrx_lock);
  63
  64         spi_message_init(&msg);
  65         switch (size) {
  66         case 4:
  67                 adis->tx[6] = ADIS_WRITE_REG(reg + 3);
  68                 adis->tx[7] = (value >> 24) & 0xff;
  69                 adis->tx[4] = ADIS_WRITE_REG(reg + 2);
  70                 adis->tx[5] = (value >> 16) & 0xff;
  71         case 2:
  72                 adis->tx[2] = ADIS_WRITE_REG(reg + 1);
  73                 adis->tx[3] = (value >> 8) & 0xff;
  74         case 1:
  75                 adis->tx[0] = ADIS_WRITE_REG(reg);
  76                 adis->tx[1] = value & 0xff;
  77                 break;
  78         default:
  79                 ret = -EINVAL;
  80                 goto out_unlock;
  81         }
  82
  83         xfers[size - 1].cs_change = 0;
  84
  85         for (i = 0; i < size; i++)
  86                 spi_message_add_tail(&xfers[i], &msg);
  87
  88         ret = spi_sync(adis->spi, &msg);
  89         if (ret) {
  90                 dev_err(&adis->spi->dev, "Failed to write register 0x%02X: %d\n",
  91                                 reg, ret);
  92         }
  93
  94 out_unlock:
  95         mutex_unlock(&adis->txrx_lock);
  96
  97         return ret;
  98 }
  99 EXPORT_SYMBOL_GPL(adis_write_reg);
 100
 101 /**
 102  * adis_read_reg() - read 2 bytes from a 16-bit register
 103  * @adis: The adis device
 104  * @reg: The address of the lower of the two registers
 105  * @val: The value read back from the device
 106  */
 107 int adis_read_reg(struct adis *adis, unsigned int reg,
 108         unsigned int *val, unsigned int size)
 109 {
 110         struct spi_message msg;
 111         int ret;
 112         struct spi_transfer xfers[] = {
 113                 {
 114                         .tx_buf = adis->tx,
 115                         .bits_per_word = 8,
 116                         .len = 2,
 117                         .cs_change = 1,
 118                         .delay_usecs = adis->data->read_delay,
 119                 }, {
 120                         .tx_buf = adis->tx + 2,
 121                         .rx_buf = adis->rx,
 122                         .bits_per_word = 8,
 123                         .len = 2,
 124                         .cs_change = 1,
 125                         .delay_usecs = adis->data->read_delay,
 126                 }, {
 127                         .rx_buf = adis->rx + 2,
 128                         .bits_per_word = 8,
 129                         .len = 2,
 130                         .delay_usecs = adis->data->read_delay,
 131                 },
 132         };
 133
 134         mutex_lock(&adis->txrx_lock);
 135         spi_message_init(&msg);
 136
 137         switch (size) {
 138         case 4:
 139                 adis->tx[0] = ADIS_READ_REG(reg + 2);
 140                 adis->tx[1] = 0;
 141                 spi_message_add_tail(&xfers[0], &msg);
 142         case 2:
 143                 adis->tx[2] = ADIS_READ_REG(reg);
 144                 adis->tx[3] = 0;
 145                 spi_message_add_tail(&xfers[1], &msg);
 146                 spi_message_add_tail(&xfers[2], &msg);
 147                 break;
 148         default:
 149                 ret = -EINVAL;
 150                 goto out_unlock;
 151         }
 152
 153         ret = spi_sync(adis->spi, &msg);
 154         if (ret) {
 155                 dev_err(&adis->spi->dev, "Failed to read register 0x%02X: %d\n",
 156                                 reg, ret);
 157                 goto out_unlock;
 158         }
 159
 160         switch (size) {
 161         case 4:
 162                 *val = get_unaligned_be32(adis->rx);
 163                 break;
 164         case 2:
 165                 *val = get_unaligned_be16(adis->rx + 2);
 166                 break;
 167         }
 168
 169 out_unlock:
 170         mutex_unlock(&adis->txrx_lock);
 171
 172         return ret;
 173 }
 174 EXPORT_SYMBOL_GPL(adis_read_reg);
 175
 176 #ifdef CONFIG_DEBUG_FS
 177
 178 int adis_debugfs_reg_access(struct iio_dev *indio_dev,
 179         unsigned int reg, unsigned int writeval, unsigned int *readval)
 180 {
 181         struct adis *adis = iio_device_get_drvdata(indio_dev);
 182
 183         if (readval) {
 184                 uint16_t val16;
 185                 int ret;
 186
 187                 ret = adis_read_reg_16(adis, reg, &val16);
 188                 *readval = val16;
 189
 190                 return ret;
 191         } else {
 192                 return adis_write_reg_16(adis, reg, writeval);
 193         }
 194 }
 195 EXPORT_SYMBOL(adis_debugfs_reg_access);
 196
 197 #endif
 198
 199 /**
 200  * adis_enable_irq() - Enable or disable data ready IRQ
 201  * @adis: The adis device
 202  * @enable: Whether to enable the IRQ
 203  *
 204  * Returns 0 on success, negative error code otherwise
 205  */
 206 int adis_enable_irq(struct adis *adis, bool enable)
 207 {
 208         int ret = 0;
 209         uint16_t msc;
 210
 211         ret = adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc);
 212         if (ret)
 213                 goto error_ret;
 214
 215         msc |= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH;
 216         msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2;
 217         if (enable)
 218                 msc |= ADIS_MSC_CTRL_DATA_RDY_EN;
 219         else
 220                 msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN;
 221
 222         ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc);
 223
 224 error_ret:
 225         return ret;
 226 }
 227 EXPORT_SYMBOL(adis_enable_irq);
 228
 229 /**
 230  * adis_check_status() - Check the device for error conditions
 231  * @adis: The adis device
 232  *
 233  * Returns 0 on success, a negative error code otherwise
 234  */
 235 int adis_check_status(struct adis *adis)
 236 {
 237         uint16_t status;
 238         int ret;
 239         int i;
 240
 241         ret = adis_read_reg_16(adis, adis->data->diag_stat_reg, &status);
 242         if (ret < 0)
 243                 return ret;
 244
 245         status &= adis->data->status_error_mask;
 246
 247         if (status == 0)
 248                 return 0;
 249
 250         for (i = 0; i < 16; ++i) {
 251                 if (status & BIT(i)) {
 252                         dev_err(&adis->spi->dev, "%s.\n",
 253                                 adis->data->status_error_msgs[i]);
 254                 }
 255         }
 256
 257         return -EIO;
 258 }
 259 EXPORT_SYMBOL_GPL(adis_check_status);
 260
 261 /**
 262  * adis_reset() - Reset the device
 263  * @adis: The adis device
 264  *
 265  * Returns 0 on success, a negative error code otherwise
 266  */
 267 int adis_reset(struct adis *adis)
 268 {
 269         int ret;
 270
 271         ret = adis_write_reg_8(adis, adis->data->glob_cmd_reg,
 272                         ADIS_GLOB_CMD_SW_RESET);
 273         if (ret)
 274                 dev_err(&adis->spi->dev, "Failed to reset device: %d\n", ret);
 275
 276         return ret;
 277 }
 278 EXPORT_SYMBOL_GPL(adis_reset);
 279
 280 static int adis_self_test(struct adis *adis)
 281 {
 282         int ret;
 283
 284         ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg,
 285                         adis->data->self_test_mask);
 286         if (ret) {
 287                 dev_err(&adis->spi->dev, "Failed to initiate self test: %d\n",
 288                         ret);
 289                 return ret;
 290         }
 291
 292         msleep(adis->data->startup_delay);
 293
 294         return adis_check_status(adis);
 295 }
 296
 297 /**
 298  * adis_inital_startup() - Performs device self-test
 299  * @adis: The adis device
 300  *
 301  * Returns 0 if the device is operational, a negative error code otherwise.
 302  *
 303  * This function should be called early on in the device initialization sequence
 304  * to ensure that the device is in a sane and known state and that it is usable.
 305  */
 306 int adis_initial_startup(struct adis *adis)
 307 {
 308         int ret;
 309
 310         ret = adis_self_test(adis);
 311         if (ret) {
 312                 dev_err(&adis->spi->dev, "Self-test failed, trying reset.\n");
 313                 adis_reset(adis);
 314                 msleep(adis->data->startup_delay);
 315                 ret = adis_self_test(adis);
 316                 if (ret) {
 317                         dev_err(&adis->spi->dev, "Second self-test failed, giving up.\n");
 318                         return ret;
 319                 }
 320         }
 321
 322         return 0;
 323 }
 324 EXPORT_SYMBOL_GPL(adis_initial_startup);
 325
 326 /**
 327  * adis_single_conversion() - Performs a single sample conversion
 328  * @indio_dev: The IIO device
 329  * @chan: The IIO channel
 330  * @error_mask: Mask for the error bit
 331  * @val: Result of the conversion
 332  *
 333  * Returns IIO_VAL_INT on success, a negative error code otherwise.
 334  *
 335  * The function performs a single conversion on a given channel and post
 336  * processes the value accordingly to the channel spec. If a error_mask is given
 337  * the function will check if the mask is set in the returned raw value. If it
 338  * is set the function will perform a self-check. If the device does not report
 339  * a error bit in the channels raw value set error_mask to 0.
 340  */
 341 int adis_single_conversion(struct iio_dev *indio_dev,
 342         const struct iio_chan_spec *chan, unsigned int error_mask, int *val)
 343 {
 344         struct adis *adis = iio_device_get_drvdata(indio_dev);
 345         unsigned int uval;
 346         int ret;
 347
 348         mutex_lock(&indio_dev->mlock);
 349
 350         ret = adis_read_reg(adis, chan->address, &uval,
 351                         chan->scan_type.storagebits / 8);
 352         if (ret)
 353                 goto err_unlock;
 354
 355         if (uval & error_mask) {
 356                 ret = adis_check_status(adis);
 357                 if (ret)
 358                         goto err_unlock;
 359         }
 360
 361         if (chan->scan_type.sign == 's')
 362                 *val = sign_extend32(uval, chan->scan_type.realbits - 1);
 363         else
 364                 *val = uval & ((1 << chan->scan_type.realbits) - 1);
 365
 366         ret = IIO_VAL_INT;
 367 err_unlock:
 368         mutex_unlock(&indio_dev->mlock);
 369         return ret;
 370 }
 371 EXPORT_SYMBOL_GPL(adis_single_conversion);
 372
 373 /**
 374  * adis_init() - Initialize adis device structure
 375  * @adis:       The adis device
 376  * @indio_dev:  The iio device
 377  * @spi:        The spi device
 378  * @data:       Chip specific data
 379  *
 380  * Returns 0 on success, a negative error code otherwise.
 381  *
 382  * This function must be called, before any other adis helper function may be
 383  * called.
 384  */
 385 int adis_init(struct adis *adis, struct iio_dev *indio_dev,
 386         struct spi_device *spi, const struct adis_data *data)
 387 {
 388         mutex_init(&adis->txrx_lock);
 389         adis->spi = spi;
 390         adis->data = data;
 391         iio_device_set_drvdata(indio_dev, adis);
 392
 393         return adis_enable_irq(adis, false);
 394 }
 395 EXPORT_SYMBOL_GPL(adis_init);
 396
 397 MODULE_LICENSE("GPL");
 398 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
 399 MODULE_DESCRIPTION("Common library code for ADIS16XXX devices");