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 */
67 static 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
78 static 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
83 static const struct regmap_range bm1390_precious_ranges[] = {
84 {
85 .range_min = BM1390_REG_STATUS,
86 .range_max = BM1390_REG_STATUS,
87 },
88 };
89
90 static 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
95 static 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
105 static 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
110 static 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
117 static 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
122 static 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
134 enum {
135 BM1390_STATE_SAMPLE,
136 BM1390_STATE_FIFO,
137 };
138
139 struct 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
148 struct 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
163 enum {
164 BM1390_CHAN_PRESSURE,
165 BM1390_CHAN_TEMP,
166 };
167
168 static 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 */
204 static const unsigned long bm1390_scan_masks[] = {
205 BIT(BM1390_CHAN_PRESSURE),
206 BIT(BM1390_CHAN_PRESSURE) | BIT(BM1390_CHAN_TEMP),
207 0
208 };
209
bm1390_read_temp(struct bm1390_data * data,int * temp)210 static int bm1390_read_temp(struct bm1390_data *data, int *temp)
211 {
212 __be16 temp_raw;
213 int ret;
214
215 ret = regmap_bulk_read(data->regmap, BM1390_REG_TEMP_HI, &temp_raw,
216 sizeof(temp_raw));
217 if (ret)
218 return ret;
219
220 *temp = be16_to_cpu(temp_raw);
221
222 return 0;
223 }
224
bm1390_pressure_read(struct bm1390_data * data,u32 * pressure)225 static 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(data->regmap, BM1390_REG_PRESSURE_BASE,
232 raw, 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 */
242 enum bm1390_meas_mode {
243 BM1390_MEAS_MODE_STOP = 0x0,
244 BM1390_MEAS_MODE_1SHOT = 0x1,
245 BM1390_MEAS_MODE_CONTINUOUS = 0x2,
246 };
247
bm1390_meas_set(struct bm1390_data * data,enum bm1390_meas_mode mode)248 static int bm1390_meas_set(struct bm1390_data *data, enum bm1390_meas_mode mode)
249 {
250 return regmap_update_bits(data->regmap, BM1390_REG_MODE_CTRL,
251 BM1390_MASK_MEAS_MODE, 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
bm1390_read_data(struct bm1390_data * data,struct iio_chan_spec const * chan,int * val,int * val2)262 static 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)(&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, 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, val);
280 break;
281 case IIO_TEMP:
282 msleep(BM1390_MAX_MEAS_TIME_MS);
283 ret = bm1390_read_temp(data, val);
284 break;
285 default:
286 ret = -EINVAL;
287 }
288 warn = bm1390_meas_set(data, 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
bm1390_read_raw(struct iio_dev * idev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)295 static 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(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 ret = iio_device_claim_direct_mode(idev);
323 if (ret)
324 return ret;
325
326 ret = bm1390_read_data(data, chan, val, val2);
327 iio_device_release_direct_mode(idev);
328 if (ret)
329 return ret;
330
331 return IIO_VAL_INT;
332 default:
333 return -EINVAL;
334 }
335 }
336
__bm1390_fifo_flush(struct iio_dev * idev,unsigned int samples,s64 timestamp)337 static int __bm1390_fifo_flush(struct iio_dev *idev, unsigned int samples,
338 s64 timestamp)
339 {
340 /* BM1390_FIFO_LENGTH is small so we shouldn't run out of stack */
341 struct bm1390_data_buf buffer[BM1390_FIFO_LENGTH];
342 struct bm1390_data *data = iio_priv(idev);
343 int smp_lvl, ret, i, warn, dummy;
344 u64 sample_period;
345 __be16 temp = 0;
346
347 ret = regmap_read(data->regmap, BM1390_REG_FIFO_LVL, &smp_lvl);
348 if (ret)
349 return ret;
350
351 smp_lvl = FIELD_GET(BM1390_MASK_FIFO_LVL, smp_lvl);
352 if (!smp_lvl)
353 return 0;
354
355 if (smp_lvl > BM1390_FIFO_LENGTH) {
356 /*
357 * The fifo holds maximum of 4 samples so valid values
358 * should be 0, 1, 2, 3, 4 - rest are probably bit errors
359 * in I2C line. Don't overflow if this happens.
360 */
361 dev_err(data->dev, "bad FIFO level %d\n", smp_lvl);
362 smp_lvl = BM1390_FIFO_LENGTH;
363 }
364
365 sample_period = timestamp - data->old_timestamp;
366 do_div(sample_period, smp_lvl);
367
368 if (samples && smp_lvl > samples)
369 smp_lvl = samples;
370
371
372 /*
373 * After some testing it appears that the temperature is not readable
374 * until the FIFO access has been done after the WMI. Thus, we need
375 * to read the all pressure values to memory and read the temperature
376 * only after that.
377 */
378 for (i = 0; i < smp_lvl; i++) {
379 /*
380 * When we start reading data from the FIFO the sensor goes to
381 * special FIFO reading mode. If any other register is accessed
382 * during the FIFO read, samples can be dropped. Prevent access
383 * until FIFO_LVL is read. We have mutex locked and we do also
384 * go performing reading of FIFO_LVL even if this read fails.
385 */
386 if (test_bit(BM1390_CHAN_PRESSURE, idev->active_scan_mask)) {
387 ret = bm1390_pressure_read(data, &buffer[i].pressure);
388 if (ret)
389 break;
390 }
391
392 /*
393 * Old timestamp is either the previous sample IRQ time,
394 * previous flush-time or, if this was first sample, the enable
395 * time. When we add a sample period to that we should get the
396 * best approximation of the time-stamp we are handling.
397 *
398 * Idea is to always keep the "old_timestamp" matching the
399 * timestamp which we are currently handling.
400 */
401 data->old_timestamp += sample_period;
402 buffer[i].ts = data->old_timestamp;
403 }
404 /* Reading the FIFO_LVL closes the FIFO access sequence */
405 warn = regmap_read(data->regmap, BM1390_REG_FIFO_LVL, &dummy);
406 if (warn)
407 dev_warn(data->dev, "Closing FIFO sequence failed\n");
408
409 if (ret)
410 return ret;
411
412 if (test_bit(BM1390_CHAN_TEMP, idev->active_scan_mask)) {
413 ret = regmap_bulk_read(data->regmap, BM1390_REG_TEMP_HI, &temp,
414 sizeof(temp));
415 if (ret)
416 return ret;
417 }
418
419 for (i = 0; i < smp_lvl; i++) {
420 buffer[i].temp = temp;
421 iio_push_to_buffers(idev, &buffer[i]);
422 }
423
424 return smp_lvl;
425 }
426
bm1390_fifo_flush(struct iio_dev * idev,unsigned int samples)427 static int bm1390_fifo_flush(struct iio_dev *idev, unsigned int samples)
428 {
429 struct bm1390_data *data = iio_priv(idev);
430 s64 timestamp;
431 int ret;
432
433 /*
434 * If fifo_flush is being called from IRQ handler we know the stored
435 * timestamp is fairly accurate for the last stored sample. If we are
436 * called as a result of a read operation from userspace and hence
437 * before the watermark interrupt was triggered, take a timestamp
438 * now. We can fall anywhere in between two samples so the error in this
439 * case is at most one sample period.
440 * We need to have the IRQ disabled or we risk of messing-up
441 * the timestamps. If we are ran from IRQ, then the
442 * IRQF_ONESHOT has us covered - but if we are ran by the
443 * user-space read we need to disable the IRQ to be on a safe
444 * side. We do this usng synchronous disable so that if the
445 * IRQ thread is being ran on other CPU we wait for it to be
446 * finished.
447 */
448
449 timestamp = iio_get_time_ns(idev);
450 mutex_lock(&data->mutex);
451 ret = __bm1390_fifo_flush(idev, samples, timestamp);
452 mutex_unlock(&data->mutex);
453
454 return ret;
455 }
456
bm1390_set_watermark(struct iio_dev * idev,unsigned int val)457 static int bm1390_set_watermark(struct iio_dev *idev, unsigned int val)
458 {
459 struct bm1390_data *data = iio_priv(idev);
460
461 if (val < BM1390_WMI_MIN || val > BM1390_WMI_MAX)
462 return -EINVAL;
463
464 mutex_lock(&data->mutex);
465 data->watermark = val;
466 mutex_unlock(&data->mutex);
467
468 return 0;
469 }
470
471 static const struct iio_info bm1390_noirq_info = {
472 .read_raw = &bm1390_read_raw,
473 };
474
475 static const struct iio_info bm1390_info = {
476 .read_raw = &bm1390_read_raw,
477 .hwfifo_set_watermark = bm1390_set_watermark,
478 .hwfifo_flush_to_buffer = bm1390_fifo_flush,
479 };
480
bm1390_chip_init(struct bm1390_data * data)481 static int bm1390_chip_init(struct bm1390_data *data)
482 {
483 int ret;
484
485 ret = regmap_write_bits(data->regmap, BM1390_REG_POWER,
486 BM1390_MASK_POWER, BM1390_POWER_ON);
487 if (ret)
488 return ret;
489
490 msleep(1);
491
492 ret = regmap_write_bits(data->regmap, BM1390_REG_RESET,
493 BM1390_MASK_RESET, BM1390_RESET);
494 if (ret)
495 return ret;
496
497 msleep(1);
498
499 ret = regmap_write_bits(data->regmap, BM1390_REG_RESET,
500 BM1390_MASK_RESET, BM1390_RESET_RELEASE);
501 if (ret)
502 return ret;
503
504 msleep(1);
505
506 ret = regmap_reinit_cache(data->regmap, &bm1390_regmap);
507 if (ret) {
508 dev_err(data->dev, "Failed to reinit reg cache\n");
509 return ret;
510 }
511
512 /*
513 * Default to use IIR filter in "middle" mode. Also the AVE_NUM must
514 * be fixed when IIR is in use.
515 */
516 ret = regmap_update_bits(data->regmap, BM1390_REG_MODE_CTRL,
517 BM1390_MASK_AVE_NUM, BM1390_IIR_AVE_NUM);
518 if (ret)
519 return ret;
520
521 return regmap_update_bits(data->regmap, BM1390_REG_FIFO_CTRL,
522 BM1390_MASK_IIR_MODE, BM1390_IIR_MODE_MID);
523 }
524
bm1390_fifo_set_wmi(struct bm1390_data * data)525 static int bm1390_fifo_set_wmi(struct bm1390_data *data)
526 {
527 u8 regval;
528
529 regval = FIELD_PREP(BM1390_MASK_FIFO_LEN,
530 data->watermark - BM1390_WMI_MIN);
531
532 return regmap_update_bits(data->regmap, BM1390_REG_FIFO_CTRL,
533 BM1390_MASK_FIFO_LEN, regval);
534 }
535
bm1390_fifo_enable(struct iio_dev * idev)536 static int bm1390_fifo_enable(struct iio_dev *idev)
537 {
538 struct bm1390_data *data = iio_priv(idev);
539 int ret;
540
541 /* We can't do buffered stuff without IRQ as we never get WMI */
542 if (data->irq <= 0)
543 return -EINVAL;
544
545 guard(mutex)(&data->mutex);
546
547 if (data->trigger_enabled)
548 return -EBUSY;
549
550 /* Update watermark to HW */
551 ret = bm1390_fifo_set_wmi(data);
552 if (ret)
553 return ret;
554
555 /* Enable WMI_IRQ */
556 ret = regmap_set_bits(data->regmap, BM1390_REG_MODE_CTRL,
557 BM1390_MASK_WMI_EN);
558 if (ret)
559 return ret;
560
561 /* Enable FIFO */
562 ret = regmap_set_bits(data->regmap, BM1390_REG_FIFO_CTRL,
563 BM1390_MASK_FIFO_EN);
564 if (ret)
565 return ret;
566
567 data->state = BM1390_STATE_FIFO;
568
569 data->old_timestamp = iio_get_time_ns(idev);
570
571 return bm1390_meas_set(data, BM1390_MEAS_MODE_CONTINUOUS);
572 }
573
bm1390_fifo_disable(struct iio_dev * idev)574 static int bm1390_fifo_disable(struct iio_dev *idev)
575 {
576 struct bm1390_data *data = iio_priv(idev);
577 int ret;
578
579 msleep(1);
580
581 guard(mutex)(&data->mutex);
582 ret = bm1390_meas_set(data, BM1390_MEAS_MODE_STOP);
583 if (ret)
584 return ret;
585
586 /* Disable FIFO */
587 ret = regmap_clear_bits(data->regmap, BM1390_REG_FIFO_CTRL,
588 BM1390_MASK_FIFO_EN);
589 if (ret)
590 return ret;
591
592 data->state = BM1390_STATE_SAMPLE;
593
594 /* Disable WMI_IRQ */
595 return regmap_clear_bits(data->regmap, BM1390_REG_MODE_CTRL,
596 BM1390_MASK_WMI_EN);
597 }
598
bm1390_buffer_postenable(struct iio_dev * idev)599 static int bm1390_buffer_postenable(struct iio_dev *idev)
600 {
601 /*
602 * If we use data-ready trigger, then the IRQ masks should be handled by
603 * trigger enable and the hardware buffer is not used but we just update
604 * results to the IIO FIFO when data-ready triggers.
605 */
606 if (iio_device_get_current_mode(idev) == INDIO_BUFFER_TRIGGERED)
607 return 0;
608
609 return bm1390_fifo_enable(idev);
610 }
611
bm1390_buffer_predisable(struct iio_dev * idev)612 static int bm1390_buffer_predisable(struct iio_dev *idev)
613 {
614 if (iio_device_get_current_mode(idev) == INDIO_BUFFER_TRIGGERED)
615 return 0;
616
617 return bm1390_fifo_disable(idev);
618 }
619
620 static const struct iio_buffer_setup_ops bm1390_buffer_ops = {
621 .postenable = bm1390_buffer_postenable,
622 .predisable = bm1390_buffer_predisable,
623 };
624
bm1390_trigger_handler(int irq,void * p)625 static irqreturn_t bm1390_trigger_handler(int irq, void *p)
626 {
627 struct iio_poll_func *pf = p;
628 struct iio_dev *idev = pf->indio_dev;
629 struct bm1390_data *data = iio_priv(idev);
630 int ret, status;
631
632 /* DRDY is acked by reading status reg */
633 ret = regmap_read(data->regmap, BM1390_REG_STATUS, &status);
634 if (ret || !status)
635 return IRQ_NONE;
636
637 dev_dbg(data->dev, "DRDY trig status 0x%x\n", status);
638
639 if (test_bit(BM1390_CHAN_PRESSURE, idev->active_scan_mask)) {
640 ret = bm1390_pressure_read(data, &data->buf.pressure);
641 if (ret) {
642 dev_warn(data->dev, "sample read failed %d\n", ret);
643 return IRQ_NONE;
644 }
645 }
646
647 if (test_bit(BM1390_CHAN_TEMP, idev->active_scan_mask)) {
648 ret = regmap_bulk_read(data->regmap, BM1390_REG_TEMP_HI,
649 &data->buf.temp, sizeof(data->buf.temp));
650 if (ret) {
651 dev_warn(data->dev, "temp read failed %d\n", ret);
652 return IRQ_HANDLED;
653 }
654 }
655
656 iio_push_to_buffers_with_timestamp(idev, &data->buf, data->timestamp);
657 iio_trigger_notify_done(idev->trig);
658
659 return IRQ_HANDLED;
660 }
661
662 /* Get timestamps and wake the thread if we need to read data */
bm1390_irq_handler(int irq,void * private)663 static irqreturn_t bm1390_irq_handler(int irq, void *private)
664 {
665 struct iio_dev *idev = private;
666 struct bm1390_data *data = iio_priv(idev);
667
668 data->timestamp = iio_get_time_ns(idev);
669
670 if (data->state == BM1390_STATE_FIFO || data->trigger_enabled)
671 return IRQ_WAKE_THREAD;
672
673 return IRQ_NONE;
674 }
675
bm1390_irq_thread_handler(int irq,void * private)676 static irqreturn_t bm1390_irq_thread_handler(int irq, void *private)
677 {
678 struct iio_dev *idev = private;
679 struct bm1390_data *data = iio_priv(idev);
680
681 guard(mutex)(&data->mutex);
682
683 if (data->trigger_enabled) {
684 iio_trigger_poll_nested(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 data->timestamp);
693 if (ok > 0)
694 return IRQ_HANDLED;
695 }
696
697 return IRQ_NONE;
698 }
699
bm1390_set_drdy_irq(struct bm1390_data * data,bool en)700 static int bm1390_set_drdy_irq(struct bm1390_data *data, bool en)
701 {
702 if (en)
703 return regmap_set_bits(data->regmap, BM1390_REG_MODE_CTRL,
704 BM1390_MASK_DRDY_EN);
705 return regmap_clear_bits(data->regmap, BM1390_REG_MODE_CTRL,
706 BM1390_MASK_DRDY_EN);
707 }
708
bm1390_trigger_set_state(struct iio_trigger * trig,bool state)709 static 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)(&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, BM1390_MEAS_MODE_CONTINUOUS);
729 if (ret)
730 return ret;
731 } else {
732 int dummy;
733
734 ret = bm1390_meas_set(data, 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(data->regmap, BM1390_REG_STATUS, &dummy);
744 if (ret)
745 dev_warn(data->dev, "status read failed\n");
746 }
747
748 return bm1390_set_drdy_irq(data, state);
749 }
750
751 static const struct iio_trigger_ops bm1390_trigger_ops = {
752 .set_trigger_state = bm1390_trigger_set_state,
753 };
754
bm1390_setup_buffer(struct bm1390_data * data,struct iio_dev * idev)755 static 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(data->dev, ret,
766 "iio_triggered_buffer_setup FAIL\n");
767
768 idev->available_scan_masks = bm1390_scan_masks;
769
770 return 0;
771 }
772
bm1390_setup_trigger(struct bm1390_data * data,struct iio_dev * idev,int irq)773 static 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(itrig, data);
789
790 name = devm_kasprintf(data->dev, GFP_KERNEL, "%s-bm1390",
791 dev_name(data->dev));
792 if (name == NULL)
793 return -ENOMEM;
794
795 ret = devm_request_threaded_irq(data->dev, irq, bm1390_irq_handler,
796 &bm1390_irq_thread_handler,
797 IRQF_ONESHOT, name, idev);
798 if (ret)
799 return dev_err_probe(data->dev, ret, "Could not request IRQ\n");
800
801
802 ret = devm_iio_trigger_register(data->dev, itrig);
803 if (ret)
804 return dev_err_probe(data->dev, ret,
805 "Trigger registration failed\n");
806
807 return 0;
808 }
809
bm1390_probe(struct i2c_client * i2c)810 static 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(regmap))
823 return dev_err_probe(dev, PTR_ERR(regmap),
824 "Failed to initialize Regmap\n");
825
826 ret = devm_regulator_get_enable(dev, "vdd");
827 if (ret)
828 return dev_err_probe(dev, ret, "Failed to get regulator\n");
829
830 ret = regmap_read(regmap, BM1390_REG_PART_ID, &part_id);
831 if (ret)
832 return dev_err_probe(dev, ret, "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(dev, sizeof(*data));
838 if (!idev)
839 return -ENOMEM;
840
841 data = iio_priv(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, ret, "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, 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, ret,
879 "Unable to register iio device\n");
880
881 return 0;
882 }
883
884 static const struct of_device_id bm1390_of_match[] = {
885 { .compatible = "rohm,bm1390glv-z" },
886 {}
887 };
888 MODULE_DEVICE_TABLE(of, bm1390_of_match);
889
890 static const struct i2c_device_id bm1390_id[] = {
891 { "bm1390glv-z", },
892 {}
893 };
894 MODULE_DEVICE_TABLE(i2c, bm1390_id);
895
896 static 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 };
909 module_i2c_driver(bm1390_driver);
910
911 MODULE_AUTHOR("Matti Vaittinen <[email protected]>");
912 MODULE_DESCRIPTION("Driver for ROHM BM1390 pressure sensor");
913 MODULE_LICENSE("GPL");
914