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         return st->rx[0];
 220 error_ret:
 221         return ret;
 222 }
 223
 224 /**
 225  * sca3000_show_rev() - sysfs interface to read the chip revision number
 226  **/
 227 static ssize_t sca3000_show_rev(struct device *dev,
 228                                 struct device_attribute *attr,
 229                                 char *buf)
 230 {
 231         int len = 0, ret;
 232         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 233         struct sca3000_state *st = iio_priv(indio_dev);
 234
 235         mutex_lock(&st->lock);
 236         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_REVID, 1);
 237         if (ret < 0)
 238                 goto error_ret;
 239         len += sprintf(buf + len,
 240                        "major=%d, minor=%d\n",
 241                        st->rx[0] & SCA3000_REVID_MAJOR_MASK,
 242                        st->rx[0] & SCA3000_REVID_MINOR_MASK);
 243 error_ret:
 244         mutex_unlock(&st->lock);
 245
 246         return ret ? ret : len;
 247 }
 248
 249 /**
 250  * sca3000_show_available_measurement_modes() display available modes
 251  *
 252  * This is all read from chip specific data in the driver. Not all
 253  * of the sca3000 series support modes other than normal.
 254  **/
 255 static ssize_t
 256 sca3000_show_available_measurement_modes(struct device *dev,
 257                                          struct device_attribute *attr,
 258                                          char *buf)
 259 {
 260         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 261         struct sca3000_state *st = iio_priv(indio_dev);
 262         int len = 0;
 263
 264         len += sprintf(buf + len, "0 - normal mode");
 265         switch (st->info->option_mode_1) {
 266         case SCA3000_OP_MODE_NARROW:
 267                 len += sprintf(buf + len, ", 1 - narrow mode");
 268                 break;
 269         case SCA3000_OP_MODE_BYPASS:
 270                 len += sprintf(buf + len, ", 1 - bypass mode");
 271                 break;
 272         }
 273         switch (st->info->option_mode_2) {
 274         case SCA3000_OP_MODE_WIDE:
 275                 len += sprintf(buf + len, ", 2 - wide mode");
 276                 break;
 277         }
 278         /* always supported */
 279         len += sprintf(buf + len, " 3 - motion detection\n");
 280
 281         return len;
 282 }
 283
 284 /**
 285  * sca3000_show_measurement_mode() sysfs read of current mode
 286  **/
 287 static ssize_t
 288 sca3000_show_measurement_mode(struct device *dev,
 289                               struct device_attribute *attr,
 290                               char *buf)
 291 {
 292         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 293         struct sca3000_state *st = iio_priv(indio_dev);
 294         int len = 0, ret;
 295
 296         mutex_lock(&st->lock);
 297         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 298         if (ret)
 299                 goto error_ret;
 300         /* mask bottom 2 bits - only ones that are relevant */
 301         st->rx[0] &= 0x03;
 302         switch (st->rx[0]) {
 303         case SCA3000_MEAS_MODE_NORMAL:
 304                 len += sprintf(buf + len, "0 - normal mode\n");
 305                 break;
 306         case SCA3000_MEAS_MODE_MOT_DET:
 307                 len += sprintf(buf + len, "3 - motion detection\n");
 308                 break;
 309         case SCA3000_MEAS_MODE_OP_1:
 310                 switch (st->info->option_mode_1) {
 311                 case SCA3000_OP_MODE_NARROW:
 312                         len += sprintf(buf + len, "1 - narrow mode\n");
 313                         break;
 314                 case SCA3000_OP_MODE_BYPASS:
 315                         len += sprintf(buf + len, "1 - bypass mode\n");
 316                         break;
 317                 }
 318                 break;
 319         case SCA3000_MEAS_MODE_OP_2:
 320                 switch (st->info->option_mode_2) {
 321                 case SCA3000_OP_MODE_WIDE:
 322                         len += sprintf(buf + len, "2 - wide mode\n");
 323                         break;
 324                 }
 325                 break;
 326         }
 327
 328 error_ret:
 329         mutex_unlock(&st->lock);
 330
 331         return ret ? ret : len;
 332 }
 333
 334 /**
 335  * sca3000_store_measurement_mode() set the current mode
 336  **/
 337 static ssize_t
 338 sca3000_store_measurement_mode(struct device *dev,
 339                                struct device_attribute *attr,
 340                                const char *buf,
 341                                size_t len)
 342 {
 343         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 344         struct sca3000_state *st = iio_priv(indio_dev);
 345         int ret;
 346         u8 mask = 0x03;
 347         u8 val;
 348
 349         mutex_lock(&st->lock);
 350         ret = kstrtou8(buf, 10, &val);
 351         if (ret)
 352                 goto error_ret;
 353         if (val > 3) {
 354                 ret = -EINVAL;
 355                 goto error_ret;
 356         }
 357         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 358         if (ret)
 359                 goto error_ret;
 360         st->rx[0] &= ~mask;
 361         st->rx[0] |= (val & mask);
 362         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, st->rx[0]);
 363         if (ret)
 364                 goto error_ret;
 365         mutex_unlock(&st->lock);
 366
 367         return len;
 368
 369 error_ret:
 370         mutex_unlock(&st->lock);
 371
 372         return ret;
 373 }
 374
 375 /*
 376  * Not even vaguely standard attributes so defined here rather than
 377  * in the relevant IIO core headers
 378  */
 379 static IIO_DEVICE_ATTR(measurement_mode_available, S_IRUGO,
 380                        sca3000_show_available_measurement_modes,
 381                        NULL, 0);
 382
 383 static IIO_DEVICE_ATTR(measurement_mode, S_IRUGO | S_IWUSR,
 384                        sca3000_show_measurement_mode,
 385                        sca3000_store_measurement_mode,
 386                        0);
 387
 388 /* More standard attributes */
 389
 390 static IIO_DEVICE_ATTR(revision, S_IRUGO, sca3000_show_rev, NULL, 0);
 391
 392 static const struct iio_event_spec sca3000_event = {
 393         .type = IIO_EV_TYPE_MAG,
 394         .dir = IIO_EV_DIR_RISING,
 395         .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
 396 };
 397
 398 #define SCA3000_CHAN(index, mod)                                \
 399         {                                                       \
 400                 .type = IIO_ACCEL,                              \
 401                 .modified = 1,                                  \
 402                 .channel2 = mod,                                \
 403                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
 404                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),\
 405                 .address = index,                               \
 406                 .scan_index = index,                            \
 407                 .scan_type = {                                  \
 408                         .sign = 's',                            \
 409                         .realbits = 11,                         \
 410                         .storagebits = 16,                      \
 411                         .shift = 5,                             \
 412                 },                                              \
 413                 .event_spec = &sca3000_event,                   \
 414                 .num_event_specs = 1,                           \
 415          }
 416
 417 static const struct iio_chan_spec sca3000_channels[] = {
 418         SCA3000_CHAN(0, IIO_MOD_X),
 419         SCA3000_CHAN(1, IIO_MOD_Y),
 420         SCA3000_CHAN(2, IIO_MOD_Z),
 421 };
 422
 423 static const struct iio_chan_spec sca3000_channels_with_temp[] = {
 424         SCA3000_CHAN(0, IIO_MOD_X),
 425         SCA3000_CHAN(1, IIO_MOD_Y),
 426         SCA3000_CHAN(2, IIO_MOD_Z),
 427         {
 428                 .type = IIO_TEMP,
 429                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 430                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
 431                         BIT(IIO_CHAN_INFO_OFFSET),
 432                 /* No buffer support */
 433                 .scan_index = -1,
 434         },
 435 };
 436
 437 static u8 sca3000_addresses[3][3] = {
 438         [0] = {SCA3000_REG_ADDR_X_MSB, SCA3000_REG_CTRL_SEL_MD_X_TH,
 439                SCA3000_MD_CTRL_OR_X},
 440         [1] = {SCA3000_REG_ADDR_Y_MSB, SCA3000_REG_CTRL_SEL_MD_Y_TH,
 441                SCA3000_MD_CTRL_OR_Y},
 442         [2] = {SCA3000_REG_ADDR_Z_MSB, SCA3000_REG_CTRL_SEL_MD_Z_TH,
 443                SCA3000_MD_CTRL_OR_Z},
 444 };
 445
 446 static int sca3000_read_raw(struct iio_dev *indio_dev,
 447                             struct iio_chan_spec const *chan,
 448                             int *val,
 449                             int *val2,
 450                             long mask)
 451 {
 452         struct sca3000_state *st = iio_priv(indio_dev);
 453         int ret;
 454         u8 address;
 455
 456         switch (mask) {
 457         case IIO_CHAN_INFO_RAW:
 458                 mutex_lock(&st->lock);
 459                 if (chan->type == IIO_ACCEL) {
 460                         if (st->mo_det_use_count) {
 461                                 mutex_unlock(&st->lock);
 462                                 return -EBUSY;
 463                         }
 464                         address = sca3000_addresses[chan->address][0];
 465                         ret = sca3000_read_data_short(st, address, 2);
 466                         if (ret < 0) {
 467                                 mutex_unlock(&st->lock);
 468                                 return ret;
 469                         }
 470                         *val = (be16_to_cpup((__be16 *)st->rx) >> 3) & 0x1FFF;
 471                         *val = ((*val) << (sizeof(*val) * 8 - 13)) >>
 472                                 (sizeof(*val) * 8 - 13);
 473                 } else {
 474                         /* get the temperature when available */
 475                         ret = sca3000_read_data_short(st,
 476                                                       SCA3000_REG_ADDR_TEMP_MSB,
 477                                                       2);
 478                         if (ret < 0) {
 479                                 mutex_unlock(&st->lock);
 480                                 return ret;
 481                         }
 482                         *val = ((st->rx[0] & 0x3F) << 3) |
 483                                ((st->rx[1] & 0xE0) >> 5);
 484                 }
 485                 mutex_unlock(&st->lock);
 486                 return IIO_VAL_INT;
 487         case IIO_CHAN_INFO_SCALE:
 488                 *val = 0;
 489                 if (chan->type == IIO_ACCEL)
 490                         *val2 = st->info->scale;
 491                 else /* temperature */
 492                         *val2 = 555556;
 493                 return IIO_VAL_INT_PLUS_MICRO;
 494         case IIO_CHAN_INFO_OFFSET:
 495                 *val = -214;
 496                 *val2 = 600000;
 497                 return IIO_VAL_INT_PLUS_MICRO;
 498         default:
 499                 return -EINVAL;
 500         }
 501 }
 502
 503 /**
 504  * sca3000_read_av_freq() sysfs function to get available frequencies
 505  *
 506  * The later modes are only relevant to the ring buffer - and depend on current
 507  * mode. Note that data sheet gives rather wide tolerances for these so integer
 508  * division will give good enough answer and not all chips have them specified
 509  * at all.
 510  **/
 511 static ssize_t sca3000_read_av_freq(struct device *dev,
 512                                     struct device_attribute *attr,
 513                                     char *buf)
 514 {
 515         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 516         struct sca3000_state *st = iio_priv(indio_dev);
 517         int len = 0, ret, val;
 518
 519         mutex_lock(&st->lock);
 520         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 521         val = st->rx[0];
 522         mutex_unlock(&st->lock);
 523         if (ret)
 524                 goto error_ret;
 525
 526         switch (val & 0x03) {
 527         case SCA3000_MEAS_MODE_NORMAL:
 528                 len += sprintf(buf + len, "%d %d %d\n",
 529                                st->info->measurement_mode_freq,
 530                                st->info->measurement_mode_freq / 2,
 531                                st->info->measurement_mode_freq / 4);
 532                 break;
 533         case SCA3000_MEAS_MODE_OP_1:
 534                 len += sprintf(buf + len, "%d %d %d\n",
 535                                st->info->option_mode_1_freq,
 536                                st->info->option_mode_1_freq / 2,
 537                                st->info->option_mode_1_freq / 4);
 538                 break;
 539         case SCA3000_MEAS_MODE_OP_2:
 540                 len += sprintf(buf + len, "%d %d %d\n",
 541                                st->info->option_mode_2_freq,
 542                                st->info->option_mode_2_freq / 2,
 543                                st->info->option_mode_2_freq / 4);
 544                 break;
 545         }
 546         return len;
 547 error_ret:
 548         return ret;
 549 }
 550
 551 /**
 552  * __sca3000_get_base_freq() obtain mode specific base frequency
 553  *
 554  * lock must be held
 555  **/
 556 static inline int __sca3000_get_base_freq(struct sca3000_state *st,
 557                                           const struct sca3000_chip_info *info,
 558                                           int *base_freq)
 559 {
 560         int ret;
 561
 562         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 563         if (ret)
 564                 goto error_ret;
 565         switch (0x03 & st->rx[0]) {
 566         case SCA3000_MEAS_MODE_NORMAL:
 567                 *base_freq = info->measurement_mode_freq;
 568                 break;
 569         case SCA3000_MEAS_MODE_OP_1:
 570                 *base_freq = info->option_mode_1_freq;
 571                 break;
 572         case SCA3000_MEAS_MODE_OP_2:
 573                 *base_freq = info->option_mode_2_freq;
 574                 break;
 575         }
 576 error_ret:
 577         return ret;
 578 }
 579
 580 /**
 581  * sca3000_read_frequency() sysfs interface to get the current frequency
 582  **/
 583 static ssize_t sca3000_read_frequency(struct device *dev,
 584                                       struct device_attribute *attr,
 585                                       char *buf)
 586 {
 587         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 588         struct sca3000_state *st = iio_priv(indio_dev);
 589         int ret, len = 0, base_freq = 0, val;
 590
 591         mutex_lock(&st->lock);
 592         ret = __sca3000_get_base_freq(st, st->info, &base_freq);
 593         if (ret)
 594                 goto error_ret_mut;
 595         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
 596         mutex_unlock(&st->lock);
 597         if (ret < 0)
 598                 goto error_ret;
 599         val = ret;
 600         if (base_freq > 0)
 601                 switch (val & 0x03) {
 602                 case 0x00:
 603                 case 0x03:
 604                         len = sprintf(buf, "%d\n", base_freq);
 605                         break;
 606                 case 0x01:
 607                         len = sprintf(buf, "%d\n", base_freq / 2);
 608                         break;
 609                 case 0x02:
 610                         len = sprintf(buf, "%d\n", base_freq / 4);
 611                         break;
 612         }
 613
 614         return len;
 615 error_ret_mut:
 616         mutex_unlock(&st->lock);
 617 error_ret:
 618         return ret;
 619 }
 620
 621 /**
 622  * sca3000_set_frequency() sysfs interface to set the current frequency
 623  **/
 624 static ssize_t sca3000_set_frequency(struct device *dev,
 625                                      struct device_attribute *attr,
 626                                      const char *buf,
 627                                      size_t len)
 628 {
 629         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 630         struct sca3000_state *st = iio_priv(indio_dev);
 631         int ret, base_freq = 0;
 632         int ctrlval;
 633         int val;
 634
 635         ret = kstrtoint(buf, 10, &val);
 636         if (ret)
 637                 return ret;
 638
 639         mutex_lock(&st->lock);
 640         /* What mode are we in? */
 641         ret = __sca3000_get_base_freq(st, st->info, &base_freq);
 642         if (ret)
 643                 goto error_free_lock;
 644
 645         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
 646         if (ret < 0)
 647                 goto error_free_lock;
 648         ctrlval = ret;
 649         /* clear the bits */
 650         ctrlval &= ~0x03;
 651
 652         if (val == base_freq / 2) {
 653                 ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_2;
 654         } else if (val == base_freq / 4) {
 655                 ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_4;
 656         } else if (val != base_freq) {
 657                 ret = -EINVAL;
 658                 goto error_free_lock;
 659         }
 660         ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
 661                                      ctrlval);
 662 error_free_lock:
 663         mutex_unlock(&st->lock);
 664
 665         return ret ? ret : len;
 666 }
 667
 668 /*
 669  * Should only really be registered if ring buffer support is compiled in.
 670  * Does no harm however and doing it right would add a fair bit of complexity
 671  */
 672 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(sca3000_read_av_freq);
 673
 674 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 675                               sca3000_read_frequency,
 676                               sca3000_set_frequency);
 677
 678 /**
 679  * sca3000_read_thresh() - query of a threshold
 680  **/
 681 static int sca3000_read_thresh(struct iio_dev *indio_dev,
 682                                const struct iio_chan_spec *chan,
 683                                enum iio_event_type type,
 684                                enum iio_event_direction dir,
 685                                enum iio_event_info info,
 686                                int *val, int *val2)
 687 {
 688         int ret, i;
 689         struct sca3000_state *st = iio_priv(indio_dev);
 690         int num = chan->channel2;
 691
 692         mutex_lock(&st->lock);
 693         ret = sca3000_read_ctrl_reg(st, sca3000_addresses[num][1]);
 694         mutex_unlock(&st->lock);
 695         if (ret < 0)
 696                 return ret;
 697         *val = 0;
 698         if (num == 1)
 699                 for_each_set_bit(i, (unsigned long *)&ret,
 700                                  ARRAY_SIZE(st->info->mot_det_mult_y))
 701                         *val += st->info->mot_det_mult_y[i];
 702         else
 703                 for_each_set_bit(i, (unsigned long *)&ret,
 704                                  ARRAY_SIZE(st->info->mot_det_mult_xz))
 705                         *val += st->info->mot_det_mult_xz[i];
 706
 707         return IIO_VAL_INT;
 708 }
 709
 710 /**
 711  * sca3000_write_thresh() control of threshold
 712  **/
 713 static int sca3000_write_thresh(struct iio_dev *indio_dev,
 714                                 const struct iio_chan_spec *chan,
 715                                 enum iio_event_type type,
 716                                 enum iio_event_direction dir,
 717                                 enum iio_event_info info,
 718                                 int val, int val2)
 719 {
 720         struct sca3000_state *st = iio_priv(indio_dev);
 721         int num = chan->channel2;
 722         int ret;
 723         int i;
 724         u8 nonlinear = 0;
 725
 726         if (num == 1) {
 727                 i = ARRAY_SIZE(st->info->mot_det_mult_y);
 728                 while (i > 0)
 729                         if (val >= st->info->mot_det_mult_y[--i]) {
 730                                 nonlinear |= (1 << i);
 731                                 val -= st->info->mot_det_mult_y[i];
 732                         }
 733         } else {
 734                 i = ARRAY_SIZE(st->info->mot_det_mult_xz);
 735                 while (i > 0)
 736                         if (val >= st->info->mot_det_mult_xz[--i]) {
 737                                 nonlinear |= (1 << i);
 738                                 val -= st->info->mot_det_mult_xz[i];
 739                         }
 740         }
 741
 742         mutex_lock(&st->lock);
 743         ret = sca3000_write_ctrl_reg(st, sca3000_addresses[num][1], nonlinear);
 744         mutex_unlock(&st->lock);
 745
 746         return ret;
 747 }
 748
 749 static struct attribute *sca3000_attributes[] = {
 750         &iio_dev_attr_revision.dev_attr.attr,
 751         &iio_dev_attr_measurement_mode_available.dev_attr.attr,
 752         &iio_dev_attr_measurement_mode.dev_attr.attr,
 753         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 754         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 755         NULL,
 756 };
 757
 758 static const struct attribute_group sca3000_attribute_group = {
 759         .attrs = sca3000_attributes,
 760 };
 761
 762 /**
 763  * sca3000_event_handler() - handling ring and non ring events
 764  *
 765  * Ring related interrupt handler. Depending on event, push to
 766  * the ring buffer event chrdev or the event one.
 767  *
 768  * This function is complicated by the fact that the devices can signify ring
 769  * and non ring events via the same interrupt line and they can only
 770  * be distinguished via a read of the relevant status register.
 771  **/
 772 static irqreturn_t sca3000_event_handler(int irq, void *private)
 773 {
 774         struct iio_dev *indio_dev = private;
 775         struct sca3000_state *st = iio_priv(indio_dev);
 776         int ret, val;
 777         s64 last_timestamp = iio_get_time_ns(indio_dev);
 778
 779         /*
 780          * Could lead if badly timed to an extra read of status reg,
 781          * but ensures no interrupt is missed.
 782          */
 783         mutex_lock(&st->lock);
 784         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1);
 785         val = st->rx[0];
 786         mutex_unlock(&st->lock);
 787         if (ret)
 788                 goto done;
 789
 790         sca3000_ring_int_process(val, indio_dev->buffer);
 791
 792         if (val & SCA3000_INT_STATUS_FREE_FALL)
 793                 iio_push_event(indio_dev,
 794                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 795                                                   0,
 796                                                   IIO_MOD_X_AND_Y_AND_Z,
 797                                                   IIO_EV_TYPE_MAG,
 798                                                   IIO_EV_DIR_FALLING),
 799                                last_timestamp);
 800
 801         if (val & SCA3000_INT_STATUS_Y_TRIGGER)
 802                 iio_push_event(indio_dev,
 803                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 804                                                   0,
 805                                                   IIO_MOD_Y,
 806                                                   IIO_EV_TYPE_MAG,
 807                                                   IIO_EV_DIR_RISING),
 808                                last_timestamp);
 809
 810         if (val & SCA3000_INT_STATUS_X_TRIGGER)
 811                 iio_push_event(indio_dev,
 812                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 813                                                   0,
 814                                                   IIO_MOD_X,
 815                                                   IIO_EV_TYPE_MAG,
 816                                                   IIO_EV_DIR_RISING),
 817                                last_timestamp);
 818
 819         if (val & SCA3000_INT_STATUS_Z_TRIGGER)
 820                 iio_push_event(indio_dev,
 821                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 822                                                   0,
 823                                                   IIO_MOD_Z,
 824                                                   IIO_EV_TYPE_MAG,
 825                                                   IIO_EV_DIR_RISING),
 826                                last_timestamp);
 827
 828 done:
 829         return IRQ_HANDLED;
 830 }
 831
 832 /**
 833  * sca3000_read_event_config() what events are enabled
 834  **/
 835 static int sca3000_read_event_config(struct iio_dev *indio_dev,
 836                                      const struct iio_chan_spec *chan,
 837                                      enum iio_event_type type,
 838                                      enum iio_event_direction dir)
 839 {
 840         struct sca3000_state *st = iio_priv(indio_dev);
 841         int ret;
 842         u8 protect_mask = 0x03;
 843         int num = chan->channel2;
 844
 845         /* read current value of mode register */
 846         mutex_lock(&st->lock);
 847         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 848         if (ret)
 849                 goto error_ret;
 850
 851         if ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET) {
 852                 ret = 0;
 853         } else {
 854                 ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
 855                 if (ret < 0)
 856                         goto error_ret;
 857                 /* only supporting logical or's for now */
 858                 ret = !!(ret & sca3000_addresses[num][2]);
 859         }
 860 error_ret:
 861         mutex_unlock(&st->lock);
 862
 863         return ret;
 864 }
 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         if (ret < 0)
1050                 goto error_ret;
1051         ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
1052                                      (ret & SCA3000_OUT_CTRL_PROT_MASK)
1053                                      | SCA3000_OUT_CTRL_BUF_X_EN
1054                                      | SCA3000_OUT_CTRL_BUF_Y_EN
1055                                      | SCA3000_OUT_CTRL_BUF_Z_EN
1056                                      | SCA3000_OUT_CTRL_BUF_DIV_4);
1057         if (ret)
1058                 goto error_ret;
1059         /* Enable interrupts, relevant to mode and set up as active low */
1060         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1061         if (ret)
1062                 goto error_ret;
1063         ret = sca3000_write_reg(st,
1064                                 SCA3000_REG_ADDR_INT_MASK,
1065                                 (ret & SCA3000_INT_MASK_PROT_MASK)
1066                                 | SCA3000_INT_MASK_ACTIVE_LOW);
1067         if (ret)
1068                 goto error_ret;
1069         /*
1070          * Select normal measurement mode, free fall off, ring off
1071          * Ring in 12 bit mode - it is fine to overwrite reserved bits 3,5
1072          * as that occurs in one of the example on the datasheet
1073          */
1074         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
1075         if (ret)
1076                 goto error_ret;
1077         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
1078                                 (st->rx[0] & SCA3000_MODE_PROT_MASK));
1079         st->bpse = 11;
1080
1081 error_ret:
1082         mutex_unlock(&st->lock);
1083         return ret;
1084 }
1085
1086 static const struct iio_info sca3000_info = {
1087         .attrs = &sca3000_attribute_group,
1088         .read_raw = &sca3000_read_raw,
1089         .event_attrs = &sca3000_event_attribute_group,
1090         .read_event_value = &sca3000_read_thresh,
1091         .write_event_value = &sca3000_write_thresh,
1092         .read_event_config = &sca3000_read_event_config,
1093         .write_event_config = &sca3000_write_event_config,
1094         .driver_module = THIS_MODULE,
1095 };
1096
1097 static int sca3000_probe(struct spi_device *spi)
1098 {
1099         int ret;
1100         struct sca3000_state *st;
1101         struct iio_dev *indio_dev;
1102
1103         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
1104         if (!indio_dev)
1105                 return -ENOMEM;
1106
1107         st = iio_priv(indio_dev);
1108         spi_set_drvdata(spi, indio_dev);
1109         st->us = spi;
1110         mutex_init(&st->lock);
1111         st->info = &sca3000_spi_chip_info_tbl[spi_get_device_id(spi)
1112                                               ->driver_data];
1113
1114         indio_dev->dev.parent = &spi->dev;
1115         indio_dev->name = spi_get_device_id(spi)->name;
1116         indio_dev->info = &sca3000_info;
1117         if (st->info->temp_output) {
1118                 indio_dev->channels = sca3000_channels_with_temp;
1119                 indio_dev->num_channels =
1120                         ARRAY_SIZE(sca3000_channels_with_temp);
1121         } else {
1122                 indio_dev->channels = sca3000_channels;
1123                 indio_dev->num_channels = ARRAY_SIZE(sca3000_channels);
1124         }
1125         indio_dev->modes = INDIO_DIRECT_MODE;
1126
1127         sca3000_configure_ring(indio_dev);
1128         ret = iio_device_register(indio_dev);
1129         if (ret < 0)
1130                 return ret;
1131
1132         if (spi->irq) {
1133                 ret = request_threaded_irq(spi->irq,
1134                                            NULL,
1135                                            &sca3000_event_handler,
1136                                            IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1137                                            "sca3000",
1138                                            indio_dev);
1139                 if (ret)
1140                         goto error_unregister_dev;
1141         }
1142         sca3000_register_ring_funcs(indio_dev);
1143         ret = sca3000_clean_setup(st);
1144         if (ret)
1145                 goto error_free_irq;
1146         return 0;
1147
1148 error_free_irq:
1149         if (spi->irq)
1150                 free_irq(spi->irq, indio_dev);
1151 error_unregister_dev:
1152         iio_device_unregister(indio_dev);
1153         return ret;
1154 }
1155
1156 static int sca3000_stop_all_interrupts(struct sca3000_state *st)
1157 {
1158         int ret;
1159
1160         mutex_lock(&st->lock);
1161         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1162         if (ret)
1163                 goto error_ret;
1164         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_INT_MASK,
1165                                 (st->rx[0] &
1166                                  ~(SCA3000_INT_MASK_RING_THREE_QUARTER |
1167                                    SCA3000_INT_MASK_RING_HALF |
1168                                    SCA3000_INT_MASK_ALL_INTS)));
1169 error_ret:
1170         mutex_unlock(&st->lock);
1171         return ret;
1172 }
1173
1174 static int sca3000_remove(struct spi_device *spi)
1175 {
1176         struct iio_dev *indio_dev = spi_get_drvdata(spi);
1177         struct sca3000_state *st = iio_priv(indio_dev);
1178
1179         /* Must ensure no interrupts can be generated after this! */
1180         sca3000_stop_all_interrupts(st);
1181         if (spi->irq)
1182                 free_irq(spi->irq, indio_dev);
1183         iio_device_unregister(indio_dev);
1184         sca3000_unconfigure_ring(indio_dev);
1185
1186         return 0;
1187 }
1188
1189 static const struct spi_device_id sca3000_id[] = {
1190         {"sca3000_d01", d01},
1191         {"sca3000_e02", e02},
1192         {"sca3000_e04", e04},
1193         {"sca3000_e05", e05},
1194         {}
1195 };
1196 MODULE_DEVICE_TABLE(spi, sca3000_id);
1197
1198 static struct spi_driver sca3000_driver = {
1199         .driver = {
1200                 .name = "sca3000",
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");