drivers/staging/iio/accel/sca3000_core.c

   1 /*
   2  * sca3000_core.c -- support VTI sca3000 series accelerometers via SPI
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 as published by
   6  * the Free Software Foundation.
   7  *
   8  * Copyright (c) 2009 Jonathan Cameron <jic23@kernel.org>
   9  *
  10  * See industrialio/accels/sca3000.h for comments.
  11  */
  12
  13 #include <linux/interrupt.h>
  14 #include <linux/fs.h>
  15 #include <linux/device.h>
  16 #include <linux/slab.h>
  17 #include <linux/kernel.h>
  18 #include <linux/spi/spi.h>
  19 #include <linux/sysfs.h>
  20 #include <linux/module.h>
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/sysfs.h>
  23 #include <linux/iio/events.h>
  24 #include <linux/iio/buffer.h>
  25
  26 #include "sca3000.h"
  27
  28 enum sca3000_variant {
  29         d01,
  30         e02,
  31         e04,
  32         e05,
  33 };
  34
  35 /*
  36  * Note where option modes are not defined, the chip simply does not
  37  * support any.
  38  * Other chips in the sca3000 series use i2c and are not included here.
  39  *
  40  * Some of these devices are only listed in the family data sheet and
  41  * do not actually appear to be available.
  42  */
  43 static const struct sca3000_chip_info sca3000_spi_chip_info_tbl[] = {
  44         [d01] = {
  45                 .scale = 7357,
  46                 .temp_output = true,
  47                 .measurement_mode_freq = 250,
  48                 .option_mode_1 = SCA3000_OP_MODE_BYPASS,
  49                 .option_mode_1_freq = 250,
  50                 .mot_det_mult_xz = {50, 100, 200, 350, 650, 1300},
  51                 .mot_det_mult_y = {50, 100, 150, 250, 450, 850, 1750},
  52         },
  53         [e02] = {
  54                 .scale = 9810,
  55                 .measurement_mode_freq = 125,
  56                 .option_mode_1 = SCA3000_OP_MODE_NARROW,
  57                 .option_mode_1_freq = 63,
  58                 .mot_det_mult_xz = {100, 150, 300, 550, 1050, 2050},
  59                 .mot_det_mult_y = {50, 100, 200, 350, 700, 1350, 2700},
  60         },
  61         [e04] = {
  62                 .scale = 19620,
  63                 .measurement_mode_freq = 100,
  64                 .option_mode_1 = SCA3000_OP_MODE_NARROW,
  65                 .option_mode_1_freq = 50,
  66                 .option_mode_2 = SCA3000_OP_MODE_WIDE,
  67                 .option_mode_2_freq = 400,
  68                 .mot_det_mult_xz = {200, 300, 600, 1100, 2100, 4100},
  69                 .mot_det_mult_y = {100, 200, 400, 7000, 1400, 2700, 54000},
  70         },
  71         [e05] = {
  72                 .scale = 61313,
  73                 .measurement_mode_freq = 200,
  74                 .option_mode_1 = SCA3000_OP_MODE_NARROW,
  75                 .option_mode_1_freq = 50,
  76                 .option_mode_2 = SCA3000_OP_MODE_WIDE,
  77                 .option_mode_2_freq = 400,
  78                 .mot_det_mult_xz = {600, 900, 1700, 3200, 6100, 11900},
  79                 .mot_det_mult_y = {300, 600, 1200, 2000, 4100, 7800, 15600},
  80         },
  81 };
  82
  83 int sca3000_write_reg(struct sca3000_state *st, u8 address, u8 val)
  84 {
  85         st->tx[0] = SCA3000_WRITE_REG(address);
  86         st->tx[1] = val;
  87         return spi_write(st->us, st->tx, 2);
  88 }
  89
  90 int sca3000_read_data_short(struct sca3000_state *st,
  91                             uint8_t reg_address_high,
  92                             int len)
  93 {
  94         struct spi_transfer xfer[2] = {
  95                 {
  96                         .len = 1,
  97                         .tx_buf = st->tx,
  98                 }, {
  99                         .len = len,
 100                         .rx_buf = st->rx,
 101                 }
 102         };
 103         st->tx[0] = SCA3000_READ_REG(reg_address_high);
 104
 105         return spi_sync_transfer(st->us, xfer, ARRAY_SIZE(xfer));
 106 }
 107
 108 /**
 109  * sca3000_reg_lock_on() test if the ctrl register lock is on
 110  *
 111  * Lock must be held.
 112  **/
 113 static int sca3000_reg_lock_on(struct sca3000_state *st)
 114 {
 115         int ret;
 116
 117         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_STATUS, 1);
 118         if (ret < 0)
 119                 return ret;
 120
 121         return !(st->rx[0] & SCA3000_LOCKED);
 122 }
 123
 124 /**
 125  * __sca3000_unlock_reg_lock() unlock the control registers
 126  *
 127  * Note the device does not appear to support doing this in a single transfer.
 128  * This should only ever be used as part of ctrl reg read.
 129  * Lock must be held before calling this
 130  **/
 131 static int __sca3000_unlock_reg_lock(struct sca3000_state *st)
 132 {
 133         struct spi_transfer xfer[3] = {
 134                 {
 135                         .len = 2,
 136                         .cs_change = 1,
 137                         .tx_buf = st->tx,
 138                 }, {
 139                         .len = 2,
 140                         .cs_change = 1,
 141                         .tx_buf = st->tx + 2,
 142                 }, {
 143                         .len = 2,
 144                         .tx_buf = st->tx + 4,
 145                 },
 146         };
 147         st->tx[0] = SCA3000_WRITE_REG(SCA3000_REG_ADDR_UNLOCK);
 148         st->tx[1] = 0x00;
 149         st->tx[2] = SCA3000_WRITE_REG(SCA3000_REG_ADDR_UNLOCK);
 150         st->tx[3] = 0x50;
 151         st->tx[4] = SCA3000_WRITE_REG(SCA3000_REG_ADDR_UNLOCK);
 152         st->tx[5] = 0xA0;
 153
 154         return spi_sync_transfer(st->us, xfer, ARRAY_SIZE(xfer));
 155 }
 156
 157 /**
 158  * sca3000_write_ctrl_reg() write to a lock protect ctrl register
 159  * @sel: selects which registers we wish to write to
 160  * @val: the value to be written
 161  *
 162  * Certain control registers are protected against overwriting by the lock
 163  * register and use a shared write address. This function allows writing of
 164  * these registers.
 165  * Lock must be held.
 166  **/
 167 static int sca3000_write_ctrl_reg(struct sca3000_state *st,
 168                                   uint8_t sel,
 169                                   uint8_t val)
 170 {
 171
 172         int ret;
 173
 174         ret = sca3000_reg_lock_on(st);
 175         if (ret < 0)
 176                 goto error_ret;
 177         if (ret) {
 178                 ret = __sca3000_unlock_reg_lock(st);
 179                 if (ret)
 180                         goto error_ret;
 181         }
 182
 183         /* Set the control select register */
 184         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_CTRL_SEL, sel);
 185         if (ret)
 186                 goto error_ret;
 187
 188         /* Write the actual value into the register */
 189         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_CTRL_DATA, val);
 190
 191 error_ret:
 192         return ret;
 193 }
 194
 195 /**
 196  * sca3000_read_ctrl_reg() read from lock protected control register.
 197  *
 198  * Lock must be held.
 199  **/
 200 static int sca3000_read_ctrl_reg(struct sca3000_state *st,
 201                                  u8 ctrl_reg)
 202 {
 203         int ret;
 204
 205         ret = sca3000_reg_lock_on(st);
 206         if (ret < 0)
 207                 goto error_ret;
 208         if (ret) {
 209                 ret = __sca3000_unlock_reg_lock(st);
 210                 if (ret)
 211                         goto error_ret;
 212         }
 213         /* Set the control select register */
 214         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_CTRL_SEL, ctrl_reg);
 215         if (ret)
 216                 goto error_ret;
 217         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_CTRL_DATA, 1);
 218         if (ret)
 219                 goto error_ret;
 220         else
 221                 return st->rx[0];
 222 error_ret:
 223         return ret;
 224 }
 225
 226 /**
 227  * sca3000_show_rev() - sysfs interface to read the chip revision number
 228  **/
 229 static ssize_t sca3000_show_rev(struct device *dev,
 230                                 struct device_attribute *attr,
 231                                 char *buf)
 232 {
 233         int len = 0, ret;
 234         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 235         struct sca3000_state *st = iio_priv(indio_dev);
 236
 237         mutex_lock(&st->lock);
 238         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_REVID, 1);
 239         if (ret < 0)
 240                 goto error_ret;
 241         len += sprintf(buf + len,
 242                        "major=%d, minor=%d\n",
 243                        st->rx[0] & SCA3000_REVID_MAJOR_MASK,
 244                        st->rx[0] & SCA3000_REVID_MINOR_MASK);
 245 error_ret:
 246         mutex_unlock(&st->lock);
 247
 248         return ret ? ret : len;
 249 }
 250
 251 /**
 252  * sca3000_show_available_measurement_modes() display available modes
 253  *
 254  * This is all read from chip specific data in the driver. Not all
 255  * of the sca3000 series support modes other than normal.
 256  **/
 257 static ssize_t
 258 sca3000_show_available_measurement_modes(struct device *dev,
 259                                          struct device_attribute *attr,
 260                                          char *buf)
 261 {
 262         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 263         struct sca3000_state *st = iio_priv(indio_dev);
 264         int len = 0;
 265
 266         len += sprintf(buf + len, "0 - normal mode");
 267         switch (st->info->option_mode_1) {
 268         case SCA3000_OP_MODE_NARROW:
 269                 len += sprintf(buf + len, ", 1 - narrow mode");
 270                 break;
 271         case SCA3000_OP_MODE_BYPASS:
 272                 len += sprintf(buf + len, ", 1 - bypass mode");
 273                 break;
 274         }
 275         switch (st->info->option_mode_2) {
 276         case SCA3000_OP_MODE_WIDE:
 277                 len += sprintf(buf + len, ", 2 - wide mode");
 278                 break;
 279         }
 280         /* always supported */
 281         len += sprintf(buf + len, " 3 - motion detection\n");
 282
 283         return len;
 284 }
 285
 286 /**
 287  * sca3000_show_measurement_mode() sysfs read of current mode
 288  **/
 289 static ssize_t
 290 sca3000_show_measurement_mode(struct device *dev,
 291                               struct device_attribute *attr,
 292                               char *buf)
 293 {
 294         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 295         struct sca3000_state *st = iio_priv(indio_dev);
 296         int len = 0, ret;
 297
 298         mutex_lock(&st->lock);
 299         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 300         if (ret)
 301                 goto error_ret;
 302         /* mask bottom 2 bits - only ones that are relevant */
 303         st->rx[0] &= 0x03;
 304         switch (st->rx[0]) {
 305         case SCA3000_MEAS_MODE_NORMAL:
 306                 len += sprintf(buf + len, "0 - normal mode\n");
 307                 break;
 308         case SCA3000_MEAS_MODE_MOT_DET:
 309                 len += sprintf(buf + len, "3 - motion detection\n");
 310                 break;
 311         case SCA3000_MEAS_MODE_OP_1:
 312                 switch (st->info->option_mode_1) {
 313                 case SCA3000_OP_MODE_NARROW:
 314                         len += sprintf(buf + len, "1 - narrow mode\n");
 315                         break;
 316                 case SCA3000_OP_MODE_BYPASS:
 317                         len += sprintf(buf + len, "1 - bypass mode\n");
 318                         break;
 319                 }
 320                 break;
 321         case SCA3000_MEAS_MODE_OP_2:
 322                 switch (st->info->option_mode_2) {
 323                 case SCA3000_OP_MODE_WIDE:
 324                         len += sprintf(buf + len, "2 - wide mode\n");
 325                         break;
 326                 }
 327                 break;
 328         }
 329
 330 error_ret:
 331         mutex_unlock(&st->lock);
 332
 333         return ret ? ret : len;
 334 }
 335
 336 /**
 337  * sca3000_store_measurement_mode() set the current mode
 338  **/
 339 static ssize_t
 340 sca3000_store_measurement_mode(struct device *dev,
 341                                struct device_attribute *attr,
 342                                const char *buf,
 343                                size_t len)
 344 {
 345         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 346         struct sca3000_state *st = iio_priv(indio_dev);
 347         int ret;
 348         u8 mask = 0x03;
 349         u8 val;
 350
 351         mutex_lock(&st->lock);
 352         ret = kstrtou8(buf, 10, &val);
 353         if (ret)
 354                 goto error_ret;
 355         if (val > 3) {
 356                 ret = -EINVAL;
 357                 goto error_ret;
 358         }
 359         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 360         if (ret)
 361                 goto error_ret;
 362         st->rx[0] &= ~mask;
 363         st->rx[0] |= (val & mask);
 364         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, st->rx[0]);
 365         if (ret)
 366                 goto error_ret;
 367         mutex_unlock(&st->lock);
 368
 369         return len;
 370
 371 error_ret:
 372         mutex_unlock(&st->lock);
 373
 374         return ret;
 375 }
 376
 377
 378 /*
 379  * Not even vaguely standard attributes so defined here rather than
 380  * in the relevant IIO core headers
 381  */
 382 static IIO_DEVICE_ATTR(measurement_mode_available, S_IRUGO,
 383                        sca3000_show_available_measurement_modes,
 384                        NULL, 0);
 385
 386 static IIO_DEVICE_ATTR(measurement_mode, S_IRUGO | S_IWUSR,
 387                        sca3000_show_measurement_mode,
 388                        sca3000_store_measurement_mode,
 389                        0);
 390
 391 /* More standard attributes */
 392
 393 static IIO_DEVICE_ATTR(revision, S_IRUGO, sca3000_show_rev, NULL, 0);
 394
 395 static const struct iio_event_spec sca3000_event = {
 396         .type = IIO_EV_TYPE_MAG,
 397         .dir = IIO_EV_DIR_RISING,
 398         .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
 399 };
 400
 401 #define SCA3000_CHAN(index, mod)                                \
 402         {                                                       \
 403                 .type = IIO_ACCEL,                              \
 404                 .modified = 1,                                  \
 405                 .channel2 = mod,                                \
 406                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
 407                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),\
 408                 .address = index,                               \
 409                 .scan_index = index,                            \
 410                 .scan_type = {                                  \
 411                         .sign = 's',                            \
 412                         .realbits = 11,                         \
 413                         .storagebits = 16,                      \
 414                         .shift = 5,                             \
 415                 },                                              \
 416                 .event_spec = &sca3000_event,                   \
 417                 .num_event_specs = 1,                           \
 418          }
 419
 420 static const struct iio_chan_spec sca3000_channels[] = {
 421         SCA3000_CHAN(0, IIO_MOD_X),
 422         SCA3000_CHAN(1, IIO_MOD_Y),
 423         SCA3000_CHAN(2, IIO_MOD_Z),
 424 };
 425
 426 static const struct iio_chan_spec sca3000_channels_with_temp[] = {
 427         SCA3000_CHAN(0, IIO_MOD_X),
 428         SCA3000_CHAN(1, IIO_MOD_Y),
 429         SCA3000_CHAN(2, IIO_MOD_Z),
 430         {
 431                 .type = IIO_TEMP,
 432                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 433                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
 434                         BIT(IIO_CHAN_INFO_OFFSET),
 435                 /* No buffer support */
 436                 .scan_index = -1,
 437         },
 438 };
 439
 440 static u8 sca3000_addresses[3][3] = {
 441         [0] = {SCA3000_REG_ADDR_X_MSB, SCA3000_REG_CTRL_SEL_MD_X_TH,
 442                SCA3000_MD_CTRL_OR_X},
 443         [1] = {SCA3000_REG_ADDR_Y_MSB, SCA3000_REG_CTRL_SEL_MD_Y_TH,
 444                SCA3000_MD_CTRL_OR_Y},
 445         [2] = {SCA3000_REG_ADDR_Z_MSB, SCA3000_REG_CTRL_SEL_MD_Z_TH,
 446                SCA3000_MD_CTRL_OR_Z},
 447 };
 448
 449 static int sca3000_read_raw(struct iio_dev *indio_dev,
 450                             struct iio_chan_spec const *chan,
 451                             int *val,
 452                             int *val2,
 453                             long mask)
 454 {
 455         struct sca3000_state *st = iio_priv(indio_dev);
 456         int ret;
 457         u8 address;
 458
 459         switch (mask) {
 460         case IIO_CHAN_INFO_RAW:
 461                 mutex_lock(&st->lock);
 462                 if (chan->type == IIO_ACCEL) {
 463                         if (st->mo_det_use_count) {
 464                                 mutex_unlock(&st->lock);
 465                                 return -EBUSY;
 466                         }
 467                         address = sca3000_addresses[chan->address][0];
 468                         ret = sca3000_read_data_short(st, address, 2);
 469                         if (ret < 0) {
 470                                 mutex_unlock(&st->lock);
 471                                 return ret;
 472                         }
 473                         *val = (be16_to_cpup((__be16 *)st->rx) >> 3) & 0x1FFF;
 474                         *val = ((*val) << (sizeof(*val)*8 - 13)) >>
 475                                 (sizeof(*val)*8 - 13);
 476                 } else {
 477                         /* get the temperature when available */
 478                         ret = sca3000_read_data_short(st,
 479                                 SCA3000_REG_ADDR_TEMP_MSB, 2);
 480                         if (ret < 0) {
 481                                 mutex_unlock(&st->lock);
 482                                 return ret;
 483                         }
 484                         *val = ((st->rx[0] & 0x3F) << 3) |
 485                                ((st->rx[1] & 0xE0) >> 5);
 486                 }
 487                 mutex_unlock(&st->lock);
 488                 return IIO_VAL_INT;
 489         case IIO_CHAN_INFO_SCALE:
 490                 *val = 0;
 491                 if (chan->type == IIO_ACCEL)
 492                         *val2 = st->info->scale;
 493                 else /* temperature */
 494                         *val2 = 555556;
 495                 return IIO_VAL_INT_PLUS_MICRO;
 496         case IIO_CHAN_INFO_OFFSET:
 497                 *val = -214;
 498                 *val2 = 600000;
 499                 return IIO_VAL_INT_PLUS_MICRO;
 500         default:
 501                 return -EINVAL;
 502         }
 503 }
 504
 505 /**
 506  * sca3000_read_av_freq() sysfs function to get available frequencies
 507  *
 508  * The later modes are only relevant to the ring buffer - and depend on current
 509  * mode. Note that data sheet gives rather wide tolerances for these so integer
 510  * division will give good enough answer and not all chips have them specified
 511  * at all.
 512  **/
 513 static ssize_t sca3000_read_av_freq(struct device *dev,
 514                              struct device_attribute *attr,
 515                              char *buf)
 516 {
 517         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 518         struct sca3000_state *st = iio_priv(indio_dev);
 519         int len = 0, ret, val;
 520
 521         mutex_lock(&st->lock);
 522         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 523         val = st->rx[0];
 524         mutex_unlock(&st->lock);
 525         if (ret)
 526                 goto error_ret;
 527
 528         switch (val & 0x03) {
 529         case SCA3000_MEAS_MODE_NORMAL:
 530                 len += sprintf(buf + len, "%d %d %d\n",
 531                                st->info->measurement_mode_freq,
 532                                st->info->measurement_mode_freq/2,
 533                                st->info->measurement_mode_freq/4);
 534                 break;
 535         case SCA3000_MEAS_MODE_OP_1:
 536                 len += sprintf(buf + len, "%d %d %d\n",
 537                                st->info->option_mode_1_freq,
 538                                st->info->option_mode_1_freq/2,
 539                                st->info->option_mode_1_freq/4);
 540                 break;
 541         case SCA3000_MEAS_MODE_OP_2:
 542                 len += sprintf(buf + len, "%d %d %d\n",
 543                                st->info->option_mode_2_freq,
 544                                st->info->option_mode_2_freq/2,
 545                                st->info->option_mode_2_freq/4);
 546                 break;
 547         }
 548         return len;
 549 error_ret:
 550         return ret;
 551 }
 552 /**
 553  * __sca3000_get_base_freq() obtain mode specific base frequency
 554  *
 555  * lock must be held
 556  **/
 557 static inline int __sca3000_get_base_freq(struct sca3000_state *st,
 558                                           const struct sca3000_chip_info *info,
 559                                           int *base_freq)
 560 {
 561         int ret;
 562
 563         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 564         if (ret)
 565                 goto error_ret;
 566         switch (0x03 & st->rx[0]) {
 567         case SCA3000_MEAS_MODE_NORMAL:
 568                 *base_freq = info->measurement_mode_freq;
 569                 break;
 570         case SCA3000_MEAS_MODE_OP_1:
 571                 *base_freq = info->option_mode_1_freq;
 572                 break;
 573         case SCA3000_MEAS_MODE_OP_2:
 574                 *base_freq = info->option_mode_2_freq;
 575                 break;
 576         }
 577 error_ret:
 578         return ret;
 579 }
 580
 581 /**
 582  * sca3000_read_frequency() sysfs interface to get the current frequency
 583  **/
 584 static ssize_t sca3000_read_frequency(struct device *dev,
 585                                struct device_attribute *attr,
 586                                char *buf)
 587 {
 588         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 589         struct sca3000_state *st = iio_priv(indio_dev);
 590         int ret, len = 0, base_freq = 0, val;
 591
 592         mutex_lock(&st->lock);
 593         ret = __sca3000_get_base_freq(st, st->info, &base_freq);
 594         if (ret)
 595                 goto error_ret_mut;
 596         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
 597         mutex_unlock(&st->lock);
 598         if (ret)
 599                 goto error_ret;
 600         val = ret;
 601         if (base_freq > 0)
 602                 switch (val & 0x03) {
 603                 case 0x00:
 604                 case 0x03:
 605                         len = sprintf(buf, "%d\n", base_freq);
 606                         break;
 607                 case 0x01:
 608                         len = sprintf(buf, "%d\n", base_freq/2);
 609                         break;
 610                 case 0x02:
 611                         len = sprintf(buf, "%d\n", base_freq/4);
 612                         break;
 613         }
 614
 615         return len;
 616 error_ret_mut:
 617         mutex_unlock(&st->lock);
 618 error_ret:
 619         return ret;
 620 }
 621
 622 /**
 623  * sca3000_set_frequency() sysfs interface to set the current frequency
 624  **/
 625 static ssize_t sca3000_set_frequency(struct device *dev,
 626                               struct device_attribute *attr,
 627                               const char *buf,
 628                               size_t len)
 629 {
 630         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 631         struct sca3000_state *st = iio_priv(indio_dev);
 632         int ret, base_freq = 0;
 633         int ctrlval;
 634         int val;
 635
 636         ret = kstrtoint(buf, 10, &val);
 637         if (ret)
 638                 return ret;
 639
 640         mutex_lock(&st->lock);
 641         /* What mode are we in? */
 642         ret = __sca3000_get_base_freq(st, st->info, &base_freq);
 643         if (ret)
 644                 goto error_free_lock;
 645
 646         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
 647         if (ret < 0)
 648                 goto error_free_lock;
 649         ctrlval = ret;
 650         /* clear the bits */
 651         ctrlval &= ~0x03;
 652
 653         if (val == base_freq/2) {
 654                 ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_2;
 655         } else if (val == base_freq/4) {
 656                 ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_4;
 657         } else if (val != base_freq) {
 658                 ret = -EINVAL;
 659                 goto error_free_lock;
 660         }
 661         ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
 662                                      ctrlval);
 663 error_free_lock:
 664         mutex_unlock(&st->lock);
 665
 666         return ret ? ret : len;
 667 }
 668
 669 /*
 670  * Should only really be registered if ring buffer support is compiled in.
 671  * Does no harm however and doing it right would add a fair bit of complexity
 672  */
 673 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(sca3000_read_av_freq);
 674
 675 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 676                               sca3000_read_frequency,
 677                               sca3000_set_frequency);
 678
 679 /**
 680  * sca3000_read_thresh() - query of a threshold
 681  **/
 682 static int sca3000_read_thresh(struct iio_dev *indio_dev,
 683                                const struct iio_chan_spec *chan,
 684                                enum iio_event_type type,
 685                                enum iio_event_direction dir,
 686                                enum iio_event_info info,
 687                                int *val, int *val2)
 688 {
 689         int ret, i;
 690         struct sca3000_state *st = iio_priv(indio_dev);
 691         int num = chan->channel2;
 692
 693         mutex_lock(&st->lock);
 694         ret = sca3000_read_ctrl_reg(st, sca3000_addresses[num][1]);
 695         mutex_unlock(&st->lock);
 696         if (ret < 0)
 697                 return ret;
 698         *val = 0;
 699         if (num == 1)
 700                 for_each_set_bit(i, (unsigned long *)&ret,
 701                                  ARRAY_SIZE(st->info->mot_det_mult_y))
 702                         *val += st->info->mot_det_mult_y[i];
 703         else
 704                 for_each_set_bit(i, (unsigned long *)&ret,
 705                                  ARRAY_SIZE(st->info->mot_det_mult_xz))
 706                         *val += st->info->mot_det_mult_xz[i];
 707
 708         return IIO_VAL_INT;
 709 }
 710
 711 /**
 712  * sca3000_write_thresh() control of threshold
 713  **/
 714 static int sca3000_write_thresh(struct iio_dev *indio_dev,
 715                                 const struct iio_chan_spec *chan,
 716                                 enum iio_event_type type,
 717                                 enum iio_event_direction dir,
 718                                 enum iio_event_info info,
 719                                 int val, int val2)
 720 {
 721         struct sca3000_state *st = iio_priv(indio_dev);
 722         int num = chan->channel2;
 723         int ret;
 724         int i;
 725         u8 nonlinear = 0;
 726
 727         if (num == 1) {
 728                 i = ARRAY_SIZE(st->info->mot_det_mult_y);
 729                 while (i > 0)
 730                         if (val >= st->info->mot_det_mult_y[--i]) {
 731                                 nonlinear |= (1 << i);
 732                                 val -= st->info->mot_det_mult_y[i];
 733                         }
 734         } else {
 735                 i = ARRAY_SIZE(st->info->mot_det_mult_xz);
 736                 while (i > 0)
 737                         if (val >= st->info->mot_det_mult_xz[--i]) {
 738                                 nonlinear |= (1 << i);
 739                                 val -= st->info->mot_det_mult_xz[i];
 740                         }
 741         }
 742
 743         mutex_lock(&st->lock);
 744         ret = sca3000_write_ctrl_reg(st, sca3000_addresses[num][1], nonlinear);
 745         mutex_unlock(&st->lock);
 746
 747         return ret;
 748 }
 749
 750 static struct attribute *sca3000_attributes[] = {
 751         &iio_dev_attr_revision.dev_attr.attr,
 752         &iio_dev_attr_measurement_mode_available.dev_attr.attr,
 753         &iio_dev_attr_measurement_mode.dev_attr.attr,
 754         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 755         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 756         NULL,
 757 };
 758
 759 static const struct attribute_group sca3000_attribute_group = {
 760         .attrs = sca3000_attributes,
 761 };
 762
 763 /**
 764  * sca3000_event_handler() - handling ring and non ring events
 765  *
 766  * Ring related interrupt handler. Depending on event, push to
 767  * the ring buffer event chrdev or the event one.
 768  *
 769  * This function is complicated by the fact that the devices can signify ring
 770  * and non ring events via the same interrupt line and they can only
 771  * be distinguished via a read of the relevant status register.
 772  **/
 773 static irqreturn_t sca3000_event_handler(int irq, void *private)
 774 {
 775         struct iio_dev *indio_dev = private;
 776         struct sca3000_state *st = iio_priv(indio_dev);
 777         int ret, val;
 778         s64 last_timestamp = iio_get_time_ns();
 779
 780         /*
 781          * Could lead if badly timed to an extra read of status reg,
 782          * but ensures no interrupt is missed.
 783          */
 784         mutex_lock(&st->lock);
 785         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1);
 786         val = st->rx[0];
 787         mutex_unlock(&st->lock);
 788         if (ret)
 789                 goto done;
 790
 791         sca3000_ring_int_process(val, indio_dev->buffer);
 792
 793         if (val & SCA3000_INT_STATUS_FREE_FALL)
 794                 iio_push_event(indio_dev,
 795                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 796                                                   0,
 797                                                   IIO_MOD_X_AND_Y_AND_Z,
 798                                                   IIO_EV_TYPE_MAG,
 799                                                   IIO_EV_DIR_FALLING),
 800                                last_timestamp);
 801
 802         if (val & SCA3000_INT_STATUS_Y_TRIGGER)
 803                 iio_push_event(indio_dev,
 804                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 805                                                   0,
 806                                                   IIO_MOD_Y,
 807                                                   IIO_EV_TYPE_MAG,
 808                                                   IIO_EV_DIR_RISING),
 809                                last_timestamp);
 810
 811         if (val & SCA3000_INT_STATUS_X_TRIGGER)
 812                 iio_push_event(indio_dev,
 813                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 814                                                   0,
 815                                                   IIO_MOD_X,
 816                                                   IIO_EV_TYPE_MAG,
 817                                                   IIO_EV_DIR_RISING),
 818                                last_timestamp);
 819
 820         if (val & SCA3000_INT_STATUS_Z_TRIGGER)
 821                 iio_push_event(indio_dev,
 822                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 823                                                   0,
 824                                                   IIO_MOD_Z,
 825                                                   IIO_EV_TYPE_MAG,
 826                                                   IIO_EV_DIR_RISING),
 827                                last_timestamp);
 828
 829 done:
 830         return IRQ_HANDLED;
 831 }
 832
 833 /**
 834  * sca3000_read_event_config() what events are enabled
 835  **/
 836 static int sca3000_read_event_config(struct iio_dev *indio_dev,
 837                                      const struct iio_chan_spec *chan,
 838                                      enum iio_event_type type,
 839                                      enum iio_event_direction dir)
 840 {
 841         struct sca3000_state *st = iio_priv(indio_dev);
 842         int ret;
 843         u8 protect_mask = 0x03;
 844         int num = chan->channel2;
 845
 846         /* read current value of mode register */
 847         mutex_lock(&st->lock);
 848         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 849         if (ret)
 850                 goto error_ret;
 851
 852         if ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET)
 853                 ret = 0;
 854         else {
 855                 ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
 856                 if (ret < 0)
 857                         goto error_ret;
 858                 /* only supporting logical or's for now */
 859                 ret = !!(ret & sca3000_addresses[num][2]);
 860         }
 861 error_ret:
 862         mutex_unlock(&st->lock);
 863
 864         return ret;
 865 }
 866 /**
 867  * sca3000_query_free_fall_mode() is free fall mode enabled
 868  **/
 869 static ssize_t sca3000_query_free_fall_mode(struct device *dev,
 870                                             struct device_attribute *attr,
 871                                             char *buf)
 872 {
 873         int ret;
 874         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 875         struct sca3000_state *st = iio_priv(indio_dev);
 876         int val;
 877
 878         mutex_lock(&st->lock);
 879         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 880         val = st->rx[0];
 881         mutex_unlock(&st->lock);
 882         if (ret < 0)
 883                 return ret;
 884         return sprintf(buf, "%d\n", !!(val & SCA3000_FREE_FALL_DETECT));
 885 }
 886
 887 /**
 888  * sca3000_set_free_fall_mode() simple on off control for free fall int
 889  *
 890  * In these chips the free fall detector should send an interrupt if
 891  * the device falls more than 25cm.  This has not been tested due
 892  * to fragile wiring.
 893  **/
 894 static ssize_t sca3000_set_free_fall_mode(struct device *dev,
 895                                           struct device_attribute *attr,
 896                                           const char *buf,
 897                                           size_t len)
 898 {
 899         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 900         struct sca3000_state *st = iio_priv(indio_dev);
 901         u8 val;
 902         int ret;
 903         u8 protect_mask = SCA3000_FREE_FALL_DETECT;
 904
 905         mutex_lock(&st->lock);
 906         ret = kstrtou8(buf, 10, &val);
 907         if (ret)
 908                 goto error_ret;
 909
 910         /* read current value of mode register */
 911         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 912         if (ret)
 913                 goto error_ret;
 914
 915         /* if off and should be on */
 916         if (val && !(st->rx[0] & protect_mask))
 917                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 918                                         (st->rx[0] | SCA3000_FREE_FALL_DETECT));
 919         /* if on and should be off */
 920         else if (!val && (st->rx[0] & protect_mask))
 921                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 922                                         (st->rx[0] & ~protect_mask));
 923 error_ret:
 924         mutex_unlock(&st->lock);
 925
 926         return ret ? ret : len;
 927 }
 928
 929 /**
 930  * sca3000_write_event_config() simple on off control for motion detector
 931  *
 932  * This is a per axis control, but enabling any will result in the
 933  * motion detector unit being enabled.
 934  * N.B. enabling motion detector stops normal data acquisition.
 935  * There is a complexity in knowing which mode to return to when
 936  * this mode is disabled.  Currently normal mode is assumed.
 937  **/
 938 static int sca3000_write_event_config(struct iio_dev *indio_dev,
 939                                       const struct iio_chan_spec *chan,
 940                                       enum iio_event_type type,
 941                                       enum iio_event_direction dir,
 942                                       int state)
 943 {
 944         struct sca3000_state *st = iio_priv(indio_dev);
 945         int ret, ctrlval;
 946         u8 protect_mask = 0x03;
 947         int num = chan->channel2;
 948
 949         mutex_lock(&st->lock);
 950         /*
 951          * First read the motion detector config to find out if
 952          * this axis is on
 953          */
 954         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
 955         if (ret < 0)
 956                 goto exit_point;
 957         ctrlval = ret;
 958         /* if off and should be on */
 959         if (state && !(ctrlval & sca3000_addresses[num][2])) {
 960                 ret = sca3000_write_ctrl_reg(st,
 961                                              SCA3000_REG_CTRL_SEL_MD_CTRL,
 962                                              ctrlval |
 963                                              sca3000_addresses[num][2]);
 964                 if (ret)
 965                         goto exit_point;
 966                 st->mo_det_use_count++;
 967         } else if (!state && (ctrlval & sca3000_addresses[num][2])) {
 968                 ret = sca3000_write_ctrl_reg(st,
 969                                              SCA3000_REG_CTRL_SEL_MD_CTRL,
 970                                              ctrlval &
 971                                              ~(sca3000_addresses[num][2]));
 972                 if (ret)
 973                         goto exit_point;
 974                 st->mo_det_use_count--;
 975         }
 976
 977         /* read current value of mode register */
 978         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 979         if (ret)
 980                 goto exit_point;
 981         /* if off and should be on */
 982         if ((st->mo_det_use_count)
 983             && ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET))
 984                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 985                                         (st->rx[0] & ~protect_mask)
 986                                         | SCA3000_MEAS_MODE_MOT_DET);
 987         /* if on and should be off */
 988         else if (!(st->mo_det_use_count)
 989                  && ((st->rx[0] & protect_mask) == SCA3000_MEAS_MODE_MOT_DET))
 990                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 991                                         (st->rx[0] & ~protect_mask));
 992 exit_point:
 993         mutex_unlock(&st->lock);
 994
 995         return ret;
 996 }
 997
 998 /* Free fall detector related event attribute */
 999 static IIO_DEVICE_ATTR_NAMED(accel_xayaz_mag_falling_en,
1000                              in_accel_x&y&z_mag_falling_en,
1001                              S_IRUGO | S_IWUSR,
1002                              sca3000_query_free_fall_mode,
1003                              sca3000_set_free_fall_mode,
1004                              0);
1005
1006 static IIO_CONST_ATTR_NAMED(accel_xayaz_mag_falling_period,
1007                             in_accel_x&y&z_mag_falling_period,
1008                             "0.226");
1009
1010 static struct attribute *sca3000_event_attributes[] = {
1011         &iio_dev_attr_accel_xayaz_mag_falling_en.dev_attr.attr,
1012         &iio_const_attr_accel_xayaz_mag_falling_period.dev_attr.attr,
1013         NULL,
1014 };
1015
1016 static struct attribute_group sca3000_event_attribute_group = {
1017         .attrs = sca3000_event_attributes,
1018         .name = "events",
1019 };
1020
1021 /**
1022  * sca3000_clean_setup() get the device into a predictable state
1023  *
1024  * Devices use flash memory to store many of the register values
1025  * and hence can come up in somewhat unpredictable states.
1026  * Hence reset everything on driver load.
1027  **/
1028 static int sca3000_clean_setup(struct sca3000_state *st)
1029 {
1030         int ret;
1031
1032         mutex_lock(&st->lock);
1033         /* Ensure all interrupts have been acknowledged */
1034         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1);
1035         if (ret)
1036                 goto error_ret;
1037
1038         /* Turn off all motion detection channels */
1039         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
1040         if (ret < 0)
1041                 goto error_ret;
1042         ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL,
1043                                      ret & SCA3000_MD_CTRL_PROT_MASK);
1044         if (ret)
1045                 goto error_ret;
1046
1047         /* Disable ring buffer */
1048         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
1049         ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
1050                                      (ret & SCA3000_OUT_CTRL_PROT_MASK)
1051                                      | SCA3000_OUT_CTRL_BUF_X_EN
1052                                      | SCA3000_OUT_CTRL_BUF_Y_EN
1053                                      | SCA3000_OUT_CTRL_BUF_Z_EN
1054                                      | SCA3000_OUT_CTRL_BUF_DIV_4);
1055         if (ret)
1056                 goto error_ret;
1057         /* Enable interrupts, relevant to mode and set up as active low */
1058         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1059         if (ret)
1060                 goto error_ret;
1061         ret = sca3000_write_reg(st,
1062                                 SCA3000_REG_ADDR_INT_MASK,
1063                                 (ret & SCA3000_INT_MASK_PROT_MASK)
1064                                 | SCA3000_INT_MASK_ACTIVE_LOW);
1065         if (ret)
1066                 goto error_ret;
1067         /*
1068          * Select normal measurement mode, free fall off, ring off
1069          * Ring in 12 bit mode - it is fine to overwrite reserved bits 3,5
1070          * as that occurs in one of the example on the datasheet
1071          */
1072         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
1073         if (ret)
1074                 goto error_ret;
1075         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
1076                                 (st->rx[0] & SCA3000_MODE_PROT_MASK));
1077         st->bpse = 11;
1078
1079 error_ret:
1080         mutex_unlock(&st->lock);
1081         return ret;
1082 }
1083
1084 static const struct iio_info sca3000_info = {
1085         .attrs = &sca3000_attribute_group,
1086         .read_raw = &sca3000_read_raw,
1087         .event_attrs = &sca3000_event_attribute_group,
1088         .read_event_value = &sca3000_read_thresh,
1089         .write_event_value = &sca3000_write_thresh,
1090         .read_event_config = &sca3000_read_event_config,
1091         .write_event_config = &sca3000_write_event_config,
1092         .driver_module = THIS_MODULE,
1093 };
1094
1095 static int sca3000_probe(struct spi_device *spi)
1096 {
1097         int ret;
1098         struct sca3000_state *st;
1099         struct iio_dev *indio_dev;
1100
1101         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
1102         if (!indio_dev)
1103                 return -ENOMEM;
1104
1105         st = iio_priv(indio_dev);
1106         spi_set_drvdata(spi, indio_dev);
1107         st->us = spi;
1108         mutex_init(&st->lock);
1109         st->info = &sca3000_spi_chip_info_tbl[spi_get_device_id(spi)
1110                                               ->driver_data];
1111
1112         indio_dev->dev.parent = &spi->dev;
1113         indio_dev->name = spi_get_device_id(spi)->name;
1114         indio_dev->info = &sca3000_info;
1115         if (st->info->temp_output) {
1116                 indio_dev->channels = sca3000_channels_with_temp;
1117                 indio_dev->num_channels =
1118                         ARRAY_SIZE(sca3000_channels_with_temp);
1119         } else {
1120                 indio_dev->channels = sca3000_channels;
1121                 indio_dev->num_channels = ARRAY_SIZE(sca3000_channels);
1122         }
1123         indio_dev->modes = INDIO_DIRECT_MODE;
1124
1125         sca3000_configure_ring(indio_dev);
1126         ret = iio_device_register(indio_dev);
1127         if (ret < 0)
1128                 return ret;
1129
1130         if (spi->irq) {
1131                 ret = request_threaded_irq(spi->irq,
1132                                            NULL,
1133                                            &sca3000_event_handler,
1134                                            IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1135                                            "sca3000",
1136                                            indio_dev);
1137                 if (ret)
1138                         goto error_unregister_dev;
1139         }
1140         sca3000_register_ring_funcs(indio_dev);
1141         ret = sca3000_clean_setup(st);
1142         if (ret)
1143                 goto error_free_irq;
1144         return 0;
1145
1146 error_free_irq:
1147         if (spi->irq)
1148                 free_irq(spi->irq, indio_dev);
1149 error_unregister_dev:
1150         iio_device_unregister(indio_dev);
1151         return ret;
1152 }
1153
1154 static int sca3000_stop_all_interrupts(struct sca3000_state *st)
1155 {
1156         int ret;
1157
1158         mutex_lock(&st->lock);
1159         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1160         if (ret)
1161                 goto error_ret;
1162         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_INT_MASK,
1163                                 (st->rx[0] &
1164                                  ~(SCA3000_INT_MASK_RING_THREE_QUARTER |
1165                                    SCA3000_INT_MASK_RING_HALF |
1166                                    SCA3000_INT_MASK_ALL_INTS)));
1167 error_ret:
1168         mutex_unlock(&st->lock);
1169         return ret;
1170 }
1171
1172 static int sca3000_remove(struct spi_device *spi)
1173 {
1174         struct iio_dev *indio_dev = spi_get_drvdata(spi);
1175         struct sca3000_state *st = iio_priv(indio_dev);
1176
1177         /* Must ensure no interrupts can be generated after this! */
1178         sca3000_stop_all_interrupts(st);
1179         if (spi->irq)
1180                 free_irq(spi->irq, indio_dev);
1181         iio_device_unregister(indio_dev);
1182         sca3000_unconfigure_ring(indio_dev);
1183
1184         return 0;
1185 }
1186
1187 static const struct spi_device_id sca3000_id[] = {
1188         {"sca3000_d01", d01},
1189         {"sca3000_e02", e02},
1190         {"sca3000_e04", e04},
1191         {"sca3000_e05", e05},
1192         {}
1193 };
1194 MODULE_DEVICE_TABLE(spi, sca3000_id);
1195
1196 static struct spi_driver sca3000_driver = {
1197         .driver = {
1198                 .name = "sca3000",
1199                 .owner = THIS_MODULE,
1200         },
1201         .probe = sca3000_probe,
1202         .remove = sca3000_remove,
1203         .id_table = sca3000_id,
1204 };
1205 module_spi_driver(sca3000_driver);
1206
1207 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
1208 MODULE_DESCRIPTION("VTI SCA3000 Series Accelerometers SPI driver");
1209 MODULE_LICENSE("GPL v2");