drivers/iio/pressure/zpa2326.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Murata ZPA2326 pressure and temperature sensor IIO driver
   4  *
   5  * Copyright (c) 2016 Parrot S.A.
   6  *
   7  * Author: Gregor Boirie <gregor.boirie@parrot.com>
   8  */
   9
  10 /**
  11  * DOC: ZPA2326 theory of operations
  12  *
  13  * This driver supports %INDIO_DIRECT_MODE and %INDIO_BUFFER_TRIGGERED IIO
  14  * modes.
  15  * A internal hardware trigger is also implemented to dispatch registered IIO
  16  * trigger consumers upon "sample ready" interrupts.
  17  *
  18  * ZPA2326 hardware supports 2 sampling mode: one shot and continuous.
  19  *
  20  * A complete one shot sampling cycle gets device out of low power mode,
  21  * performs pressure and temperature measurements, then automatically switches
  22  * back to low power mode. It is meant for on demand sampling with optimal power
  23  * saving at the cost of lower sampling rate and higher software overhead.
  24  * This is a natural candidate for IIO read_raw hook implementation
  25  * (%INDIO_DIRECT_MODE). It is also used for triggered buffering support to
  26  * ensure explicit synchronization with external trigger events
  27  * (%INDIO_BUFFER_TRIGGERED).
  28  *
  29  * The continuous mode works according to a periodic hardware measurement
  30  * process continuously pushing samples into an internal hardware FIFO (for
  31  * pressure samples only). Measurement cycle completion may be signaled by a
  32  * "sample ready" interrupt.
  33  * Typical software sequence of operations :
  34  * - get device out of low power mode,
  35  * - setup hardware sampling period,
  36  * - at end of period, upon data ready interrupt: pop pressure samples out of
  37  *   hardware FIFO and fetch temperature sample
  38  * - when no longer needed, stop sampling process by putting device into
  39  *   low power mode.
  40  * This mode is used to implement %INDIO_BUFFER_TRIGGERED mode if device tree
  41  * declares a valid interrupt line. In this case, the internal hardware trigger
  42  * drives acquisition.
  43  *
  44  * Note that hardware sampling frequency is taken into account only when
  45  * internal hardware trigger is attached as the highest sampling rate seems to
  46  * be the most energy efficient.
  47  *
  48  * TODO:
  49  *   preset pressure threshold crossing / IIO events ;
  50  *   differential pressure sampling ;
  51  *   hardware samples averaging.
  52  */
  53
  54 #include <linux/module.h>
  55 #include <linux/kernel.h>
  56 #include <linux/delay.h>
  57 #include <linux/interrupt.h>
  58 #include <linux/regulator/consumer.h>
  59 #include <linux/pm_runtime.h>
  60 #include <linux/regmap.h>
  61 #include <linux/iio/iio.h>
  62 #include <linux/iio/sysfs.h>
  63 #include <linux/iio/buffer.h>
  64 #include <linux/iio/trigger.h>
  65 #include <linux/iio/trigger_consumer.h>
  66 #include <linux/iio/triggered_buffer.h>
  67 #include <asm/unaligned.h>
  68 #include "zpa2326.h"
  69
  70 /* 200 ms should be enough for the longest conversion time in one-shot mode. */
  71 #define ZPA2326_CONVERSION_JIFFIES (HZ / 5)
  72
  73 /* There should be a 1 ms delay (Tpup) after getting out of reset. */
  74 #define ZPA2326_TPUP_USEC_MIN      (1000)
  75 #define ZPA2326_TPUP_USEC_MAX      (2000)
  76
  77 /**
  78  * struct zpa2326_frequency - Hardware sampling frequency descriptor
  79  * @hz : Frequency in Hertz.
  80  * @odr: Output Data Rate word as expected by %ZPA2326_CTRL_REG3_REG.
  81  */
  82 struct zpa2326_frequency {
  83         int hz;
  84         u16 odr;
  85 };
  86
  87 /*
  88  * Keep these in strict ascending order: last array entry is expected to
  89  * correspond to the highest sampling frequency.
  90  */
  91 static const struct zpa2326_frequency zpa2326_sampling_frequencies[] = {
  92         { .hz = 1,  .odr = 1 << ZPA2326_CTRL_REG3_ODR_SHIFT },
  93         { .hz = 5,  .odr = 5 << ZPA2326_CTRL_REG3_ODR_SHIFT },
  94         { .hz = 11, .odr = 6 << ZPA2326_CTRL_REG3_ODR_SHIFT },
  95         { .hz = 23, .odr = 7 << ZPA2326_CTRL_REG3_ODR_SHIFT },
  96 };
  97
  98 /* Return the highest hardware sampling frequency available. */
  99 static const struct zpa2326_frequency *zpa2326_highest_frequency(void)
 100 {
 101         return &zpa2326_sampling_frequencies[
 102                 ARRAY_SIZE(zpa2326_sampling_frequencies) - 1];
 103 }
 104
 105 /**
 106  * struct zpa_private - Per-device internal private state
 107  * @timestamp:  Buffered samples ready datum.
 108  * @regmap:     Underlying I2C / SPI bus adapter used to abstract slave register
 109  *              accesses.
 110  * @result:     Allows sampling logic to get completion status of operations
 111  *              that interrupt handlers perform asynchronously.
 112  * @data_ready: Interrupt handler uses this to wake user context up at sampling
 113  *              operation completion.
 114  * @trigger:    Optional hardware / interrupt driven trigger used to notify
 115  *              external devices a new sample is ready.
 116  * @waken:      Flag indicating whether or not device has just been powered on.
 117  * @irq:        Optional interrupt line: negative or zero if not declared into
 118  *              DT, in which case sampling logic keeps polling status register
 119  *              to detect completion.
 120  * @frequency:  Current hardware sampling frequency.
 121  * @vref:       Power / voltage reference.
 122  * @vdd:        Power supply.
 123  */
 124 struct zpa2326_private {
 125         s64                             timestamp;
 126         struct regmap                  *regmap;
 127         int                             result;
 128         struct completion               data_ready;
 129         struct iio_trigger             *trigger;
 130         bool                            waken;
 131         int                             irq;
 132         const struct zpa2326_frequency *frequency;
 133         struct regulator               *vref;
 134         struct regulator               *vdd;
 135 };
 136
 137 #define zpa2326_err(idev, fmt, ...)                                     \
 138         dev_err(idev->dev.parent, fmt "\n", ##__VA_ARGS__)
 139
 140 #define zpa2326_warn(idev, fmt, ...)                                    \
 141         dev_warn(idev->dev.parent, fmt "\n", ##__VA_ARGS__)
 142
 143 #define zpa2326_dbg(idev, fmt, ...)                                     \
 144         dev_dbg(idev->dev.parent, fmt "\n", ##__VA_ARGS__)
 145
 146 bool zpa2326_isreg_writeable(struct device *dev, unsigned int reg)
 147 {
 148         switch (reg) {
 149         case ZPA2326_REF_P_XL_REG:
 150         case ZPA2326_REF_P_L_REG:
 151         case ZPA2326_REF_P_H_REG:
 152         case ZPA2326_RES_CONF_REG:
 153         case ZPA2326_CTRL_REG0_REG:
 154         case ZPA2326_CTRL_REG1_REG:
 155         case ZPA2326_CTRL_REG2_REG:
 156         case ZPA2326_CTRL_REG3_REG:
 157         case ZPA2326_THS_P_LOW_REG:
 158         case ZPA2326_THS_P_HIGH_REG:
 159                 return true;
 160
 161         default:
 162                 return false;
 163         }
 164 }
 165 EXPORT_SYMBOL_GPL(zpa2326_isreg_writeable);
 166
 167 bool zpa2326_isreg_readable(struct device *dev, unsigned int reg)
 168 {
 169         switch (reg) {
 170         case ZPA2326_REF_P_XL_REG:
 171         case ZPA2326_REF_P_L_REG:
 172         case ZPA2326_REF_P_H_REG:
 173         case ZPA2326_DEVICE_ID_REG:
 174         case ZPA2326_RES_CONF_REG:
 175         case ZPA2326_CTRL_REG0_REG:
 176         case ZPA2326_CTRL_REG1_REG:
 177         case ZPA2326_CTRL_REG2_REG:
 178         case ZPA2326_CTRL_REG3_REG:
 179         case ZPA2326_INT_SOURCE_REG:
 180         case ZPA2326_THS_P_LOW_REG:
 181         case ZPA2326_THS_P_HIGH_REG:
 182         case ZPA2326_STATUS_REG:
 183         case ZPA2326_PRESS_OUT_XL_REG:
 184         case ZPA2326_PRESS_OUT_L_REG:
 185         case ZPA2326_PRESS_OUT_H_REG:
 186         case ZPA2326_TEMP_OUT_L_REG:
 187         case ZPA2326_TEMP_OUT_H_REG:
 188                 return true;
 189
 190         default:
 191                 return false;
 192         }
 193 }
 194 EXPORT_SYMBOL_GPL(zpa2326_isreg_readable);
 195
 196 bool zpa2326_isreg_precious(struct device *dev, unsigned int reg)
 197 {
 198         switch (reg) {
 199         case ZPA2326_INT_SOURCE_REG:
 200         case ZPA2326_PRESS_OUT_H_REG:
 201                 return true;
 202
 203         default:
 204                 return false;
 205         }
 206 }
 207 EXPORT_SYMBOL_GPL(zpa2326_isreg_precious);
 208
 209 /**
 210  * zpa2326_enable_device() - Enable device, i.e. get out of low power mode.
 211  * @indio_dev: The IIO device associated with the hardware to enable.
 212  *
 213  * Required to access complete register space and to perform any sampling
 214  * or control operations.
 215  *
 216  * Return: Zero when successful, a negative error code otherwise.
 217  */
 218 static int zpa2326_enable_device(const struct iio_dev *indio_dev)
 219 {
 220         int err;
 221
 222         err = regmap_write(((struct zpa2326_private *)
 223                             iio_priv(indio_dev))->regmap,
 224                             ZPA2326_CTRL_REG0_REG, ZPA2326_CTRL_REG0_ENABLE);
 225         if (err) {
 226                 zpa2326_err(indio_dev, "failed to enable device (%d)", err);
 227                 return err;
 228         }
 229
 230         zpa2326_dbg(indio_dev, "enabled");
 231
 232         return 0;
 233 }
 234
 235 /**
 236  * zpa2326_sleep() - Disable device, i.e. switch to low power mode.
 237  * @indio_dev: The IIO device associated with the hardware to disable.
 238  *
 239  * Only %ZPA2326_DEVICE_ID_REG and %ZPA2326_CTRL_REG0_REG registers may be
 240  * accessed once device is in the disabled state.
 241  *
 242  * Return: Zero when successful, a negative error code otherwise.
 243  */
 244 static int zpa2326_sleep(const struct iio_dev *indio_dev)
 245 {
 246         int err;
 247
 248         err = regmap_write(((struct zpa2326_private *)
 249                             iio_priv(indio_dev))->regmap,
 250                             ZPA2326_CTRL_REG0_REG, 0);
 251         if (err) {
 252                 zpa2326_err(indio_dev, "failed to sleep (%d)", err);
 253                 return err;
 254         }
 255
 256         zpa2326_dbg(indio_dev, "sleeping");
 257
 258         return 0;
 259 }
 260
 261 /**
 262  * zpa2326_reset_device() - Reset device to default hardware state.
 263  * @indio_dev: The IIO device associated with the hardware to reset.
 264  *
 265  * Disable sampling and empty hardware FIFO.
 266  * Device must be enabled before reset, i.e. not in low power mode.
 267  *
 268  * Return: Zero when successful, a negative error code otherwise.
 269  */
 270 static int zpa2326_reset_device(const struct iio_dev *indio_dev)
 271 {
 272         int err;
 273
 274         err = regmap_write(((struct zpa2326_private *)
 275                             iio_priv(indio_dev))->regmap,
 276                             ZPA2326_CTRL_REG2_REG, ZPA2326_CTRL_REG2_SWRESET);
 277         if (err) {
 278                 zpa2326_err(indio_dev, "failed to reset device (%d)", err);
 279                 return err;
 280         }
 281
 282         usleep_range(ZPA2326_TPUP_USEC_MIN, ZPA2326_TPUP_USEC_MAX);
 283
 284         zpa2326_dbg(indio_dev, "reset");
 285
 286         return 0;
 287 }
 288
 289 /**
 290  * zpa2326_start_oneshot() - Start a single sampling cycle, i.e. in one shot
 291  *                           mode.
 292  * @indio_dev: The IIO device associated with the sampling hardware.
 293  *
 294  * Device must have been previously enabled and configured for one shot mode.
 295  * Device will be switched back to low power mode at end of cycle.
 296  *
 297  * Return: Zero when successful, a negative error code otherwise.
 298  */
 299 static int zpa2326_start_oneshot(const struct iio_dev *indio_dev)
 300 {
 301         int err;
 302
 303         err = regmap_write(((struct zpa2326_private *)
 304                             iio_priv(indio_dev))->regmap,
 305                             ZPA2326_CTRL_REG0_REG,
 306                             ZPA2326_CTRL_REG0_ENABLE |
 307                             ZPA2326_CTRL_REG0_ONE_SHOT);
 308         if (err) {
 309                 zpa2326_err(indio_dev, "failed to start one shot cycle (%d)",
 310                             err);
 311                 return err;
 312         }
 313
 314         zpa2326_dbg(indio_dev, "one shot cycle started");
 315
 316         return 0;
 317 }
 318
 319 /**
 320  * zpa2326_power_on() - Power on device to allow subsequent configuration.
 321  * @indio_dev: The IIO device associated with the sampling hardware.
 322  * @private:   Internal private state related to @indio_dev.
 323  *
 324  * Sampling will be disabled, preventing strange things from happening in our
 325  * back. Hardware FIFO content will be cleared.
 326  * When successful, device will be left in the enabled state to allow further
 327  * configuration.
 328  *
 329  * Return: Zero when successful, a negative error code otherwise.
 330  */
 331 static int zpa2326_power_on(const struct iio_dev         *indio_dev,
 332                             const struct zpa2326_private *private)
 333 {
 334         int err;
 335
 336         err = regulator_enable(private->vref);
 337         if (err)
 338                 return err;
 339
 340         err = regulator_enable(private->vdd);
 341         if (err)
 342                 goto vref;
 343
 344         zpa2326_dbg(indio_dev, "powered on");
 345
 346         err = zpa2326_enable_device(indio_dev);
 347         if (err)
 348                 goto vdd;
 349
 350         err = zpa2326_reset_device(indio_dev);
 351         if (err)
 352                 goto sleep;
 353
 354         return 0;
 355
 356 sleep:
 357         zpa2326_sleep(indio_dev);
 358 vdd:
 359         regulator_disable(private->vdd);
 360 vref:
 361         regulator_disable(private->vref);
 362
 363         zpa2326_dbg(indio_dev, "powered off");
 364
 365         return err;
 366 }
 367
 368 /**
 369  * zpa2326_power_off() - Power off device, i.e. disable attached power
 370  *                       regulators.
 371  * @indio_dev: The IIO device associated with the sampling hardware.
 372  * @private:   Internal private state related to @indio_dev.
 373  *
 374  * Return: Zero when successful, a negative error code otherwise.
 375  */
 376 static void zpa2326_power_off(const struct iio_dev         *indio_dev,
 377                               const struct zpa2326_private *private)
 378 {
 379         regulator_disable(private->vdd);
 380         regulator_disable(private->vref);
 381
 382         zpa2326_dbg(indio_dev, "powered off");
 383 }
 384
 385 /**
 386  * zpa2326_config_oneshot() - Setup device for one shot / on demand mode.
 387  * @indio_dev: The IIO device associated with the sampling hardware.
 388  * @irq:       Optional interrupt line the hardware uses to notify new data
 389  *             samples are ready. Negative or zero values indicate no interrupts
 390  *             are available, meaning polling is required.
 391  *
 392  * Output Data Rate is configured for the highest possible rate so that
 393  * conversion time and power consumption are reduced to a minimum.
 394  * Note that hardware internal averaging machinery (not implemented in this
 395  * driver) is not applicable in this mode.
 396  *
 397  * Device must have been previously enabled before calling
 398  * zpa2326_config_oneshot().
 399  *
 400  * Return: Zero when successful, a negative error code otherwise.
 401  */
 402 static int zpa2326_config_oneshot(const struct iio_dev *indio_dev,
 403                                   int                   irq)
 404 {
 405         struct regmap                  *regs = ((struct zpa2326_private *)
 406                                                 iio_priv(indio_dev))->regmap;
 407         const struct zpa2326_frequency *freq = zpa2326_highest_frequency();
 408         int                             err;
 409
 410         /* Setup highest available Output Data Rate for one shot mode. */
 411         err = regmap_write(regs, ZPA2326_CTRL_REG3_REG, freq->odr);
 412         if (err)
 413                 return err;
 414
 415         if (irq > 0) {
 416                 /* Request interrupt when new sample is available. */
 417                 err = regmap_write(regs, ZPA2326_CTRL_REG1_REG,
 418                                    (u8)~ZPA2326_CTRL_REG1_MASK_DATA_READY);
 419
 420                 if (err) {
 421                         dev_err(indio_dev->dev.parent,
 422                                 "failed to setup one shot mode (%d)", err);
 423                         return err;
 424                 }
 425         }
 426
 427         zpa2326_dbg(indio_dev, "one shot mode setup @%dHz", freq->hz);
 428
 429         return 0;
 430 }
 431
 432 /**
 433  * zpa2326_clear_fifo() - Clear remaining entries in hardware FIFO.
 434  * @indio_dev: The IIO device associated with the sampling hardware.
 435  * @min_count: Number of samples present within hardware FIFO.
 436  *
 437  * @min_count argument is a hint corresponding to the known minimum number of
 438  * samples currently living in the FIFO. This allows to reduce the number of bus
 439  * accesses by skipping status register read operation as long as we know for
 440  * sure there are still entries left.
 441  *
 442  * Return: Zero when successful, a negative error code otherwise.
 443  */
 444 static int zpa2326_clear_fifo(const struct iio_dev *indio_dev,
 445                               unsigned int          min_count)
 446 {
 447         struct regmap *regs = ((struct zpa2326_private *)
 448                                iio_priv(indio_dev))->regmap;
 449         int            err;
 450         unsigned int   val;
 451
 452         if (!min_count) {
 453                 /*
 454                  * No hint: read status register to determine whether FIFO is
 455                  * empty or not.
 456                  */
 457                 err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
 458
 459                 if (err < 0)
 460                         goto err;
 461
 462                 if (val & ZPA2326_STATUS_FIFO_E)
 463                         /* Fifo is empty: nothing to trash. */
 464                         return 0;
 465         }
 466
 467         /* Clear FIFO. */
 468         do {
 469                 /*
 470                  * A single fetch from pressure MSB register is enough to pop
 471                  * values out of FIFO.
 472                  */
 473                 err = regmap_read(regs, ZPA2326_PRESS_OUT_H_REG, &val);
 474                 if (err < 0)
 475                         goto err;
 476
 477                 if (min_count) {
 478                         /*
 479                          * We know for sure there are at least min_count entries
 480                          * left in FIFO. Skip status register read.
 481                          */
 482                         min_count--;
 483                         continue;
 484                 }
 485
 486                 err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
 487                 if (err < 0)
 488                         goto err;
 489
 490         } while (!(val & ZPA2326_STATUS_FIFO_E));
 491
 492         zpa2326_dbg(indio_dev, "FIFO cleared");
 493
 494         return 0;
 495
 496 err:
 497         zpa2326_err(indio_dev, "failed to clear FIFO (%d)", err);
 498
 499         return err;
 500 }
 501
 502 /**
 503  * zpa2326_dequeue_pressure() - Retrieve the most recent pressure sample from
 504  *                              hardware FIFO.
 505  * @indio_dev: The IIO device associated with the sampling hardware.
 506  * @pressure:  Sampled pressure output.
 507  *
 508  * Note that ZPA2326 hardware FIFO stores pressure samples only.
 509  *
 510  * Return: Zero when successful, a negative error code otherwise.
 511  */
 512 static int zpa2326_dequeue_pressure(const struct iio_dev *indio_dev,
 513                                     u32                  *pressure)
 514 {
 515         struct regmap *regs = ((struct zpa2326_private *)
 516                                iio_priv(indio_dev))->regmap;
 517         unsigned int   val;
 518         int            err;
 519         int            cleared = -1;
 520
 521         err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
 522         if (err < 0)
 523                 return err;
 524
 525         *pressure = 0;
 526
 527         if (val & ZPA2326_STATUS_P_OR) {
 528                 /*
 529                  * Fifo overrun : first sample dequeued from FIFO is the
 530                  * newest.
 531                  */
 532                 zpa2326_warn(indio_dev, "FIFO overflow");
 533
 534                 err = regmap_bulk_read(regs, ZPA2326_PRESS_OUT_XL_REG, pressure,
 535                                        3);
 536                 if (err)
 537                         return err;
 538
 539 #define ZPA2326_FIFO_DEPTH (16U)
 540                 /* Hardware FIFO may hold no more than 16 pressure samples. */
 541                 return zpa2326_clear_fifo(indio_dev, ZPA2326_FIFO_DEPTH - 1);
 542         }
 543
 544         /*
 545          * Fifo has not overflown : retrieve newest sample. We need to pop
 546          * values out until FIFO is empty : last fetched pressure is the newest.
 547          * In nominal cases, we should find a single queued sample only.
 548          */
 549         do {
 550                 err = regmap_bulk_read(regs, ZPA2326_PRESS_OUT_XL_REG, pressure,
 551                                        3);
 552                 if (err)
 553                         return err;
 554
 555                 err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
 556                 if (err < 0)
 557                         return err;
 558
 559                 cleared++;
 560         } while (!(val & ZPA2326_STATUS_FIFO_E));
 561
 562         if (cleared)
 563                 /*
 564                  * Samples were pushed by hardware during previous rounds but we
 565                  * didn't consume them fast enough: inform user.
 566                  */
 567                 zpa2326_dbg(indio_dev, "cleared %d FIFO entries", cleared);
 568
 569         return 0;
 570 }
 571
 572 /**
 573  * zpa2326_fill_sample_buffer() - Enqueue new channel samples to IIO buffer.
 574  * @indio_dev: The IIO device associated with the sampling hardware.
 575  * @private:   Internal private state related to @indio_dev.
 576  *
 577  * Return: Zero when successful, a negative error code otherwise.
 578  */
 579 static int zpa2326_fill_sample_buffer(struct iio_dev               *indio_dev,
 580                                       const struct zpa2326_private *private)
 581 {
 582         struct {
 583                 u32 pressure;
 584                 u16 temperature;
 585                 u64 timestamp;
 586         }   sample;
 587         int err;
 588
 589         if (test_bit(0, indio_dev->active_scan_mask)) {
 590                 /* Get current pressure from hardware FIFO. */
 591                 err = zpa2326_dequeue_pressure(indio_dev, &sample.pressure);
 592                 if (err) {
 593                         zpa2326_warn(indio_dev, "failed to fetch pressure (%d)",
 594                                      err);
 595                         return err;
 596                 }
 597         }
 598
 599         if (test_bit(1, indio_dev->active_scan_mask)) {
 600                 /* Get current temperature. */
 601                 err = regmap_bulk_read(private->regmap, ZPA2326_TEMP_OUT_L_REG,
 602                                        &sample.temperature, 2);
 603                 if (err) {
 604                         zpa2326_warn(indio_dev,
 605                                      "failed to fetch temperature (%d)", err);
 606                         return err;
 607                 }
 608         }
 609
 610         /*
 611          * Now push samples using timestamp stored either :
 612          *   - by hardware interrupt handler if interrupt is available: see
 613          *     zpa2326_handle_irq(),
 614          *   - or oneshot completion polling machinery : see
 615          *     zpa2326_trigger_handler().
 616          */
 617         zpa2326_dbg(indio_dev, "filling raw samples buffer");
 618
 619         iio_push_to_buffers_with_timestamp(indio_dev, &sample,
 620                                            private->timestamp);
 621
 622         return 0;
 623 }
 624
 625 #ifdef CONFIG_PM
 626 static int zpa2326_runtime_suspend(struct device *parent)
 627 {
 628         const struct iio_dev *indio_dev = dev_get_drvdata(parent);
 629
 630         if (pm_runtime_autosuspend_expiration(parent))
 631                 /* Userspace changed autosuspend delay. */
 632                 return -EAGAIN;
 633
 634         zpa2326_power_off(indio_dev, iio_priv(indio_dev));
 635
 636         return 0;
 637 }
 638
 639 static int zpa2326_runtime_resume(struct device *parent)
 640 {
 641         const struct iio_dev *indio_dev = dev_get_drvdata(parent);
 642
 643         return zpa2326_power_on(indio_dev, iio_priv(indio_dev));
 644 }
 645
 646 const struct dev_pm_ops zpa2326_pm_ops = {
 647         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
 648                                 pm_runtime_force_resume)
 649         SET_RUNTIME_PM_OPS(zpa2326_runtime_suspend, zpa2326_runtime_resume,
 650                            NULL)
 651 };
 652 EXPORT_SYMBOL_GPL(zpa2326_pm_ops);
 653
 654 /**
 655  * zpa2326_resume() - Request the PM layer to power supply the device.
 656  * @indio_dev: The IIO device associated with the sampling hardware.
 657  *
 658  * Return:
 659  *  < 0 - a negative error code meaning failure ;
 660  *    0 - success, device has just been powered up ;
 661  *    1 - success, device was already powered.
 662  */
 663 static int zpa2326_resume(const struct iio_dev *indio_dev)
 664 {
 665         int err;
 666
 667         err = pm_runtime_get_sync(indio_dev->dev.parent);
 668         if (err < 0) {
 669                 pm_runtime_put(indio_dev->dev.parent);
 670                 return err;
 671         }
 672
 673         if (err > 0) {
 674                 /*
 675                  * Device was already power supplied: get it out of low power
 676                  * mode and inform caller.
 677                  */
 678                 zpa2326_enable_device(indio_dev);
 679                 return 1;
 680         }
 681
 682         /* Inform caller device has just been brought back to life. */
 683         return 0;
 684 }
 685
 686 /**
 687  * zpa2326_suspend() - Schedule a power down using autosuspend feature of PM
 688  *                     layer.
 689  * @indio_dev: The IIO device associated with the sampling hardware.
 690  *
 691  * Device is switched to low power mode at first to save power even when
 692  * attached regulator is a "dummy" one.
 693  */
 694 static void zpa2326_suspend(struct iio_dev *indio_dev)
 695 {
 696         struct device *parent = indio_dev->dev.parent;
 697
 698         zpa2326_sleep(indio_dev);
 699
 700         pm_runtime_mark_last_busy(parent);
 701         pm_runtime_put_autosuspend(parent);
 702 }
 703
 704 static void zpa2326_init_runtime(struct device *parent)
 705 {
 706         pm_runtime_get_noresume(parent);
 707         pm_runtime_set_active(parent);
 708         pm_runtime_enable(parent);
 709         pm_runtime_set_autosuspend_delay(parent, 1000);
 710         pm_runtime_use_autosuspend(parent);
 711         pm_runtime_mark_last_busy(parent);
 712         pm_runtime_put_autosuspend(parent);
 713 }
 714
 715 static void zpa2326_fini_runtime(struct device *parent)
 716 {
 717         pm_runtime_disable(parent);
 718         pm_runtime_set_suspended(parent);
 719 }
 720 #else /* !CONFIG_PM */
 721 static int zpa2326_resume(const struct iio_dev *indio_dev)
 722 {
 723         zpa2326_enable_device(indio_dev);
 724
 725         return 0;
 726 }
 727
 728 static void zpa2326_suspend(struct iio_dev *indio_dev)
 729 {
 730         zpa2326_sleep(indio_dev);
 731 }
 732
 733 #define zpa2326_init_runtime(_parent)
 734 #define zpa2326_fini_runtime(_parent)
 735 #endif /* !CONFIG_PM */
 736
 737 /**
 738  * zpa2326_handle_irq() - Process hardware interrupts.
 739  * @irq:  Interrupt line the hardware uses to notify new data has arrived.
 740  * @data: The IIO device associated with the sampling hardware.
 741  *
 742  * Timestamp buffered samples as soon as possible then schedule threaded bottom
 743  * half.
 744  *
 745  * Return: Always successful.
 746  */
 747 static irqreturn_t zpa2326_handle_irq(int irq, void *data)
 748 {
 749         struct iio_dev *indio_dev = data;
 750
 751         if (iio_buffer_enabled(indio_dev)) {
 752                 /* Timestamping needed for buffered sampling only. */
 753                 ((struct zpa2326_private *)
 754                  iio_priv(indio_dev))->timestamp = iio_get_time_ns(indio_dev);
 755         }
 756
 757         return IRQ_WAKE_THREAD;
 758 }
 759
 760 /**
 761  * zpa2326_handle_threaded_irq() - Interrupt bottom-half handler.
 762  * @irq:  Interrupt line the hardware uses to notify new data has arrived.
 763  * @data: The IIO device associated with the sampling hardware.
 764  *
 765  * Mainly ensures interrupt is caused by a real "new sample available"
 766  * condition. This relies upon the ability to perform blocking / sleeping bus
 767  * accesses to slave's registers. This is why zpa2326_handle_threaded_irq() is
 768  * called from within a thread, i.e. not called from hard interrupt context.
 769  *
 770  * When device is using its own internal hardware trigger in continuous sampling
 771  * mode, data are available into hardware FIFO once interrupt has occurred. All
 772  * we have to do is to dispatch the trigger, which in turn will fetch data and
 773  * fill IIO buffer.
 774  *
 775  * When not using its own internal hardware trigger, the device has been
 776  * configured in one-shot mode either by an external trigger or the IIO read_raw
 777  * hook. This means one of the latter is currently waiting for sampling
 778  * completion, in which case we must simply wake it up.
 779  *
 780  * See zpa2326_trigger_handler().
 781  *
 782  * Return:
 783  *   %IRQ_NONE - no consistent interrupt happened ;
 784  *   %IRQ_HANDLED - there was new samples available.
 785  */
 786 static irqreturn_t zpa2326_handle_threaded_irq(int irq, void *data)
 787 {
 788         struct iio_dev         *indio_dev = data;
 789         struct zpa2326_private *priv = iio_priv(indio_dev);
 790         unsigned int            val;
 791         bool                    cont;
 792         irqreturn_t             ret = IRQ_NONE;
 793
 794         /*
 795          * Are we using our own internal trigger in triggered buffer mode, i.e.,
 796          * currently working in continuous sampling mode ?
 797          */
 798         cont = (iio_buffer_enabled(indio_dev) &&
 799                 iio_trigger_using_own(indio_dev));
 800
 801         /*
 802          * Device works according to a level interrupt scheme: reading interrupt
 803          * status de-asserts interrupt line.
 804          */
 805         priv->result = regmap_read(priv->regmap, ZPA2326_INT_SOURCE_REG, &val);
 806         if (priv->result < 0) {
 807                 if (cont)
 808                         return IRQ_NONE;
 809
 810                 goto complete;
 811         }
 812
 813         /* Data ready is the only interrupt source we requested. */
 814         if (!(val & ZPA2326_INT_SOURCE_DATA_READY)) {
 815                 /*
 816                  * Interrupt happened but no new sample available: likely caused
 817                  * by spurious interrupts, in which case, returning IRQ_NONE
 818                  * allows to benefit from the generic spurious interrupts
 819                  * handling.
 820                  */
 821                 zpa2326_warn(indio_dev, "unexpected interrupt status %02x",
 822                              val);
 823
 824                 if (cont)
 825                         return IRQ_NONE;
 826
 827                 priv->result = -ENODATA;
 828                 goto complete;
 829         }
 830
 831         /* New sample available: dispatch internal trigger consumers. */
 832         iio_trigger_poll_chained(priv->trigger);
 833
 834         if (cont)
 835                 /*
 836                  * Internal hardware trigger has been scheduled above : it will
 837                  * fetch data on its own.
 838                  */
 839                 return IRQ_HANDLED;
 840
 841         ret = IRQ_HANDLED;
 842
 843 complete:
 844         /*
 845          * Wake up direct or externaly triggered buffer mode waiters: see
 846          * zpa2326_sample_oneshot() and zpa2326_trigger_handler().
 847          */
 848         complete(&priv->data_ready);
 849
 850         return ret;
 851 }
 852
 853 /**
 854  * zpa2326_wait_oneshot_completion() - Wait for oneshot data ready interrupt.
 855  * @indio_dev: The IIO device associated with the sampling hardware.
 856  * @private:   Internal private state related to @indio_dev.
 857  *
 858  * Return: Zero when successful, a negative error code otherwise.
 859  */
 860 static int zpa2326_wait_oneshot_completion(const struct iio_dev   *indio_dev,
 861                                            struct zpa2326_private *private)
 862 {
 863         unsigned int val;
 864         long     timeout;
 865
 866         zpa2326_dbg(indio_dev, "waiting for one shot completion interrupt");
 867
 868         timeout = wait_for_completion_interruptible_timeout(
 869                 &private->data_ready, ZPA2326_CONVERSION_JIFFIES);
 870         if (timeout > 0)
 871                 /*
 872                  * Interrupt handler completed before timeout: return operation
 873                  * status.
 874                  */
 875                 return private->result;
 876
 877         /* Clear all interrupts just to be sure. */
 878         regmap_read(private->regmap, ZPA2326_INT_SOURCE_REG, &val);
 879
 880         if (!timeout) {
 881                 /* Timed out. */
 882                 zpa2326_warn(indio_dev, "no one shot interrupt occurred (%ld)",
 883                              timeout);
 884                 return -ETIME;
 885         }
 886
 887         zpa2326_warn(indio_dev, "wait for one shot interrupt cancelled");
 888         return -ERESTARTSYS;
 889 }
 890
 891 static int zpa2326_init_managed_irq(struct device          *parent,
 892                                     struct iio_dev         *indio_dev,
 893                                     struct zpa2326_private *private,
 894                                     int                     irq)
 895 {
 896         int err;
 897
 898         private->irq = irq;
 899
 900         if (irq <= 0) {
 901                 /*
 902                  * Platform declared no interrupt line: device will be polled
 903                  * for data availability.
 904                  */
 905                 dev_info(parent, "no interrupt found, running in polling mode");
 906                 return 0;
 907         }
 908
 909         init_completion(&private->data_ready);
 910
 911         /* Request handler to be scheduled into threaded interrupt context. */
 912         err = devm_request_threaded_irq(parent, irq, zpa2326_handle_irq,
 913                                         zpa2326_handle_threaded_irq,
 914                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 915                                         dev_name(parent), indio_dev);
 916         if (err) {
 917                 dev_err(parent, "failed to request interrupt %d (%d)", irq,
 918                         err);
 919                 return err;
 920         }
 921
 922         dev_info(parent, "using interrupt %d", irq);
 923
 924         return 0;
 925 }
 926
 927 /**
 928  * zpa2326_poll_oneshot_completion() - Actively poll for one shot data ready.
 929  * @indio_dev: The IIO device associated with the sampling hardware.
 930  *
 931  * Loop over registers content to detect end of sampling cycle. Used when DT
 932  * declared no valid interrupt lines.
 933  *
 934  * Return: Zero when successful, a negative error code otherwise.
 935  */
 936 static int zpa2326_poll_oneshot_completion(const struct iio_dev *indio_dev)
 937 {
 938         unsigned long  tmout = jiffies + ZPA2326_CONVERSION_JIFFIES;
 939         struct regmap *regs = ((struct zpa2326_private *)
 940                                iio_priv(indio_dev))->regmap;
 941         unsigned int   val;
 942         int            err;
 943
 944         zpa2326_dbg(indio_dev, "polling for one shot completion");
 945
 946         /*
 947          * At least, 100 ms is needed for the device to complete its one-shot
 948          * cycle.
 949          */
 950         if (msleep_interruptible(100))
 951                 return -ERESTARTSYS;
 952
 953         /* Poll for conversion completion in hardware. */
 954         while (true) {
 955                 err = regmap_read(regs, ZPA2326_CTRL_REG0_REG, &val);
 956                 if (err < 0)
 957                         goto err;
 958
 959                 if (!(val & ZPA2326_CTRL_REG0_ONE_SHOT))
 960                         /* One-shot bit self clears at conversion end. */
 961                         break;
 962
 963                 if (time_after(jiffies, tmout)) {
 964                         /* Prevent from waiting forever : let's time out. */
 965                         err = -ETIME;
 966                         goto err;
 967                 }
 968
 969                 usleep_range(10000, 20000);
 970         }
 971
 972         /*
 973          * In oneshot mode, pressure sample availability guarantees that
 974          * temperature conversion has also completed : just check pressure
 975          * status bit to keep things simple.
 976          */
 977         err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
 978         if (err < 0)
 979                 goto err;
 980
 981         if (!(val & ZPA2326_STATUS_P_DA)) {
 982                 /* No sample available. */
 983                 err = -ENODATA;
 984                 goto err;
 985         }
 986
 987         return 0;
 988
 989 err:
 990         zpa2326_warn(indio_dev, "failed to poll one shot completion (%d)", err);
 991
 992         return err;
 993 }
 994
 995 /**
 996  * zpa2326_fetch_raw_sample() - Retrieve a raw sample and convert it to CPU
 997  *                              endianness.
 998  * @indio_dev: The IIO device associated with the sampling hardware.
 999  * @type:      Type of measurement / channel to fetch from.
1000  * @value:     Sample output.
1001  *
1002  * Return: Zero when successful, a negative error code otherwise.
1003  */
1004 static int zpa2326_fetch_raw_sample(const struct iio_dev *indio_dev,
1005                                     enum iio_chan_type    type,
1006                                     int                  *value)
1007 {
1008         struct regmap *regs = ((struct zpa2326_private *)
1009                                iio_priv(indio_dev))->regmap;
1010         int            err;
1011         u8             v[3];
1012
1013         switch (type) {
1014         case IIO_PRESSURE:
1015                 zpa2326_dbg(indio_dev, "fetching raw pressure sample");
1016
1017                 err = regmap_bulk_read(regs, ZPA2326_PRESS_OUT_XL_REG, v, sizeof(v));
1018                 if (err) {
1019                         zpa2326_warn(indio_dev, "failed to fetch pressure (%d)",
1020                                      err);
1021                         return err;
1022                 }
1023
1024                 *value = get_unaligned_le24(&v[0]);
1025
1026                 return IIO_VAL_INT;
1027
1028         case IIO_TEMP:
1029                 zpa2326_dbg(indio_dev, "fetching raw temperature sample");
1030
1031                 err = regmap_bulk_read(regs, ZPA2326_TEMP_OUT_L_REG, value, 2);
1032                 if (err) {
1033                         zpa2326_warn(indio_dev,
1034                                      "failed to fetch temperature (%d)", err);
1035                         return err;
1036                 }
1037
1038                 /* Temperature is a 16 bits wide little-endian signed int. */
1039                 *value = (int)le16_to_cpup((__le16 *)value);
1040
1041                 return IIO_VAL_INT;
1042
1043         default:
1044                 return -EINVAL;
1045         }
1046 }
1047
1048 /**
1049  * zpa2326_sample_oneshot() - Perform a complete one shot sampling cycle.
1050  * @indio_dev: The IIO device associated with the sampling hardware.
1051  * @type:      Type of measurement / channel to fetch from.
1052  * @value:     Sample output.
1053  *
1054  * Return: Zero when successful, a negative error code otherwise.
1055  */
1056 static int zpa2326_sample_oneshot(struct iio_dev     *indio_dev,
1057                                   enum iio_chan_type  type,
1058                                   int                *value)
1059 {
1060         int                     ret;
1061         struct zpa2326_private *priv;
1062
1063         ret = iio_device_claim_direct_mode(indio_dev);
1064         if (ret)
1065                 return ret;
1066
1067         ret = zpa2326_resume(indio_dev);
1068         if (ret < 0)
1069                 goto release;
1070
1071         priv = iio_priv(indio_dev);
1072
1073         if (ret > 0) {
1074                 /*
1075                  * We were already power supplied. Just clear hardware FIFO to
1076                  * get rid of samples acquired during previous rounds (if any).
1077                  * Sampling operation always generates both temperature and
1078                  * pressure samples. The latter are always enqueued into
1079                  * hardware FIFO. This may lead to situations were pressure
1080                  * samples still sit into FIFO when previous cycle(s) fetched
1081                  * temperature data only.
1082                  * Hence, we need to clear hardware FIFO content to prevent from
1083                  * getting outdated values at the end of current cycle.
1084                  */
1085                 if (type == IIO_PRESSURE) {
1086                         ret = zpa2326_clear_fifo(indio_dev, 0);
1087                         if (ret)
1088                                 goto suspend;
1089                 }
1090         } else {
1091                 /*
1092                  * We have just been power supplied, i.e. device is in default
1093                  * "out of reset" state, meaning we need to reconfigure it
1094                  * entirely.
1095                  */
1096                 ret = zpa2326_config_oneshot(indio_dev, priv->irq);
1097                 if (ret)
1098                         goto suspend;
1099         }
1100
1101         /* Start a sampling cycle in oneshot mode. */
1102         ret = zpa2326_start_oneshot(indio_dev);
1103         if (ret)
1104                 goto suspend;
1105
1106         /* Wait for sampling cycle to complete. */
1107         if (priv->irq > 0)
1108                 ret = zpa2326_wait_oneshot_completion(indio_dev, priv);
1109         else
1110                 ret = zpa2326_poll_oneshot_completion(indio_dev);
1111
1112         if (ret)
1113                 goto suspend;
1114
1115         /* Retrieve raw sample value and convert it to CPU endianness. */
1116         ret = zpa2326_fetch_raw_sample(indio_dev, type, value);
1117
1118 suspend:
1119         zpa2326_suspend(indio_dev);
1120 release:
1121         iio_device_release_direct_mode(indio_dev);
1122
1123         return ret;
1124 }
1125
1126 /**
1127  * zpa2326_trigger_handler() - Perform an IIO buffered sampling round in one
1128  *                             shot mode.
1129  * @irq:  The software interrupt assigned to @data
1130  * @data: The IIO poll function dispatched by external trigger our device is
1131  *        attached to.
1132  *
1133  * Bottom-half handler called by the IIO trigger to which our device is
1134  * currently attached. Allows us to synchronize this device buffered sampling
1135  * either with external events (such as timer expiration, external device sample
1136  * ready, etc...) or with its own interrupt (internal hardware trigger).
1137  *
1138  * When using an external trigger, basically run the same sequence of operations
1139  * as for zpa2326_sample_oneshot() with the following hereafter. Hardware FIFO
1140  * is not cleared since already done at buffering enable time and samples
1141  * dequeueing always retrieves the most recent value.
1142  *
1143  * Otherwise, when internal hardware trigger has dispatched us, just fetch data
1144  * from hardware FIFO.
1145  *
1146  * Fetched data will pushed unprocessed to IIO buffer since samples conversion
1147  * is delegated to userspace in buffered mode (endianness, etc...).
1148  *
1149  * Return:
1150  *   %IRQ_NONE - no consistent interrupt happened ;
1151  *   %IRQ_HANDLED - there was new samples available.
1152  */
1153 static irqreturn_t zpa2326_trigger_handler(int irq, void *data)
1154 {
1155         struct iio_dev         *indio_dev = ((struct iio_poll_func *)
1156                                              data)->indio_dev;
1157         struct zpa2326_private *priv = iio_priv(indio_dev);
1158         bool                    cont;
1159
1160         /*
1161          * We have been dispatched, meaning we are in triggered buffer mode.
1162          * Using our own internal trigger implies we are currently in continuous
1163          * hardware sampling mode.
1164          */
1165         cont = iio_trigger_using_own(indio_dev);
1166
1167         if (!cont) {
1168                 /* On demand sampling : start a one shot cycle. */
1169                 if (zpa2326_start_oneshot(indio_dev))
1170                         goto out;
1171
1172                 /* Wait for sampling cycle to complete. */
1173                 if (priv->irq <= 0) {
1174                         /* No interrupt available: poll for completion. */
1175                         if (zpa2326_poll_oneshot_completion(indio_dev))
1176                                 goto out;
1177
1178                         /* Only timestamp sample once it is ready. */
1179                         priv->timestamp = iio_get_time_ns(indio_dev);
1180                 } else {
1181                         /* Interrupt handlers will timestamp for us. */
1182                         if (zpa2326_wait_oneshot_completion(indio_dev, priv))
1183                                 goto out;
1184                 }
1185         }
1186
1187         /* Enqueue to IIO buffer / userspace. */
1188         zpa2326_fill_sample_buffer(indio_dev, priv);
1189
1190 out:
1191         if (!cont)
1192                 /* Don't switch to low power if sampling continuously. */
1193                 zpa2326_sleep(indio_dev);
1194
1195         /* Inform attached trigger we are done. */
1196         iio_trigger_notify_done(indio_dev->trig);
1197
1198         return IRQ_HANDLED;
1199 }
1200
1201 /**
1202  * zpa2326_preenable_buffer() - Prepare device for configuring triggered
1203  *                              sampling
1204  * modes.
1205  * @indio_dev: The IIO device associated with the sampling hardware.
1206  *
1207  * Basically power up device.
1208  * Called with IIO device's lock held.
1209  *
1210  * Return: Zero when successful, a negative error code otherwise.
1211  */
1212 static int zpa2326_preenable_buffer(struct iio_dev *indio_dev)
1213 {
1214         int ret = zpa2326_resume(indio_dev);
1215
1216         if (ret < 0)
1217                 return ret;
1218
1219         /* Tell zpa2326_postenable_buffer() if we have just been powered on. */
1220         ((struct zpa2326_private *)
1221          iio_priv(indio_dev))->waken = iio_priv(indio_dev);
1222
1223         return 0;
1224 }
1225
1226 /**
1227  * zpa2326_postenable_buffer() - Configure device for triggered sampling.
1228  * @indio_dev: The IIO device associated with the sampling hardware.
1229  *
1230  * Basically setup one-shot mode if plugging external trigger.
1231  * Otherwise, let internal trigger configure continuous sampling :
1232  * see zpa2326_set_trigger_state().
1233  *
1234  * If an error is returned, IIO layer will call our postdisable hook for us,
1235  * i.e. no need to explicitly power device off here.
1236  * Called with IIO device's lock held.
1237  *
1238  * Called with IIO device's lock held.
1239  *
1240  * Return: Zero when successful, a negative error code otherwise.
1241  */
1242 static int zpa2326_postenable_buffer(struct iio_dev *indio_dev)
1243 {
1244         const struct zpa2326_private *priv = iio_priv(indio_dev);
1245         int                           err;
1246
1247         if (!priv->waken) {
1248                 /*
1249                  * We were already power supplied. Just clear hardware FIFO to
1250                  * get rid of samples acquired during previous rounds (if any).
1251                  */
1252                 err = zpa2326_clear_fifo(indio_dev, 0);
1253                 if (err) {
1254                         zpa2326_err(indio_dev,
1255                                     "failed to enable buffering (%d)", err);
1256                         return err;
1257                 }
1258         }
1259
1260         if (!iio_trigger_using_own(indio_dev) && priv->waken) {
1261                 /*
1262                  * We are using an external trigger and we have just been
1263                  * powered up: reconfigure one-shot mode.
1264                  */
1265                 err = zpa2326_config_oneshot(indio_dev, priv->irq);
1266                 if (err) {
1267                         zpa2326_err(indio_dev,
1268                                     "failed to enable buffering (%d)", err);
1269                         return err;
1270                 }
1271         }
1272
1273         return 0;
1274 }
1275
1276 static int zpa2326_postdisable_buffer(struct iio_dev *indio_dev)
1277 {
1278         zpa2326_suspend(indio_dev);
1279
1280         return 0;
1281 }
1282
1283 static const struct iio_buffer_setup_ops zpa2326_buffer_setup_ops = {
1284         .preenable   = zpa2326_preenable_buffer,
1285         .postenable  = zpa2326_postenable_buffer,
1286         .postdisable = zpa2326_postdisable_buffer
1287 };
1288
1289 /**
1290  * zpa2326_set_trigger_state() - Start / stop continuous sampling.
1291  * @trig:  The trigger being attached to IIO device associated with the sampling
1292  *         hardware.
1293  * @state: Tell whether to start (true) or stop (false)
1294  *
1295  * Basically enable / disable hardware continuous sampling mode.
1296  *
1297  * Called with IIO device's lock held at postenable() or predisable() time.
1298  *
1299  * Return: Zero when successful, a negative error code otherwise.
1300  */
1301 static int zpa2326_set_trigger_state(struct iio_trigger *trig, bool state)
1302 {
1303         const struct iio_dev         *indio_dev = dev_get_drvdata(
1304                                                         trig->dev.parent);
1305         const struct zpa2326_private *priv = iio_priv(indio_dev);
1306         int                           err;
1307
1308         if (!state) {
1309                 /*
1310                  * Switch trigger off : in case of failure, interrupt is left
1311                  * disabled in order to prevent handler from accessing released
1312                  * resources.
1313                  */
1314                 unsigned int val;
1315
1316                 /*
1317                  * As device is working in continuous mode, handlers may be
1318                  * accessing resources we are currently freeing...
1319                  * Prevent this by disabling interrupt handlers and ensure
1320                  * the device will generate no more interrupts unless explicitly
1321                  * required to, i.e. by restoring back to default one shot mode.
1322                  */
1323                 disable_irq(priv->irq);
1324
1325                 /*
1326                  * Disable continuous sampling mode to restore settings for
1327                  * one shot / direct sampling operations.
1328                  */
1329                 err = regmap_write(priv->regmap, ZPA2326_CTRL_REG3_REG,
1330                                    zpa2326_highest_frequency()->odr);
1331                 if (err)
1332                         return err;
1333
1334                 /*
1335                  * Now that device won't generate interrupts on its own,
1336                  * acknowledge any currently active interrupts (may happen on
1337                  * rare occasions while stopping continuous mode).
1338                  */
1339                 err = regmap_read(priv->regmap, ZPA2326_INT_SOURCE_REG, &val);
1340                 if (err < 0)
1341                         return err;
1342
1343                 /*
1344                  * Re-enable interrupts only if we can guarantee the device will
1345                  * generate no more interrupts to prevent handlers from
1346                  * accessing released resources.
1347                  */
1348                 enable_irq(priv->irq);
1349
1350                 zpa2326_dbg(indio_dev, "continuous mode stopped");
1351         } else {
1352                 /*
1353                  * Switch trigger on : start continuous sampling at required
1354                  * frequency.
1355                  */
1356
1357                 if (priv->waken) {
1358                         /* Enable interrupt if getting out of reset. */
1359                         err = regmap_write(priv->regmap, ZPA2326_CTRL_REG1_REG,
1360                                            (u8)
1361                                            ~ZPA2326_CTRL_REG1_MASK_DATA_READY);
1362                         if (err)
1363                                 return err;
1364                 }
1365
1366                 /* Enable continuous sampling at specified frequency. */
1367                 err = regmap_write(priv->regmap, ZPA2326_CTRL_REG3_REG,
1368                                    ZPA2326_CTRL_REG3_ENABLE_MEAS |
1369                                    priv->frequency->odr);
1370                 if (err)
1371                         return err;
1372
1373                 zpa2326_dbg(indio_dev, "continuous mode setup @%dHz",
1374                             priv->frequency->hz);
1375         }
1376
1377         return 0;
1378 }
1379
1380 static const struct iio_trigger_ops zpa2326_trigger_ops = {
1381         .set_trigger_state = zpa2326_set_trigger_state,
1382 };
1383
1384 /**
1385  * zpa2326_init_trigger() - Create an interrupt driven / hardware trigger
1386  *                          allowing to notify external devices a new sample is
1387  *                          ready.
1388  * @parent:    Hardware sampling device @indio_dev is a child of.
1389  * @indio_dev: The IIO device associated with the sampling hardware.
1390  * @private:   Internal private state related to @indio_dev.
1391  * @irq:       Optional interrupt line the hardware uses to notify new data
1392  *             samples are ready. Negative or zero values indicate no interrupts
1393  *             are available, meaning polling is required.
1394  *
1395  * Only relevant when DT declares a valid interrupt line.
1396  *
1397  * Return: Zero when successful, a negative error code otherwise.
1398  */
1399 static int zpa2326_init_managed_trigger(struct device          *parent,
1400                                         struct iio_dev         *indio_dev,
1401                                         struct zpa2326_private *private,
1402                                         int                     irq)
1403 {
1404         struct iio_trigger *trigger;
1405         int                 ret;
1406
1407         if (irq <= 0)
1408                 return 0;
1409
1410         trigger = devm_iio_trigger_alloc(parent, "%s-dev%d",
1411                                          indio_dev->name, indio_dev->id);
1412         if (!trigger)
1413                 return -ENOMEM;
1414
1415         /* Basic setup. */
1416         trigger->dev.parent = parent;
1417         trigger->ops = &zpa2326_trigger_ops;
1418
1419         private->trigger = trigger;
1420
1421         /* Register to triggers space. */
1422         ret = devm_iio_trigger_register(parent, trigger);
1423         if (ret)
1424                 dev_err(parent, "failed to register hardware trigger (%d)",
1425                         ret);
1426
1427         return ret;
1428 }
1429
1430 static int zpa2326_get_frequency(const struct iio_dev *indio_dev)
1431 {
1432         return ((struct zpa2326_private *)iio_priv(indio_dev))->frequency->hz;
1433 }
1434
1435 static int zpa2326_set_frequency(struct iio_dev *indio_dev, int hz)
1436 {
1437         struct zpa2326_private *priv = iio_priv(indio_dev);
1438         int                     freq;
1439         int                     err;
1440
1441         /* Check if requested frequency is supported. */
1442         for (freq = 0; freq < ARRAY_SIZE(zpa2326_sampling_frequencies); freq++)
1443                 if (zpa2326_sampling_frequencies[freq].hz == hz)
1444                         break;
1445         if (freq == ARRAY_SIZE(zpa2326_sampling_frequencies))
1446                 return -EINVAL;
1447
1448         /* Don't allow changing frequency if buffered sampling is ongoing. */
1449         err = iio_device_claim_direct_mode(indio_dev);
1450         if (err)
1451                 return err;
1452
1453         priv->frequency = &zpa2326_sampling_frequencies[freq];
1454
1455         iio_device_release_direct_mode(indio_dev);
1456
1457         return 0;
1458 }
1459
1460 /* Expose supported hardware sampling frequencies (Hz) through sysfs. */
1461 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("1 5 11 23");
1462
1463 static struct attribute *zpa2326_attributes[] = {
1464         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
1465         NULL
1466 };
1467
1468 static const struct attribute_group zpa2326_attribute_group = {
1469         .attrs = zpa2326_attributes,
1470 };
1471
1472 static int zpa2326_read_raw(struct iio_dev             *indio_dev,
1473                             struct iio_chan_spec const *chan,
1474                             int                        *val,
1475                             int                        *val2,
1476                             long                        mask)
1477 {
1478         switch (mask) {
1479         case IIO_CHAN_INFO_RAW:
1480                 return zpa2326_sample_oneshot(indio_dev, chan->type, val);
1481
1482         case IIO_CHAN_INFO_SCALE:
1483                 switch (chan->type) {
1484                 case IIO_PRESSURE:
1485                         /*
1486                          * Pressure resolution is 1/64 Pascal. Scale to kPascal
1487                          * as required by IIO ABI.
1488                          */
1489                         *val = 1;
1490                         *val2 = 64000;
1491                         return IIO_VAL_FRACTIONAL;
1492
1493                 case IIO_TEMP:
1494                         /*
1495                          * Temperature follows the equation:
1496                          *     Temp[degC] = Tempcode * 0.00649 - 176.83
1497                          * where:
1498                          *     Tempcode is composed the raw sampled 16 bits.
1499                          *
1500                          * Hence, to produce a temperature in milli-degrees
1501                          * Celsius according to IIO ABI, we need to apply the
1502                          * following equation to raw samples:
1503                          *     Temp[milli degC] = (Tempcode + Offset) * Scale
1504                          * where:
1505                          *     Offset = -176.83 / 0.00649
1506                          *     Scale = 0.00649 * 1000
1507                          */
1508                         *val = 6;
1509                         *val2 = 490000;
1510                         return IIO_VAL_INT_PLUS_MICRO;
1511
1512                 default:
1513                         return -EINVAL;
1514                 }
1515
1516         case IIO_CHAN_INFO_OFFSET:
1517                 switch (chan->type) {
1518                 case IIO_TEMP:
1519                         *val = -17683000;
1520                         *val2 = 649;
1521                         return IIO_VAL_FRACTIONAL;
1522
1523                 default:
1524                         return -EINVAL;
1525                 }
1526
1527         case IIO_CHAN_INFO_SAMP_FREQ:
1528                 *val = zpa2326_get_frequency(indio_dev);
1529                 return IIO_VAL_INT;
1530
1531         default:
1532                 return -EINVAL;
1533         }
1534 }
1535
1536 static int zpa2326_write_raw(struct iio_dev             *indio_dev,
1537                              const struct iio_chan_spec *chan,
1538                              int                         val,
1539                              int                         val2,
1540                              long                        mask)
1541 {
1542         if ((mask != IIO_CHAN_INFO_SAMP_FREQ) || val2)
1543                 return -EINVAL;
1544
1545         return zpa2326_set_frequency(indio_dev, val);
1546 }
1547
1548 static const struct iio_chan_spec zpa2326_channels[] = {
1549         [0] = {
1550                 .type                    = IIO_PRESSURE,
1551                 .scan_index              = 0,
1552                 .scan_type               = {
1553                         .sign                   = 'u',
1554                         .realbits               = 24,
1555                         .storagebits            = 32,
1556                         .endianness             = IIO_LE,
1557                 },
1558                 .info_mask_separate      = BIT(IIO_CHAN_INFO_RAW) |
1559                                            BIT(IIO_CHAN_INFO_SCALE),
1560                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
1561         },
1562         [1] = {
1563                 .type                    = IIO_TEMP,
1564                 .scan_index              = 1,
1565                 .scan_type               = {
1566                         .sign                   = 's',
1567                         .realbits               = 16,
1568                         .storagebits            = 16,
1569                         .endianness             = IIO_LE,
1570                 },
1571                 .info_mask_separate      = BIT(IIO_CHAN_INFO_RAW) |
1572                                            BIT(IIO_CHAN_INFO_SCALE) |
1573                                            BIT(IIO_CHAN_INFO_OFFSET),
1574                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
1575         },
1576         [2] = IIO_CHAN_SOFT_TIMESTAMP(2),
1577 };
1578
1579 static const struct iio_info zpa2326_info = {
1580         .attrs         = &zpa2326_attribute_group,
1581         .read_raw      = zpa2326_read_raw,
1582         .write_raw     = zpa2326_write_raw,
1583 };
1584
1585 static struct iio_dev *zpa2326_create_managed_iiodev(struct device *device,
1586                                                      const char    *name,
1587                                                      struct regmap *regmap)
1588 {
1589         struct iio_dev *indio_dev;
1590
1591         /* Allocate space to hold IIO device internal state. */
1592         indio_dev = devm_iio_device_alloc(device,
1593                                           sizeof(struct zpa2326_private));
1594         if (!indio_dev)
1595                 return NULL;
1596
1597         /* Setup for userspace synchronous on demand sampling. */
1598         indio_dev->modes = INDIO_DIRECT_MODE;
1599         indio_dev->channels = zpa2326_channels;
1600         indio_dev->num_channels = ARRAY_SIZE(zpa2326_channels);
1601         indio_dev->name = name;
1602         indio_dev->info = &zpa2326_info;
1603
1604         return indio_dev;
1605 }
1606
1607 int zpa2326_probe(struct device *parent,
1608                   const char    *name,
1609                   int            irq,
1610                   unsigned int   hwid,
1611                   struct regmap *regmap)
1612 {
1613         struct iio_dev         *indio_dev;
1614         struct zpa2326_private *priv;
1615         int                     err;
1616         unsigned int            id;
1617
1618         indio_dev = zpa2326_create_managed_iiodev(parent, name, regmap);
1619         if (!indio_dev)
1620                 return -ENOMEM;
1621
1622         priv = iio_priv(indio_dev);
1623
1624         priv->vref = devm_regulator_get(parent, "vref");
1625         if (IS_ERR(priv->vref))
1626                 return PTR_ERR(priv->vref);
1627
1628         priv->vdd = devm_regulator_get(parent, "vdd");
1629         if (IS_ERR(priv->vdd))
1630                 return PTR_ERR(priv->vdd);
1631
1632         /* Set default hardware sampling frequency to highest rate supported. */
1633         priv->frequency = zpa2326_highest_frequency();
1634
1635         /*
1636          * Plug device's underlying bus abstraction : this MUST be set before
1637          * registering interrupt handlers since an interrupt might happen if
1638          * power up sequence is not properly applied.
1639          */
1640         priv->regmap = regmap;
1641
1642         err = devm_iio_triggered_buffer_setup(parent, indio_dev, NULL,
1643                                               zpa2326_trigger_handler,
1644                                               &zpa2326_buffer_setup_ops);
1645         if (err)
1646                 return err;
1647
1648         err = zpa2326_init_managed_trigger(parent, indio_dev, priv, irq);
1649         if (err)
1650                 return err;
1651
1652         err = zpa2326_init_managed_irq(parent, indio_dev, priv, irq);
1653         if (err)
1654                 return err;
1655
1656         /* Power up to check device ID and perform initial hardware setup. */
1657         err = zpa2326_power_on(indio_dev, priv);
1658         if (err)
1659                 return err;
1660
1661         /* Read id register to check we are talking to the right slave. */
1662         err = regmap_read(regmap, ZPA2326_DEVICE_ID_REG, &id);
1663         if (err)
1664                 goto sleep;
1665
1666         if (id != hwid) {
1667                 dev_err(parent, "found device with unexpected id %02x", id);
1668                 err = -ENODEV;
1669                 goto sleep;
1670         }
1671
1672         err = zpa2326_config_oneshot(indio_dev, irq);
1673         if (err)
1674                 goto sleep;
1675
1676         /* Setup done : go sleeping. Device will be awaken upon user request. */
1677         err = zpa2326_sleep(indio_dev);
1678         if (err)
1679                 goto poweroff;
1680
1681         dev_set_drvdata(parent, indio_dev);
1682
1683         zpa2326_init_runtime(parent);
1684
1685         err = iio_device_register(indio_dev);
1686         if (err) {
1687                 zpa2326_fini_runtime(parent);
1688                 goto poweroff;
1689         }
1690
1691         return 0;
1692
1693 sleep:
1694         /* Put to sleep just in case power regulators are "dummy" ones. */
1695         zpa2326_sleep(indio_dev);
1696 poweroff:
1697         zpa2326_power_off(indio_dev, priv);
1698
1699         return err;
1700 }
1701 EXPORT_SYMBOL_GPL(zpa2326_probe);
1702
1703 void zpa2326_remove(const struct device *parent)
1704 {
1705         struct iio_dev *indio_dev = dev_get_drvdata(parent);
1706
1707         iio_device_unregister(indio_dev);
1708         zpa2326_fini_runtime(indio_dev->dev.parent);
1709         zpa2326_sleep(indio_dev);
1710         zpa2326_power_off(indio_dev, iio_priv(indio_dev));
1711 }
1712 EXPORT_SYMBOL_GPL(zpa2326_remove);
1713
1714 MODULE_AUTHOR("Gregor Boirie <gregor.boirie@parrot.com>");
1715 MODULE_DESCRIPTION("Core driver for Murata ZPA2326 pressure sensor");
1716 MODULE_LICENSE("GPL v2");