drivers/iio/gyro/adxrs450.c

   1 /*
   2  * ADXRS450/ADXRS453 Digital Output Gyroscope Driver
   3  *
   4  * Copyright 2011 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2.
   7  */
   8
   9 #include <linux/interrupt.h>
  10 #include <linux/irq.h>
  11 #include <linux/delay.h>
  12 #include <linux/mutex.h>
  13 #include <linux/device.h>
  14 #include <linux/kernel.h>
  15 #include <linux/spi/spi.h>
  16 #include <linux/slab.h>
  17 #include <linux/sysfs.h>
  18 #include <linux/list.h>
  19 #include <linux/module.h>
  20
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/sysfs.h>
  23
  24 #define ADXRS450_STARTUP_DELAY  50 /* ms */
  25
  26 /* The MSB for the spi commands */
  27 #define ADXRS450_SENSOR_DATA    (0x20 << 24)
  28 #define ADXRS450_WRITE_DATA     (0x40 << 24)
  29 #define ADXRS450_READ_DATA      (0x80 << 24)
  30
  31 #define ADXRS450_RATE1  0x00    /* Rate Registers */
  32 #define ADXRS450_TEMP1  0x02    /* Temperature Registers */
  33 #define ADXRS450_LOCST1 0x04    /* Low CST Memory Registers */
  34 #define ADXRS450_HICST1 0x06    /* High CST Memory Registers */
  35 #define ADXRS450_QUAD1  0x08    /* Quad Memory Registers */
  36 #define ADXRS450_FAULT1 0x0A    /* Fault Registers */
  37 #define ADXRS450_PID1   0x0C    /* Part ID Register 1 */
  38 #define ADXRS450_SNH    0x0E    /* Serial Number Registers, 4 bytes */
  39 #define ADXRS450_SNL    0x10
  40 #define ADXRS450_DNC1   0x12    /* Dynamic Null Correction Registers */
  41 /* Check bits */
  42 #define ADXRS450_P      0x01
  43 #define ADXRS450_CHK    0x02
  44 #define ADXRS450_CST    0x04
  45 #define ADXRS450_PWR    0x08
  46 #define ADXRS450_POR    0x10
  47 #define ADXRS450_NVM    0x20
  48 #define ADXRS450_Q      0x40
  49 #define ADXRS450_PLL    0x80
  50 #define ADXRS450_UV     0x100
  51 #define ADXRS450_OV     0x200
  52 #define ADXRS450_AMP    0x400
  53 #define ADXRS450_FAIL   0x800
  54
  55 #define ADXRS450_WRERR_MASK     (0x7 << 29)
  56
  57 #define ADXRS450_MAX_RX 4
  58 #define ADXRS450_MAX_TX 4
  59
  60 #define ADXRS450_GET_ST(a)      ((a >> 26) & 0x3)
  61
  62 enum {
  63         ID_ADXRS450,
  64         ID_ADXRS453,
  65 };
  66
  67 /**
  68  * struct adxrs450_state - device instance specific data
  69  * @us:                 actual spi_device
  70  * @buf_lock:           mutex to protect tx and rx
  71  * @tx:                 transmit buffer
  72  * @rx:                 receive buffer
  73  **/
  74 struct adxrs450_state {
  75         struct spi_device       *us;
  76         struct mutex            buf_lock;
  77         __be32                  tx ____cacheline_aligned;
  78         __be32                  rx;
  79
  80 };
  81
  82 /**
  83  * adxrs450_spi_read_reg_16() - read 2 bytes from a register pair
  84  * @indio_dev: device associated with child of actual iio_dev
  85  * @reg_address: the address of the lower of the two registers, which should be
  86  *      an even address, the second register's address is reg_address + 1.
  87  * @val: somewhere to pass back the value read
  88  **/
  89 static int adxrs450_spi_read_reg_16(struct iio_dev *indio_dev,
  90                                     u8 reg_address,
  91                                     u16 *val)
  92 {
  93         struct adxrs450_state *st = iio_priv(indio_dev);
  94         u32 tx;
  95         int ret;
  96         struct spi_transfer xfers[] = {
  97                 {
  98                         .tx_buf = &st->tx,
  99                         .bits_per_word = 8,
 100                         .len = sizeof(st->tx),
 101                         .cs_change = 1,
 102                 }, {
 103                         .rx_buf = &st->rx,
 104                         .bits_per_word = 8,
 105                         .len = sizeof(st->rx),
 106                 },
 107         };
 108
 109         mutex_lock(&st->buf_lock);
 110         tx = ADXRS450_READ_DATA | (reg_address << 17);
 111
 112         if (!(hweight32(tx) & 1))
 113                 tx |= ADXRS450_P;
 114
 115         st->tx = cpu_to_be32(tx);
 116         ret = spi_sync_transfer(st->us, xfers, ARRAY_SIZE(xfers));
 117         if (ret) {
 118                 dev_err(&st->us->dev, "problem while reading 16 bit register 0x%02x\n",
 119                                 reg_address);
 120                 goto error_ret;
 121         }
 122
 123         *val = (be32_to_cpu(st->rx) >> 5) & 0xFFFF;
 124
 125 error_ret:
 126         mutex_unlock(&st->buf_lock);
 127         return ret;
 128 }
 129
 130 /**
 131  * adxrs450_spi_write_reg_16() - write 2 bytes data to a register pair
 132  * @indio_dev: device associated with child of actual actual iio_dev
 133  * @reg_address: the address of the lower of the two registers,which should be
 134  *      an even address, the second register's address is reg_address + 1.
 135  * @val: value to be written.
 136  **/
 137 static int adxrs450_spi_write_reg_16(struct iio_dev *indio_dev,
 138                                      u8 reg_address,
 139                                      u16 val)
 140 {
 141         struct adxrs450_state *st = iio_priv(indio_dev);
 142         u32 tx;
 143         int ret;
 144
 145         mutex_lock(&st->buf_lock);
 146         tx = ADXRS450_WRITE_DATA | (reg_address << 17) | (val << 1);
 147
 148         if (!(hweight32(tx) & 1))
 149                 tx |= ADXRS450_P;
 150
 151         st->tx = cpu_to_be32(tx);
 152         ret = spi_write(st->us, &st->tx, sizeof(st->tx));
 153         if (ret)
 154                 dev_err(&st->us->dev, "problem while writing 16 bit register 0x%02x\n",
 155                         reg_address);
 156         usleep_range(100, 1000); /* enforce sequential transfer delay 0.1ms */
 157         mutex_unlock(&st->buf_lock);
 158         return ret;
 159 }
 160
 161 /**
 162  * adxrs450_spi_sensor_data() - read 2 bytes sensor data
 163  * @indio_dev: device associated with child of actual iio_dev
 164  * @val: somewhere to pass back the value read
 165  **/
 166 static int adxrs450_spi_sensor_data(struct iio_dev *indio_dev, s16 *val)
 167 {
 168         struct adxrs450_state *st = iio_priv(indio_dev);
 169         int ret;
 170         struct spi_transfer xfers[] = {
 171                 {
 172                         .tx_buf = &st->tx,
 173                         .bits_per_word = 8,
 174                         .len = sizeof(st->tx),
 175                         .cs_change = 1,
 176                 }, {
 177                         .rx_buf = &st->rx,
 178                         .bits_per_word = 8,
 179                         .len = sizeof(st->rx),
 180                 },
 181         };
 182
 183         mutex_lock(&st->buf_lock);
 184         st->tx = cpu_to_be32(ADXRS450_SENSOR_DATA);
 185
 186         ret = spi_sync_transfer(st->us, xfers, ARRAY_SIZE(xfers));
 187         if (ret) {
 188                 dev_err(&st->us->dev, "Problem while reading sensor data\n");
 189                 goto error_ret;
 190         }
 191
 192         *val = (be32_to_cpu(st->rx) >> 10) & 0xFFFF;
 193
 194 error_ret:
 195         mutex_unlock(&st->buf_lock);
 196         return ret;
 197 }
 198
 199 /**
 200  * adxrs450_spi_initial() - use for initializing procedure.
 201  * @st: device instance specific data
 202  * @val: somewhere to pass back the value read
 203  * @chk: Whether to perform fault check
 204  **/
 205 static int adxrs450_spi_initial(struct adxrs450_state *st,
 206                 u32 *val, char chk)
 207 {
 208         int ret;
 209         u32 tx;
 210         struct spi_transfer xfers = {
 211                 .tx_buf = &st->tx,
 212                 .rx_buf = &st->rx,
 213                 .bits_per_word = 8,
 214                 .len = sizeof(st->tx),
 215         };
 216
 217         mutex_lock(&st->buf_lock);
 218         tx = ADXRS450_SENSOR_DATA;
 219         if (chk)
 220                 tx |= (ADXRS450_CHK | ADXRS450_P);
 221         st->tx = cpu_to_be32(tx);
 222         ret = spi_sync_transfer(st->us, &xfers, 1);
 223         if (ret) {
 224                 dev_err(&st->us->dev, "Problem while reading initializing data\n");
 225                 goto error_ret;
 226         }
 227
 228         *val = be32_to_cpu(st->rx);
 229
 230 error_ret:
 231         mutex_unlock(&st->buf_lock);
 232         return ret;
 233 }
 234
 235 /* Recommended Startup Sequence by spec */
 236 static int adxrs450_initial_setup(struct iio_dev *indio_dev)
 237 {
 238         u32 t;
 239         u16 data;
 240         int ret;
 241         struct adxrs450_state *st = iio_priv(indio_dev);
 242
 243         msleep(ADXRS450_STARTUP_DELAY*2);
 244         ret = adxrs450_spi_initial(st, &t, 1);
 245         if (ret)
 246                 return ret;
 247         if (t != 0x01)
 248                 dev_warn(&st->us->dev, "The initial power on response is not correct! Restart without reset?\n");
 249
 250         msleep(ADXRS450_STARTUP_DELAY);
 251         ret = adxrs450_spi_initial(st, &t, 0);
 252         if (ret)
 253                 return ret;
 254
 255         msleep(ADXRS450_STARTUP_DELAY);
 256         ret = adxrs450_spi_initial(st, &t, 0);
 257         if (ret)
 258                 return ret;
 259         if (((t & 0xff) | 0x01) != 0xff || ADXRS450_GET_ST(t) != 2) {
 260                 dev_err(&st->us->dev, "The second response is not correct!\n");
 261                 return -EIO;
 262
 263         }
 264         ret = adxrs450_spi_initial(st, &t, 0);
 265         if (ret)
 266                 return ret;
 267         if (((t & 0xff) | 0x01) != 0xff || ADXRS450_GET_ST(t) != 2) {
 268                 dev_err(&st->us->dev, "The third response is not correct!\n");
 269                 return -EIO;
 270
 271         }
 272         ret = adxrs450_spi_read_reg_16(indio_dev, ADXRS450_FAULT1, &data);
 273         if (ret)
 274                 return ret;
 275         if (data & 0x0fff) {
 276                 dev_err(&st->us->dev, "The device is not in normal status!\n");
 277                 return -EINVAL;
 278         }
 279
 280         return 0;
 281 }
 282
 283 static int adxrs450_write_raw(struct iio_dev *indio_dev,
 284                               struct iio_chan_spec const *chan,
 285                               int val,
 286                               int val2,
 287                               long mask)
 288 {
 289         int ret;
 290         switch (mask) {
 291         case IIO_CHAN_INFO_CALIBBIAS:
 292                 if (val < -0x400 || val >= 0x400)
 293                         return -EINVAL;
 294                 ret = adxrs450_spi_write_reg_16(indio_dev,
 295                                                 ADXRS450_DNC1, val);
 296                 break;
 297         default:
 298                 ret = -EINVAL;
 299                 break;
 300         }
 301         return ret;
 302 }
 303
 304 static int adxrs450_read_raw(struct iio_dev *indio_dev,
 305                              struct iio_chan_spec const *chan,
 306                              int *val,
 307                              int *val2,
 308                              long mask)
 309 {
 310         int ret;
 311         s16 t;
 312
 313         switch (mask) {
 314         case IIO_CHAN_INFO_RAW:
 315                 switch (chan->type) {
 316                 case IIO_ANGL_VEL:
 317                         ret = adxrs450_spi_sensor_data(indio_dev, &t);
 318                         if (ret)
 319                                 break;
 320                         *val = t;
 321                         ret = IIO_VAL_INT;
 322                         break;
 323                 case IIO_TEMP:
 324                         ret = adxrs450_spi_read_reg_16(indio_dev,
 325                                                        ADXRS450_TEMP1, &t);
 326                         if (ret)
 327                                 break;
 328                         *val = (t >> 6) + 225;
 329                         ret = IIO_VAL_INT;
 330                         break;
 331                 default:
 332                         ret = -EINVAL;
 333                         break;
 334                 }
 335                 break;
 336         case IIO_CHAN_INFO_SCALE:
 337                 switch (chan->type) {
 338                 case IIO_ANGL_VEL:
 339                         *val = 0;
 340                         *val2 = 218166;
 341                         return IIO_VAL_INT_PLUS_NANO;
 342                 case IIO_TEMP:
 343                         *val = 200;
 344                         *val2 = 0;
 345                         return IIO_VAL_INT;
 346                 default:
 347                         return -EINVAL;
 348                 }
 349         case IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW:
 350                 ret = adxrs450_spi_read_reg_16(indio_dev, ADXRS450_QUAD1, &t);
 351                 if (ret)
 352                         break;
 353                 *val = t;
 354                 ret = IIO_VAL_INT;
 355                 break;
 356         case IIO_CHAN_INFO_CALIBBIAS:
 357                 ret = adxrs450_spi_read_reg_16(indio_dev, ADXRS450_DNC1, &t);
 358                 if (ret)
 359                         break;
 360                 *val = sign_extend32(t, 9);
 361                 ret = IIO_VAL_INT;
 362                 break;
 363         default:
 364                 ret = -EINVAL;
 365                 break;
 366         }
 367
 368         return ret;
 369 }
 370
 371 static const struct iio_chan_spec adxrs450_channels[2][2] = {
 372         [ID_ADXRS450] = {
 373                 {
 374                         .type = IIO_ANGL_VEL,
 375                         .modified = 1,
 376                         .channel2 = IIO_MOD_Z,
 377                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 378                         BIT(IIO_CHAN_INFO_CALIBBIAS) |
 379                         BIT(IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW) |
 380                         BIT(IIO_CHAN_INFO_SCALE),
 381                 }, {
 382                         .type = IIO_TEMP,
 383                         .indexed = 1,
 384                         .channel = 0,
 385                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 386                         BIT(IIO_CHAN_INFO_SCALE),
 387                 }
 388         },
 389         [ID_ADXRS453] = {
 390                 {
 391                         .type = IIO_ANGL_VEL,
 392                         .modified = 1,
 393                         .channel2 = IIO_MOD_Z,
 394                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 395                         BIT(IIO_CHAN_INFO_SCALE) |
 396                         BIT(IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW),
 397                 }, {
 398                         .type = IIO_TEMP,
 399                         .indexed = 1,
 400                         .channel = 0,
 401                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 402                         BIT(IIO_CHAN_INFO_SCALE),
 403                 }
 404         },
 405 };
 406
 407 static const struct iio_info adxrs450_info = {
 408         .driver_module = THIS_MODULE,
 409         .read_raw = &adxrs450_read_raw,
 410         .write_raw = &adxrs450_write_raw,
 411 };
 412
 413 static int adxrs450_probe(struct spi_device *spi)
 414 {
 415         int ret;
 416         struct adxrs450_state *st;
 417         struct iio_dev *indio_dev;
 418
 419         /* setup the industrialio driver allocated elements */
 420         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 421         if (!indio_dev)
 422                 return -ENOMEM;
 423         st = iio_priv(indio_dev);
 424         st->us = spi;
 425         mutex_init(&st->buf_lock);
 426         /* This is only used for removal purposes */
 427         spi_set_drvdata(spi, indio_dev);
 428
 429         indio_dev->dev.parent = &spi->dev;
 430         indio_dev->info = &adxrs450_info;
 431         indio_dev->modes = INDIO_DIRECT_MODE;
 432         indio_dev->channels =
 433                 adxrs450_channels[spi_get_device_id(spi)->driver_data];
 434         indio_dev->num_channels = ARRAY_SIZE(adxrs450_channels);
 435         indio_dev->name = spi->dev.driver->name;
 436
 437         ret = devm_iio_device_register(&spi->dev, indio_dev);
 438         if (ret)
 439                 return ret;
 440
 441         /* Get the device into a sane initial state */
 442         ret = adxrs450_initial_setup(indio_dev);
 443         if (ret)
 444                 return ret;
 445
 446         return 0;
 447 }
 448
 449 static const struct spi_device_id adxrs450_id[] = {
 450         {"adxrs450", ID_ADXRS450},
 451         {"adxrs453", ID_ADXRS453},
 452         {}
 453 };
 454 MODULE_DEVICE_TABLE(spi, adxrs450_id);
 455
 456 static struct spi_driver adxrs450_driver = {
 457         .driver = {
 458                 .name = "adxrs450",
 459         },
 460         .probe = adxrs450_probe,
 461         .id_table       = adxrs450_id,
 462 };
 463 module_spi_driver(adxrs450_driver);
 464
 465 MODULE_AUTHOR("Cliff Cai <cliff.cai@xxxxxxxxxx>");
 466 MODULE_DESCRIPTION("Analog Devices ADXRS450/ADXRS453 Gyroscope SPI driver");
 467 MODULE_LICENSE("GPL v2");