drivers/iio/accel/kxsd9.c

   1 /*
   2  * kxsd9.c      simple support for the Kionix KXSD9 3D
   3  *              accelerometer.
   4  *
   5  * Copyright (c) 2008-2009 Jonathan Cameron <jic23@kernel.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * The i2c interface is very similar, so shouldn't be a problem once
  12  * I have a suitable wire made up.
  13  *
  14  * TODO:        Support the motion detector
  15  */
  16
  17 #include <linux/device.h>
  18 #include <linux/kernel.h>
  19 #include <linux/sysfs.h>
  20 #include <linux/slab.h>
  21 #include <linux/module.h>
  22 #include <linux/regmap.h>
  23 #include <linux/bitops.h>
  24 #include <linux/delay.h>
  25 #include <linux/regulator/consumer.h>
  26 #include <linux/pm_runtime.h>
  27 #include <linux/iio/iio.h>
  28 #include <linux/iio/sysfs.h>
  29 #include <linux/iio/buffer.h>
  30 #include <linux/iio/triggered_buffer.h>
  31 #include <linux/iio/trigger_consumer.h>
  32
  33 #include "kxsd9.h"
  34
  35 #define KXSD9_REG_X             0x00
  36 #define KXSD9_REG_Y             0x02
  37 #define KXSD9_REG_Z             0x04
  38 #define KXSD9_REG_AUX           0x06
  39 #define KXSD9_REG_RESET         0x0a
  40 #define KXSD9_REG_CTRL_C        0x0c
  41
  42 #define KXSD9_CTRL_C_FS_MASK    0x03
  43 #define KXSD9_CTRL_C_FS_8G      0x00
  44 #define KXSD9_CTRL_C_FS_6G      0x01
  45 #define KXSD9_CTRL_C_FS_4G      0x02
  46 #define KXSD9_CTRL_C_FS_2G      0x03
  47 #define KXSD9_CTRL_C_MOT_LAT    BIT(3)
  48 #define KXSD9_CTRL_C_MOT_LEV    BIT(4)
  49 #define KXSD9_CTRL_C_LP_MASK    0xe0
  50 #define KXSD9_CTRL_C_LP_NONE    0x00
  51 #define KXSD9_CTRL_C_LP_2000HZC BIT(5)
  52 #define KXSD9_CTRL_C_LP_2000HZB BIT(6)
  53 #define KXSD9_CTRL_C_LP_2000HZA (BIT(5)|BIT(6))
  54 #define KXSD9_CTRL_C_LP_1000HZ  BIT(7)
  55 #define KXSD9_CTRL_C_LP_500HZ   (BIT(7)|BIT(5))
  56 #define KXSD9_CTRL_C_LP_100HZ   (BIT(7)|BIT(6))
  57 #define KXSD9_CTRL_C_LP_50HZ    (BIT(7)|BIT(6)|BIT(5))
  58
  59 #define KXSD9_REG_CTRL_B        0x0d
  60
  61 #define KXSD9_CTRL_B_CLK_HLD    BIT(7)
  62 #define KXSD9_CTRL_B_ENABLE     BIT(6)
  63 #define KXSD9_CTRL_B_ST         BIT(5) /* Self-test */
  64
  65 #define KXSD9_REG_CTRL_A        0x0e
  66
  67 /**
  68  * struct kxsd9_state - device related storage
  69  * @dev: pointer to the parent device
  70  * @map: regmap to the device
  71  * @orientation: mounting matrix, flipped axis etc
  72  * @regs: regulators for this device, VDD and IOVDD
  73  * @scale: the current scaling setting
  74  */
  75 struct kxsd9_state {
  76         struct device *dev;
  77         struct regmap *map;
  78         struct iio_mount_matrix orientation;
  79         struct regulator_bulk_data regs[2];
  80         u8 scale;
  81 };
  82
  83 #define KXSD9_SCALE_2G "0.011978"
  84 #define KXSD9_SCALE_4G "0.023927"
  85 #define KXSD9_SCALE_6G "0.035934"
  86 #define KXSD9_SCALE_8G "0.047853"
  87
  88 /* reverse order */
  89 static const int kxsd9_micro_scales[4] = { 47853, 35934, 23927, 11978 };
  90
  91 #define KXSD9_ZERO_G_OFFSET -2048
  92
  93 /*
  94  * Regulator names
  95  */
  96 static const char kxsd9_reg_vdd[] = "vdd";
  97 static const char kxsd9_reg_iovdd[] = "iovdd";
  98
  99 static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro)
 100 {
 101         int ret, i;
 102         struct kxsd9_state *st = iio_priv(indio_dev);
 103         bool foundit = false;
 104
 105         for (i = 0; i < 4; i++)
 106                 if (micro == kxsd9_micro_scales[i]) {
 107                         foundit = true;
 108                         break;
 109                 }
 110         if (!foundit)
 111                 return -EINVAL;
 112
 113         ret = regmap_update_bits(st->map,
 114                                  KXSD9_REG_CTRL_C,
 115                                  KXSD9_CTRL_C_FS_MASK,
 116                                  i);
 117         if (ret < 0)
 118                 goto error_ret;
 119
 120         /* Cached scale when the sensor is powered down */
 121         st->scale = i;
 122
 123 error_ret:
 124         return ret;
 125 }
 126
 127 static IIO_CONST_ATTR(accel_scale_available,
 128                 KXSD9_SCALE_2G " "
 129                 KXSD9_SCALE_4G " "
 130                 KXSD9_SCALE_6G " "
 131                 KXSD9_SCALE_8G);
 132
 133 static struct attribute *kxsd9_attributes[] = {
 134         &iio_const_attr_accel_scale_available.dev_attr.attr,
 135         NULL,
 136 };
 137
 138 static int kxsd9_write_raw(struct iio_dev *indio_dev,
 139                            struct iio_chan_spec const *chan,
 140                            int val,
 141                            int val2,
 142                            long mask)
 143 {
 144         int ret = -EINVAL;
 145         struct kxsd9_state *st = iio_priv(indio_dev);
 146
 147         pm_runtime_get_sync(st->dev);
 148
 149         if (mask == IIO_CHAN_INFO_SCALE) {
 150                 /* Check no integer component */
 151                 if (val)
 152                         return -EINVAL;
 153                 ret = kxsd9_write_scale(indio_dev, val2);
 154         }
 155
 156         pm_runtime_mark_last_busy(st->dev);
 157         pm_runtime_put_autosuspend(st->dev);
 158
 159         return ret;
 160 }
 161
 162 static int kxsd9_read_raw(struct iio_dev *indio_dev,
 163                           struct iio_chan_spec const *chan,
 164                           int *val, int *val2, long mask)
 165 {
 166         int ret = -EINVAL;
 167         struct kxsd9_state *st = iio_priv(indio_dev);
 168         unsigned int regval;
 169         __be16 raw_val;
 170         u16 nval;
 171
 172         pm_runtime_get_sync(st->dev);
 173
 174         switch (mask) {
 175         case IIO_CHAN_INFO_RAW:
 176                 ret = regmap_bulk_read(st->map, chan->address, &raw_val,
 177                                        sizeof(raw_val));
 178                 if (ret)
 179                         goto error_ret;
 180                 nval = be16_to_cpu(raw_val);
 181                 /* Only 12 bits are valid */
 182                 nval >>= 4;
 183                 *val = nval;
 184                 ret = IIO_VAL_INT;
 185                 break;
 186         case IIO_CHAN_INFO_OFFSET:
 187                 /* This has a bias of -2048 */
 188                 *val = KXSD9_ZERO_G_OFFSET;
 189                 ret = IIO_VAL_INT;
 190                 break;
 191         case IIO_CHAN_INFO_SCALE:
 192                 ret = regmap_read(st->map,
 193                                   KXSD9_REG_CTRL_C,
 194                                   &regval);
 195                 if (ret < 0)
 196                         goto error_ret;
 197                 *val = 0;
 198                 *val2 = kxsd9_micro_scales[regval & KXSD9_CTRL_C_FS_MASK];
 199                 ret = IIO_VAL_INT_PLUS_MICRO;
 200                 break;
 201         }
 202
 203 error_ret:
 204         pm_runtime_mark_last_busy(st->dev);
 205         pm_runtime_put_autosuspend(st->dev);
 206
 207         return ret;
 208 };
 209
 210 static irqreturn_t kxsd9_trigger_handler(int irq, void *p)
 211 {
 212         const struct iio_poll_func *pf = p;
 213         struct iio_dev *indio_dev = pf->indio_dev;
 214         struct kxsd9_state *st = iio_priv(indio_dev);
 215         int ret;
 216         /* 4 * 16bit values AND timestamp */
 217         __be16 hw_values[8];
 218
 219         ret = regmap_bulk_read(st->map,
 220                                KXSD9_REG_X,
 221                                &hw_values,
 222                                8);
 223         if (ret) {
 224                 dev_err(st->dev,
 225                         "error reading data\n");
 226                 return ret;
 227         }
 228
 229         iio_push_to_buffers_with_timestamp(indio_dev,
 230                                            hw_values,
 231                                            iio_get_time_ns(indio_dev));
 232         iio_trigger_notify_done(indio_dev->trig);
 233
 234         return IRQ_HANDLED;
 235 }
 236
 237 static int kxsd9_buffer_preenable(struct iio_dev *indio_dev)
 238 {
 239         struct kxsd9_state *st = iio_priv(indio_dev);
 240
 241         pm_runtime_get_sync(st->dev);
 242
 243         return 0;
 244 }
 245
 246 static int kxsd9_buffer_postdisable(struct iio_dev *indio_dev)
 247 {
 248         struct kxsd9_state *st = iio_priv(indio_dev);
 249
 250         pm_runtime_mark_last_busy(st->dev);
 251         pm_runtime_put_autosuspend(st->dev);
 252
 253         return 0;
 254 }
 255
 256 static const struct iio_buffer_setup_ops kxsd9_buffer_setup_ops = {
 257         .preenable = kxsd9_buffer_preenable,
 258         .postenable = iio_triggered_buffer_postenable,
 259         .predisable = iio_triggered_buffer_predisable,
 260         .postdisable = kxsd9_buffer_postdisable,
 261 };
 262
 263 static const struct iio_mount_matrix *
 264 kxsd9_get_mount_matrix(const struct iio_dev *indio_dev,
 265                        const struct iio_chan_spec *chan)
 266 {
 267         struct kxsd9_state *st = iio_priv(indio_dev);
 268
 269         return &st->orientation;
 270 }
 271
 272 static const struct iio_chan_spec_ext_info kxsd9_ext_info[] = {
 273         IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, kxsd9_get_mount_matrix),
 274         { },
 275 };
 276
 277 #define KXSD9_ACCEL_CHAN(axis, index)                                           \
 278         {                                                               \
 279                 .type = IIO_ACCEL,                                      \
 280                 .modified = 1,                                          \
 281                 .channel2 = IIO_MOD_##axis,                             \
 282                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 283                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
 284                                         BIT(IIO_CHAN_INFO_OFFSET),      \
 285                 .ext_info = kxsd9_ext_info,                             \
 286                 .address = KXSD9_REG_##axis,                            \
 287                 .scan_index = index,                                    \
 288                 .scan_type = {                                          \
 289                         .sign = 'u',                                    \
 290                         .realbits = 12,                                 \
 291                         .storagebits = 16,                              \
 292                         .shift = 4,                                     \
 293                         .endianness = IIO_BE,                           \
 294                 },                                                      \
 295         }
 296
 297 static const struct iio_chan_spec kxsd9_channels[] = {
 298         KXSD9_ACCEL_CHAN(X, 0),
 299         KXSD9_ACCEL_CHAN(Y, 1),
 300         KXSD9_ACCEL_CHAN(Z, 2),
 301         {
 302                 .type = IIO_VOLTAGE,
 303                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 304                 .indexed = 1,
 305                 .address = KXSD9_REG_AUX,
 306                 .scan_index = 3,
 307                 .scan_type = {
 308                         .sign = 'u',
 309                         .realbits = 12,
 310                         .storagebits = 16,
 311                         .shift = 4,
 312                         .endianness = IIO_BE,
 313                 },
 314         },
 315         IIO_CHAN_SOFT_TIMESTAMP(4),
 316 };
 317
 318 static const struct attribute_group kxsd9_attribute_group = {
 319         .attrs = kxsd9_attributes,
 320 };
 321
 322 static int kxsd9_power_up(struct kxsd9_state *st)
 323 {
 324         int ret;
 325
 326         /* Enable the regulators */
 327         ret = regulator_bulk_enable(ARRAY_SIZE(st->regs), st->regs);
 328         if (ret) {
 329                 dev_err(st->dev, "Cannot enable regulators\n");
 330                 return ret;
 331         }
 332
 333         /* Power up */
 334         ret = regmap_write(st->map,
 335                            KXSD9_REG_CTRL_B,
 336                            KXSD9_CTRL_B_ENABLE);
 337         if (ret)
 338                 return ret;
 339
 340         /*
 341          * Set 1000Hz LPF, 2g fullscale, motion wakeup threshold 1g,
 342          * latched wakeup
 343          */
 344         ret = regmap_write(st->map,
 345                            KXSD9_REG_CTRL_C,
 346                            KXSD9_CTRL_C_LP_1000HZ |
 347                            KXSD9_CTRL_C_MOT_LEV |
 348                            KXSD9_CTRL_C_MOT_LAT |
 349                            st->scale);
 350         if (ret)
 351                 return ret;
 352
 353         /*
 354          * Power-up time depends on the LPF setting, but typ 15.9 ms, let's
 355          * set 20 ms to allow for some slack.
 356          */
 357         msleep(20);
 358
 359         return 0;
 360 };
 361
 362 static int kxsd9_power_down(struct kxsd9_state *st)
 363 {
 364         int ret;
 365
 366         /*
 367          * Set into low power mode - since there may be more users of the
 368          * regulators this is the first step of the power saving: it will
 369          * make sure we conserve power even if there are others users on the
 370          * regulators.
 371          */
 372         ret = regmap_update_bits(st->map,
 373                                  KXSD9_REG_CTRL_B,
 374                                  KXSD9_CTRL_B_ENABLE,
 375                                  0);
 376         if (ret)
 377                 return ret;
 378
 379         /* Disable the regulators */
 380         ret = regulator_bulk_disable(ARRAY_SIZE(st->regs), st->regs);
 381         if (ret) {
 382                 dev_err(st->dev, "Cannot disable regulators\n");
 383                 return ret;
 384         }
 385
 386         return 0;
 387 }
 388
 389 static const struct iio_info kxsd9_info = {
 390         .read_raw = &kxsd9_read_raw,
 391         .write_raw = &kxsd9_write_raw,
 392         .attrs = &kxsd9_attribute_group,
 393         .driver_module = THIS_MODULE,
 394 };
 395
 396 /* Four channels apart from timestamp, scan mask = 0x0f */
 397 static const unsigned long kxsd9_scan_masks[] = { 0xf, 0 };
 398
 399 int kxsd9_common_probe(struct device *dev,
 400                        struct regmap *map,
 401                        const char *name)
 402 {
 403         struct iio_dev *indio_dev;
 404         struct kxsd9_state *st;
 405         int ret;
 406
 407         indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
 408         if (!indio_dev)
 409                 return -ENOMEM;
 410
 411         st = iio_priv(indio_dev);
 412         st->dev = dev;
 413         st->map = map;
 414
 415         indio_dev->channels = kxsd9_channels;
 416         indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels);
 417         indio_dev->name = name;
 418         indio_dev->dev.parent = dev;
 419         indio_dev->info = &kxsd9_info;
 420         indio_dev->modes = INDIO_DIRECT_MODE;
 421         indio_dev->available_scan_masks = kxsd9_scan_masks;
 422
 423         /* Read the mounting matrix, if present */
 424         ret = of_iio_read_mount_matrix(dev,
 425                                        "mount-matrix",
 426                                        &st->orientation);
 427         if (ret)
 428                 return ret;
 429
 430         /* Fetch and turn on regulators */
 431         st->regs[0].supply = kxsd9_reg_vdd;
 432         st->regs[1].supply = kxsd9_reg_iovdd;
 433         ret = devm_regulator_bulk_get(dev,
 434                                       ARRAY_SIZE(st->regs),
 435                                       st->regs);
 436         if (ret) {
 437                 dev_err(dev, "Cannot get regulators\n");
 438                 return ret;
 439         }
 440         /* Default scaling */
 441         st->scale = KXSD9_CTRL_C_FS_2G;
 442
 443         kxsd9_power_up(st);
 444
 445         ret = iio_triggered_buffer_setup(indio_dev,
 446                                          iio_pollfunc_store_time,
 447                                          kxsd9_trigger_handler,
 448                                          &kxsd9_buffer_setup_ops);
 449         if (ret) {
 450                 dev_err(dev, "triggered buffer setup failed\n");
 451                 goto err_power_down;
 452         }
 453
 454         ret = iio_device_register(indio_dev);
 455         if (ret)
 456                 goto err_cleanup_buffer;
 457
 458         dev_set_drvdata(dev, indio_dev);
 459
 460         /* Enable runtime PM */
 461         pm_runtime_get_noresume(dev);
 462         pm_runtime_set_active(dev);
 463         pm_runtime_enable(dev);
 464         /*
 465          * Set autosuspend to two orders of magnitude larger than the
 466          * start-up time. 20ms start-up time means 2000ms autosuspend,
 467          * i.e. 2 seconds.
 468          */
 469         pm_runtime_set_autosuspend_delay(dev, 2000);
 470         pm_runtime_use_autosuspend(dev);
 471         pm_runtime_put(dev);
 472
 473         return 0;
 474
 475 err_cleanup_buffer:
 476         iio_triggered_buffer_cleanup(indio_dev);
 477 err_power_down:
 478         kxsd9_power_down(st);
 479
 480         return ret;
 481 }
 482 EXPORT_SYMBOL(kxsd9_common_probe);
 483
 484 int kxsd9_common_remove(struct device *dev)
 485 {
 486         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 487         struct kxsd9_state *st = iio_priv(indio_dev);
 488
 489         iio_triggered_buffer_cleanup(indio_dev);
 490         iio_device_unregister(indio_dev);
 491         pm_runtime_get_sync(dev);
 492         pm_runtime_put_noidle(dev);
 493         pm_runtime_disable(dev);
 494         kxsd9_power_down(st);
 495
 496         return 0;
 497 }
 498 EXPORT_SYMBOL(kxsd9_common_remove);
 499
 500 #ifdef CONFIG_PM
 501 static int kxsd9_runtime_suspend(struct device *dev)
 502 {
 503         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 504         struct kxsd9_state *st = iio_priv(indio_dev);
 505
 506         return kxsd9_power_down(st);
 507 }
 508
 509 static int kxsd9_runtime_resume(struct device *dev)
 510 {
 511         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 512         struct kxsd9_state *st = iio_priv(indio_dev);
 513
 514         return kxsd9_power_up(st);
 515 }
 516 #endif /* CONFIG_PM */
 517
 518 const struct dev_pm_ops kxsd9_dev_pm_ops = {
 519         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
 520                                 pm_runtime_force_resume)
 521         SET_RUNTIME_PM_OPS(kxsd9_runtime_suspend,
 522                            kxsd9_runtime_resume, NULL)
 523 };
 524 EXPORT_SYMBOL(kxsd9_dev_pm_ops);
 525
 526 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
 527 MODULE_DESCRIPTION("Kionix KXSD9 driver");
 528 MODULE_LICENSE("GPL v2");