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