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