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