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