2 * Murata ZPA2326 pressure and temperature sensor IIO driver
4 * Copyright (c) 2016 Parrot S.A.
6 * Author: Gregor Boirie <gregor.boirie@parrot.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published by
10 * the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 * DOC: ZPA2326 theory of operations
21 * This driver supports %INDIO_DIRECT_MODE and %INDIO_BUFFER_TRIGGERED IIO
23 * A internal hardware trigger is also implemented to dispatch registered IIO
24 * trigger consumers upon "sample ready" interrupts.
26 * ZPA2326 hardware supports 2 sampling mode: one shot and continuous.
28 * A complete one shot sampling cycle gets device out of low power mode,
29 * performs pressure and temperature measurements, then automatically switches
30 * back to low power mode. It is meant for on demand sampling with optimal power
31 * saving at the cost of lower sampling rate and higher software overhead.
32 * This is a natural candidate for IIO read_raw hook implementation
33 * (%INDIO_DIRECT_MODE). It is also used for triggered buffering support to
34 * ensure explicit synchronization with external trigger events
35 * (%INDIO_BUFFER_TRIGGERED).
37 * The continuous mode works according to a periodic hardware measurement
38 * process continuously pushing samples into an internal hardware FIFO (for
39 * pressure samples only). Measurement cycle completion may be signaled by a
40 * "sample ready" interrupt.
41 * Typical software sequence of operations :
42 * - get device out of low power mode,
43 * - setup hardware sampling period,
44 * - at end of period, upon data ready interrupt: pop pressure samples out of
45 * hardware FIFO and fetch temperature sample
46 * - when no longer needed, stop sampling process by putting device into
48 * This mode is used to implement %INDIO_BUFFER_TRIGGERED mode if device tree
49 * declares a valid interrupt line. In this case, the internal hardware trigger
52 * Note that hardware sampling frequency is taken into account only when
53 * internal hardware trigger is attached as the highest sampling rate seems to
54 * be the most energy efficient.
57 * preset pressure threshold crossing / IIO events ;
58 * differential pressure sampling ;
59 * hardware samples averaging.
62 #include <linux/module.h>
63 #include <linux/kernel.h>
64 #include <linux/delay.h>
65 #include <linux/interrupt.h>
66 #include <linux/regulator/consumer.h>
67 #include <linux/pm_runtime.h>
68 #include <linux/regmap.h>
69 #include <linux/iio/iio.h>
70 #include <linux/iio/sysfs.h>
71 #include <linux/iio/buffer.h>
72 #include <linux/iio/trigger.h>
73 #include <linux/iio/trigger_consumer.h>
74 #include <linux/iio/triggered_buffer.h>
77 /* 200 ms should be enough for the longest conversion time in one-shot mode. */
78 #define ZPA2326_CONVERSION_JIFFIES (HZ / 5)
80 /* There should be a 1 ms delay (Tpup) after getting out of reset. */
81 #define ZPA2326_TPUP_USEC_MIN (1000)
82 #define ZPA2326_TPUP_USEC_MAX (2000)
85 * struct zpa2326_frequency - Hardware sampling frequency descriptor
86 * @hz : Frequency in Hertz.
87 * @odr: Output Data Rate word as expected by %ZPA2326_CTRL_REG3_REG.
89 struct zpa2326_frequency
{
95 * Keep these in strict ascending order: last array entry is expected to
96 * correspond to the highest sampling frequency.
98 static const struct zpa2326_frequency zpa2326_sampling_frequencies
[] = {
99 { .hz
= 1, .odr
= 1 << ZPA2326_CTRL_REG3_ODR_SHIFT
},
100 { .hz
= 5, .odr
= 5 << ZPA2326_CTRL_REG3_ODR_SHIFT
},
101 { .hz
= 11, .odr
= 6 << ZPA2326_CTRL_REG3_ODR_SHIFT
},
102 { .hz
= 23, .odr
= 7 << ZPA2326_CTRL_REG3_ODR_SHIFT
},
105 /* Return the highest hardware sampling frequency available. */
106 static const struct zpa2326_frequency
*zpa2326_highest_frequency(void)
108 return &zpa2326_sampling_frequencies
[
109 ARRAY_SIZE(zpa2326_sampling_frequencies
) - 1];
113 * struct zpa_private - Per-device internal private state
114 * @timestamp: Buffered samples ready datum.
115 * @regmap: Underlying I2C / SPI bus adapter used to abstract slave register
117 * @result: Allows sampling logic to get completion status of operations
118 * that interrupt handlers perform asynchronously.
119 * @data_ready: Interrupt handler uses this to wake user context up at sampling
120 * operation completion.
121 * @trigger: Optional hardware / interrupt driven trigger used to notify
122 * external devices a new sample is ready.
123 * @waken: Flag indicating whether or not device has just been powered on.
124 * @irq: Optional interrupt line: negative or zero if not declared into
125 * DT, in which case sampling logic keeps polling status register
126 * to detect completion.
127 * @frequency: Current hardware sampling frequency.
128 * @vref: Power / voltage reference.
129 * @vdd: Power supply.
131 struct zpa2326_private
{
133 struct regmap
*regmap
;
135 struct completion data_ready
;
136 struct iio_trigger
*trigger
;
139 const struct zpa2326_frequency
*frequency
;
140 struct regulator
*vref
;
141 struct regulator
*vdd
;
144 #define zpa2326_err(idev, fmt, ...) \
145 dev_err(idev->dev.parent, fmt "\n", ##__VA_ARGS__)
147 #define zpa2326_warn(idev, fmt, ...) \
148 dev_warn(idev->dev.parent, fmt "\n", ##__VA_ARGS__)
150 #define zpa2326_dbg(idev, fmt, ...) \
151 dev_dbg(idev->dev.parent, fmt "\n", ##__VA_ARGS__)
153 bool zpa2326_isreg_writeable(struct device
*dev
, unsigned int reg
)
156 case ZPA2326_REF_P_XL_REG
:
157 case ZPA2326_REF_P_L_REG
:
158 case ZPA2326_REF_P_H_REG
:
159 case ZPA2326_RES_CONF_REG
:
160 case ZPA2326_CTRL_REG0_REG
:
161 case ZPA2326_CTRL_REG1_REG
:
162 case ZPA2326_CTRL_REG2_REG
:
163 case ZPA2326_CTRL_REG3_REG
:
164 case ZPA2326_THS_P_LOW_REG
:
165 case ZPA2326_THS_P_HIGH_REG
:
172 EXPORT_SYMBOL_GPL(zpa2326_isreg_writeable
);
174 bool zpa2326_isreg_readable(struct device
*dev
, unsigned int reg
)
177 case ZPA2326_REF_P_XL_REG
:
178 case ZPA2326_REF_P_L_REG
:
179 case ZPA2326_REF_P_H_REG
:
180 case ZPA2326_DEVICE_ID_REG
:
181 case ZPA2326_RES_CONF_REG
:
182 case ZPA2326_CTRL_REG0_REG
:
183 case ZPA2326_CTRL_REG1_REG
:
184 case ZPA2326_CTRL_REG2_REG
:
185 case ZPA2326_CTRL_REG3_REG
:
186 case ZPA2326_INT_SOURCE_REG
:
187 case ZPA2326_THS_P_LOW_REG
:
188 case ZPA2326_THS_P_HIGH_REG
:
189 case ZPA2326_STATUS_REG
:
190 case ZPA2326_PRESS_OUT_XL_REG
:
191 case ZPA2326_PRESS_OUT_L_REG
:
192 case ZPA2326_PRESS_OUT_H_REG
:
193 case ZPA2326_TEMP_OUT_L_REG
:
194 case ZPA2326_TEMP_OUT_H_REG
:
201 EXPORT_SYMBOL_GPL(zpa2326_isreg_readable
);
203 bool zpa2326_isreg_precious(struct device
*dev
, unsigned int reg
)
206 case ZPA2326_INT_SOURCE_REG
:
207 case ZPA2326_PRESS_OUT_H_REG
:
214 EXPORT_SYMBOL_GPL(zpa2326_isreg_precious
);
217 * zpa2326_enable_device() - Enable device, i.e. get out of low power mode.
218 * @indio_dev: The IIO device associated with the hardware to enable.
220 * Required to access complete register space and to perform any sampling
221 * or control operations.
223 * Return: Zero when successful, a negative error code otherwise.
225 static int zpa2326_enable_device(const struct iio_dev
*indio_dev
)
229 err
= regmap_write(((struct zpa2326_private
*)
230 iio_priv(indio_dev
))->regmap
,
231 ZPA2326_CTRL_REG0_REG
, ZPA2326_CTRL_REG0_ENABLE
);
233 zpa2326_err(indio_dev
, "failed to enable device (%d)", err
);
237 zpa2326_dbg(indio_dev
, "enabled");
243 * zpa2326_sleep() - Disable device, i.e. switch to low power mode.
244 * @indio_dev: The IIO device associated with the hardware to disable.
246 * Only %ZPA2326_DEVICE_ID_REG and %ZPA2326_CTRL_REG0_REG registers may be
247 * accessed once device is in the disabled state.
249 * Return: Zero when successful, a negative error code otherwise.
251 static int zpa2326_sleep(const struct iio_dev
*indio_dev
)
255 err
= regmap_write(((struct zpa2326_private
*)
256 iio_priv(indio_dev
))->regmap
,
257 ZPA2326_CTRL_REG0_REG
, 0);
259 zpa2326_err(indio_dev
, "failed to sleep (%d)", err
);
263 zpa2326_dbg(indio_dev
, "sleeping");
269 * zpa2326_reset_device() - Reset device to default hardware state.
270 * @indio_dev: The IIO device associated with the hardware to reset.
272 * Disable sampling and empty hardware FIFO.
273 * Device must be enabled before reset, i.e. not in low power mode.
275 * Return: Zero when successful, a negative error code otherwise.
277 static int zpa2326_reset_device(const struct iio_dev
*indio_dev
)
281 err
= regmap_write(((struct zpa2326_private
*)
282 iio_priv(indio_dev
))->regmap
,
283 ZPA2326_CTRL_REG2_REG
, ZPA2326_CTRL_REG2_SWRESET
);
285 zpa2326_err(indio_dev
, "failed to reset device (%d)", err
);
289 usleep_range(ZPA2326_TPUP_USEC_MIN
, ZPA2326_TPUP_USEC_MAX
);
291 zpa2326_dbg(indio_dev
, "reset");
297 * zpa2326_start_oneshot() - Start a single sampling cycle, i.e. in one shot
299 * @indio_dev: The IIO device associated with the sampling hardware.
301 * Device must have been previously enabled and configured for one shot mode.
302 * Device will be switched back to low power mode at end of cycle.
304 * Return: Zero when successful, a negative error code otherwise.
306 static int zpa2326_start_oneshot(const struct iio_dev
*indio_dev
)
310 err
= regmap_write(((struct zpa2326_private
*)
311 iio_priv(indio_dev
))->regmap
,
312 ZPA2326_CTRL_REG0_REG
,
313 ZPA2326_CTRL_REG0_ENABLE
|
314 ZPA2326_CTRL_REG0_ONE_SHOT
);
316 zpa2326_err(indio_dev
, "failed to start one shot cycle (%d)",
321 zpa2326_dbg(indio_dev
, "one shot cycle started");
327 * zpa2326_power_on() - Power on device to allow subsequent configuration.
328 * @indio_dev: The IIO device associated with the sampling hardware.
329 * @private: Internal private state related to @indio_dev.
331 * Sampling will be disabled, preventing strange things from happening in our
332 * back. Hardware FIFO content will be cleared.
333 * When successful, device will be left in the enabled state to allow further
336 * Return: Zero when successful, a negative error code otherwise.
338 static int zpa2326_power_on(const struct iio_dev
*indio_dev
,
339 const struct zpa2326_private
*private)
343 err
= regulator_enable(private->vref
);
347 err
= regulator_enable(private->vdd
);
351 zpa2326_dbg(indio_dev
, "powered on");
353 err
= zpa2326_enable_device(indio_dev
);
357 err
= zpa2326_reset_device(indio_dev
);
364 zpa2326_sleep(indio_dev
);
366 regulator_disable(private->vdd
);
368 regulator_disable(private->vref
);
370 zpa2326_dbg(indio_dev
, "powered off");
376 * zpa2326_power_off() - Power off device, i.e. disable attached power
378 * @indio_dev: The IIO device associated with the sampling hardware.
379 * @private: Internal private state related to @indio_dev.
381 * Return: Zero when successful, a negative error code otherwise.
383 static void zpa2326_power_off(const struct iio_dev
*indio_dev
,
384 const struct zpa2326_private
*private)
386 regulator_disable(private->vdd
);
387 regulator_disable(private->vref
);
389 zpa2326_dbg(indio_dev
, "powered off");
393 * zpa2326_config_oneshot() - Setup device for one shot / on demand mode.
394 * @indio_dev: The IIO device associated with the sampling hardware.
395 * @irq: Optional interrupt line the hardware uses to notify new data
396 * samples are ready. Negative or zero values indicate no interrupts
397 * are available, meaning polling is required.
399 * Output Data Rate is configured for the highest possible rate so that
400 * conversion time and power consumption are reduced to a minimum.
401 * Note that hardware internal averaging machinery (not implemented in this
402 * driver) is not applicable in this mode.
404 * Device must have been previously enabled before calling
405 * zpa2326_config_oneshot().
407 * Return: Zero when successful, a negative error code otherwise.
409 static int zpa2326_config_oneshot(const struct iio_dev
*indio_dev
,
412 struct regmap
*regs
= ((struct zpa2326_private
*)
413 iio_priv(indio_dev
))->regmap
;
414 const struct zpa2326_frequency
*freq
= zpa2326_highest_frequency();
417 /* Setup highest available Output Data Rate for one shot mode. */
418 err
= regmap_write(regs
, ZPA2326_CTRL_REG3_REG
, freq
->odr
);
423 /* Request interrupt when new sample is available. */
424 err
= regmap_write(regs
, ZPA2326_CTRL_REG1_REG
,
425 (u8
)~ZPA2326_CTRL_REG1_MASK_DATA_READY
);
428 dev_err(indio_dev
->dev
.parent
,
429 "failed to setup one shot mode (%d)", err
);
434 zpa2326_dbg(indio_dev
, "one shot mode setup @%dHz", freq
->hz
);
440 * zpa2326_clear_fifo() - Clear remaining entries in hardware FIFO.
441 * @indio_dev: The IIO device associated with the sampling hardware.
442 * @min_count: Number of samples present within hardware FIFO.
444 * @min_count argument is a hint corresponding to the known minimum number of
445 * samples currently living in the FIFO. This allows to reduce the number of bus
446 * accesses by skipping status register read operation as long as we know for
447 * sure there are still entries left.
449 * Return: Zero when successful, a negative error code otherwise.
451 static int zpa2326_clear_fifo(const struct iio_dev
*indio_dev
,
452 unsigned int min_count
)
454 struct regmap
*regs
= ((struct zpa2326_private
*)
455 iio_priv(indio_dev
))->regmap
;
461 * No hint: read status register to determine whether FIFO is
464 err
= regmap_read(regs
, ZPA2326_STATUS_REG
, &val
);
469 if (val
& ZPA2326_STATUS_FIFO_E
)
470 /* Fifo is empty: nothing to trash. */
477 * A single fetch from pressure MSB register is enough to pop
478 * values out of FIFO.
480 err
= regmap_read(regs
, ZPA2326_PRESS_OUT_H_REG
, &val
);
486 * We know for sure there are at least min_count entries
487 * left in FIFO. Skip status register read.
493 err
= regmap_read(regs
, ZPA2326_STATUS_REG
, &val
);
497 } while (!(val
& ZPA2326_STATUS_FIFO_E
));
499 zpa2326_dbg(indio_dev
, "FIFO cleared");
504 zpa2326_err(indio_dev
, "failed to clear FIFO (%d)", err
);
510 * zpa2326_dequeue_pressure() - Retrieve the most recent pressure sample from
512 * @indio_dev: The IIO device associated with the sampling hardware.
513 * @pressure: Sampled pressure output.
515 * Note that ZPA2326 hardware FIFO stores pressure samples only.
517 * Return: Zero when successful, a negative error code otherwise.
519 static int zpa2326_dequeue_pressure(const struct iio_dev
*indio_dev
,
522 struct regmap
*regs
= ((struct zpa2326_private
*)
523 iio_priv(indio_dev
))->regmap
;
528 err
= regmap_read(regs
, ZPA2326_STATUS_REG
, &val
);
534 if (val
& ZPA2326_STATUS_P_OR
) {
536 * Fifo overrun : first sample dequeued from FIFO is the
539 zpa2326_warn(indio_dev
, "FIFO overflow");
541 err
= regmap_bulk_read(regs
, ZPA2326_PRESS_OUT_XL_REG
, pressure
,
546 #define ZPA2326_FIFO_DEPTH (16U)
547 /* Hardware FIFO may hold no more than 16 pressure samples. */
548 return zpa2326_clear_fifo(indio_dev
, ZPA2326_FIFO_DEPTH
- 1);
552 * Fifo has not overflown : retrieve newest sample. We need to pop
553 * values out until FIFO is empty : last fetched pressure is the newest.
554 * In nominal cases, we should find a single queued sample only.
557 err
= regmap_bulk_read(regs
, ZPA2326_PRESS_OUT_XL_REG
, pressure
,
562 err
= regmap_read(regs
, ZPA2326_STATUS_REG
, &val
);
567 } while (!(val
& ZPA2326_STATUS_FIFO_E
));
571 * Samples were pushed by hardware during previous rounds but we
572 * didn't consume them fast enough: inform user.
574 zpa2326_dbg(indio_dev
, "cleared %d FIFO entries", cleared
);
580 * zpa2326_fill_sample_buffer() - Enqueue new channel samples to IIO buffer.
581 * @indio_dev: The IIO device associated with the sampling hardware.
582 * @private: Internal private state related to @indio_dev.
584 * Return: Zero when successful, a negative error code otherwise.
586 static int zpa2326_fill_sample_buffer(struct iio_dev
*indio_dev
,
587 const struct zpa2326_private
*private)
596 if (test_bit(0, indio_dev
->active_scan_mask
)) {
597 /* Get current pressure from hardware FIFO. */
598 err
= zpa2326_dequeue_pressure(indio_dev
, &sample
.pressure
);
600 zpa2326_warn(indio_dev
, "failed to fetch pressure (%d)",
606 if (test_bit(1, indio_dev
->active_scan_mask
)) {
607 /* Get current temperature. */
608 err
= regmap_bulk_read(private->regmap
, ZPA2326_TEMP_OUT_L_REG
,
609 &sample
.temperature
, 2);
611 zpa2326_warn(indio_dev
,
612 "failed to fetch temperature (%d)", err
);
618 * Now push samples using timestamp stored either :
619 * - by hardware interrupt handler if interrupt is available: see
620 * zpa2326_handle_irq(),
621 * - or oneshot completion polling machinery : see
622 * zpa2326_trigger_handler().
624 zpa2326_dbg(indio_dev
, "filling raw samples buffer");
626 iio_push_to_buffers_with_timestamp(indio_dev
, &sample
,
633 static int zpa2326_runtime_suspend(struct device
*parent
)
635 const struct iio_dev
*indio_dev
= dev_get_drvdata(parent
);
637 if (pm_runtime_autosuspend_expiration(parent
))
638 /* Userspace changed autosuspend delay. */
641 zpa2326_power_off(indio_dev
, iio_priv(indio_dev
));
646 static int zpa2326_runtime_resume(struct device
*parent
)
648 const struct iio_dev
*indio_dev
= dev_get_drvdata(parent
);
650 return zpa2326_power_on(indio_dev
, iio_priv(indio_dev
));
653 const struct dev_pm_ops zpa2326_pm_ops
= {
654 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend
,
655 pm_runtime_force_resume
)
656 SET_RUNTIME_PM_OPS(zpa2326_runtime_suspend
, zpa2326_runtime_resume
,
659 EXPORT_SYMBOL_GPL(zpa2326_pm_ops
);
662 * zpa2326_resume() - Request the PM layer to power supply the device.
663 * @indio_dev: The IIO device associated with the sampling hardware.
666 * < 0 - a negative error code meaning failure ;
667 * 0 - success, device has just been powered up ;
668 * 1 - success, device was already powered.
670 static int zpa2326_resume(const struct iio_dev
*indio_dev
)
674 err
= pm_runtime_get_sync(indio_dev
->dev
.parent
);
680 * Device was already power supplied: get it out of low power
681 * mode and inform caller.
683 zpa2326_enable_device(indio_dev
);
687 /* Inform caller device has just been brought back to life. */
692 * zpa2326_suspend() - Schedule a power down using autosuspend feature of PM
694 * @indio_dev: The IIO device associated with the sampling hardware.
696 * Device is switched to low power mode at first to save power even when
697 * attached regulator is a "dummy" one.
699 static void zpa2326_suspend(struct iio_dev
*indio_dev
)
701 struct device
*parent
= indio_dev
->dev
.parent
;
703 zpa2326_sleep(indio_dev
);
705 pm_runtime_mark_last_busy(parent
);
706 pm_runtime_put_autosuspend(parent
);
709 static void zpa2326_init_runtime(struct device
*parent
)
711 pm_runtime_get_noresume(parent
);
712 pm_runtime_set_active(parent
);
713 pm_runtime_enable(parent
);
714 pm_runtime_set_autosuspend_delay(parent
, 1000);
715 pm_runtime_use_autosuspend(parent
);
716 pm_runtime_mark_last_busy(parent
);
717 pm_runtime_put_autosuspend(parent
);
720 static void zpa2326_fini_runtime(struct device
*parent
)
722 pm_runtime_disable(parent
);
723 pm_runtime_set_suspended(parent
);
725 #else /* !CONFIG_PM */
726 static int zpa2326_resume(const struct iio_dev
*indio_dev
)
728 zpa2326_enable_device(indio_dev
);
733 static void zpa2326_suspend(struct iio_dev
*indio_dev
)
735 zpa2326_sleep(indio_dev
);
738 #define zpa2326_init_runtime(_parent)
739 #define zpa2326_fini_runtime(_parent)
740 #endif /* !CONFIG_PM */
743 * zpa2326_handle_irq() - Process hardware interrupts.
744 * @irq: Interrupt line the hardware uses to notify new data has arrived.
745 * @data: The IIO device associated with the sampling hardware.
747 * Timestamp buffered samples as soon as possible then schedule threaded bottom
750 * Return: Always successful.
752 static irqreturn_t
zpa2326_handle_irq(int irq
, void *data
)
754 struct iio_dev
*indio_dev
= data
;
756 if (iio_buffer_enabled(indio_dev
)) {
757 /* Timestamping needed for buffered sampling only. */
758 ((struct zpa2326_private
*)
759 iio_priv(indio_dev
))->timestamp
= iio_get_time_ns(indio_dev
);
762 return IRQ_WAKE_THREAD
;
766 * zpa2326_handle_threaded_irq() - Interrupt bottom-half handler.
767 * @irq: Interrupt line the hardware uses to notify new data has arrived.
768 * @data: The IIO device associated with the sampling hardware.
770 * Mainly ensures interrupt is caused by a real "new sample available"
771 * condition. This relies upon the ability to perform blocking / sleeping bus
772 * accesses to slave's registers. This is why zpa2326_handle_threaded_irq() is
773 * called from within a thread, i.e. not called from hard interrupt context.
775 * When device is using its own internal hardware trigger in continuous sampling
776 * mode, data are available into hardware FIFO once interrupt has occurred. All
777 * we have to do is to dispatch the trigger, which in turn will fetch data and
780 * When not using its own internal hardware trigger, the device has been
781 * configured in one-shot mode either by an external trigger or the IIO read_raw
782 * hook. This means one of the latter is currently waiting for sampling
783 * completion, in which case we must simply wake it up.
785 * See zpa2326_trigger_handler().
788 * %IRQ_NONE - no consistent interrupt happened ;
789 * %IRQ_HANDLED - there was new samples available.
791 static irqreturn_t
zpa2326_handle_threaded_irq(int irq
, void *data
)
793 struct iio_dev
*indio_dev
= data
;
794 struct zpa2326_private
*priv
= iio_priv(indio_dev
);
797 irqreturn_t ret
= IRQ_NONE
;
800 * Are we using our own internal trigger in triggered buffer mode, i.e.,
801 * currently working in continuous sampling mode ?
803 cont
= (iio_buffer_enabled(indio_dev
) &&
804 iio_trigger_using_own(indio_dev
));
807 * Device works according to a level interrupt scheme: reading interrupt
808 * status de-asserts interrupt line.
810 priv
->result
= regmap_read(priv
->regmap
, ZPA2326_INT_SOURCE_REG
, &val
);
811 if (priv
->result
< 0) {
818 /* Data ready is the only interrupt source we requested. */
819 if (!(val
& ZPA2326_INT_SOURCE_DATA_READY
)) {
821 * Interrupt happened but no new sample available: likely caused
822 * by spurious interrupts, in which case, returning IRQ_NONE
823 * allows to benefit from the generic spurious interrupts
826 zpa2326_warn(indio_dev
, "unexpected interrupt status %02x",
832 priv
->result
= -ENODATA
;
836 /* New sample available: dispatch internal trigger consumers. */
837 iio_trigger_poll_chained(priv
->trigger
);
841 * Internal hardware trigger has been scheduled above : it will
842 * fetch data on its own.
850 * Wake up direct or externaly triggered buffer mode waiters: see
851 * zpa2326_sample_oneshot() and zpa2326_trigger_handler().
853 complete(&priv
->data_ready
);
859 * zpa2326_wait_oneshot_completion() - Wait for oneshot data ready interrupt.
860 * @indio_dev: The IIO device associated with the sampling hardware.
861 * @private: Internal private state related to @indio_dev.
863 * Return: Zero when successful, a negative error code otherwise.
865 static int zpa2326_wait_oneshot_completion(const struct iio_dev
*indio_dev
,
866 struct zpa2326_private
*private)
872 zpa2326_dbg(indio_dev
, "waiting for one shot completion interrupt");
874 timeout
= wait_for_completion_interruptible_timeout(
875 &private->data_ready
, ZPA2326_CONVERSION_JIFFIES
);
878 * Interrupt handler completed before timeout: return operation
881 return private->result
;
883 /* Clear all interrupts just to be sure. */
884 regmap_read(private->regmap
, ZPA2326_INT_SOURCE_REG
, &val
);
888 zpa2326_warn(indio_dev
, "no one shot interrupt occurred (%ld)",
891 } else if (timeout
< 0) {
892 zpa2326_warn(indio_dev
,
893 "wait for one shot interrupt cancelled");
900 static int zpa2326_init_managed_irq(struct device
*parent
,
901 struct iio_dev
*indio_dev
,
902 struct zpa2326_private
*private,
911 * Platform declared no interrupt line: device will be polled
912 * for data availability.
914 dev_info(parent
, "no interrupt found, running in polling mode");
918 init_completion(&private->data_ready
);
920 /* Request handler to be scheduled into threaded interrupt context. */
921 err
= devm_request_threaded_irq(parent
, irq
, zpa2326_handle_irq
,
922 zpa2326_handle_threaded_irq
,
923 IRQF_TRIGGER_RISING
| IRQF_ONESHOT
,
924 dev_name(parent
), indio_dev
);
926 dev_err(parent
, "failed to request interrupt %d (%d)", irq
,
931 dev_info(parent
, "using interrupt %d", irq
);
937 * zpa2326_poll_oneshot_completion() - Actively poll for one shot data ready.
938 * @indio_dev: The IIO device associated with the sampling hardware.
940 * Loop over registers content to detect end of sampling cycle. Used when DT
941 * declared no valid interrupt lines.
943 * Return: Zero when successful, a negative error code otherwise.
945 static int zpa2326_poll_oneshot_completion(const struct iio_dev
*indio_dev
)
947 unsigned long tmout
= jiffies
+ ZPA2326_CONVERSION_JIFFIES
;
948 struct regmap
*regs
= ((struct zpa2326_private
*)
949 iio_priv(indio_dev
))->regmap
;
953 zpa2326_dbg(indio_dev
, "polling for one shot completion");
956 * At least, 100 ms is needed for the device to complete its one-shot
959 if (msleep_interruptible(100))
962 /* Poll for conversion completion in hardware. */
964 err
= regmap_read(regs
, ZPA2326_CTRL_REG0_REG
, &val
);
968 if (!(val
& ZPA2326_CTRL_REG0_ONE_SHOT
))
969 /* One-shot bit self clears at conversion end. */
972 if (time_after(jiffies
, tmout
)) {
973 /* Prevent from waiting forever : let's time out. */
978 usleep_range(10000, 20000);
982 * In oneshot mode, pressure sample availability guarantees that
983 * temperature conversion has also completed : just check pressure
984 * status bit to keep things simple.
986 err
= regmap_read(regs
, ZPA2326_STATUS_REG
, &val
);
990 if (!(val
& ZPA2326_STATUS_P_DA
)) {
991 /* No sample available. */
999 zpa2326_warn(indio_dev
, "failed to poll one shot completion (%d)", err
);
1005 * zpa2326_fetch_raw_sample() - Retrieve a raw sample and convert it to CPU
1007 * @indio_dev: The IIO device associated with the sampling hardware.
1008 * @type: Type of measurement / channel to fetch from.
1009 * @value: Sample output.
1011 * Return: Zero when successful, a negative error code otherwise.
1013 static int zpa2326_fetch_raw_sample(const struct iio_dev
*indio_dev
,
1014 enum iio_chan_type type
,
1017 struct regmap
*regs
= ((struct zpa2326_private
*)
1018 iio_priv(indio_dev
))->regmap
;
1023 zpa2326_dbg(indio_dev
, "fetching raw pressure sample");
1025 err
= regmap_bulk_read(regs
, ZPA2326_PRESS_OUT_XL_REG
, value
,
1028 zpa2326_warn(indio_dev
, "failed to fetch pressure (%d)",
1033 /* Pressure is a 24 bits wide little-endian unsigned int. */
1034 *value
= (((u8
*)value
)[2] << 16) | (((u8
*)value
)[1] << 8) |
1040 zpa2326_dbg(indio_dev
, "fetching raw temperature sample");
1042 err
= regmap_bulk_read(regs
, ZPA2326_TEMP_OUT_L_REG
, value
, 2);
1044 zpa2326_warn(indio_dev
,
1045 "failed to fetch temperature (%d)", err
);
1049 /* Temperature is a 16 bits wide little-endian signed int. */
1050 *value
= (int)le16_to_cpup((__le16
*)value
);
1060 * zpa2326_sample_oneshot() - Perform a complete one shot sampling cycle.
1061 * @indio_dev: The IIO device associated with the sampling hardware.
1062 * @type: Type of measurement / channel to fetch from.
1063 * @value: Sample output.
1065 * Return: Zero when successful, a negative error code otherwise.
1067 static int zpa2326_sample_oneshot(struct iio_dev
*indio_dev
,
1068 enum iio_chan_type type
,
1072 struct zpa2326_private
*priv
;
1074 ret
= iio_device_claim_direct_mode(indio_dev
);
1078 ret
= zpa2326_resume(indio_dev
);
1082 priv
= iio_priv(indio_dev
);
1086 * We were already power supplied. Just clear hardware FIFO to
1087 * get rid of samples acquired during previous rounds (if any).
1088 * Sampling operation always generates both temperature and
1089 * pressure samples. The latter are always enqueued into
1090 * hardware FIFO. This may lead to situations were pressure
1091 * samples still sit into FIFO when previous cycle(s) fetched
1092 * temperature data only.
1093 * Hence, we need to clear hardware FIFO content to prevent from
1094 * getting outdated values at the end of current cycle.
1096 if (type
== IIO_PRESSURE
) {
1097 ret
= zpa2326_clear_fifo(indio_dev
, 0);
1103 * We have just been power supplied, i.e. device is in default
1104 * "out of reset" state, meaning we need to reconfigure it
1107 ret
= zpa2326_config_oneshot(indio_dev
, priv
->irq
);
1112 /* Start a sampling cycle in oneshot mode. */
1113 ret
= zpa2326_start_oneshot(indio_dev
);
1117 /* Wait for sampling cycle to complete. */
1119 ret
= zpa2326_wait_oneshot_completion(indio_dev
, priv
);
1121 ret
= zpa2326_poll_oneshot_completion(indio_dev
);
1126 /* Retrieve raw sample value and convert it to CPU endianness. */
1127 ret
= zpa2326_fetch_raw_sample(indio_dev
, type
, value
);
1130 zpa2326_suspend(indio_dev
);
1132 iio_device_release_direct_mode(indio_dev
);
1138 * zpa2326_trigger_handler() - Perform an IIO buffered sampling round in one
1140 * @irq: The software interrupt assigned to @data
1141 * @data: The IIO poll function dispatched by external trigger our device is
1144 * Bottom-half handler called by the IIO trigger to which our device is
1145 * currently attached. Allows us to synchronize this device buffered sampling
1146 * either with external events (such as timer expiration, external device sample
1147 * ready, etc...) or with its own interrupt (internal hardware trigger).
1149 * When using an external trigger, basically run the same sequence of operations
1150 * as for zpa2326_sample_oneshot() with the following hereafter. Hardware FIFO
1151 * is not cleared since already done at buffering enable time and samples
1152 * dequeueing always retrieves the most recent value.
1154 * Otherwise, when internal hardware trigger has dispatched us, just fetch data
1155 * from hardware FIFO.
1157 * Fetched data will pushed unprocessed to IIO buffer since samples conversion
1158 * is delegated to userspace in buffered mode (endianness, etc...).
1161 * %IRQ_NONE - no consistent interrupt happened ;
1162 * %IRQ_HANDLED - there was new samples available.
1164 static irqreturn_t
zpa2326_trigger_handler(int irq
, void *data
)
1166 struct iio_dev
*indio_dev
= ((struct iio_poll_func
*)
1168 struct zpa2326_private
*priv
= iio_priv(indio_dev
);
1172 * We have been dispatched, meaning we are in triggered buffer mode.
1173 * Using our own internal trigger implies we are currently in continuous
1174 * hardware sampling mode.
1176 cont
= iio_trigger_using_own(indio_dev
);
1179 /* On demand sampling : start a one shot cycle. */
1180 if (zpa2326_start_oneshot(indio_dev
))
1183 /* Wait for sampling cycle to complete. */
1184 if (priv
->irq
<= 0) {
1185 /* No interrupt available: poll for completion. */
1186 if (zpa2326_poll_oneshot_completion(indio_dev
))
1189 /* Only timestamp sample once it is ready. */
1190 priv
->timestamp
= iio_get_time_ns(indio_dev
);
1192 /* Interrupt handlers will timestamp for us. */
1193 if (zpa2326_wait_oneshot_completion(indio_dev
, priv
))
1198 /* Enqueue to IIO buffer / userspace. */
1199 zpa2326_fill_sample_buffer(indio_dev
, priv
);
1203 /* Don't switch to low power if sampling continuously. */
1204 zpa2326_sleep(indio_dev
);
1206 /* Inform attached trigger we are done. */
1207 iio_trigger_notify_done(indio_dev
->trig
);
1213 * zpa2326_preenable_buffer() - Prepare device for configuring triggered
1216 * @indio_dev: The IIO device associated with the sampling hardware.
1218 * Basically power up device.
1219 * Called with IIO device's lock held.
1221 * Return: Zero when successful, a negative error code otherwise.
1223 static int zpa2326_preenable_buffer(struct iio_dev
*indio_dev
)
1225 int ret
= zpa2326_resume(indio_dev
);
1230 /* Tell zpa2326_postenable_buffer() if we have just been powered on. */
1231 ((struct zpa2326_private
*)
1232 iio_priv(indio_dev
))->waken
= iio_priv(indio_dev
);
1238 * zpa2326_postenable_buffer() - Configure device for triggered sampling.
1239 * @indio_dev: The IIO device associated with the sampling hardware.
1241 * Basically setup one-shot mode if plugging external trigger.
1242 * Otherwise, let internal trigger configure continuous sampling :
1243 * see zpa2326_set_trigger_state().
1245 * If an error is returned, IIO layer will call our postdisable hook for us,
1246 * i.e. no need to explicitly power device off here.
1247 * Called with IIO device's lock held.
1249 * Called with IIO device's lock held.
1251 * Return: Zero when successful, a negative error code otherwise.
1253 static int zpa2326_postenable_buffer(struct iio_dev
*indio_dev
)
1255 const struct zpa2326_private
*priv
= iio_priv(indio_dev
);
1260 * We were already power supplied. Just clear hardware FIFO to
1261 * get rid of samples acquired during previous rounds (if any).
1263 err
= zpa2326_clear_fifo(indio_dev
, 0);
1268 if (!iio_trigger_using_own(indio_dev
) && priv
->waken
) {
1270 * We are using an external trigger and we have just been
1271 * powered up: reconfigure one-shot mode.
1273 err
= zpa2326_config_oneshot(indio_dev
, priv
->irq
);
1278 /* Plug our own trigger event handler. */
1279 err
= iio_triggered_buffer_postenable(indio_dev
);
1286 zpa2326_err(indio_dev
, "failed to enable buffering (%d)", err
);
1291 static int zpa2326_postdisable_buffer(struct iio_dev
*indio_dev
)
1293 zpa2326_suspend(indio_dev
);
1298 static const struct iio_buffer_setup_ops zpa2326_buffer_setup_ops
= {
1299 .preenable
= zpa2326_preenable_buffer
,
1300 .postenable
= zpa2326_postenable_buffer
,
1301 .predisable
= iio_triggered_buffer_predisable
,
1302 .postdisable
= zpa2326_postdisable_buffer
1306 * zpa2326_set_trigger_state() - Start / stop continuous sampling.
1307 * @trig: The trigger being attached to IIO device associated with the sampling
1309 * @state: Tell whether to start (true) or stop (false)
1311 * Basically enable / disable hardware continuous sampling mode.
1313 * Called with IIO device's lock held at postenable() or predisable() time.
1315 * Return: Zero when successful, a negative error code otherwise.
1317 static int zpa2326_set_trigger_state(struct iio_trigger
*trig
, bool state
)
1319 const struct iio_dev
*indio_dev
= dev_get_drvdata(
1321 const struct zpa2326_private
*priv
= iio_priv(indio_dev
);
1326 * Switch trigger off : in case of failure, interrupt is left
1327 * disabled in order to prevent handler from accessing released
1333 * As device is working in continuous mode, handlers may be
1334 * accessing resources we are currently freeing...
1335 * Prevent this by disabling interrupt handlers and ensure
1336 * the device will generate no more interrupts unless explicitly
1337 * required to, i.e. by restoring back to default one shot mode.
1339 disable_irq(priv
->irq
);
1342 * Disable continuous sampling mode to restore settings for
1343 * one shot / direct sampling operations.
1345 err
= regmap_write(priv
->regmap
, ZPA2326_CTRL_REG3_REG
,
1346 zpa2326_highest_frequency()->odr
);
1351 * Now that device won't generate interrupts on its own,
1352 * acknowledge any currently active interrupts (may happen on
1353 * rare occasions while stopping continuous mode).
1355 err
= regmap_read(priv
->regmap
, ZPA2326_INT_SOURCE_REG
, &val
);
1360 * Re-enable interrupts only if we can guarantee the device will
1361 * generate no more interrupts to prevent handlers from
1362 * accessing released resources.
1364 enable_irq(priv
->irq
);
1366 zpa2326_dbg(indio_dev
, "continuous mode stopped");
1369 * Switch trigger on : start continuous sampling at required
1374 /* Enable interrupt if getting out of reset. */
1375 err
= regmap_write(priv
->regmap
, ZPA2326_CTRL_REG1_REG
,
1377 ~ZPA2326_CTRL_REG1_MASK_DATA_READY
);
1382 /* Enable continuous sampling at specified frequency. */
1383 err
= regmap_write(priv
->regmap
, ZPA2326_CTRL_REG3_REG
,
1384 ZPA2326_CTRL_REG3_ENABLE_MEAS
|
1385 priv
->frequency
->odr
);
1389 zpa2326_dbg(indio_dev
, "continuous mode setup @%dHz",
1390 priv
->frequency
->hz
);
1396 static const struct iio_trigger_ops zpa2326_trigger_ops
= {
1397 .owner
= THIS_MODULE
,
1398 .set_trigger_state
= zpa2326_set_trigger_state
,
1402 * zpa2326_init_trigger() - Create an interrupt driven / hardware trigger
1403 * allowing to notify external devices a new sample is
1405 * @parent: Hardware sampling device @indio_dev is a child of.
1406 * @indio_dev: The IIO device associated with the sampling hardware.
1407 * @private: Internal private state related to @indio_dev.
1408 * @irq: Optional interrupt line the hardware uses to notify new data
1409 * samples are ready. Negative or zero values indicate no interrupts
1410 * are available, meaning polling is required.
1412 * Only relevant when DT declares a valid interrupt line.
1414 * Return: Zero when successful, a negative error code otherwise.
1416 static int zpa2326_init_managed_trigger(struct device
*parent
,
1417 struct iio_dev
*indio_dev
,
1418 struct zpa2326_private
*private,
1421 struct iio_trigger
*trigger
;
1427 trigger
= devm_iio_trigger_alloc(parent
, "%s-dev%d",
1428 indio_dev
->name
, indio_dev
->id
);
1433 trigger
->dev
.parent
= parent
;
1434 trigger
->ops
= &zpa2326_trigger_ops
;
1436 private->trigger
= trigger
;
1438 /* Register to triggers space. */
1439 ret
= devm_iio_trigger_register(parent
, trigger
);
1441 dev_err(parent
, "failed to register hardware trigger (%d)",
1447 static int zpa2326_get_frequency(const struct iio_dev
*indio_dev
)
1449 return ((struct zpa2326_private
*)iio_priv(indio_dev
))->frequency
->hz
;
1452 static int zpa2326_set_frequency(struct iio_dev
*indio_dev
, int hz
)
1454 struct zpa2326_private
*priv
= iio_priv(indio_dev
);
1458 /* Check if requested frequency is supported. */
1459 for (freq
= 0; freq
< ARRAY_SIZE(zpa2326_sampling_frequencies
); freq
++)
1460 if (zpa2326_sampling_frequencies
[freq
].hz
== hz
)
1462 if (freq
== ARRAY_SIZE(zpa2326_sampling_frequencies
))
1465 /* Don't allow changing frequency if buffered sampling is ongoing. */
1466 err
= iio_device_claim_direct_mode(indio_dev
);
1470 priv
->frequency
= &zpa2326_sampling_frequencies
[freq
];
1472 iio_device_release_direct_mode(indio_dev
);
1477 /* Expose supported hardware sampling frequencies (Hz) through sysfs. */
1478 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("1 5 11 23");
1480 static struct attribute
*zpa2326_attributes
[] = {
1481 &iio_const_attr_sampling_frequency_available
.dev_attr
.attr
,
1485 static const struct attribute_group zpa2326_attribute_group
= {
1486 .attrs
= zpa2326_attributes
,
1489 static int zpa2326_read_raw(struct iio_dev
*indio_dev
,
1490 struct iio_chan_spec
const *chan
,
1496 case IIO_CHAN_INFO_RAW
:
1497 return zpa2326_sample_oneshot(indio_dev
, chan
->type
, val
);
1499 case IIO_CHAN_INFO_SCALE
:
1500 switch (chan
->type
) {
1503 * Pressure resolution is 1/64 Pascal. Scale to kPascal
1504 * as required by IIO ABI.
1508 return IIO_VAL_FRACTIONAL
;
1512 * Temperature follows the equation:
1513 * Temp[degC] = Tempcode * 0.00649 - 176.83
1515 * Tempcode is composed the raw sampled 16 bits.
1517 * Hence, to produce a temperature in milli-degrees
1518 * Celsius according to IIO ABI, we need to apply the
1519 * following equation to raw samples:
1520 * Temp[milli degC] = (Tempcode + Offset) * Scale
1522 * Offset = -176.83 / 0.00649
1523 * Scale = 0.00649 * 1000
1527 return IIO_VAL_INT_PLUS_MICRO
;
1533 case IIO_CHAN_INFO_OFFSET
:
1534 switch (chan
->type
) {
1538 return IIO_VAL_FRACTIONAL
;
1544 case IIO_CHAN_INFO_SAMP_FREQ
:
1545 *val
= zpa2326_get_frequency(indio_dev
);
1553 static int zpa2326_write_raw(struct iio_dev
*indio_dev
,
1554 const struct iio_chan_spec
*chan
,
1559 if ((mask
!= IIO_CHAN_INFO_SAMP_FREQ
) || val2
)
1562 return zpa2326_set_frequency(indio_dev
, val
);
1565 static const struct iio_chan_spec zpa2326_channels
[] = {
1567 .type
= IIO_PRESSURE
,
1573 .endianness
= IIO_LE
,
1575 .info_mask_separate
= BIT(IIO_CHAN_INFO_RAW
) |
1576 BIT(IIO_CHAN_INFO_SCALE
),
1577 .info_mask_shared_by_all
= BIT(IIO_CHAN_INFO_SAMP_FREQ
),
1586 .endianness
= IIO_LE
,
1588 .info_mask_separate
= BIT(IIO_CHAN_INFO_RAW
) |
1589 BIT(IIO_CHAN_INFO_SCALE
) |
1590 BIT(IIO_CHAN_INFO_OFFSET
),
1591 .info_mask_shared_by_all
= BIT(IIO_CHAN_INFO_SAMP_FREQ
),
1593 [2] = IIO_CHAN_SOFT_TIMESTAMP(2),
1596 static const struct iio_info zpa2326_info
= {
1597 .driver_module
= THIS_MODULE
,
1598 .attrs
= &zpa2326_attribute_group
,
1599 .read_raw
= zpa2326_read_raw
,
1600 .write_raw
= zpa2326_write_raw
,
1603 static struct iio_dev
*zpa2326_create_managed_iiodev(struct device
*device
,
1605 struct regmap
*regmap
)
1607 struct iio_dev
*indio_dev
;
1609 /* Allocate space to hold IIO device internal state. */
1610 indio_dev
= devm_iio_device_alloc(device
,
1611 sizeof(struct zpa2326_private
));
1615 /* Setup for userspace synchronous on demand sampling. */
1616 indio_dev
->modes
= INDIO_DIRECT_MODE
;
1617 indio_dev
->dev
.parent
= device
;
1618 indio_dev
->channels
= zpa2326_channels
;
1619 indio_dev
->num_channels
= ARRAY_SIZE(zpa2326_channels
);
1620 indio_dev
->name
= name
;
1621 indio_dev
->info
= &zpa2326_info
;
1626 int zpa2326_probe(struct device
*parent
,
1630 struct regmap
*regmap
)
1632 struct iio_dev
*indio_dev
;
1633 struct zpa2326_private
*priv
;
1637 indio_dev
= zpa2326_create_managed_iiodev(parent
, name
, regmap
);
1641 priv
= iio_priv(indio_dev
);
1643 priv
->vref
= devm_regulator_get(parent
, "vref");
1644 if (IS_ERR(priv
->vref
))
1645 return PTR_ERR(priv
->vref
);
1647 priv
->vdd
= devm_regulator_get(parent
, "vdd");
1648 if (IS_ERR(priv
->vdd
))
1649 return PTR_ERR(priv
->vdd
);
1651 /* Set default hardware sampling frequency to highest rate supported. */
1652 priv
->frequency
= zpa2326_highest_frequency();
1655 * Plug device's underlying bus abstraction : this MUST be set before
1656 * registering interrupt handlers since an interrupt might happen if
1657 * power up sequence is not properly applied.
1659 priv
->regmap
= regmap
;
1661 err
= devm_iio_triggered_buffer_setup(parent
, indio_dev
, NULL
,
1662 zpa2326_trigger_handler
,
1663 &zpa2326_buffer_setup_ops
);
1667 err
= zpa2326_init_managed_trigger(parent
, indio_dev
, priv
, irq
);
1671 err
= zpa2326_init_managed_irq(parent
, indio_dev
, priv
, irq
);
1675 /* Power up to check device ID and perform initial hardware setup. */
1676 err
= zpa2326_power_on(indio_dev
, priv
);
1680 /* Read id register to check we are talking to the right slave. */
1681 err
= regmap_read(regmap
, ZPA2326_DEVICE_ID_REG
, &id
);
1686 dev_err(parent
, "found device with unexpected id %02x", id
);
1691 err
= zpa2326_config_oneshot(indio_dev
, irq
);
1695 /* Setup done : go sleeping. Device will be awaken upon user request. */
1696 err
= zpa2326_sleep(indio_dev
);
1700 dev_set_drvdata(parent
, indio_dev
);
1702 zpa2326_init_runtime(parent
);
1704 err
= iio_device_register(indio_dev
);
1706 zpa2326_fini_runtime(parent
);
1713 /* Put to sleep just in case power regulators are "dummy" ones. */
1714 zpa2326_sleep(indio_dev
);
1716 zpa2326_power_off(indio_dev
, priv
);
1720 EXPORT_SYMBOL_GPL(zpa2326_probe
);
1722 void zpa2326_remove(const struct device
*parent
)
1724 struct iio_dev
*indio_dev
= dev_get_drvdata(parent
);
1726 iio_device_unregister(indio_dev
);
1727 zpa2326_fini_runtime(indio_dev
->dev
.parent
);
1728 zpa2326_sleep(indio_dev
);
1729 zpa2326_power_off(indio_dev
, iio_priv(indio_dev
));
1731 EXPORT_SYMBOL_GPL(zpa2326_remove
);
1733 MODULE_AUTHOR("Gregor Boirie <gregor.boirie@parrot.com>");
1734 MODULE_DESCRIPTION("Core driver for Murata ZPA2326 pressure sensor");
1735 MODULE_LICENSE("GPL v2");