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 #define zpa2326_dbg(_idev, _format, _arg...) \ 151 dev_dbg(_idev->dev.parent, _format, ##_arg) 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 int ret; 869 unsigned int val; 870 long timeout; 871 872 zpa2326_dbg(indio_dev, "waiting for one shot completion interrupt"); 873 874 timeout = wait_for_completion_interruptible_timeout( 875 &private->data_ready, ZPA2326_CONVERSION_JIFFIES); 876 if (timeout > 0) 877 /* 878 * Interrupt handler completed before timeout: return operation 879 * status. 880 */ 881 return private->result; 882 883 /* Clear all interrupts just to be sure. */ 884 regmap_read(private->regmap, ZPA2326_INT_SOURCE_REG, &val); 885 886 if (!timeout) { 887 /* Timed out. */ 888 zpa2326_warn(indio_dev, "no one shot interrupt occurred (%ld)", 889 timeout); 890 ret = -ETIME; 891 } else if (timeout < 0) { 892 zpa2326_warn(indio_dev, 893 "wait for one shot interrupt cancelled"); 894 ret = -ERESTARTSYS; 895 } 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