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