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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 */ 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 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 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 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 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 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 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 <mazziesaccount@gmail.com>"); 912 MODULE_DESCRIPTION("Driver for ROHM BM1390 pressure sensor"); 913 MODULE_LICENSE("GPL"); 914