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                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),\
 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 /**
 448  * __sca3000_get_base_freq() obtain mode specific base frequency
 449  *
 450  * lock must be held
 451  **/
 452 static inline int __sca3000_get_base_freq(struct sca3000_state *st,
 453                                           const struct sca3000_chip_info *info,
 454                                           int *base_freq)
 455 {
 456         int ret;
 457
 458         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 459         if (ret)
 460                 goto error_ret;
 461         switch (0x03 & st->rx[0]) {
 462         case SCA3000_MEAS_MODE_NORMAL:
 463                 *base_freq = info->measurement_mode_freq;
 464                 break;
 465         case SCA3000_MEAS_MODE_OP_1:
 466                 *base_freq = info->option_mode_1_freq;
 467                 break;
 468         case SCA3000_MEAS_MODE_OP_2:
 469                 *base_freq = info->option_mode_2_freq;
 470                 break;
 471         }
 472 error_ret:
 473         return ret;
 474 }
 475
 476 /**
 477  * read_raw handler for IIO_CHAN_INFO_SAMP_FREQ
 478  *
 479  * lock must be held
 480  **/
 481 static int read_raw_samp_freq(struct sca3000_state *st, int *val)
 482 {
 483         int ret;
 484
 485         ret = __sca3000_get_base_freq(st, st->info, val);
 486         if (ret)
 487                 return ret;
 488
 489         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
 490         if (ret < 0)
 491                 return ret;
 492
 493         if (*val > 0) {
 494                 ret &= SCA3000_OUT_CTRL_BUF_DIV_MASK;
 495                 switch (ret) {
 496                 case SCA3000_OUT_CTRL_BUF_DIV_2:
 497                         *val /= 2;
 498                         break;
 499                 case SCA3000_OUT_CTRL_BUF_DIV_4:
 500                         *val /= 4;
 501                         break;
 502                 }
 503         }
 504
 505         return 0;
 506 }
 507
 508 /**
 509  * write_raw handler for IIO_CHAN_INFO_SAMP_FREQ
 510  *
 511  * lock must be held
 512  **/
 513 static int write_raw_samp_freq(struct sca3000_state *st, int val)
 514 {
 515         int ret, base_freq, ctrlval;
 516
 517         ret = __sca3000_get_base_freq(st, st->info, &base_freq);
 518         if (ret)
 519                 return ret;
 520
 521         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
 522         if (ret < 0)
 523                 return ret;
 524
 525         ctrlval = ret & ~SCA3000_OUT_CTRL_BUF_DIV_MASK;
 526
 527         if (val == base_freq / 2)
 528                 ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_2;
 529         if (val == base_freq / 4)
 530                 ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_4;
 531         else if (val != base_freq)
 532                 return -EINVAL;
 533
 534         return sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
 535                                      ctrlval);
 536 }
 537
 538 static int sca3000_read_raw(struct iio_dev *indio_dev,
 539                             struct iio_chan_spec const *chan,
 540                             int *val,
 541                             int *val2,
 542                             long mask)
 543 {
 544         struct sca3000_state *st = iio_priv(indio_dev);
 545         int ret;
 546         u8 address;
 547
 548         switch (mask) {
 549         case IIO_CHAN_INFO_RAW:
 550                 mutex_lock(&st->lock);
 551                 if (chan->type == IIO_ACCEL) {
 552                         if (st->mo_det_use_count) {
 553                                 mutex_unlock(&st->lock);
 554                                 return -EBUSY;
 555                         }
 556                         address = sca3000_addresses[chan->address][0];
 557                         ret = sca3000_read_data_short(st, address, 2);
 558                         if (ret < 0) {
 559                                 mutex_unlock(&st->lock);
 560                                 return ret;
 561                         }
 562                         *val = (be16_to_cpup((__be16 *)st->rx) >> 3) & 0x1FFF;
 563                         *val = ((*val) << (sizeof(*val) * 8 - 13)) >>
 564                                 (sizeof(*val) * 8 - 13);
 565                 } else {
 566                         /* get the temperature when available */
 567                         ret = sca3000_read_data_short(st,
 568                                                       SCA3000_REG_ADDR_TEMP_MSB,
 569                                                       2);
 570                         if (ret < 0) {
 571                                 mutex_unlock(&st->lock);
 572                                 return ret;
 573                         }
 574                         *val = ((st->rx[0] & 0x3F) << 3) |
 575                                ((st->rx[1] & 0xE0) >> 5);
 576                 }
 577                 mutex_unlock(&st->lock);
 578                 return IIO_VAL_INT;
 579         case IIO_CHAN_INFO_SCALE:
 580                 *val = 0;
 581                 if (chan->type == IIO_ACCEL)
 582                         *val2 = st->info->scale;
 583                 else /* temperature */
 584                         *val2 = 555556;
 585                 return IIO_VAL_INT_PLUS_MICRO;
 586         case IIO_CHAN_INFO_OFFSET:
 587                 *val = -214;
 588                 *val2 = 600000;
 589                 return IIO_VAL_INT_PLUS_MICRO;
 590         case IIO_CHAN_INFO_SAMP_FREQ:
 591                 mutex_lock(&st->lock);
 592                 ret = read_raw_samp_freq(st, val);
 593                 mutex_unlock(&st->lock);
 594                 return ret ? ret : IIO_VAL_INT;
 595         default:
 596                 return -EINVAL;
 597         }
 598 }
 599
 600 static int sca3000_write_raw(struct iio_dev *indio_dev,
 601                              struct iio_chan_spec const *chan,
 602                              int val, int val2, long mask)
 603 {
 604         struct sca3000_state *st = iio_priv(indio_dev);
 605         int ret;
 606
 607         switch (mask) {
 608         case IIO_CHAN_INFO_SAMP_FREQ:
 609                 if (val2)
 610                         return -EINVAL;
 611                 mutex_lock(&st->lock);
 612                 ret = write_raw_samp_freq(st, val);
 613                 mutex_unlock(&st->lock);
 614                 return ret;
 615         default:
 616                 return -EINVAL;
 617         }
 618
 619         return ret;
 620 }
 621
 622 /**
 623  * sca3000_read_av_freq() sysfs function to get available frequencies
 624  *
 625  * The later modes are only relevant to the ring buffer - and depend on current
 626  * mode. Note that data sheet gives rather wide tolerances for these so integer
 627  * division will give good enough answer and not all chips have them specified
 628  * at all.
 629  **/
 630 static ssize_t sca3000_read_av_freq(struct device *dev,
 631                                     struct device_attribute *attr,
 632                                     char *buf)
 633 {
 634         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 635         struct sca3000_state *st = iio_priv(indio_dev);
 636         int len = 0, ret, val;
 637
 638         mutex_lock(&st->lock);
 639         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 640         val = st->rx[0];
 641         mutex_unlock(&st->lock);
 642         if (ret)
 643                 goto error_ret;
 644
 645         switch (val & 0x03) {
 646         case SCA3000_MEAS_MODE_NORMAL:
 647                 len += sprintf(buf + len, "%d %d %d\n",
 648                                st->info->measurement_mode_freq,
 649                                st->info->measurement_mode_freq / 2,
 650                                st->info->measurement_mode_freq / 4);
 651                 break;
 652         case SCA3000_MEAS_MODE_OP_1:
 653                 len += sprintf(buf + len, "%d %d %d\n",
 654                                st->info->option_mode_1_freq,
 655                                st->info->option_mode_1_freq / 2,
 656                                st->info->option_mode_1_freq / 4);
 657                 break;
 658         case SCA3000_MEAS_MODE_OP_2:
 659                 len += sprintf(buf + len, "%d %d %d\n",
 660                                st->info->option_mode_2_freq,
 661                                st->info->option_mode_2_freq / 2,
 662                                st->info->option_mode_2_freq / 4);
 663                 break;
 664         }
 665         return len;
 666 error_ret:
 667         return ret;
 668 }
 669
 670 /*
 671  * Should only really be registered if ring buffer support is compiled in.
 672  * Does no harm however and doing it right would add a fair bit of complexity
 673  */
 674 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(sca3000_read_av_freq);
 675
 676 /**
 677  * sca3000_read_thresh() - query of a threshold
 678  **/
 679 static int sca3000_read_thresh(struct iio_dev *indio_dev,
 680                                const struct iio_chan_spec *chan,
 681                                enum iio_event_type type,
 682                                enum iio_event_direction dir,
 683                                enum iio_event_info info,
 684                                int *val, int *val2)
 685 {
 686         int ret, i;
 687         struct sca3000_state *st = iio_priv(indio_dev);
 688         int num = chan->channel2;
 689
 690         mutex_lock(&st->lock);
 691         ret = sca3000_read_ctrl_reg(st, sca3000_addresses[num][1]);
 692         mutex_unlock(&st->lock);
 693         if (ret < 0)
 694                 return ret;
 695         *val = 0;
 696         if (num == 1)
 697                 for_each_set_bit(i, (unsigned long *)&ret,
 698                                  ARRAY_SIZE(st->info->mot_det_mult_y))
 699                         *val += st->info->mot_det_mult_y[i];
 700         else
 701                 for_each_set_bit(i, (unsigned long *)&ret,
 702                                  ARRAY_SIZE(st->info->mot_det_mult_xz))
 703                         *val += st->info->mot_det_mult_xz[i];
 704
 705         return IIO_VAL_INT;
 706 }
 707
 708 /**
 709  * sca3000_write_thresh() control of threshold
 710  **/
 711 static int sca3000_write_thresh(struct iio_dev *indio_dev,
 712                                 const struct iio_chan_spec *chan,
 713                                 enum iio_event_type type,
 714                                 enum iio_event_direction dir,
 715                                 enum iio_event_info info,
 716                                 int val, int val2)
 717 {
 718         struct sca3000_state *st = iio_priv(indio_dev);
 719         int num = chan->channel2;
 720         int ret;
 721         int i;
 722         u8 nonlinear = 0;
 723
 724         if (num == 1) {
 725                 i = ARRAY_SIZE(st->info->mot_det_mult_y);
 726                 while (i > 0)
 727                         if (val >= st->info->mot_det_mult_y[--i]) {
 728                                 nonlinear |= (1 << i);
 729                                 val -= st->info->mot_det_mult_y[i];
 730                         }
 731         } else {
 732                 i = ARRAY_SIZE(st->info->mot_det_mult_xz);
 733                 while (i > 0)
 734                         if (val >= st->info->mot_det_mult_xz[--i]) {
 735                                 nonlinear |= (1 << i);
 736                                 val -= st->info->mot_det_mult_xz[i];
 737                         }
 738         }
 739
 740         mutex_lock(&st->lock);
 741         ret = sca3000_write_ctrl_reg(st, sca3000_addresses[num][1], nonlinear);
 742         mutex_unlock(&st->lock);
 743
 744         return ret;
 745 }
 746
 747 static struct attribute *sca3000_attributes[] = {
 748         &iio_dev_attr_revision.dev_attr.attr,
 749         &iio_dev_attr_measurement_mode_available.dev_attr.attr,
 750         &iio_dev_attr_measurement_mode.dev_attr.attr,
 751         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 752         NULL,
 753 };
 754
 755 static const struct attribute_group sca3000_attribute_group = {
 756         .attrs = sca3000_attributes,
 757 };
 758
 759 /**
 760  * sca3000_event_handler() - handling ring and non ring events
 761  *
 762  * Ring related interrupt handler. Depending on event, push to
 763  * the ring buffer event chrdev or the event one.
 764  *
 765  * This function is complicated by the fact that the devices can signify ring
 766  * and non ring events via the same interrupt line and they can only
 767  * be distinguished via a read of the relevant status register.
 768  **/
 769 static irqreturn_t sca3000_event_handler(int irq, void *private)
 770 {
 771         struct iio_dev *indio_dev = private;
 772         struct sca3000_state *st = iio_priv(indio_dev);
 773         int ret, val;
 774         s64 last_timestamp = iio_get_time_ns(indio_dev);
 775
 776         /*
 777          * Could lead if badly timed to an extra read of status reg,
 778          * but ensures no interrupt is missed.
 779          */
 780         mutex_lock(&st->lock);
 781         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1);
 782         val = st->rx[0];
 783         mutex_unlock(&st->lock);
 784         if (ret)
 785                 goto done;
 786
 787         sca3000_ring_int_process(val, indio_dev->buffer);
 788
 789         if (val & SCA3000_INT_STATUS_FREE_FALL)
 790                 iio_push_event(indio_dev,
 791                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 792                                                   0,
 793                                                   IIO_MOD_X_AND_Y_AND_Z,
 794                                                   IIO_EV_TYPE_MAG,
 795                                                   IIO_EV_DIR_FALLING),
 796                                last_timestamp);
 797
 798         if (val & SCA3000_INT_STATUS_Y_TRIGGER)
 799                 iio_push_event(indio_dev,
 800                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 801                                                   0,
 802                                                   IIO_MOD_Y,
 803                                                   IIO_EV_TYPE_MAG,
 804                                                   IIO_EV_DIR_RISING),
 805                                last_timestamp);
 806
 807         if (val & SCA3000_INT_STATUS_X_TRIGGER)
 808                 iio_push_event(indio_dev,
 809                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 810                                                   0,
 811                                                   IIO_MOD_X,
 812                                                   IIO_EV_TYPE_MAG,
 813                                                   IIO_EV_DIR_RISING),
 814                                last_timestamp);
 815
 816         if (val & SCA3000_INT_STATUS_Z_TRIGGER)
 817                 iio_push_event(indio_dev,
 818                                IIO_MOD_EVENT_CODE(IIO_ACCEL,
 819                                                   0,
 820                                                   IIO_MOD_Z,
 821                                                   IIO_EV_TYPE_MAG,
 822                                                   IIO_EV_DIR_RISING),
 823                                last_timestamp);
 824
 825 done:
 826         return IRQ_HANDLED;
 827 }
 828
 829 /**
 830  * sca3000_read_event_config() what events are enabled
 831  **/
 832 static int sca3000_read_event_config(struct iio_dev *indio_dev,
 833                                      const struct iio_chan_spec *chan,
 834                                      enum iio_event_type type,
 835                                      enum iio_event_direction dir)
 836 {
 837         struct sca3000_state *st = iio_priv(indio_dev);
 838         int ret;
 839         u8 protect_mask = 0x03;
 840         int num = chan->channel2;
 841
 842         /* read current value of mode register */
 843         mutex_lock(&st->lock);
 844         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 845         if (ret)
 846                 goto error_ret;
 847
 848         if ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET) {
 849                 ret = 0;
 850         } else {
 851                 ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
 852                 if (ret < 0)
 853                         goto error_ret;
 854                 /* only supporting logical or's for now */
 855                 ret = !!(ret & sca3000_addresses[num][2]);
 856         }
 857 error_ret:
 858         mutex_unlock(&st->lock);
 859
 860         return ret;
 861 }
 862
 863 /**
 864  * sca3000_query_free_fall_mode() is free fall mode enabled
 865  **/
 866 static ssize_t sca3000_query_free_fall_mode(struct device *dev,
 867                                             struct device_attribute *attr,
 868                                             char *buf)
 869 {
 870         int ret;
 871         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 872         struct sca3000_state *st = iio_priv(indio_dev);
 873         int val;
 874
 875         mutex_lock(&st->lock);
 876         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 877         val = st->rx[0];
 878         mutex_unlock(&st->lock);
 879         if (ret < 0)
 880                 return ret;
 881         return sprintf(buf, "%d\n", !!(val & SCA3000_FREE_FALL_DETECT));
 882 }
 883
 884 /**
 885  * sca3000_set_free_fall_mode() simple on off control for free fall int
 886  *
 887  * In these chips the free fall detector should send an interrupt if
 888  * the device falls more than 25cm.  This has not been tested due
 889  * to fragile wiring.
 890  **/
 891 static ssize_t sca3000_set_free_fall_mode(struct device *dev,
 892                                           struct device_attribute *attr,
 893                                           const char *buf,
 894                                           size_t len)
 895 {
 896         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 897         struct sca3000_state *st = iio_priv(indio_dev);
 898         u8 val;
 899         int ret;
 900         u8 protect_mask = SCA3000_FREE_FALL_DETECT;
 901
 902         mutex_lock(&st->lock);
 903         ret = kstrtou8(buf, 10, &val);
 904         if (ret)
 905                 goto error_ret;
 906
 907         /* read current value of mode register */
 908         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 909         if (ret)
 910                 goto error_ret;
 911
 912         /* if off and should be on */
 913         if (val && !(st->rx[0] & protect_mask))
 914                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 915                                         (st->rx[0] | SCA3000_FREE_FALL_DETECT));
 916         /* if on and should be off */
 917         else if (!val && (st->rx[0] & protect_mask))
 918                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 919                                         (st->rx[0] & ~protect_mask));
 920 error_ret:
 921         mutex_unlock(&st->lock);
 922
 923         return ret ? ret : len;
 924 }
 925
 926 /**
 927  * sca3000_write_event_config() simple on off control for motion detector
 928  *
 929  * This is a per axis control, but enabling any will result in the
 930  * motion detector unit being enabled.
 931  * N.B. enabling motion detector stops normal data acquisition.
 932  * There is a complexity in knowing which mode to return to when
 933  * this mode is disabled.  Currently normal mode is assumed.
 934  **/
 935 static int sca3000_write_event_config(struct iio_dev *indio_dev,
 936                                       const struct iio_chan_spec *chan,
 937                                       enum iio_event_type type,
 938                                       enum iio_event_direction dir,
 939                                       int state)
 940 {
 941         struct sca3000_state *st = iio_priv(indio_dev);
 942         int ret, ctrlval;
 943         u8 protect_mask = 0x03;
 944         int num = chan->channel2;
 945
 946         mutex_lock(&st->lock);
 947         /*
 948          * First read the motion detector config to find out if
 949          * this axis is on
 950          */
 951         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
 952         if (ret < 0)
 953                 goto exit_point;
 954         ctrlval = ret;
 955         /* if off and should be on */
 956         if (state && !(ctrlval & sca3000_addresses[num][2])) {
 957                 ret = sca3000_write_ctrl_reg(st,
 958                                              SCA3000_REG_CTRL_SEL_MD_CTRL,
 959                                              ctrlval |
 960                                              sca3000_addresses[num][2]);
 961                 if (ret)
 962                         goto exit_point;
 963                 st->mo_det_use_count++;
 964         } else if (!state && (ctrlval & sca3000_addresses[num][2])) {
 965                 ret = sca3000_write_ctrl_reg(st,
 966                                              SCA3000_REG_CTRL_SEL_MD_CTRL,
 967                                              ctrlval &
 968                                              ~(sca3000_addresses[num][2]));
 969                 if (ret)
 970                         goto exit_point;
 971                 st->mo_det_use_count--;
 972         }
 973
 974         /* read current value of mode register */
 975         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 976         if (ret)
 977                 goto exit_point;
 978         /* if off and should be on */
 979         if ((st->mo_det_use_count) &&
 980             ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET))
 981                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 982                                         (st->rx[0] & ~protect_mask)
 983                                         | SCA3000_MEAS_MODE_MOT_DET);
 984         /* if on and should be off */
 985         else if (!(st->mo_det_use_count) &&
 986                  ((st->rx[0] & protect_mask) == SCA3000_MEAS_MODE_MOT_DET))
 987                 ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 988                                         (st->rx[0] & ~protect_mask));
 989 exit_point:
 990         mutex_unlock(&st->lock);
 991
 992         return ret;
 993 }
 994
 995 /* Free fall detector related event attribute */
 996 static IIO_DEVICE_ATTR_NAMED(accel_xayaz_mag_falling_en,
 997                              in_accel_x & y & z_mag_falling_en,
 998                              S_IRUGO | S_IWUSR,
 999                              sca3000_query_free_fall_mode,
1000                              sca3000_set_free_fall_mode,
1001                              0);
1002
1003 static IIO_CONST_ATTR_NAMED(accel_xayaz_mag_falling_period,
1004                             in_accel_x & y & z_mag_falling_period,
1005                             "0.226");
1006
1007 static struct attribute *sca3000_event_attributes[] = {
1008         &iio_dev_attr_accel_xayaz_mag_falling_en.dev_attr.attr,
1009         &iio_const_attr_accel_xayaz_mag_falling_period.dev_attr.attr,
1010         NULL,
1011 };
1012
1013 static struct attribute_group sca3000_event_attribute_group = {
1014         .attrs = sca3000_event_attributes,
1015         .name = "events",
1016 };
1017
1018 /**
1019  * sca3000_clean_setup() get the device into a predictable state
1020  *
1021  * Devices use flash memory to store many of the register values
1022  * and hence can come up in somewhat unpredictable states.
1023  * Hence reset everything on driver load.
1024  **/
1025 static int sca3000_clean_setup(struct sca3000_state *st)
1026 {
1027         int ret;
1028
1029         mutex_lock(&st->lock);
1030         /* Ensure all interrupts have been acknowledged */
1031         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1);
1032         if (ret)
1033                 goto error_ret;
1034
1035         /* Turn off all motion detection channels */
1036         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
1037         if (ret < 0)
1038                 goto error_ret;
1039         ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL,
1040                                      ret & SCA3000_MD_CTRL_PROT_MASK);
1041         if (ret)
1042                 goto error_ret;
1043
1044         /* Disable ring buffer */
1045         ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
1046         if (ret < 0)
1047                 goto error_ret;
1048         ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
1049                                      (ret & SCA3000_OUT_CTRL_PROT_MASK)
1050                                      | SCA3000_OUT_CTRL_BUF_X_EN
1051                                      | SCA3000_OUT_CTRL_BUF_Y_EN
1052                                      | SCA3000_OUT_CTRL_BUF_Z_EN
1053                                      | SCA3000_OUT_CTRL_BUF_DIV_4);
1054         if (ret)
1055                 goto error_ret;
1056         /* Enable interrupts, relevant to mode and set up as active low */
1057         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1058         if (ret)
1059                 goto error_ret;
1060         ret = sca3000_write_reg(st,
1061                                 SCA3000_REG_ADDR_INT_MASK,
1062                                 (ret & SCA3000_INT_MASK_PROT_MASK)
1063                                 | SCA3000_INT_MASK_ACTIVE_LOW);
1064         if (ret)
1065                 goto error_ret;
1066         /*
1067          * Select normal measurement mode, free fall off, ring off
1068          * Ring in 12 bit mode - it is fine to overwrite reserved bits 3,5
1069          * as that occurs in one of the example on the datasheet
1070          */
1071         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
1072         if (ret)
1073                 goto error_ret;
1074         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
1075                                 (st->rx[0] & SCA3000_MODE_PROT_MASK));
1076         st->bpse = 11;
1077
1078 error_ret:
1079         mutex_unlock(&st->lock);
1080         return ret;
1081 }
1082
1083 static const struct iio_info sca3000_info = {
1084         .attrs = &sca3000_attribute_group,
1085         .read_raw = &sca3000_read_raw,
1086         .write_raw = &sca3000_write_raw,
1087         .event_attrs = &sca3000_event_attribute_group,
1088         .read_event_value = &sca3000_read_thresh,
1089         .write_event_value = &sca3000_write_thresh,
1090         .read_event_config = &sca3000_read_event_config,
1091         .write_event_config = &sca3000_write_event_config,
1092         .driver_module = THIS_MODULE,
1093 };
1094
1095 static int sca3000_probe(struct spi_device *spi)
1096 {
1097         int ret;
1098         struct sca3000_state *st;
1099         struct iio_dev *indio_dev;
1100
1101         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
1102         if (!indio_dev)
1103                 return -ENOMEM;
1104
1105         st = iio_priv(indio_dev);
1106         spi_set_drvdata(spi, indio_dev);
1107         st->us = spi;
1108         mutex_init(&st->lock);
1109         st->info = &sca3000_spi_chip_info_tbl[spi_get_device_id(spi)
1110                                               ->driver_data];
1111
1112         indio_dev->dev.parent = &spi->dev;
1113         indio_dev->name = spi_get_device_id(spi)->name;
1114         indio_dev->info = &sca3000_info;
1115         if (st->info->temp_output) {
1116                 indio_dev->channels = sca3000_channels_with_temp;
1117                 indio_dev->num_channels =
1118                         ARRAY_SIZE(sca3000_channels_with_temp);
1119         } else {
1120                 indio_dev->channels = sca3000_channels;
1121                 indio_dev->num_channels = ARRAY_SIZE(sca3000_channels);
1122         }
1123         indio_dev->modes = INDIO_DIRECT_MODE;
1124
1125         sca3000_configure_ring(indio_dev);
1126         ret = iio_device_register(indio_dev);
1127         if (ret < 0)
1128                 return ret;
1129
1130         if (spi->irq) {
1131                 ret = request_threaded_irq(spi->irq,
1132                                            NULL,
1133                                            &sca3000_event_handler,
1134                                            IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1135                                            "sca3000",
1136                                            indio_dev);
1137                 if (ret)
1138                         goto error_unregister_dev;
1139         }
1140         sca3000_register_ring_funcs(indio_dev);
1141         ret = sca3000_clean_setup(st);
1142         if (ret)
1143                 goto error_free_irq;
1144         return 0;
1145
1146 error_free_irq:
1147         if (spi->irq)
1148                 free_irq(spi->irq, indio_dev);
1149 error_unregister_dev:
1150         iio_device_unregister(indio_dev);
1151         return ret;
1152 }
1153
1154 static int sca3000_stop_all_interrupts(struct sca3000_state *st)
1155 {
1156         int ret;
1157
1158         mutex_lock(&st->lock);
1159         ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1160         if (ret)
1161                 goto error_ret;
1162         ret = sca3000_write_reg(st, SCA3000_REG_ADDR_INT_MASK,
1163                                 (st->rx[0] &
1164                                  ~(SCA3000_INT_MASK_RING_THREE_QUARTER |
1165                                    SCA3000_INT_MASK_RING_HALF |
1166                                    SCA3000_INT_MASK_ALL_INTS)));
1167 error_ret:
1168         mutex_unlock(&st->lock);
1169         return ret;
1170 }
1171
1172 static int sca3000_remove(struct spi_device *spi)
1173 {
1174         struct iio_dev *indio_dev = spi_get_drvdata(spi);
1175         struct sca3000_state *st = iio_priv(indio_dev);
1176
1177         /* Must ensure no interrupts can be generated after this! */
1178         sca3000_stop_all_interrupts(st);
1179         if (spi->irq)
1180                 free_irq(spi->irq, indio_dev);
1181         iio_device_unregister(indio_dev);
1182         sca3000_unconfigure_ring(indio_dev);
1183
1184         return 0;
1185 }
1186
1187 static const struct spi_device_id sca3000_id[] = {
1188         {"sca3000_d01", d01},
1189         {"sca3000_e02", e02},
1190         {"sca3000_e04", e04},
1191         {"sca3000_e05", e05},
1192         {}
1193 };
1194 MODULE_DEVICE_TABLE(spi, sca3000_id);
1195
1196 static struct spi_driver sca3000_driver = {
1197         .driver = {
1198                 .name = "sca3000",
1199         },
1200         .probe = sca3000_probe,
1201         .remove = sca3000_remove,
1202         .id_table = sca3000_id,
1203 };
1204 module_spi_driver(sca3000_driver);
1205
1206 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
1207 MODULE_DESCRIPTION("VTI SCA3000 Series Accelerometers SPI driver");
1208 MODULE_LICENSE("GPL v2");