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