1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * BM1390 ROHM pressure sensor
4 *
5 * Copyright (c) 2023, ROHM Semiconductor.
6 * https://fscdn.rohm.com/en/products/databook/datasheet/ic/sensor/pressure/bm1390glv-z-e.pdf
7 */
8
9#include <linux/bitfield.h>
10#include <linux/bits.h>
11#include <linux/cleanup.h>
12#include <linux/device.h>
13#include <linux/i2c.h>
14#include <linux/module.h>
15#include <linux/regmap.h>
16#include <linux/regulator/consumer.h>
17
18#include <linux/iio/iio.h>
19#include <linux/iio/trigger.h>
20#include <linux/iio/trigger_consumer.h>
21#include <linux/iio/triggered_buffer.h>
22
23#define BM1390_REG_MANUFACT_ID 0x0f
24#define BM1390_REG_PART_ID 0x10
25#define BM1390_REG_POWER 0x12
26#define BM1390_MASK_POWER BIT(0)
27#define BM1390_POWER_ON BM1390_MASK_POWER
28#define BM1390_POWER_OFF 0x00
29#define BM1390_REG_RESET 0x13
30#define BM1390_MASK_RESET BIT(0)
31#define BM1390_RESET_RELEASE BM1390_MASK_RESET
32#define BM1390_RESET 0x00
33#define BM1390_REG_MODE_CTRL 0x14
34#define BM1390_MASK_MEAS_MODE GENMASK(1, 0)
35#define BM1390_MASK_DRDY_EN BIT(4)
36#define BM1390_MASK_WMI_EN BIT(2)
37#define BM1390_MASK_AVE_NUM GENMASK(7, 5)
38
39/*
40 * Data-sheet states that when the IIR is used, the AVE_NUM must be set to
41 * value 110b
42 */
43#define BM1390_IIR_AVE_NUM 0x06
44#define BM1390_REG_FIFO_CTRL 0x15
45#define BM1390_MASK_IIR_MODE GENMASK(1, 0)
46#define BM1390_IIR_MODE_OFF 0x0
47#define BM1390_IIR_MODE_WEAK 0x1
48#define BM1390_IIR_MODE_MID 0x2
49#define BM1390_IIR_MODE_STRONG 0x3
50
51#define BM1390_MASK_FIFO_LEN BIT(6)
52#define BM1390_MASK_FIFO_EN BIT(7)
53#define BM1390_WMI_MIN 2
54#define BM1390_WMI_MAX 3
55
56#define BM1390_REG_FIFO_LVL 0x18
57#define BM1390_MASK_FIFO_LVL GENMASK(2, 0)
58#define BM1390_REG_STATUS 0x19
59#define BM1390_REG_PRESSURE_BASE 0x1a
60#define BM1390_REG_TEMP_HI 0x1d
61#define BM1390_REG_TEMP_LO 0x1e
62#define BM1390_MAX_REGISTER BM1390_REG_TEMP_LO
63
64#define BM1390_ID 0x34
65
66/* Regmap configs */
67static const struct regmap_range bm1390_volatile_ranges[] = {
68 {
69 .range_min = BM1390_REG_STATUS,
70 .range_max = BM1390_REG_STATUS,
71 },
72 {
73 .range_min = BM1390_REG_FIFO_LVL,
74 .range_max = BM1390_REG_TEMP_LO,
75 },
76};
77
78static const struct regmap_access_table bm1390_volatile_regs = {
79 .yes_ranges = &bm1390_volatile_ranges[0],
80 .n_yes_ranges = ARRAY_SIZE(bm1390_volatile_ranges),
81};
82
83static const struct regmap_range bm1390_precious_ranges[] = {
84 {
85 .range_min = BM1390_REG_STATUS,
86 .range_max = BM1390_REG_STATUS,
87 },
88};
89
90static const struct regmap_access_table bm1390_precious_regs = {
91 .yes_ranges = &bm1390_precious_ranges[0],
92 .n_yes_ranges = ARRAY_SIZE(bm1390_precious_ranges),
93};
94
95static const struct regmap_range bm1390_read_only_ranges[] = {
96 {
97 .range_min = BM1390_REG_MANUFACT_ID,
98 .range_max = BM1390_REG_PART_ID,
99 }, {
100 .range_min = BM1390_REG_FIFO_LVL,
101 .range_max = BM1390_REG_TEMP_LO,
102 },
103};
104
105static const struct regmap_access_table bm1390_ro_regs = {
106 .no_ranges = &bm1390_read_only_ranges[0],
107 .n_no_ranges = ARRAY_SIZE(bm1390_read_only_ranges),
108};
109
110static const struct regmap_range bm1390_noinc_read_ranges[] = {
111 {
112 .range_min = BM1390_REG_PRESSURE_BASE,
113 .range_max = BM1390_REG_TEMP_LO,
114 },
115};
116
117static const struct regmap_access_table bm1390_nir_regs = {
118 .yes_ranges = &bm1390_noinc_read_ranges[0],
119 .n_yes_ranges = ARRAY_SIZE(bm1390_noinc_read_ranges),
120};
121
122static const struct regmap_config bm1390_regmap = {
123 .reg_bits = 8,
124 .val_bits = 8,
125 .volatile_table = &bm1390_volatile_regs,
126 .wr_table = &bm1390_ro_regs,
127 .rd_noinc_table = &bm1390_nir_regs,
128 .precious_table = &bm1390_precious_regs,
129 .max_register = BM1390_MAX_REGISTER,
130 .cache_type = REGCACHE_RBTREE,
131 .disable_locking = true,
132};
133
134enum {
135 BM1390_STATE_SAMPLE,
136 BM1390_STATE_FIFO,
137};
138
139struct bm1390_data_buf {
140 u32 pressure;
141 __be16 temp;
142 aligned_s64 ts;
143};
144
145/* BM1390 has FIFO for 4 pressure samples */
146#define BM1390_FIFO_LENGTH 4
147
148struct bm1390_data {
149 s64 timestamp, old_timestamp;
150 struct iio_trigger *trig;
151 struct regmap *regmap;
152 struct device *dev;
153 struct bm1390_data_buf buf;
154 int irq;
155 unsigned int state;
156 bool trigger_enabled;
157 u8 watermark;
158
159 /* Prevent accessing sensor during FIFO read sequence */
160 struct mutex mutex;
161};
162
163enum {
164 BM1390_CHAN_PRESSURE,
165 BM1390_CHAN_TEMP,
166};
167
168static const struct iio_chan_spec bm1390_channels[] = {
169 {
170 .type = IIO_PRESSURE,
171 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
172 /*
173 * When IIR is used, we must fix amount of averaged samples.
174 * Thus we don't allow setting oversampling ratio.
175 */
176 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
177 .scan_index = BM1390_CHAN_PRESSURE,
178 .scan_type = {
179 .sign = 'u',
180 .realbits = 22,
181 .storagebits = 32,
182 .endianness = IIO_LE,
183 },
184 },
185 {
186 .type = IIO_TEMP,
187 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
188 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
189 .scan_index = BM1390_CHAN_TEMP,
190 .scan_type = {
191 .sign = 's',
192 .realbits = 16,
193 .storagebits = 16,
194 .endianness = IIO_BE,
195 },
196 },
197 IIO_CHAN_SOFT_TIMESTAMP(2),
198};
199
200/*
201 * We can't skip reading the pressure because the watermark IRQ is acked
202 * only when the pressure data is read from the FIFO.
203 */
204static const unsigned long bm1390_scan_masks[] = {
205 BIT(BM1390_CHAN_PRESSURE),
206 BIT(BM1390_CHAN_PRESSURE) | BIT(BM1390_CHAN_TEMP),
207 0
208};
209
210static int bm1390_read_temp(struct bm1390_data *data, int *temp)
211{
212 __be16 temp_raw;
213 int ret;
214
215 ret = regmap_bulk_read(map: data->regmap, BM1390_REG_TEMP_HI, val: &temp_raw,
216 val_count: sizeof(temp_raw));
217 if (ret)
218 return ret;
219
220 *temp = be16_to_cpu(temp_raw);
221
222 return 0;
223}
224
225static int bm1390_pressure_read(struct bm1390_data *data, u32 *pressure)
226{
227 /* Pressure data is in 3 8-bit registers */
228 u8 raw[3];
229 int ret;
230
231 ret = regmap_bulk_read(map: data->regmap, BM1390_REG_PRESSURE_BASE,
232 val: raw, val_count: sizeof(raw));
233 if (ret < 0)
234 return ret;
235
236 *pressure = (u32)(raw[2] >> 2 | raw[1] << 6 | raw[0] << 14);
237
238 return 0;
239}
240
241 /* The enum values map directly to register bits */
242enum bm1390_meas_mode {
243 BM1390_MEAS_MODE_STOP = 0x0,
244 BM1390_MEAS_MODE_1SHOT = 0x1,
245 BM1390_MEAS_MODE_CONTINUOUS = 0x2,
246};
247
248static int bm1390_meas_set(struct bm1390_data *data, enum bm1390_meas_mode mode)
249{
250 return regmap_update_bits(map: data->regmap, BM1390_REG_MODE_CTRL,
251 BM1390_MASK_MEAS_MODE, val: mode);
252}
253
254/*
255 * If the trigger is not used we just wait until the measurement has
256 * completed. The data-sheet says maximum measurement cycle (regardless
257 * the AVE_NUM) is 200 mS so let's just sleep at least that long. If speed
258 * is needed the trigger should be used.
259 */
260#define BM1390_MAX_MEAS_TIME_MS 205
261
262static int bm1390_read_data(struct bm1390_data *data,
263 struct iio_chan_spec const *chan, int *val, int *val2)
264{
265 int ret, warn;
266
267 guard(mutex)(T: &data->mutex);
268 /*
269 * We use 'continuous mode' even for raw read because according to the
270 * data-sheet an one-shot mode can't be used with IIR filter.
271 */
272 ret = bm1390_meas_set(data, mode: BM1390_MEAS_MODE_CONTINUOUS);
273 if (ret)
274 return ret;
275
276 switch (chan->type) {
277 case IIO_PRESSURE:
278 msleep(BM1390_MAX_MEAS_TIME_MS);
279 ret = bm1390_pressure_read(data, pressure: val);
280 break;
281 case IIO_TEMP:
282 msleep(BM1390_MAX_MEAS_TIME_MS);
283 ret = bm1390_read_temp(data, temp: val);
284 break;
285 default:
286 ret = -EINVAL;
287 }
288 warn = bm1390_meas_set(data, mode: BM1390_MEAS_MODE_STOP);
289 if (warn)
290 dev_warn(data->dev, "Failed to stop measurement (%d)\n", warn);
291
292 return 0;
293}
294
295static int bm1390_read_raw(struct iio_dev *idev,
296 struct iio_chan_spec const *chan,
297 int *val, int *val2, long mask)
298{
299 struct bm1390_data *data = iio_priv(indio_dev: idev);
300 int ret;
301
302 switch (mask) {
303 case IIO_CHAN_INFO_SCALE:
304 if (chan->type == IIO_TEMP) {
305 *val = 31;
306 *val2 = 250000;
307
308 return IIO_VAL_INT_PLUS_MICRO;
309 } else if (chan->type == IIO_PRESSURE) {
310 /*
311 * pressure in hPa is register value divided by 2048.
312 * This means kPa is 1/20480 times the register value,
313 */
314 *val = 1;
315 *val2 = 2048;
316
317 return IIO_VAL_FRACTIONAL;
318 }
319
320 return -EINVAL;
321 case IIO_CHAN_INFO_RAW:
322 if (!iio_device_claim_direct(indio_dev: idev))
323 return -EBUSY;
324
325 ret = bm1390_read_data(data, chan, val, val2);
326 iio_device_release_direct(indio_dev: idev);
327 if (ret)
328 return ret;
329
330 return IIO_VAL_INT;
331 default:
332 return -EINVAL;
333 }
334}
335
336static int __bm1390_fifo_flush(struct iio_dev *idev, unsigned int samples,
337 s64 timestamp)
338{
339 /* BM1390_FIFO_LENGTH is small so we shouldn't run out of stack */
340 struct bm1390_data_buf buffer[BM1390_FIFO_LENGTH];
341 struct bm1390_data *data = iio_priv(indio_dev: idev);
342 int smp_lvl, ret, i, warn, dummy;
343 u64 sample_period;
344 __be16 temp = 0;
345
346 ret = regmap_read(map: data->regmap, BM1390_REG_FIFO_LVL, val: &smp_lvl);
347 if (ret)
348 return ret;
349
350 smp_lvl = FIELD_GET(BM1390_MASK_FIFO_LVL, smp_lvl);
351 if (!smp_lvl)
352 return 0;
353
354 if (smp_lvl > BM1390_FIFO_LENGTH) {
355 /*
356 * The fifo holds maximum of 4 samples so valid values
357 * should be 0, 1, 2, 3, 4 - rest are probably bit errors
358 * in I2C line. Don't overflow if this happens.
359 */
360 dev_err(data->dev, "bad FIFO level %d\n", smp_lvl);
361 smp_lvl = BM1390_FIFO_LENGTH;
362 }
363
364 sample_period = timestamp - data->old_timestamp;
365 do_div(sample_period, smp_lvl);
366
367 if (samples && smp_lvl > samples)
368 smp_lvl = samples;
369
370
371 /*
372 * After some testing it appears that the temperature is not readable
373 * until the FIFO access has been done after the WMI. Thus, we need
374 * to read the all pressure values to memory and read the temperature
375 * only after that.
376 */
377 for (i = 0; i < smp_lvl; i++) {
378 /*
379 * When we start reading data from the FIFO the sensor goes to
380 * special FIFO reading mode. If any other register is accessed
381 * during the FIFO read, samples can be dropped. Prevent access
382 * until FIFO_LVL is read. We have mutex locked and we do also
383 * go performing reading of FIFO_LVL even if this read fails.
384 */
385 if (test_bit(BM1390_CHAN_PRESSURE, idev->active_scan_mask)) {
386 ret = bm1390_pressure_read(data, pressure: &buffer[i].pressure);
387 if (ret)
388 break;
389 }
390
391 /*
392 * Old timestamp is either the previous sample IRQ time,
393 * previous flush-time or, if this was first sample, the enable
394 * time. When we add a sample period to that we should get the
395 * best approximation of the time-stamp we are handling.
396 *
397 * Idea is to always keep the "old_timestamp" matching the
398 * timestamp which we are currently handling.
399 */
400 data->old_timestamp += sample_period;
401 buffer[i].ts = data->old_timestamp;
402 }
403 /* Reading the FIFO_LVL closes the FIFO access sequence */
404 warn = regmap_read(map: data->regmap, BM1390_REG_FIFO_LVL, val: &dummy);
405 if (warn)
406 dev_warn(data->dev, "Closing FIFO sequence failed\n");
407
408 if (ret)
409 return ret;
410
411 if (test_bit(BM1390_CHAN_TEMP, idev->active_scan_mask)) {
412 ret = regmap_bulk_read(map: data->regmap, BM1390_REG_TEMP_HI, val: &temp,
413 val_count: sizeof(temp));
414 if (ret)
415 return ret;
416 }
417
418 for (i = 0; i < smp_lvl; i++) {
419 buffer[i].temp = temp;
420 iio_push_to_buffers(indio_dev: idev, data: &buffer[i]);
421 }
422
423 return smp_lvl;
424}
425
426static int bm1390_fifo_flush(struct iio_dev *idev, unsigned int samples)
427{
428 struct bm1390_data *data = iio_priv(indio_dev: idev);
429 s64 timestamp;
430 int ret;
431
432 /*
433 * If fifo_flush is being called from IRQ handler we know the stored
434 * timestamp is fairly accurate for the last stored sample. If we are
435 * called as a result of a read operation from userspace and hence
436 * before the watermark interrupt was triggered, take a timestamp
437 * now. We can fall anywhere in between two samples so the error in this
438 * case is at most one sample period.
439 * We need to have the IRQ disabled or we risk of messing-up
440 * the timestamps. If we are ran from IRQ, then the
441 * IRQF_ONESHOT has us covered - but if we are ran by the
442 * user-space read we need to disable the IRQ to be on a safe
443 * side. We do this usng synchronous disable so that if the
444 * IRQ thread is being ran on other CPU we wait for it to be
445 * finished.
446 */
447
448 timestamp = iio_get_time_ns(indio_dev: idev);
449 mutex_lock(&data->mutex);
450 ret = __bm1390_fifo_flush(idev, samples, timestamp);
451 mutex_unlock(lock: &data->mutex);
452
453 return ret;
454}
455
456static int bm1390_set_watermark(struct iio_dev *idev, unsigned int val)
457{
458 struct bm1390_data *data = iio_priv(indio_dev: idev);
459
460 if (val < BM1390_WMI_MIN || val > BM1390_WMI_MAX)
461 return -EINVAL;
462
463 mutex_lock(&data->mutex);
464 data->watermark = val;
465 mutex_unlock(lock: &data->mutex);
466
467 return 0;
468}
469
470static const struct iio_info bm1390_noirq_info = {
471 .read_raw = &bm1390_read_raw,
472};
473
474static const struct iio_info bm1390_info = {
475 .read_raw = &bm1390_read_raw,
476 .hwfifo_set_watermark = bm1390_set_watermark,
477 .hwfifo_flush_to_buffer = bm1390_fifo_flush,
478};
479
480static int bm1390_chip_init(struct bm1390_data *data)
481{
482 int ret;
483
484 ret = regmap_write_bits(map: data->regmap, BM1390_REG_POWER,
485 BM1390_MASK_POWER, BM1390_POWER_ON);
486 if (ret)
487 return ret;
488
489 msleep(msecs: 1);
490
491 ret = regmap_write_bits(map: data->regmap, BM1390_REG_RESET,
492 BM1390_MASK_RESET, BM1390_RESET);
493 if (ret)
494 return ret;
495
496 msleep(msecs: 1);
497
498 ret = regmap_write_bits(map: data->regmap, BM1390_REG_RESET,
499 BM1390_MASK_RESET, BM1390_RESET_RELEASE);
500 if (ret)
501 return ret;
502
503 msleep(msecs: 1);
504
505 ret = regmap_reinit_cache(map: data->regmap, config: &bm1390_regmap);
506 if (ret) {
507 dev_err(data->dev, "Failed to reinit reg cache\n");
508 return ret;
509 }
510
511 /*
512 * Default to use IIR filter in "middle" mode. Also the AVE_NUM must
513 * be fixed when IIR is in use.
514 */
515 ret = regmap_update_bits(map: data->regmap, BM1390_REG_MODE_CTRL,
516 BM1390_MASK_AVE_NUM, BM1390_IIR_AVE_NUM);
517 if (ret)
518 return ret;
519
520 return regmap_update_bits(map: data->regmap, BM1390_REG_FIFO_CTRL,
521 BM1390_MASK_IIR_MODE, BM1390_IIR_MODE_MID);
522}
523
524static int bm1390_fifo_set_wmi(struct bm1390_data *data)
525{
526 u8 regval;
527
528 regval = FIELD_PREP(BM1390_MASK_FIFO_LEN,
529 data->watermark - BM1390_WMI_MIN);
530
531 return regmap_update_bits(map: data->regmap, BM1390_REG_FIFO_CTRL,
532 BM1390_MASK_FIFO_LEN, val: regval);
533}
534
535static int bm1390_fifo_enable(struct iio_dev *idev)
536{
537 struct bm1390_data *data = iio_priv(indio_dev: idev);
538 int ret;
539
540 /* We can't do buffered stuff without IRQ as we never get WMI */
541 if (data->irq <= 0)
542 return -EINVAL;
543
544 guard(mutex)(T: &data->mutex);
545
546 if (data->trigger_enabled)
547 return -EBUSY;
548
549 /* Update watermark to HW */
550 ret = bm1390_fifo_set_wmi(data);
551 if (ret)
552 return ret;
553
554 /* Enable WMI_IRQ */
555 ret = regmap_set_bits(map: data->regmap, BM1390_REG_MODE_CTRL,
556 BM1390_MASK_WMI_EN);
557 if (ret)
558 return ret;
559
560 /* Enable FIFO */
561 ret = regmap_set_bits(map: data->regmap, BM1390_REG_FIFO_CTRL,
562 BM1390_MASK_FIFO_EN);
563 if (ret)
564 return ret;
565
566 data->state = BM1390_STATE_FIFO;
567
568 data->old_timestamp = iio_get_time_ns(indio_dev: idev);
569
570 return bm1390_meas_set(data, mode: BM1390_MEAS_MODE_CONTINUOUS);
571}
572
573static int bm1390_fifo_disable(struct iio_dev *idev)
574{
575 struct bm1390_data *data = iio_priv(indio_dev: idev);
576 int ret;
577
578 msleep(msecs: 1);
579
580 guard(mutex)(T: &data->mutex);
581 ret = bm1390_meas_set(data, mode: BM1390_MEAS_MODE_STOP);
582 if (ret)
583 return ret;
584
585 /* Disable FIFO */
586 ret = regmap_clear_bits(map: data->regmap, BM1390_REG_FIFO_CTRL,
587 BM1390_MASK_FIFO_EN);
588 if (ret)
589 return ret;
590
591 data->state = BM1390_STATE_SAMPLE;
592
593 /* Disable WMI_IRQ */
594 return regmap_clear_bits(map: data->regmap, BM1390_REG_MODE_CTRL,
595 BM1390_MASK_WMI_EN);
596}
597
598static int bm1390_buffer_postenable(struct iio_dev *idev)
599{
600 /*
601 * If we use data-ready trigger, then the IRQ masks should be handled by
602 * trigger enable and the hardware buffer is not used but we just update
603 * results to the IIO FIFO when data-ready triggers.
604 */
605 if (iio_device_get_current_mode(indio_dev: idev) == INDIO_BUFFER_TRIGGERED)
606 return 0;
607
608 return bm1390_fifo_enable(idev);
609}
610
611static int bm1390_buffer_predisable(struct iio_dev *idev)
612{
613 if (iio_device_get_current_mode(indio_dev: idev) == INDIO_BUFFER_TRIGGERED)
614 return 0;
615
616 return bm1390_fifo_disable(idev);
617}
618
619static const struct iio_buffer_setup_ops bm1390_buffer_ops = {
620 .postenable = bm1390_buffer_postenable,
621 .predisable = bm1390_buffer_predisable,
622};
623
624static irqreturn_t bm1390_trigger_handler(int irq, void *p)
625{
626 struct iio_poll_func *pf = p;
627 struct iio_dev *idev = pf->indio_dev;
628 struct bm1390_data *data = iio_priv(indio_dev: idev);
629 int ret, status;
630
631 /* DRDY is acked by reading status reg */
632 ret = regmap_read(map: data->regmap, BM1390_REG_STATUS, val: &status);
633 if (ret || !status)
634 return IRQ_NONE;
635
636 dev_dbg(data->dev, "DRDY trig status 0x%x\n", status);
637
638 if (test_bit(BM1390_CHAN_PRESSURE, idev->active_scan_mask)) {
639 ret = bm1390_pressure_read(data, pressure: &data->buf.pressure);
640 if (ret) {
641 dev_warn(data->dev, "sample read failed %d\n", ret);
642 return IRQ_NONE;
643 }
644 }
645
646 if (test_bit(BM1390_CHAN_TEMP, idev->active_scan_mask)) {
647 ret = regmap_bulk_read(map: data->regmap, BM1390_REG_TEMP_HI,
648 val: &data->buf.temp, val_count: sizeof(data->buf.temp));
649 if (ret) {
650 dev_warn(data->dev, "temp read failed %d\n", ret);
651 return IRQ_HANDLED;
652 }
653 }
654
655 iio_push_to_buffers_with_ts(indio_dev: idev, data: &data->buf, data_total_len: sizeof(data->buf),
656 timestamp: data->timestamp);
657 iio_trigger_notify_done(trig: idev->trig);
658
659 return IRQ_HANDLED;
660}
661
662/* Get timestamps and wake the thread if we need to read data */
663static irqreturn_t bm1390_irq_handler(int irq, void *private)
664{
665 struct iio_dev *idev = private;
666 struct bm1390_data *data = iio_priv(indio_dev: idev);
667
668 data->timestamp = iio_get_time_ns(indio_dev: idev);
669
670 if (data->state == BM1390_STATE_FIFO || data->trigger_enabled)
671 return IRQ_WAKE_THREAD;
672
673 return IRQ_NONE;
674}
675
676static irqreturn_t bm1390_irq_thread_handler(int irq, void *private)
677{
678 struct iio_dev *idev = private;
679 struct bm1390_data *data = iio_priv(indio_dev: idev);
680
681 guard(mutex)(T: &data->mutex);
682
683 if (data->trigger_enabled) {
684 iio_trigger_poll_nested(trig: data->trig);
685 return IRQ_HANDLED;
686 }
687
688 if (data->state == BM1390_STATE_FIFO) {
689 int ok;
690
691 ok = __bm1390_fifo_flush(idev, BM1390_FIFO_LENGTH,
692 timestamp: data->timestamp);
693 if (ok > 0)
694 return IRQ_HANDLED;
695 }
696
697 return IRQ_NONE;
698}
699
700static int bm1390_set_drdy_irq(struct bm1390_data *data, bool en)
701{
702 if (en)
703 return regmap_set_bits(map: data->regmap, BM1390_REG_MODE_CTRL,
704 BM1390_MASK_DRDY_EN);
705 return regmap_clear_bits(map: data->regmap, BM1390_REG_MODE_CTRL,
706 BM1390_MASK_DRDY_EN);
707}
708
709static int bm1390_trigger_set_state(struct iio_trigger *trig,
710 bool state)
711{
712 struct bm1390_data *data = iio_trigger_get_drvdata(trig);
713 int ret;
714
715 guard(mutex)(T: &data->mutex);
716
717 if (data->trigger_enabled == state)
718 return 0;
719
720 if (data->state == BM1390_STATE_FIFO) {
721 dev_warn(data->dev, "Can't set trigger when FIFO enabled\n");
722 return -EBUSY;
723 }
724
725 data->trigger_enabled = state;
726
727 if (state) {
728 ret = bm1390_meas_set(data, mode: BM1390_MEAS_MODE_CONTINUOUS);
729 if (ret)
730 return ret;
731 } else {
732 int dummy;
733
734 ret = bm1390_meas_set(data, mode: BM1390_MEAS_MODE_STOP);
735 if (ret)
736 return ret;
737
738 /*
739 * We need to read the status register in order to ACK the
740 * data-ready which may have been generated just before we
741 * disabled the measurement.
742 */
743 ret = regmap_read(map: data->regmap, BM1390_REG_STATUS, val: &dummy);
744 if (ret)
745 dev_warn(data->dev, "status read failed\n");
746 }
747
748 return bm1390_set_drdy_irq(data, en: state);
749}
750
751static const struct iio_trigger_ops bm1390_trigger_ops = {
752 .set_trigger_state = bm1390_trigger_set_state,
753};
754
755static int bm1390_setup_buffer(struct bm1390_data *data, struct iio_dev *idev)
756{
757 int ret;
758
759 ret = devm_iio_triggered_buffer_setup(data->dev, idev,
760 &iio_pollfunc_store_time,
761 &bm1390_trigger_handler,
762 &bm1390_buffer_ops);
763
764 if (ret)
765 return dev_err_probe(dev: data->dev, err: ret,
766 fmt: "iio_triggered_buffer_setup FAIL\n");
767
768 idev->available_scan_masks = bm1390_scan_masks;
769
770 return 0;
771}
772
773static int bm1390_setup_trigger(struct bm1390_data *data, struct iio_dev *idev,
774 int irq)
775{
776 struct iio_trigger *itrig;
777 char *name;
778 int ret;
779
780 itrig = devm_iio_trigger_alloc(data->dev, "%sdata-rdy-dev%d", idev->name,
781 iio_device_id(idev));
782 if (!itrig)
783 return -ENOMEM;
784
785 data->trig = itrig;
786
787 itrig->ops = &bm1390_trigger_ops;
788 iio_trigger_set_drvdata(trig: itrig, data);
789
790 name = devm_kasprintf(dev: data->dev, GFP_KERNEL, fmt: "%s-bm1390",
791 dev_name(dev: data->dev));
792 if (name == NULL)
793 return -ENOMEM;
794
795 ret = devm_request_threaded_irq(dev: data->dev, irq, handler: bm1390_irq_handler,
796 thread_fn: &bm1390_irq_thread_handler,
797 IRQF_ONESHOT, devname: name, dev_id: idev);
798 if (ret)
799 return dev_err_probe(dev: data->dev, err: ret, fmt: "Could not request IRQ\n");
800
801
802 ret = devm_iio_trigger_register(dev: data->dev, trig_info: itrig);
803 if (ret)
804 return dev_err_probe(dev: data->dev, err: ret,
805 fmt: "Trigger registration failed\n");
806
807 return 0;
808}
809
810static int bm1390_probe(struct i2c_client *i2c)
811{
812 struct bm1390_data *data;
813 struct regmap *regmap;
814 struct iio_dev *idev;
815 struct device *dev;
816 unsigned int part_id;
817 int ret;
818
819 dev = &i2c->dev;
820
821 regmap = devm_regmap_init_i2c(i2c, &bm1390_regmap);
822 if (IS_ERR(ptr: regmap))
823 return dev_err_probe(dev, err: PTR_ERR(ptr: regmap),
824 fmt: "Failed to initialize Regmap\n");
825
826 ret = devm_regulator_get_enable(dev, id: "vdd");
827 if (ret)
828 return dev_err_probe(dev, err: ret, fmt: "Failed to get regulator\n");
829
830 ret = regmap_read(map: regmap, BM1390_REG_PART_ID, val: &part_id);
831 if (ret)
832 return dev_err_probe(dev, err: ret, fmt: "Failed to access sensor\n");
833
834 if (part_id != BM1390_ID)
835 dev_warn(dev, "unknown device 0x%x\n", part_id);
836
837 idev = devm_iio_device_alloc(parent: dev, sizeof_priv: sizeof(*data));
838 if (!idev)
839 return -ENOMEM;
840
841 data = iio_priv(indio_dev: idev);
842 data->regmap = regmap;
843 data->dev = dev;
844 data->irq = i2c->irq;
845 /*
846 * For now we just allow BM1390_WMI_MIN to BM1390_WMI_MAX and
847 * discard every other configuration when triggered mode is not used.
848 */
849 data->watermark = BM1390_WMI_MAX;
850 mutex_init(&data->mutex);
851
852 idev->channels = bm1390_channels;
853 idev->num_channels = ARRAY_SIZE(bm1390_channels);
854 idev->name = "bm1390";
855 idev->modes = INDIO_DIRECT_MODE;
856
857 ret = bm1390_chip_init(data);
858 if (ret)
859 return dev_err_probe(dev, err: ret, fmt: "sensor init failed\n");
860
861 ret = bm1390_setup_buffer(data, idev);
862 if (ret)
863 return ret;
864
865 /* No trigger if we don't have IRQ for data-ready and WMI */
866 if (i2c->irq > 0) {
867 idev->info = &bm1390_info;
868 idev->modes |= INDIO_BUFFER_SOFTWARE;
869 ret = bm1390_setup_trigger(data, idev, irq: i2c->irq);
870 if (ret)
871 return ret;
872 } else {
873 idev->info = &bm1390_noirq_info;
874 }
875
876 ret = devm_iio_device_register(dev, idev);
877 if (ret < 0)
878 return dev_err_probe(dev, err: ret,
879 fmt: "Unable to register iio device\n");
880
881 return 0;
882}
883
884static const struct of_device_id bm1390_of_match[] = {
885 { .compatible = "rohm,bm1390glv-z" },
886 { }
887};
888MODULE_DEVICE_TABLE(of, bm1390_of_match);
889
890static const struct i2c_device_id bm1390_id[] = {
891 { "bm1390glv-z", },
892 { }
893};
894MODULE_DEVICE_TABLE(i2c, bm1390_id);
895
896static struct i2c_driver bm1390_driver = {
897 .driver = {
898 .name = "bm1390",
899 .of_match_table = bm1390_of_match,
900 /*
901 * Probing explicitly requires a few millisecond of sleep.
902 * Enabling the VDD regulator may include ramp up rates.
903 */
904 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
905 },
906 .probe = bm1390_probe,
907 .id_table = bm1390_id,
908};
909module_i2c_driver(bm1390_driver);
910
911MODULE_AUTHOR("Matti Vaittinen <mazziesaccount@gmail.com>");
912MODULE_DESCRIPTION("Driver for ROHM BM1390 pressure sensor");
913MODULE_LICENSE("GPL");
914

source code of linux/drivers/iio/pressure/rohm-bm1390.c