drivers/staging/iio/gyro/adis16260_core.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/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 #include <linux/iio/buffer.h>
  24
  25 #include "adis16260.h"
  26
  27 static ssize_t adis16260_read_frequency_available(struct device *dev,
  28                                                   struct device_attribute *attr,
  29                                                   char *buf)
  30 {
  31         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
  32         struct adis16260_state *st = iio_priv(indio_dev);
  33         if (spi_get_device_id(st->adis.spi)->driver_data)
  34                 return sprintf(buf, "%s\n", "0.129 ~ 256");
  35         else
  36                 return sprintf(buf, "%s\n", "256 2048");
  37 }
  38
  39 static ssize_t adis16260_read_frequency(struct device *dev,
  40                 struct device_attribute *attr,
  41                 char *buf)
  42 {
  43         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
  44         struct adis16260_state *st = iio_priv(indio_dev);
  45         int ret, len = 0;
  46         u16 t;
  47         int sps;
  48         ret = adis_read_reg_16(&st->adis, ADIS16260_SMPL_PRD, &t);
  49         if (ret)
  50                 return ret;
  51
  52         if (spi_get_device_id(st->adis.spi)->driver_data) /* If an adis16251 */
  53                 sps =  (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 8 : 256;
  54         else
  55                 sps =  (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 66 : 2048;
  56         sps /= (t & ADIS16260_SMPL_PRD_DIV_MASK) + 1;
  57         len = sprintf(buf, "%d SPS\n", sps);
  58         return len;
  59 }
  60
  61 static ssize_t adis16260_write_frequency(struct device *dev,
  62                 struct device_attribute *attr,
  63                 const char *buf,
  64                 size_t len)
  65 {
  66         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
  67         struct adis16260_state *st = iio_priv(indio_dev);
  68         long val;
  69         int ret;
  70         u8 t;
  71
  72         ret = strict_strtol(buf, 10, &val);
  73         if (ret)
  74                 return ret;
  75         if (val == 0)
  76                 return -EINVAL;
  77
  78         mutex_lock(&indio_dev->mlock);
  79         if (spi_get_device_id(st->adis.spi)->driver_data) {
  80                 t = (256 / val);
  81                 if (t > 0)
  82                         t--;
  83                 t &= ADIS16260_SMPL_PRD_DIV_MASK;
  84         } else {
  85                 t = (2048 / val);
  86                 if (t > 0)
  87                         t--;
  88                 t &= ADIS16260_SMPL_PRD_DIV_MASK;
  89         }
  90         if ((t & ADIS16260_SMPL_PRD_DIV_MASK) >= 0x0A)
  91                 st->adis.spi->max_speed_hz = ADIS16260_SPI_SLOW;
  92         else
  93                 st->adis.spi->max_speed_hz = ADIS16260_SPI_FAST;
  94         ret = adis_write_reg_8(&st->adis,
  95                         ADIS16260_SMPL_PRD,
  96                         t);
  97
  98         mutex_unlock(&indio_dev->mlock);
  99
 100         return ret ? ret : len;
 101 }
 102
 103 /* Power down the device */
 104 static int adis16260_stop_device(struct iio_dev *indio_dev)
 105 {
 106         struct adis16260_state *st = iio_priv(indio_dev);
 107         int ret;
 108         u16 val = ADIS16260_SLP_CNT_POWER_OFF;
 109
 110         ret = adis_write_reg_16(&st->adis, ADIS16260_SLP_CNT, val);
 111         if (ret)
 112                 dev_err(&indio_dev->dev, "problem with turning device off: SLP_CNT");
 113
 114         return ret;
 115 }
 116
 117 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 118                 adis16260_read_frequency,
 119                 adis16260_write_frequency);
 120
 121 static IIO_DEVICE_ATTR(sampling_frequency_available,
 122                        S_IRUGO, adis16260_read_frequency_available, NULL, 0);
 123
 124 #define ADIS16260_GYRO_CHANNEL_SET(axis, mod)                           \
 125 struct iio_chan_spec adis16260_channels_##axis[] = {            \
 126         ADIS_GYRO_CHAN(mod, ADIS16260_GYRO_OUT, ADIS16260_SCAN_GYRO, \
 127                 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT | \
 128                 IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT, 14), \
 129         ADIS_INCLI_CHAN(mod, ADIS16260_ANGL_OUT, ADIS16260_SCAN_ANGL, 0, 14), \
 130         ADIS_TEMP_CHAN(ADIS16260_TEMP_OUT, ADIS16260_SCAN_TEMP, 12), \
 131         ADIS_SUPPLY_CHAN(ADIS16260_SUPPLY_OUT, ADIS16260_SCAN_SUPPLY, 12), \
 132         ADIS_AUX_ADC_CHAN(ADIS16260_AUX_ADC, ADIS16260_SCAN_AUX_ADC, 12), \
 133         IIO_CHAN_SOFT_TIMESTAMP(5),                             \
 134 }
 135
 136 static const ADIS16260_GYRO_CHANNEL_SET(x, X);
 137 static const ADIS16260_GYRO_CHANNEL_SET(y, Y);
 138 static const ADIS16260_GYRO_CHANNEL_SET(z, Z);
 139
 140 static const u8 adis16260_addresses[][2] = {
 141         [ADIS16260_SCAN_GYRO] = { ADIS16260_GYRO_OFF, ADIS16260_GYRO_SCALE },
 142 };
 143
 144 static int adis16260_read_raw(struct iio_dev *indio_dev,
 145                               struct iio_chan_spec const *chan,
 146                               int *val, int *val2,
 147                               long mask)
 148 {
 149         struct adis16260_state *st = iio_priv(indio_dev);
 150         int ret;
 151         int bits;
 152         u8 addr;
 153         s16 val16;
 154
 155         switch (mask) {
 156         case IIO_CHAN_INFO_RAW:
 157                 return adis_single_conversion(indio_dev, chan,
 158                                 ADIS16260_ERROR_ACTIVE, val);
 159         case IIO_CHAN_INFO_SCALE:
 160                 switch (chan->type) {
 161                 case IIO_ANGL_VEL:
 162                         *val = 0;
 163                         if (spi_get_device_id(st->adis.spi)->driver_data) {
 164                                 /* 0.01832 degree / sec */
 165                                 *val2 = IIO_DEGREE_TO_RAD(18320);
 166                         } else {
 167                                 /* 0.07326 degree / sec */
 168                                 *val2 = IIO_DEGREE_TO_RAD(73260);
 169                         }
 170                         return IIO_VAL_INT_PLUS_MICRO;
 171                 case IIO_VOLTAGE:
 172                         if (chan->channel == 0) {
 173                                 *val = 1;
 174                                 *val2 = 831500; /* 1.8315 mV */
 175                         } else {
 176                                 *val = 0;
 177                                 *val2 = 610500; /* 610.5 uV */
 178                         }
 179                         return IIO_VAL_INT_PLUS_MICRO;
 180                 case IIO_TEMP:
 181                         *val = 145;
 182                         *val2 = 300000; /* 0.1453 C */
 183                         return IIO_VAL_INT_PLUS_MICRO;
 184                 default:
 185                         return -EINVAL;
 186                 }
 187                 break;
 188         case IIO_CHAN_INFO_OFFSET:
 189                 *val = 250000 / 1453; /* 25 C = 0x00 */
 190                 return IIO_VAL_INT;
 191         case IIO_CHAN_INFO_CALIBBIAS:
 192                 switch (chan->type) {
 193                 case IIO_ANGL_VEL:
 194                         bits = 12;
 195                         break;
 196                 default:
 197                         return -EINVAL;
 198                 }
 199                 mutex_lock(&indio_dev->mlock);
 200                 addr = adis16260_addresses[chan->scan_index][0];
 201                 ret = adis_read_reg_16(&st->adis, addr, &val16);
 202                 if (ret) {
 203                         mutex_unlock(&indio_dev->mlock);
 204                         return ret;
 205                 }
 206                 val16 &= (1 << bits) - 1;
 207                 val16 = (s16)(val16 << (16 - bits)) >> (16 - bits);
 208                 *val = val16;
 209                 mutex_unlock(&indio_dev->mlock);
 210                 return IIO_VAL_INT;
 211         case IIO_CHAN_INFO_CALIBSCALE:
 212                 switch (chan->type) {
 213                 case IIO_ANGL_VEL:
 214                         bits = 12;
 215                         break;
 216                 default:
 217                         return -EINVAL;
 218                 }
 219                 mutex_lock(&indio_dev->mlock);
 220                 addr = adis16260_addresses[chan->scan_index][1];
 221                 ret = adis_read_reg_16(&st->adis, addr, &val16);
 222                 if (ret) {
 223                         mutex_unlock(&indio_dev->mlock);
 224                         return ret;
 225                 }
 226                 *val = (1 << bits) - 1;
 227                 mutex_unlock(&indio_dev->mlock);
 228                 return IIO_VAL_INT;
 229         }
 230         return -EINVAL;
 231 }
 232
 233 static int adis16260_write_raw(struct iio_dev *indio_dev,
 234                                struct iio_chan_spec const *chan,
 235                                int val,
 236                                int val2,
 237                                long mask)
 238 {
 239         struct adis16260_state *st = iio_priv(indio_dev);
 240         int bits = 12;
 241         s16 val16;
 242         u8 addr;
 243         switch (mask) {
 244         case IIO_CHAN_INFO_CALIBBIAS:
 245                 val16 = val & ((1 << bits) - 1);
 246                 addr = adis16260_addresses[chan->scan_index][0];
 247                 return adis_write_reg_16(&st->adis, addr, val16);
 248         case IIO_CHAN_INFO_CALIBSCALE:
 249                 val16 = val & ((1 << bits) - 1);
 250                 addr = adis16260_addresses[chan->scan_index][1];
 251                 return adis_write_reg_16(&st->adis, addr, val16);
 252         }
 253         return -EINVAL;
 254 }
 255
 256 static struct attribute *adis16260_attributes[] = {
 257         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 258         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 259         NULL
 260 };
 261
 262 static const struct attribute_group adis16260_attribute_group = {
 263         .attrs = adis16260_attributes,
 264 };
 265
 266 static const struct iio_info adis16260_info = {
 267         .attrs = &adis16260_attribute_group,
 268         .read_raw = &adis16260_read_raw,
 269         .write_raw = &adis16260_write_raw,
 270         .update_scan_mode = adis_update_scan_mode,
 271         .driver_module = THIS_MODULE,
 272 };
 273
 274 static const char * const adis1620_status_error_msgs[] = {
 275         [ADIS16260_DIAG_STAT_FLASH_CHK_BIT] = "Flash checksum error",
 276         [ADIS16260_DIAG_STAT_SELF_TEST_BIT] = "Self test error",
 277         [ADIS16260_DIAG_STAT_OVERFLOW_BIT] = "Sensor overrange",
 278         [ADIS16260_DIAG_STAT_SPI_FAIL_BIT] = "SPI failure",
 279         [ADIS16260_DIAG_STAT_FLASH_UPT_BIT] = "Flash update failed",
 280         [ADIS16260_DIAG_STAT_POWER_HIGH_BIT] = "Power supply above 5.25",
 281         [ADIS16260_DIAG_STAT_POWER_LOW_BIT] = "Power supply below 4.75",
 282 };
 283
 284 static const struct adis_data adis16260_data = {
 285         .write_delay = 30,
 286         .read_delay = 30,
 287         .msc_ctrl_reg = ADIS16260_MSC_CTRL,
 288         .glob_cmd_reg = ADIS16260_GLOB_CMD,
 289         .diag_stat_reg = ADIS16260_DIAG_STAT,
 290
 291         .self_test_mask = ADIS16260_MSC_CTRL_MEM_TEST,
 292         .startup_delay = ADIS16260_STARTUP_DELAY,
 293
 294         .status_error_msgs = adis1620_status_error_msgs,
 295         .status_error_mask = BIT(ADIS16260_DIAG_STAT_FLASH_CHK_BIT) |
 296                 BIT(ADIS16260_DIAG_STAT_SELF_TEST_BIT) |
 297                 BIT(ADIS16260_DIAG_STAT_OVERFLOW_BIT) |
 298                 BIT(ADIS16260_DIAG_STAT_SPI_FAIL_BIT) |
 299                 BIT(ADIS16260_DIAG_STAT_FLASH_UPT_BIT) |
 300                 BIT(ADIS16260_DIAG_STAT_POWER_HIGH_BIT) |
 301                 BIT(ADIS16260_DIAG_STAT_POWER_LOW_BIT),
 302 };
 303
 304 static int __devinit adis16260_probe(struct spi_device *spi)
 305 {
 306         int ret;
 307         struct adis16260_platform_data *pd = spi->dev.platform_data;
 308         struct adis16260_state *st;
 309         struct iio_dev *indio_dev;
 310
 311         /* setup the industrialio driver allocated elements */
 312         indio_dev = iio_device_alloc(sizeof(*st));
 313         if (indio_dev == NULL) {
 314                 ret = -ENOMEM;
 315                 goto error_ret;
 316         }
 317         st = iio_priv(indio_dev);
 318         if (pd)
 319                 st->negate = pd->negate;
 320         /* this is only used for removal purposes */
 321         spi_set_drvdata(spi, indio_dev);
 322
 323         indio_dev->name = spi_get_device_id(spi)->name;
 324         indio_dev->dev.parent = &spi->dev;
 325         indio_dev->info = &adis16260_info;
 326         indio_dev->num_channels
 327                 = ARRAY_SIZE(adis16260_channels_x);
 328         if (pd && pd->direction)
 329                 switch (pd->direction) {
 330                 case 'x':
 331                         indio_dev->channels = adis16260_channels_x;
 332                         break;
 333                 case 'y':
 334                         indio_dev->channels = adis16260_channels_y;
 335                         break;
 336                 case 'z':
 337                         indio_dev->channels = adis16260_channels_z;
 338                         break;
 339                 default:
 340                         return -EINVAL;
 341                 }
 342         else
 343                 indio_dev->channels = adis16260_channels_x;
 344         indio_dev->num_channels = ARRAY_SIZE(adis16260_channels_x);
 345         indio_dev->modes = INDIO_DIRECT_MODE;
 346
 347         ret = adis_init(&st->adis, indio_dev, spi, &adis16260_data);
 348         if (ret)
 349                 goto error_free_dev;
 350
 351         ret = adis_setup_buffer_and_trigger(&st->adis, indio_dev, NULL);
 352         if (ret)
 353                 goto error_free_dev;
 354
 355         if (indio_dev->buffer) {
 356                 /* Set default scan mode */
 357                 iio_scan_mask_set(indio_dev, indio_dev->buffer,
 358                                   ADIS16260_SCAN_SUPPLY);
 359                 iio_scan_mask_set(indio_dev, indio_dev->buffer,
 360                                   ADIS16260_SCAN_GYRO);
 361                 iio_scan_mask_set(indio_dev, indio_dev->buffer,
 362                                   ADIS16260_SCAN_AUX_ADC);
 363                 iio_scan_mask_set(indio_dev, indio_dev->buffer,
 364                                   ADIS16260_SCAN_TEMP);
 365                 iio_scan_mask_set(indio_dev, indio_dev->buffer,
 366                                   ADIS16260_SCAN_ANGL);
 367         }
 368
 369         /* Get the device into a sane initial state */
 370         ret = adis_initial_startup(&st->adis);
 371         if (ret)
 372                 goto error_cleanup_buffer_trigger;
 373         ret = iio_device_register(indio_dev);
 374         if (ret)
 375                 goto error_cleanup_buffer_trigger;
 376
 377         return 0;
 378
 379 error_cleanup_buffer_trigger:
 380         adis_cleanup_buffer_and_trigger(&st->adis, indio_dev);
 381 error_free_dev:
 382         iio_device_free(indio_dev);
 383 error_ret:
 384         return ret;
 385 }
 386
 387 static int __devexit adis16260_remove(struct spi_device *spi)
 388 {
 389         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 390         struct adis16260_state *st = iio_priv(indio_dev);
 391
 392         iio_device_unregister(indio_dev);
 393         adis16260_stop_device(indio_dev);
 394         adis_cleanup_buffer_and_trigger(&st->adis, indio_dev);
 395         iio_device_free(indio_dev);
 396
 397         return 0;
 398 }
 399
 400 /*
 401  * These parts do not need to be differentiated until someone adds
 402  * support for the on chip filtering.
 403  */
 404 static const struct spi_device_id adis16260_id[] = {
 405         {"adis16260", 0},
 406         {"adis16265", 0},
 407         {"adis16250", 0},
 408         {"adis16255", 0},
 409         {"adis16251", 1},
 410         {}
 411 };
 412 MODULE_DEVICE_TABLE(spi, adis16260_id);
 413
 414 static struct spi_driver adis16260_driver = {
 415         .driver = {
 416                 .name = "adis16260",
 417                 .owner = THIS_MODULE,
 418         },
 419         .probe = adis16260_probe,
 420         .remove = __devexit_p(adis16260_remove),
 421         .id_table = adis16260_id,
 422 };
 423 module_spi_driver(adis16260_driver);
 424
 425 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
 426 MODULE_DESCRIPTION("Analog Devices ADIS16260/5 Digital Gyroscope Sensor");
 427 MODULE_LICENSE("GPL v2");