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                             u8 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                                   u8 sel,
 169                                   uint8_t val)
 170 {
 171         int ret;
 172
 173         ret = sca3000_reg_lock_on(st);
 174         if (ret < 0)
 175                 goto error_ret;
 176         if (ret) {
 177                 ret = __sca3000_unlock_reg_lock(st);
 178                 if (ret)
 179                         goto error_ret;
 180         }
 181
 182         /* Set the control select register */
 183         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_CTRL_SEL, sel);
 184         if (ret)
 185                 goto error_ret;
 186
 187         /* Write the actual value into the register */
 188         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_CTRL_DATA, val);
 189
 190 error_ret:
 191         return ret;
 192 }
 193
 194 /**
 195  * sca3000_read_ctrl_reg() read from lock protected control register.
 196  *
 197  * Lock must be held.
 198  **/
 199 static int sca3000_read_ctrl_reg(struct sca3000_state *st,
 200                                  u8 ctrl_reg)
 201 {
 202         int ret;
 203
 204         ret = sca3000_reg_lock_on(st);
 205         if (ret < 0)
 206                 goto error_ret;
 207         if (ret) {
 208                 ret = __sca3000_unlock_reg_lock(st);
 209                 if (ret)
 210                         goto error_ret;
 211         }
 212         /* Set the control select register */
 213         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_CTRL_SEL, ctrl_reg);
 214         if (ret)
 215                 goto error_ret;
 216         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_CTRL_DATA, 1);
 217         if (ret)
 218                 goto error_ret;
 219         else
 220                 return st->rx[0];
 221 error_ret:
 222         return ret;
 223 }
 224
 225 /**
 226  * sca3000_show_rev() - sysfs interface to read the chip revision number
 227  **/
 228 static ssize_t sca3000_show_rev(struct device *dev,
 229                                 struct device_attribute *attr,
 230                                 char *buf)
 231 {
 232         int len = 0, ret;
 233         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 234         struct sca3000_state *st = iio_priv(indio_dev);
 235
 236         mutex_lock(&st->lock);
 237         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_REVID, 1);
 238         if (ret < 0)
 239                 goto error_ret;
 240         len += sprintf(buf + len,
 241                        "major=%d, minor=%d\n",
 242                        st->rx[0] & SCA3000_REVID_MAJOR_MASK,
 243                        st->rx[0] & SCA3000_REVID_MINOR_MASK);
 244 error_ret:
 245         mutex_unlock(&st->lock);
 246
 247         return ret ? ret : len;
 248 }
 249
 250 /**
 251  * sca3000_show_available_measurement_modes() display available modes
 252  *
 253  * This is all read from chip specific data in the driver. Not all
 254  * of the sca3000 series support modes other than normal.
 255  **/
 256 static ssize_t
 257 sca3000_show_available_measurement_modes(struct device *dev,
 258                                          struct device_attribute *attr,
 259                                          char *buf)
 260 {
 261         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 262         struct sca3000_state *st = iio_priv(indio_dev);
 263         int len = 0;
 264
 265         len += sprintf(buf + len, "0 - normal mode");
 266         switch (st->info->option_mode_1) {
 267         case SCA3000_OP_MODE_NARROW:
 268                 len += sprintf(buf + len, ", 1 - narrow mode");
 269                 break;
 270         case SCA3000_OP_MODE_BYPASS:
 271                 len += sprintf(buf + len, ", 1 - bypass mode");
 272                 break;
 273         }
 274         switch (st->info->option_mode_2) {
 275         case SCA3000_OP_MODE_WIDE:
 276                 len += sprintf(buf + len, ", 2 - wide mode");
 277                 break;
 278         }
 279         /* always supported */
 280         len += sprintf(buf + len, " 3 - motion detection\n");
 281
 282         return len;
 283 }
 284
 285 /**
 286  * sca3000_show_measurement_mode() sysfs read of current mode
 287  **/
 288 static ssize_t
 289 sca3000_show_measurement_mode(struct device *dev,
 290                               struct device_attribute *attr,
 291                               char *buf)
 292 {
 293         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 294         struct sca3000_state *st = iio_priv(indio_dev);
 295         int len = 0, ret;
 296
 297         mutex_lock(&st->lock);
 298         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 299         if (ret)
 300                 goto error_ret;
 301         /* mask bottom 2 bits - only ones that are relevant */
 302         st->rx[0] &= 0x03;
 303         switch (st->rx[0]) {
 304         case SCA3000_MEAS_MODE_NORMAL:
 305                 len += sprintf(buf + len, "0 - normal mode\n");
 306                 break;
 307         case SCA3000_MEAS_MODE_MOT_DET:
 308                 len += sprintf(buf + len, "3 - motion detection\n");
 309                 break;
 310         case SCA3000_MEAS_MODE_OP_1:
 311                 switch (st->info->option_mode_1) {
 312                 case SCA3000_OP_MODE_NARROW:
 313                         len += sprintf(buf + len, "1 - narrow mode\n");
 314                         break;
 315                 case SCA3000_OP_MODE_BYPASS:
 316                         len += sprintf(buf + len, "1 - bypass mode\n");
 317                         break;
 318                 }
 319                 break;
 320         case SCA3000_MEAS_MODE_OP_2:
 321                 switch (st->info->option_mode_2) {
 322                 case SCA3000_OP_MODE_WIDE:
 323                         len += sprintf(buf + len, "2 - wide mode\n");
 324                         break;
 325                 }
 326                 break;
 327         }
 328
 329 error_ret:
 330         mutex_unlock(&st->lock);
 331
 332         return ret ? ret : len;
 333 }
 334
 335 /**
 336  * sca3000_store_measurement_mode() set the current mode
 337  **/
 338 static ssize_t
 339 sca3000_store_measurement_mode(struct device *dev,
 340                                struct device_attribute *attr,
 341                                const char *buf,
 342                                size_t len)
 343 {
 344         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 345         struct sca3000_state *st = iio_priv(indio_dev);
 346         int ret;
 347         u8 mask = 0x03;
 348         u8 val;
 349
 350         mutex_lock(&st->lock);
 351         ret = kstrtou8(buf, 10, &val);
 352         if (ret)
 353                 goto error_ret;
 354         if (val > 3) {
 355                 ret = -EINVAL;
 356                 goto error_ret;
 357         }
 358         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 359         if (ret)
 360                 goto error_ret;
 361         st->rx[0] &= ~mask;
 362         st->rx[0] |= (val & mask);
 363         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, st->rx[0]);
 364         if (ret)
 365                 goto error_ret;
 366         mutex_unlock(&st->lock);
 367
 368         return len;
 369
 370 error_ret:
 371         mutex_unlock(&st->lock);
 372
 373         return ret;
 374 }
 375
 376 /*
 377  * Not even vaguely standard attributes so defined here rather than
 378  * in the relevant IIO core headers
 379  */
 380 static IIO_DEVICE_ATTR(measurement_mode_available, S_IRUGO,
 381                        sca3000_show_available_measurement_modes,
 382                        NULL, 0);
 383
 384 static IIO_DEVICE_ATTR(measurement_mode, S_IRUGO | S_IWUSR,
 385                        sca3000_show_measurement_mode,
 386                        sca3000_store_measurement_mode,
 387                        0);
 388
 389 /* More standard attributes */
 390
 391 static IIO_DEVICE_ATTR(revision, S_IRUGO, sca3000_show_rev, NULL, 0);
 392
 393 static const struct iio_event_spec sca3000_event = {
 394         .type = IIO_EV_TYPE_MAG,
 395         .dir = IIO_EV_DIR_RISING,
 396         .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
 397 };
 398
 399 #define SCA3000_CHAN(index, mod)                                \
 400         {                                                       \
 401                 .type = IIO_ACCEL,                              \
 402                 .modified = 1,                                  \
 403                 .channel2 = mod,                                \
 404                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
 405                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),\
 406                 .address = index,                               \
 407                 .scan_index = index,                            \
 408                 .scan_type = {                                  \
 409                         .sign = 's',                            \
 410                         .realbits = 11,                         \
 411                         .storagebits = 16,                      \
 412                         .shift = 5,                             \
 413                 },                                              \
 414                 .event_spec = &sca3000_event,                   \
 415                 .num_event_specs = 1,                           \
 416          }
 417
 418 static const struct iio_chan_spec sca3000_channels[] = {
 419         SCA3000_CHAN(0, IIO_MOD_X),
 420         SCA3000_CHAN(1, IIO_MOD_Y),
 421         SCA3000_CHAN(2, IIO_MOD_Z),
 422 };
 423
 424 static const struct iio_chan_spec sca3000_channels_with_temp[] = {
 425         SCA3000_CHAN(0, IIO_MOD_X),
 426         SCA3000_CHAN(1, IIO_MOD_Y),
 427         SCA3000_CHAN(2, IIO_MOD_Z),
 428         {
 429                 .type = IIO_TEMP,
 430                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 431                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
 432                         BIT(IIO_CHAN_INFO_OFFSET),
 433                 /* No buffer support */
 434                 .scan_index = -1,
 435         },
 436 };
 437
 438 static u8 sca3000_addresses[3][3] = {
 439         [0] = {SCA3000_REG_ADDR_X_MSB, SCA3000_REG_CTRL_SEL_MD_X_TH,
 440                SCA3000_MD_CTRL_OR_X},
 441         [1] = {SCA3000_REG_ADDR_Y_MSB, SCA3000_REG_CTRL_SEL_MD_Y_TH,
 442                SCA3000_MD_CTRL_OR_Y},
 443         [2] = {SCA3000_REG_ADDR_Z_MSB, SCA3000_REG_CTRL_SEL_MD_Z_TH,
 444                SCA3000_MD_CTRL_OR_Z},
 445 };
 446
 447 static int sca3000_read_raw(struct iio_dev *indio_dev,
 448                             struct iio_chan_spec const *chan,
 449                             int *val,
 450                             int *val2,
 451                             long mask)
 452 {
 453         struct sca3000_state *st = iio_priv(indio_dev);
 454         int ret;
 455         u8 address;
 456
 457         switch (mask) {
 458         case IIO_CHAN_INFO_RAW:
 459                 mutex_lock(&st->lock);
 460                 if (chan->type == IIO_ACCEL) {
 461                         if (st->mo_det_use_count) {
 462                                 mutex_unlock(&st->lock);
 463                                 return -EBUSY;
 464                         }
 465                         address = sca3000_addresses[chan->address][0];
 466                         ret = sca3000_read_data_short(st, address, 2);
 467                         if (ret < 0) {
 468                                 mutex_unlock(&st->lock);
 469                                 return ret;
 470                         }
 471                         *val = (be16_to_cpup((__be16 *)st->rx) >> 3) & 0x1FFF;
 472                         *val = ((*val) << (sizeof(*val) * 8 - 13)) >>
 473                                 (sizeof(*val) * 8 - 13);
 474                 } else {
 475                         /* get the temperature when available */
 476                         ret = sca3000_read_data_short(st,
 477                                                       SCA3000_REG_ADDR_TEMP_MSB,
 478                                                       2);
 479                         if (ret < 0) {
 480                                 mutex_unlock(&st->lock);
 481                                 return ret;
 482                         }
 483                         *val = ((st->rx[0] & 0x3F) << 3) |
 484                                ((st->rx[1] & 0xE0) >> 5);
 485                 }
 486                 mutex_unlock(&st->lock);
 487                 return IIO_VAL_INT;
 488         case IIO_CHAN_INFO_SCALE:
 489                 *val = 0;
 490                 if (chan->type == IIO_ACCEL)
 491                         *val2 = st->info->scale;
 492                 else /* temperature */
 493                         *val2 = 555556;
 494                 return IIO_VAL_INT_PLUS_MICRO;
 495         case IIO_CHAN_INFO_OFFSET:
 496                 *val = -214;
 497                 *val2 = 600000;
 498                 return IIO_VAL_INT_PLUS_MICRO;
 499         default:
 500                 return -EINVAL;
 501         }
 502 }
 503
 504 /**
 505  * sca3000_read_av_freq() sysfs function to get available frequencies
 506  *
 507  * The later modes are only relevant to the ring buffer - and depend on current
 508  * mode. Note that data sheet gives rather wide tolerances for these so integer
 509  * division will give good enough answer and not all chips have them specified
 510  * at all.
 511  **/
 512 static ssize_t sca3000_read_av_freq(struct device *dev,
 513                                     struct device_attribute *attr,
 514                                     char *buf)
 515 {
 516         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 517         struct sca3000_state *st = iio_priv(indio_dev);
 518         int len = 0, ret, val;
 519
 520         mutex_lock(&st->lock);
 521         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 522         val = st->rx[0];
 523         mutex_unlock(&st->lock);
 524         if (ret)
 525                 goto error_ret;
 526
 527         switch (val & 0x03) {
 528         case SCA3000_MEAS_MODE_NORMAL:
 529                 len += sprintf(buf + len, "%d %d %d\n",
 530                                st->info->measurement_mode_freq,
 531                                st->info->measurement_mode_freq / 2,
 532                                st->info->measurement_mode_freq / 4);
 533                 break;
 534         case SCA3000_MEAS_MODE_OP_1:
 535                 len += sprintf(buf + len, "%d %d %d\n",
 536                                st->info->option_mode_1_freq,
 537                                st->info->option_mode_1_freq / 2,
 538                                st->info->option_mode_1_freq / 4);
 539                 break;
 540         case SCA3000_MEAS_MODE_OP_2:
 541                 len += sprintf(buf + len, "%d %d %d\n",
 542                                st->info->option_mode_2_freq,
 543                                st->info->option_mode_2_freq / 2,
 544                                st->info->option_mode_2_freq / 4);
 545                 break;
 546         }
 547         return len;
 548 error_ret:
 549         return ret;
 550 }
 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 /**
 868  * sca3000_query_free_fall_mode() is free fall mode enabled
 869  **/
 870 static ssize_t sca3000_query_free_fall_mode(struct device *dev,
 871                                             struct device_attribute *attr,
 872                                             char *buf)
 873 {
 874         int ret;
 875         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 876         struct sca3000_state *st = iio_priv(indio_dev);
 877         int val;
 878
 879         mutex_lock(&st->lock);
 880         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 881         val = st->rx[0];
 882         mutex_unlock(&st->lock);
 883         if (ret < 0)
 884                 return ret;
 885         return sprintf(buf, "%d\n", !!(val & SCA3000_FREE_FALL_DETECT));
 886 }
 887
 888 /**
 889  * sca3000_set_free_fall_mode() simple on off control for free fall int
 890  *
 891  * In these chips the free fall detector should send an interrupt if
 892  * the device falls more than 25cm.  This has not been tested due
 893  * to fragile wiring.
 894  **/
 895 static ssize_t sca3000_set_free_fall_mode(struct device *dev,
 896                                           struct device_attribute *attr,
 897                                           const char *buf,
 898                                           size_t len)
 899 {
 900         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 901         struct sca3000_state *st = iio_priv(indio_dev);
 902         u8 val;
 903         int ret;
 904         u8 protect_mask = SCA3000_FREE_FALL_DETECT;
 905
 906         mutex_lock(&st->lock);
 907         ret = kstrtou8(buf, 10, &val);
 908         if (ret)
 909                 goto error_ret;
 910
 911         /* read current value of mode register */
 912         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 913         if (ret)
 914                 goto error_ret;
 915
 916         /* if off and should be on */
 917         if (val && !(st->rx[0] & protect_mask))
 918                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 919                                         (st->rx[0] | SCA3000_FREE_FALL_DETECT));
 920         /* if on and should be off */
 921         else if (!val && (st->rx[0] & protect_mask))
 922                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 923                                         (st->rx[0] & ~protect_mask));
 924 error_ret:
 925         mutex_unlock(&st->lock);
 926
 927         return ret ? ret : len;
 928 }
 929
 930 /**
 931  * sca3000_write_event_config() simple on off control for motion detector
 932  *
 933  * This is a per axis control, but enabling any will result in the
 934  * motion detector unit being enabled.
 935  * N.B. enabling motion detector stops normal data acquisition.
 936  * There is a complexity in knowing which mode to return to when
 937  * this mode is disabled.  Currently normal mode is assumed.
 938  **/
 939 static int sca3000_write_event_config(struct iio_dev *indio_dev,
 940                                       const struct iio_chan_spec *chan,
 941                                       enum iio_event_type type,
 942                                       enum iio_event_direction dir,
 943                                       int state)
 944 {
 945         struct sca3000_state *st = iio_priv(indio_dev);
 946         int ret, ctrlval;
 947         u8 protect_mask = 0x03;
 948         int num = chan->channel2;
 949
 950         mutex_lock(&st->lock);
 951         /*
 952          * First read the motion detector config to find out if
 953          * this axis is on
 954          */
 955         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
 956         if (ret < 0)
 957                 goto exit_point;
 958         ctrlval = ret;
 959         /* if off and should be on */
 960         if (state && !(ctrlval & sca3000_addresses[num][2])) {
 961                 ret = sca3000_write_ctrl_reg(st,
 962                                              SCA3000_REG_CTRL_SEL_MD_CTRL,
 963                                              ctrlval |
 964                                              sca3000_addresses[num][2]);
 965                 if (ret)
 966                         goto exit_point;
 967                 st->mo_det_use_count++;
 968         } else if (!state && (ctrlval & sca3000_addresses[num][2])) {
 969                 ret = sca3000_write_ctrl_reg(st,
 970                                              SCA3000_REG_CTRL_SEL_MD_CTRL,
 971                                              ctrlval &
 972                                              ~(sca3000_addresses[num][2]));
 973                 if (ret)
 974                         goto exit_point;
 975                 st->mo_det_use_count--;
 976         }
 977
 978         /* read current value of mode register */
 979         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 980         if (ret)
 981                 goto exit_point;
 982         /* if off and should be on */
 983         if ((st->mo_det_use_count)
 984             && ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET))
 985                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 986                                         (st->rx[0] & ~protect_mask)
 987                                         | SCA3000_MEAS_MODE_MOT_DET);
 988         /* if on and should be off */
 989         else if (!(st->mo_det_use_count)
 990                  && ((st->rx[0] & protect_mask) == SCA3000_MEAS_MODE_MOT_DET))
 991                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 992                                         (st->rx[0] & ~protect_mask));
 993 exit_point:
 994         mutex_unlock(&st->lock);
 995
 996         return ret;
 997 }
 998
 999 /* Free fall detector related event attribute */
1000 static IIO_DEVICE_ATTR_NAMED(accel_xayaz_mag_falling_en,
1001                              in_accel_x & y & z_mag_falling_en,
1002                              S_IRUGO | S_IWUSR,
1003                              sca3000_query_free_fall_mode,
1004                              sca3000_set_free_fall_mode,
1005                              0);
1006
1007 static IIO_CONST_ATTR_NAMED(accel_xayaz_mag_falling_period,
1008                             in_accel_x & y & z_mag_falling_period,
1009                             "0.226");
1010
1011 static struct attribute *sca3000_event_attributes[] = {
1012         &iio_dev_attr_accel_xayaz_mag_falling_en.dev_attr.attr,
1013         &iio_const_attr_accel_xayaz_mag_falling_period.dev_attr.attr,
1014         NULL,
1015 };
1016
1017 static struct attribute_group sca3000_event_attribute_group = {
1018         .attrs = sca3000_event_attributes,
1019         .name = "events",
1020 };
1021
1022 /**
1023  * sca3000_clean_setup() get the device into a predictable state
1024  *
1025  * Devices use flash memory to store many of the register values
1026  * and hence can come up in somewhat unpredictable states.
1027  * Hence reset everything on driver load.
1028  **/
1029 static int sca3000_clean_setup(struct sca3000_state *st)
1030 {
1031         int ret;
1032
1033         mutex_lock(&st->lock);
1034         /* Ensure all interrupts have been acknowledged */
1035         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1);
1036         if (ret)
1037                 goto error_ret;
1038
1039         /* Turn off all motion detection channels */
1040         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
1041         if (ret < 0)
1042                 goto error_ret;
1043         ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL,
1044                                      ret & SCA3000_MD_CTRL_PROT_MASK);
1045         if (ret)
1046                 goto error_ret;
1047
1048         /* Disable ring buffer */
1049         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
1050         ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
1051                                      (ret & SCA3000_OUT_CTRL_PROT_MASK)
1052                                      | SCA3000_OUT_CTRL_BUF_X_EN
1053                                      | SCA3000_OUT_CTRL_BUF_Y_EN
1054                                      | SCA3000_OUT_CTRL_BUF_Z_EN
1055                                      | SCA3000_OUT_CTRL_BUF_DIV_4);
1056         if (ret)
1057                 goto error_ret;
1058         /* Enable interrupts, relevant to mode and set up as active low */
1059         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1060         if (ret)
1061                 goto error_ret;
1062         ret = sca3000_write_reg(st,
1063                                 SCA3000_REG_ADDR_INT_MASK,
1064                                 (ret & SCA3000_INT_MASK_PROT_MASK)
1065                                 | SCA3000_INT_MASK_ACTIVE_LOW);
1066         if (ret)
1067                 goto error_ret;
1068         /*
1069          * Select normal measurement mode, free fall off, ring off
1070          * Ring in 12 bit mode - it is fine to overwrite reserved bits 3,5
1071          * as that occurs in one of the example on the datasheet
1072          */
1073         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
1074         if (ret)
1075                 goto error_ret;
1076         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
1077                                 (st->rx[0] & SCA3000_MODE_PROT_MASK));
1078         st->bpse = 11;
1079
1080 error_ret:
1081         mutex_unlock(&st->lock);
1082         return ret;
1083 }
1084
1085 static const struct iio_info sca3000_info = {
1086         .attrs = &sca3000_attribute_group,
1087         .read_raw = &sca3000_read_raw,
1088         .event_attrs = &sca3000_event_attribute_group,
1089         .read_event_value = &sca3000_read_thresh,
1090         .write_event_value = &sca3000_write_thresh,
1091         .read_event_config = &sca3000_read_event_config,
1092         .write_event_config = &sca3000_write_event_config,
1093         .driver_module = THIS_MODULE,
1094 };
1095
1096 static int sca3000_probe(struct spi_device *spi)
1097 {
1098         int ret;
1099         struct sca3000_state *st;
1100         struct iio_dev *indio_dev;
1101
1102         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
1103         if (!indio_dev)
1104                 return -ENOMEM;
1105
1106         st = iio_priv(indio_dev);
1107         spi_set_drvdata(spi, indio_dev);
1108         st->us = spi;
1109         mutex_init(&st->lock);
1110         st->info = &sca3000_spi_chip_info_tbl[spi_get_device_id(spi)
1111                                               ->driver_data];
1112
1113         indio_dev->dev.parent = &spi->dev;
1114         indio_dev->name = spi_get_device_id(spi)->name;
1115         indio_dev->info = &sca3000_info;
1116         if (st->info->temp_output) {
1117                 indio_dev->channels = sca3000_channels_with_temp;
1118                 indio_dev->num_channels =
1119                         ARRAY_SIZE(sca3000_channels_with_temp);
1120         } else {
1121                 indio_dev->channels = sca3000_channels;
1122                 indio_dev->num_channels = ARRAY_SIZE(sca3000_channels);
1123         }
1124         indio_dev->modes = INDIO_DIRECT_MODE;
1125
1126         sca3000_configure_ring(indio_dev);
1127         ret = iio_device_register(indio_dev);
1128         if (ret < 0)
1129                 return ret;
1130
1131         if (spi->irq) {
1132                 ret = request_threaded_irq(spi->irq,
1133                                            NULL,
1134                                            &sca3000_event_handler,
1135                                            IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1136                                            "sca3000",
1137                                            indio_dev);
1138                 if (ret)
1139                         goto error_unregister_dev;
1140         }
1141         sca3000_register_ring_funcs(indio_dev);
1142         ret = sca3000_clean_setup(st);
1143         if (ret)
1144                 goto error_free_irq;
1145         return 0;
1146
1147 error_free_irq:
1148         if (spi->irq)
1149                 free_irq(spi->irq, indio_dev);
1150 error_unregister_dev:
1151         iio_device_unregister(indio_dev);
1152         return ret;
1153 }
1154
1155 static int sca3000_stop_all_interrupts(struct sca3000_state *st)
1156 {
1157         int ret;
1158
1159         mutex_lock(&st->lock);
1160         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1161         if (ret)
1162                 goto error_ret;
1163         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_INT_MASK,
1164                                 (st->rx[0] &
1165                                  ~(SCA3000_INT_MASK_RING_THREE_QUARTER |
1166                                    SCA3000_INT_MASK_RING_HALF |
1167                                    SCA3000_INT_MASK_ALL_INTS)));
1168 error_ret:
1169         mutex_unlock(&st->lock);
1170         return ret;
1171 }
1172
1173 static int sca3000_remove(struct spi_device *spi)
1174 {
1175         struct iio_dev *indio_dev = spi_get_drvdata(spi);
1176         struct sca3000_state *st = iio_priv(indio_dev);
1177
1178         /* Must ensure no interrupts can be generated after this! */
1179         sca3000_stop_all_interrupts(st);
1180         if (spi->irq)
1181                 free_irq(spi->irq, indio_dev);
1182         iio_device_unregister(indio_dev);
1183         sca3000_unconfigure_ring(indio_dev);
1184
1185         return 0;
1186 }
1187
1188 static const struct spi_device_id sca3000_id[] = {
1189         {"sca3000_d01", d01},
1190         {"sca3000_e02", e02},
1191         {"sca3000_e04", e04},
1192         {"sca3000_e05", e05},
1193         {}
1194 };
1195 MODULE_DEVICE_TABLE(spi, sca3000_id);
1196
1197 static struct spi_driver sca3000_driver = {
1198         .driver = {
1199                 .name = "sca3000",
1200                 .owner = THIS_MODULE,
1201         },
1202         .probe = sca3000_probe,
1203         .remove = sca3000_remove,
1204         .id_table = sca3000_id,
1205 };
1206 module_spi_driver(sca3000_driver);
1207
1208 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
1209 MODULE_DESCRIPTION("VTI SCA3000 Series Accelerometers SPI driver");
1210 MODULE_LICENSE("GPL v2");