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