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"); 1736