drivers/iio/pressure/zpa2326.c

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