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