1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2010 Christoph Mair <christoph.mair@gmail.com> 4 * Copyright (c) 2012 Bosch Sensortec GmbH 5 * Copyright (c) 2012 Unixphere AB 6 * Copyright (c) 2014 Intel Corporation 7 * Copyright (c) 2016 Linus Walleij <linus.walleij@linaro.org> 8 * 9 * Driver for Bosch Sensortec BMP180 and BMP280 digital pressure sensor. 10 * 11 * Datasheet: 12 * https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf 13 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf 14 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bme280-ds002.pdf 15 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf 16 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp390-ds002.pdf 17 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp581-ds004.pdf 18 * 19 * Sensor API: 20 * https://github.com/boschsensortec/BME280_SensorAPI 21 * https://github.com/boschsensortec/BMP3_SensorAPI 22 * https://github.com/boschsensortec/BMP5_SensorAPI 23 * 24 * Notice: 25 * The link to the bmp180 datasheet points to an outdated version missing these changes: 26 * - Changed document referral from ANP015 to BST-MPS-AN004-00 on page 26 27 * - Updated equation for B3 param on section 3.5 to ((((long)AC1 * 4 + X3) << oss) + 2) / 4 28 * - Updated RoHS directive to 2011/65/EU effective 8 June 2011 on page 26 29 */ 30 31 #define pr_fmt(fmt) "bmp280: " fmt 32 33 #include <linux/bitops.h> 34 #include <linux/bitfield.h> 35 #include <linux/cleanup.h> 36 #include <linux/completion.h> 37 #include <linux/delay.h> 38 #include <linux/device.h> 39 #include <linux/gpio/consumer.h> 40 #include <linux/interrupt.h> 41 #include <linux/irq.h> /* For irq_get_irq_data() */ 42 #include <linux/module.h> 43 #include <linux/nvmem-provider.h> 44 #include <linux/pm_runtime.h> 45 #include <linux/property.h> 46 #include <linux/random.h> 47 #include <linux/regmap.h> 48 #include <linux/regulator/consumer.h> 49 #include <linux/types.h> 50 51 #include <linux/iio/buffer.h> 52 #include <linux/iio/iio.h> 53 #include <linux/iio/trigger.h> 54 #include <linux/iio/trigger_consumer.h> 55 #include <linux/iio/triggered_buffer.h> 56 57 #include <linux/unaligned.h> 58 59 #include "bmp280.h" 60 61 /* 62 * These enums are used for indexing into the array of calibration 63 * coefficients for BMP180. 64 */ 65 enum { AC1, AC2, AC3, AC4, AC5, AC6, B1, B2, MB, MC, MD }; 66 67 enum bmp380_odr { 68 BMP380_ODR_200HZ, 69 BMP380_ODR_100HZ, 70 BMP380_ODR_50HZ, 71 BMP380_ODR_25HZ, 72 BMP380_ODR_12_5HZ, 73 BMP380_ODR_6_25HZ, 74 BMP380_ODR_3_125HZ, 75 BMP380_ODR_1_5625HZ, 76 BMP380_ODR_0_78HZ, 77 BMP380_ODR_0_39HZ, 78 BMP380_ODR_0_2HZ, 79 BMP380_ODR_0_1HZ, 80 BMP380_ODR_0_05HZ, 81 BMP380_ODR_0_02HZ, 82 BMP380_ODR_0_01HZ, 83 BMP380_ODR_0_006HZ, 84 BMP380_ODR_0_003HZ, 85 BMP380_ODR_0_0015HZ, 86 }; 87 88 enum bmp580_odr { 89 BMP580_ODR_240HZ, 90 BMP580_ODR_218HZ, 91 BMP580_ODR_199HZ, 92 BMP580_ODR_179HZ, 93 BMP580_ODR_160HZ, 94 BMP580_ODR_149HZ, 95 BMP580_ODR_140HZ, 96 BMP580_ODR_129HZ, 97 BMP580_ODR_120HZ, 98 BMP580_ODR_110HZ, 99 BMP580_ODR_100HZ, 100 BMP580_ODR_89HZ, 101 BMP580_ODR_80HZ, 102 BMP580_ODR_70HZ, 103 BMP580_ODR_60HZ, 104 BMP580_ODR_50HZ, 105 BMP580_ODR_45HZ, 106 BMP580_ODR_40HZ, 107 BMP580_ODR_35HZ, 108 BMP580_ODR_30HZ, 109 BMP580_ODR_25HZ, 110 BMP580_ODR_20HZ, 111 BMP580_ODR_15HZ, 112 BMP580_ODR_10HZ, 113 BMP580_ODR_5HZ, 114 BMP580_ODR_4HZ, 115 BMP580_ODR_3HZ, 116 BMP580_ODR_2HZ, 117 BMP580_ODR_1HZ, 118 BMP580_ODR_0_5HZ, 119 BMP580_ODR_0_25HZ, 120 BMP580_ODR_0_125HZ, 121 }; 122 123 /* 124 * These enums are used for indexing into the array of compensation 125 * parameters for BMP280. 126 */ 127 enum { T1, T2, T3, P1, P2, P3, P4, P5, P6, P7, P8, P9 }; 128 129 enum { 130 /* Temperature calib indexes */ 131 BMP380_T1 = 0, 132 BMP380_T2 = 2, 133 BMP380_T3 = 4, 134 /* Pressure calib indexes */ 135 BMP380_P1 = 5, 136 BMP380_P2 = 7, 137 BMP380_P3 = 9, 138 BMP380_P4 = 10, 139 BMP380_P5 = 11, 140 BMP380_P6 = 13, 141 BMP380_P7 = 15, 142 BMP380_P8 = 16, 143 BMP380_P9 = 17, 144 BMP380_P10 = 19, 145 BMP380_P11 = 20, 146 }; 147 148 enum bmp280_scan { 149 BMP280_PRESS, 150 BMP280_TEMP, 151 BME280_HUMID, 152 }; 153 154 static const struct iio_chan_spec bmp280_channels[] = { 155 { 156 .type = IIO_PRESSURE, 157 /* PROCESSED maintained for ABI backwards compatibility */ 158 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 159 BIT(IIO_CHAN_INFO_RAW) | 160 BIT(IIO_CHAN_INFO_SCALE) | 161 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 162 .scan_index = 0, 163 .scan_type = { 164 .sign = 'u', 165 .realbits = 32, 166 .storagebits = 32, 167 .endianness = IIO_CPU, 168 }, 169 }, 170 { 171 .type = IIO_TEMP, 172 /* PROCESSED maintained for ABI backwards compatibility */ 173 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 174 BIT(IIO_CHAN_INFO_RAW) | 175 BIT(IIO_CHAN_INFO_SCALE) | 176 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 177 .scan_index = 1, 178 .scan_type = { 179 .sign = 's', 180 .realbits = 32, 181 .storagebits = 32, 182 .endianness = IIO_CPU, 183 }, 184 }, 185 IIO_CHAN_SOFT_TIMESTAMP(2), 186 }; 187 188 static const struct iio_chan_spec bme280_channels[] = { 189 { 190 .type = IIO_PRESSURE, 191 /* PROCESSED maintained for ABI backwards compatibility */ 192 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 193 BIT(IIO_CHAN_INFO_RAW) | 194 BIT(IIO_CHAN_INFO_SCALE) | 195 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 196 .scan_index = 0, 197 .scan_type = { 198 .sign = 'u', 199 .realbits = 32, 200 .storagebits = 32, 201 .endianness = IIO_CPU, 202 }, 203 }, 204 { 205 .type = IIO_TEMP, 206 /* PROCESSED maintained for ABI backwards compatibility */ 207 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 208 BIT(IIO_CHAN_INFO_RAW) | 209 BIT(IIO_CHAN_INFO_SCALE) | 210 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 211 .scan_index = 1, 212 .scan_type = { 213 .sign = 's', 214 .realbits = 32, 215 .storagebits = 32, 216 .endianness = IIO_CPU, 217 }, 218 }, 219 { 220 .type = IIO_HUMIDITYRELATIVE, 221 /* PROCESSED maintained for ABI backwards compatibility */ 222 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 223 BIT(IIO_CHAN_INFO_RAW) | 224 BIT(IIO_CHAN_INFO_SCALE) | 225 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 226 .scan_index = 2, 227 .scan_type = { 228 .sign = 'u', 229 .realbits = 32, 230 .storagebits = 32, 231 .endianness = IIO_CPU, 232 }, 233 }, 234 IIO_CHAN_SOFT_TIMESTAMP(3), 235 }; 236 237 static const struct iio_chan_spec bmp380_channels[] = { 238 { 239 .type = IIO_PRESSURE, 240 /* PROCESSED maintained for ABI backwards compatibility */ 241 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 242 BIT(IIO_CHAN_INFO_RAW) | 243 BIT(IIO_CHAN_INFO_SCALE) | 244 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 245 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) | 246 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), 247 .scan_index = 0, 248 .scan_type = { 249 .sign = 'u', 250 .realbits = 32, 251 .storagebits = 32, 252 .endianness = IIO_CPU, 253 }, 254 }, 255 { 256 .type = IIO_TEMP, 257 /* PROCESSED maintained for ABI backwards compatibility */ 258 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 259 BIT(IIO_CHAN_INFO_RAW) | 260 BIT(IIO_CHAN_INFO_SCALE) | 261 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 262 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) | 263 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), 264 .scan_index = 1, 265 .scan_type = { 266 .sign = 's', 267 .realbits = 32, 268 .storagebits = 32, 269 .endianness = IIO_CPU, 270 }, 271 }, 272 IIO_CHAN_SOFT_TIMESTAMP(2), 273 }; 274 275 static const struct iio_chan_spec bmp580_channels[] = { 276 { 277 .type = IIO_PRESSURE, 278 /* PROCESSED maintained for ABI backwards compatibility */ 279 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 280 BIT(IIO_CHAN_INFO_RAW) | 281 BIT(IIO_CHAN_INFO_SCALE) | 282 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 283 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) | 284 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), 285 .scan_index = 0, 286 .scan_type = { 287 .sign = 'u', 288 .realbits = 24, 289 .storagebits = 32, 290 .endianness = IIO_LE, 291 }, 292 }, 293 { 294 .type = IIO_TEMP, 295 /* PROCESSED maintained for ABI backwards compatibility */ 296 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 297 BIT(IIO_CHAN_INFO_RAW) | 298 BIT(IIO_CHAN_INFO_SCALE) | 299 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 300 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) | 301 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), 302 .scan_index = 1, 303 .scan_type = { 304 .sign = 's', 305 .realbits = 24, 306 .storagebits = 32, 307 .endianness = IIO_LE, 308 }, 309 }, 310 IIO_CHAN_SOFT_TIMESTAMP(2), 311 }; 312 313 static int bmp280_read_calib(struct bmp280_data *data) 314 { 315 struct bmp280_calib *calib = &data->calib.bmp280; 316 int ret; 317 318 /* Read temperature and pressure calibration values. */ 319 ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_TEMP_START, 320 data->bmp280_cal_buf, 321 sizeof(data->bmp280_cal_buf)); 322 if (ret) { 323 dev_err(data->dev, 324 "failed to read calibration parameters\n"); 325 return ret; 326 } 327 328 /* Toss calibration data into the entropy pool */ 329 add_device_randomness(data->bmp280_cal_buf, 330 sizeof(data->bmp280_cal_buf)); 331 332 /* Parse temperature calibration values. */ 333 calib->T1 = le16_to_cpu(data->bmp280_cal_buf[T1]); 334 calib->T2 = le16_to_cpu(data->bmp280_cal_buf[T2]); 335 calib->T3 = le16_to_cpu(data->bmp280_cal_buf[T3]); 336 337 /* Parse pressure calibration values. */ 338 calib->P1 = le16_to_cpu(data->bmp280_cal_buf[P1]); 339 calib->P2 = le16_to_cpu(data->bmp280_cal_buf[P2]); 340 calib->P3 = le16_to_cpu(data->bmp280_cal_buf[P3]); 341 calib->P4 = le16_to_cpu(data->bmp280_cal_buf[P4]); 342 calib->P5 = le16_to_cpu(data->bmp280_cal_buf[P5]); 343 calib->P6 = le16_to_cpu(data->bmp280_cal_buf[P6]); 344 calib->P7 = le16_to_cpu(data->bmp280_cal_buf[P7]); 345 calib->P8 = le16_to_cpu(data->bmp280_cal_buf[P8]); 346 calib->P9 = le16_to_cpu(data->bmp280_cal_buf[P9]); 347 348 return 0; 349 } 350 351 /* 352 * These enums are used for indexing into the array of humidity parameters 353 * for BME280. Due to some weird indexing, unaligned BE/LE accesses co-exist in 354 * order to prepare the FIELD_{GET/PREP}() fields. Table 16 in Section 4.2.2 of 355 * the datasheet. 356 */ 357 enum { H2 = 0, H3 = 2, H4 = 3, H5 = 4, H6 = 6 }; 358 359 static int bme280_read_calib(struct bmp280_data *data) 360 { 361 struct bmp280_calib *calib = &data->calib.bmp280; 362 struct device *dev = data->dev; 363 s16 h4_upper, h4_lower, tmp_1, tmp_2, tmp_3; 364 unsigned int tmp; 365 int ret; 366 367 /* Load shared calibration params with bmp280 first */ 368 ret = bmp280_read_calib(data); 369 if (ret) 370 return ret; 371 372 ret = regmap_read(data->regmap, BME280_REG_COMP_H1, &tmp); 373 if (ret) { 374 dev_err(dev, "failed to read H1 comp value\n"); 375 return ret; 376 } 377 calib->H1 = tmp; 378 379 ret = regmap_bulk_read(data->regmap, BME280_REG_COMP_H2, 380 data->bme280_humid_cal_buf, 381 sizeof(data->bme280_humid_cal_buf)); 382 if (ret) { 383 dev_err(dev, "failed to read humidity calibration values\n"); 384 return ret; 385 } 386 387 calib->H2 = get_unaligned_le16(&data->bme280_humid_cal_buf[H2]); 388 calib->H3 = data->bme280_humid_cal_buf[H3]; 389 tmp_1 = get_unaligned_be16(&data->bme280_humid_cal_buf[H4]); 390 tmp_2 = FIELD_GET(BME280_COMP_H4_GET_MASK_UP, tmp_1); 391 h4_upper = FIELD_PREP(BME280_COMP_H4_PREP_MASK_UP, tmp_2); 392 h4_lower = FIELD_GET(BME280_COMP_H4_MASK_LOW, tmp_1); 393 calib->H4 = sign_extend32(h4_upper | h4_lower, 11); 394 tmp_3 = get_unaligned_le16(&data->bme280_humid_cal_buf[H5]); 395 calib->H5 = FIELD_GET_SIGNED(BME280_COMP_H5_MASK, tmp_3); 396 calib->H6 = data->bme280_humid_cal_buf[H6]; 397 398 return 0; 399 } 400 401 static int bme280_read_humid_adc(struct bmp280_data *data, u16 *adc_humidity) 402 { 403 u16 value_humidity; 404 int ret; 405 406 ret = regmap_bulk_read(data->regmap, BME280_REG_HUMIDITY_MSB, 407 &data->be16, BME280_NUM_HUMIDITY_BYTES); 408 if (ret) { 409 dev_err(data->dev, "failed to read humidity\n"); 410 return ret; 411 } 412 413 value_humidity = be16_to_cpu(data->be16); 414 if (value_humidity == BMP280_HUMIDITY_SKIPPED) { 415 dev_err(data->dev, "reading humidity skipped\n"); 416 return -EIO; 417 } 418 *adc_humidity = value_humidity; 419 420 return 0; 421 } 422 423 /* 424 * Returns humidity in percent, resolution is 0.01 percent. Output value of 425 * "47445" represents 47445/1024 = 46.333 %RH. 426 * 427 * Taken from BME280 datasheet, Section 4.2.3, "Compensation formula". 428 */ 429 static u32 bme280_compensate_humidity(struct bmp280_data *data, 430 u16 adc_humidity, s32 t_fine) 431 { 432 struct bmp280_calib *calib = &data->calib.bmp280; 433 s32 var; 434 435 var = t_fine - (s32)76800; 436 var = (((((s32)adc_humidity << 14) - (calib->H4 << 20) - (calib->H5 * var)) 437 + (s32)16384) >> 15) * (((((((var * calib->H6) >> 10) 438 * (((var * (s32)calib->H3) >> 11) + (s32)32768)) >> 10) 439 + (s32)2097152) * calib->H2 + 8192) >> 14); 440 var -= ((((var >> 15) * (var >> 15)) >> 7) * (s32)calib->H1) >> 4; 441 442 var = clamp_val(var, 0, 419430400); 443 444 return var >> 12; 445 } 446 447 static int bmp280_read_temp_adc(struct bmp280_data *data, u32 *adc_temp) 448 { 449 u32 value_temp; 450 int ret; 451 452 ret = regmap_bulk_read(data->regmap, BMP280_REG_TEMP_MSB, 453 data->buf, BMP280_NUM_TEMP_BYTES); 454 if (ret) { 455 dev_err(data->dev, "failed to read temperature\n"); 456 return ret; 457 } 458 459 value_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf)); 460 if (value_temp == BMP280_TEMP_SKIPPED) { 461 dev_err(data->dev, "reading temperature skipped\n"); 462 return -EIO; 463 } 464 *adc_temp = value_temp; 465 466 return 0; 467 } 468 469 /* 470 * Returns temperature in DegC, resolution is 0.01 DegC. Output value of 471 * "5123" equals 51.23 DegC. t_fine carries fine temperature as global 472 * value. 473 * 474 * Taken from datasheet, Section 3.11.3, "Compensation formula". 475 */ 476 static s32 bmp280_calc_t_fine(struct bmp280_data *data, u32 adc_temp) 477 { 478 struct bmp280_calib *calib = &data->calib.bmp280; 479 s32 var1, var2; 480 481 var1 = (((((s32)adc_temp) >> 3) - ((s32)calib->T1 << 1)) * 482 ((s32)calib->T2)) >> 11; 483 var2 = (((((((s32)adc_temp) >> 4) - ((s32)calib->T1)) * 484 ((((s32)adc_temp >> 4) - ((s32)calib->T1))) >> 12) * 485 ((s32)calib->T3))) >> 14; 486 return var1 + var2; /* t_fine = var1 + var2 */ 487 } 488 489 static int bmp280_get_t_fine(struct bmp280_data *data, s32 *t_fine) 490 { 491 u32 adc_temp; 492 int ret; 493 494 ret = bmp280_read_temp_adc(data, &adc_temp); 495 if (ret) 496 return ret; 497 498 *t_fine = bmp280_calc_t_fine(data, adc_temp); 499 500 return 0; 501 } 502 503 static s32 bmp280_compensate_temp(struct bmp280_data *data, u32 adc_temp) 504 { 505 return (bmp280_calc_t_fine(data, adc_temp) * 5 + 128) / 256; 506 } 507 508 static int bmp280_read_press_adc(struct bmp280_data *data, u32 *adc_press) 509 { 510 u32 value_press; 511 int ret; 512 513 ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB, 514 data->buf, BMP280_NUM_PRESS_BYTES); 515 if (ret) { 516 dev_err(data->dev, "failed to read pressure\n"); 517 return ret; 518 } 519 520 value_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf)); 521 if (value_press == BMP280_PRESS_SKIPPED) { 522 dev_err(data->dev, "reading pressure skipped\n"); 523 return -EIO; 524 } 525 *adc_press = value_press; 526 527 return 0; 528 } 529 530 /* 531 * Returns pressure in Pa as unsigned 32 bit integer in Q24.8 format (24 532 * integer bits and 8 fractional bits). Output value of "24674867" 533 * represents 24674867/256 = 96386.2 Pa = 963.862 hPa 534 * 535 * Taken from datasheet, Section 3.11.3, "Compensation formula". 536 */ 537 static u32 bmp280_compensate_press(struct bmp280_data *data, 538 u32 adc_press, s32 t_fine) 539 { 540 struct bmp280_calib *calib = &data->calib.bmp280; 541 s64 var1, var2, p; 542 543 var1 = ((s64)t_fine) - 128000; 544 var2 = var1 * var1 * (s64)calib->P6; 545 var2 += (var1 * (s64)calib->P5) << 17; 546 var2 += ((s64)calib->P4) << 35; 547 var1 = ((var1 * var1 * (s64)calib->P3) >> 8) + 548 ((var1 * (s64)calib->P2) << 12); 549 var1 = ((((s64)1) << 47) + var1) * ((s64)calib->P1) >> 33; 550 551 if (var1 == 0) 552 return 0; 553 554 p = ((((s64)1048576 - (s32)adc_press) << 31) - var2) * 3125; 555 p = div64_s64(p, var1); 556 var1 = (((s64)calib->P9) * (p >> 13) * (p >> 13)) >> 25; 557 var2 = ((s64)(calib->P8) * p) >> 19; 558 p = ((p + var1 + var2) >> 8) + (((s64)calib->P7) << 4); 559 560 return (u32)p; 561 } 562 563 static int bmp280_read_temp(struct bmp280_data *data, s32 *comp_temp) 564 { 565 u32 adc_temp; 566 int ret; 567 568 ret = bmp280_read_temp_adc(data, &adc_temp); 569 if (ret) 570 return ret; 571 572 *comp_temp = bmp280_compensate_temp(data, adc_temp); 573 574 return 0; 575 } 576 577 static int bmp280_read_press(struct bmp280_data *data, u32 *comp_press) 578 { 579 u32 adc_press; 580 s32 t_fine; 581 int ret; 582 583 ret = bmp280_get_t_fine(data, &t_fine); 584 if (ret) 585 return ret; 586 587 ret = bmp280_read_press_adc(data, &adc_press); 588 if (ret) 589 return ret; 590 591 *comp_press = bmp280_compensate_press(data, adc_press, t_fine); 592 593 return 0; 594 } 595 596 static int bme280_read_humid(struct bmp280_data *data, u32 *comp_humidity) 597 { 598 u16 adc_humidity; 599 s32 t_fine; 600 int ret; 601 602 ret = bmp280_get_t_fine(data, &t_fine); 603 if (ret) 604 return ret; 605 606 ret = bme280_read_humid_adc(data, &adc_humidity); 607 if (ret) 608 return ret; 609 610 *comp_humidity = bme280_compensate_humidity(data, adc_humidity, t_fine); 611 612 return 0; 613 } 614 615 static int bmp280_read_raw_impl(struct iio_dev *indio_dev, 616 struct iio_chan_spec const *chan, 617 int *val, int *val2, long mask) 618 { 619 struct bmp280_data *data = iio_priv(indio_dev); 620 int chan_value; 621 int ret; 622 623 guard(mutex)(&data->lock); 624 625 switch (mask) { 626 case IIO_CHAN_INFO_PROCESSED: 627 ret = data->chip_info->set_mode(data, BMP280_FORCED); 628 if (ret) 629 return ret; 630 631 ret = data->chip_info->wait_conv(data); 632 if (ret) 633 return ret; 634 635 switch (chan->type) { 636 case IIO_HUMIDITYRELATIVE: 637 ret = data->chip_info->read_humid(data, &chan_value); 638 if (ret) 639 return ret; 640 641 *val = data->chip_info->humid_coeffs[0] * chan_value; 642 *val2 = data->chip_info->humid_coeffs[1]; 643 return data->chip_info->humid_coeffs_type; 644 case IIO_PRESSURE: 645 ret = data->chip_info->read_press(data, &chan_value); 646 if (ret) 647 return ret; 648 649 *val = data->chip_info->press_coeffs[0] * chan_value; 650 *val2 = data->chip_info->press_coeffs[1]; 651 return data->chip_info->press_coeffs_type; 652 case IIO_TEMP: 653 ret = data->chip_info->read_temp(data, &chan_value); 654 if (ret) 655 return ret; 656 657 *val = data->chip_info->temp_coeffs[0] * chan_value; 658 *val2 = data->chip_info->temp_coeffs[1]; 659 return data->chip_info->temp_coeffs_type; 660 default: 661 return -EINVAL; 662 } 663 case IIO_CHAN_INFO_RAW: 664 ret = data->chip_info->set_mode(data, BMP280_FORCED); 665 if (ret) 666 return ret; 667 668 ret = data->chip_info->wait_conv(data); 669 if (ret) 670 return ret; 671 672 switch (chan->type) { 673 case IIO_HUMIDITYRELATIVE: 674 ret = data->chip_info->read_humid(data, &chan_value); 675 if (ret) 676 return ret; 677 678 *val = chan_value; 679 return IIO_VAL_INT; 680 case IIO_PRESSURE: 681 ret = data->chip_info->read_press(data, &chan_value); 682 if (ret) 683 return ret; 684 685 *val = chan_value; 686 return IIO_VAL_INT; 687 case IIO_TEMP: 688 ret = data->chip_info->read_temp(data, &chan_value); 689 if (ret) 690 return ret; 691 692 *val = chan_value; 693 return IIO_VAL_INT; 694 default: 695 return -EINVAL; 696 } 697 case IIO_CHAN_INFO_SCALE: 698 switch (chan->type) { 699 case IIO_HUMIDITYRELATIVE: 700 *val = data->chip_info->humid_coeffs[0]; 701 *val2 = data->chip_info->humid_coeffs[1]; 702 return data->chip_info->humid_coeffs_type; 703 case IIO_PRESSURE: 704 *val = data->chip_info->press_coeffs[0]; 705 *val2 = data->chip_info->press_coeffs[1]; 706 return data->chip_info->press_coeffs_type; 707 case IIO_TEMP: 708 *val = data->chip_info->temp_coeffs[0]; 709 *val2 = data->chip_info->temp_coeffs[1]; 710 return data->chip_info->temp_coeffs_type; 711 default: 712 return -EINVAL; 713 } 714 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 715 switch (chan->type) { 716 case IIO_HUMIDITYRELATIVE: 717 *val = 1 << data->oversampling_humid; 718 return IIO_VAL_INT; 719 case IIO_PRESSURE: 720 *val = 1 << data->oversampling_press; 721 return IIO_VAL_INT; 722 case IIO_TEMP: 723 *val = 1 << data->oversampling_temp; 724 return IIO_VAL_INT; 725 default: 726 return -EINVAL; 727 } 728 case IIO_CHAN_INFO_SAMP_FREQ: 729 if (!data->chip_info->sampling_freq_avail) 730 return -EINVAL; 731 732 *val = data->chip_info->sampling_freq_avail[data->sampling_freq][0]; 733 *val2 = data->chip_info->sampling_freq_avail[data->sampling_freq][1]; 734 return IIO_VAL_INT_PLUS_MICRO; 735 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: 736 if (!data->chip_info->iir_filter_coeffs_avail) 737 return -EINVAL; 738 739 *val = (1 << data->iir_filter_coeff) - 1; 740 return IIO_VAL_INT; 741 default: 742 return -EINVAL; 743 } 744 } 745 746 static int bmp280_read_raw(struct iio_dev *indio_dev, 747 struct iio_chan_spec const *chan, 748 int *val, int *val2, long mask) 749 { 750 struct bmp280_data *data = iio_priv(indio_dev); 751 int ret; 752 753 ret = pm_runtime_resume_and_get(data->dev); 754 if (ret < 0) 755 return ret; 756 757 ret = bmp280_read_raw_impl(indio_dev, chan, val, val2, mask); 758 pm_runtime_put_autosuspend(data->dev); 759 760 return ret; 761 } 762 763 static int bme280_write_oversampling_ratio_humid(struct bmp280_data *data, 764 int val) 765 { 766 const int *avail = data->chip_info->oversampling_humid_avail; 767 const int n = data->chip_info->num_oversampling_humid_avail; 768 int ret, prev; 769 int i; 770 771 for (i = 0; i < n; i++) { 772 if (avail[i] == val) { 773 prev = data->oversampling_humid; 774 data->oversampling_humid = ilog2(val); 775 776 ret = data->chip_info->chip_config(data); 777 if (ret) { 778 data->oversampling_humid = prev; 779 data->chip_info->chip_config(data); 780 return ret; 781 } 782 return 0; 783 } 784 } 785 return -EINVAL; 786 } 787 788 static int bmp280_write_oversampling_ratio_temp(struct bmp280_data *data, 789 int val) 790 { 791 const int *avail = data->chip_info->oversampling_temp_avail; 792 const int n = data->chip_info->num_oversampling_temp_avail; 793 int ret, prev; 794 int i; 795 796 for (i = 0; i < n; i++) { 797 if (avail[i] == val) { 798 prev = data->oversampling_temp; 799 data->oversampling_temp = ilog2(val); 800 801 ret = data->chip_info->chip_config(data); 802 if (ret) { 803 data->oversampling_temp = prev; 804 data->chip_info->chip_config(data); 805 return ret; 806 } 807 return 0; 808 } 809 } 810 return -EINVAL; 811 } 812 813 static int bmp280_write_oversampling_ratio_press(struct bmp280_data *data, 814 int val) 815 { 816 const int *avail = data->chip_info->oversampling_press_avail; 817 const int n = data->chip_info->num_oversampling_press_avail; 818 int ret, prev; 819 int i; 820 821 for (i = 0; i < n; i++) { 822 if (avail[i] == val) { 823 prev = data->oversampling_press; 824 data->oversampling_press = ilog2(val); 825 826 ret = data->chip_info->chip_config(data); 827 if (ret) { 828 data->oversampling_press = prev; 829 data->chip_info->chip_config(data); 830 return ret; 831 } 832 return 0; 833 } 834 } 835 return -EINVAL; 836 } 837 838 static int bmp280_write_sampling_frequency(struct bmp280_data *data, 839 int val, int val2) 840 { 841 const int (*avail)[2] = data->chip_info->sampling_freq_avail; 842 const int n = data->chip_info->num_sampling_freq_avail; 843 int ret, prev; 844 int i; 845 846 for (i = 0; i < n; i++) { 847 if (avail[i][0] == val && avail[i][1] == val2) { 848 prev = data->sampling_freq; 849 data->sampling_freq = i; 850 851 ret = data->chip_info->chip_config(data); 852 if (ret) { 853 data->sampling_freq = prev; 854 data->chip_info->chip_config(data); 855 return ret; 856 } 857 return 0; 858 } 859 } 860 return -EINVAL; 861 } 862 863 static int bmp280_write_iir_filter_coeffs(struct bmp280_data *data, int val) 864 { 865 const int *avail = data->chip_info->iir_filter_coeffs_avail; 866 const int n = data->chip_info->num_iir_filter_coeffs_avail; 867 int ret, prev; 868 int i; 869 870 for (i = 0; i < n; i++) { 871 if (avail[i] - 1 == val) { 872 prev = data->iir_filter_coeff; 873 data->iir_filter_coeff = i; 874 875 ret = data->chip_info->chip_config(data); 876 if (ret) { 877 data->iir_filter_coeff = prev; 878 data->chip_info->chip_config(data); 879 return ret; 880 881 } 882 return 0; 883 } 884 } 885 return -EINVAL; 886 } 887 888 static int bmp280_write_raw_impl(struct iio_dev *indio_dev, 889 struct iio_chan_spec const *chan, 890 int val, int val2, long mask) 891 { 892 struct bmp280_data *data = iio_priv(indio_dev); 893 894 guard(mutex)(&data->lock); 895 896 /* 897 * Helper functions to update sensor running configuration. 898 * If an error happens applying new settings, will try restore 899 * previous parameters to ensure the sensor is left in a known 900 * working configuration. 901 */ 902 switch (mask) { 903 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 904 switch (chan->type) { 905 case IIO_HUMIDITYRELATIVE: 906 return bme280_write_oversampling_ratio_humid(data, val); 907 case IIO_PRESSURE: 908 return bmp280_write_oversampling_ratio_press(data, val); 909 case IIO_TEMP: 910 return bmp280_write_oversampling_ratio_temp(data, val); 911 default: 912 return -EINVAL; 913 } 914 case IIO_CHAN_INFO_SAMP_FREQ: 915 return bmp280_write_sampling_frequency(data, val, val2); 916 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: 917 return bmp280_write_iir_filter_coeffs(data, val); 918 default: 919 return -EINVAL; 920 } 921 } 922 923 static int bmp280_write_raw(struct iio_dev *indio_dev, 924 struct iio_chan_spec const *chan, 925 int val, int val2, long mask) 926 { 927 struct bmp280_data *data = iio_priv(indio_dev); 928 int ret; 929 930 ret = pm_runtime_resume_and_get(data->dev); 931 if (ret < 0) 932 return ret; 933 934 ret = bmp280_write_raw_impl(indio_dev, chan, val, val2, mask); 935 pm_runtime_put_autosuspend(data->dev); 936 937 return ret; 938 } 939 940 static int bmp280_read_avail(struct iio_dev *indio_dev, 941 struct iio_chan_spec const *chan, 942 const int **vals, int *type, int *length, 943 long mask) 944 { 945 struct bmp280_data *data = iio_priv(indio_dev); 946 947 switch (mask) { 948 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 949 switch (chan->type) { 950 case IIO_PRESSURE: 951 *vals = data->chip_info->oversampling_press_avail; 952 *length = data->chip_info->num_oversampling_press_avail; 953 break; 954 case IIO_TEMP: 955 *vals = data->chip_info->oversampling_temp_avail; 956 *length = data->chip_info->num_oversampling_temp_avail; 957 break; 958 default: 959 return -EINVAL; 960 } 961 *type = IIO_VAL_INT; 962 return IIO_AVAIL_LIST; 963 case IIO_CHAN_INFO_SAMP_FREQ: 964 *vals = (const int *)data->chip_info->sampling_freq_avail; 965 *type = IIO_VAL_INT_PLUS_MICRO; 966 /* Values are stored in a 2D matrix */ 967 *length = data->chip_info->num_sampling_freq_avail; 968 return IIO_AVAIL_LIST; 969 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: 970 *vals = data->chip_info->iir_filter_coeffs_avail; 971 *type = IIO_VAL_INT; 972 *length = data->chip_info->num_iir_filter_coeffs_avail; 973 return IIO_AVAIL_LIST; 974 default: 975 return -EINVAL; 976 } 977 } 978 979 static const struct iio_info bmp280_info = { 980 .read_raw = &bmp280_read_raw, 981 .read_avail = &bmp280_read_avail, 982 .write_raw = &bmp280_write_raw, 983 }; 984 985 static const unsigned long bmp280_avail_scan_masks[] = { 986 BIT(BMP280_TEMP) | BIT(BMP280_PRESS), 987 0 988 }; 989 990 static const unsigned long bme280_avail_scan_masks[] = { 991 BIT(BME280_HUMID) | BIT(BMP280_TEMP) | BIT(BMP280_PRESS), 992 0 993 }; 994 995 static int bmp280_preinit(struct bmp280_data *data) 996 { 997 struct device *dev = data->dev; 998 unsigned int reg; 999 int ret; 1000 1001 ret = regmap_write(data->regmap, BMP280_REG_RESET, BMP280_RST_SOFT_CMD); 1002 if (ret) 1003 return dev_err_probe(dev, ret, "Failed to reset device.\n"); 1004 1005 /* 1006 * According to the datasheet in Chapter 1: Specification, Table 2, 1007 * after resetting, the device uses the complete power-on sequence so 1008 * it needs to wait for the defined start-up time. 1009 */ 1010 fsleep(data->start_up_time_us); 1011 1012 ret = regmap_read(data->regmap, BMP280_REG_STATUS, ®); 1013 if (ret) 1014 return dev_err_probe(dev, ret, "Failed to read status register.\n"); 1015 1016 if (reg & BMP280_REG_STATUS_IM_UPDATE) 1017 return dev_err_probe(dev, -EIO, "Failed to copy NVM contents.\n"); 1018 1019 return 0; 1020 } 1021 1022 static const u8 bmp280_operation_mode[] = { 1023 [BMP280_SLEEP] = BMP280_MODE_SLEEP, 1024 [BMP280_FORCED] = BMP280_MODE_FORCED, 1025 [BMP280_NORMAL] = BMP280_MODE_NORMAL, 1026 }; 1027 1028 static int bmp280_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode) 1029 { 1030 int ret; 1031 1032 ret = regmap_write_bits(data->regmap, BMP280_REG_CTRL_MEAS, 1033 BMP280_MODE_MASK, bmp280_operation_mode[mode]); 1034 if (ret) { 1035 dev_err(data->dev, "failed to write ctrl_meas register.\n"); 1036 return ret; 1037 } 1038 1039 data->op_mode = mode; 1040 1041 return 0; 1042 } 1043 1044 static int bmp280_wait_conv(struct bmp280_data *data) 1045 { 1046 unsigned int reg, meas_time_us; 1047 int ret; 1048 1049 /* Constant part of the measurement time */ 1050 meas_time_us = BMP280_MEAS_OFFSET; 1051 1052 /* 1053 * Check if we are using a BME280 device, 1054 * Humidity measurement time 1055 */ 1056 if (data->chip_info->oversampling_humid_avail) 1057 meas_time_us += BMP280_PRESS_HUMID_MEAS_OFFSET + 1058 BIT(data->oversampling_humid) * BMP280_MEAS_DUR; 1059 1060 /* Pressure measurement time */ 1061 meas_time_us += BMP280_PRESS_HUMID_MEAS_OFFSET + 1062 BIT(data->oversampling_press) * BMP280_MEAS_DUR; 1063 1064 /* Temperature measurement time */ 1065 meas_time_us += BIT(data->oversampling_temp) * BMP280_MEAS_DUR; 1066 1067 /* Waiting time according to the BM(P/E)2 Sensor API */ 1068 fsleep(meas_time_us); 1069 1070 ret = regmap_read(data->regmap, BMP280_REG_STATUS, ®); 1071 if (ret) { 1072 dev_err(data->dev, "failed to read status register.\n"); 1073 return ret; 1074 } 1075 1076 if (reg & BMP280_REG_STATUS_MEAS_BIT) { 1077 dev_err(data->dev, "Measurement cycle didn't complete.\n"); 1078 return -EBUSY; 1079 } 1080 1081 return 0; 1082 } 1083 1084 static int bmp280_chip_config(struct bmp280_data *data) 1085 { 1086 u8 osrs = FIELD_PREP(BMP280_OSRS_TEMP_MASK, data->oversampling_temp + 1) | 1087 FIELD_PREP(BMP280_OSRS_PRESS_MASK, data->oversampling_press + 1); 1088 int ret; 1089 1090 ret = regmap_write_bits(data->regmap, BMP280_REG_CTRL_MEAS, 1091 BMP280_OSRS_TEMP_MASK | 1092 BMP280_OSRS_PRESS_MASK | 1093 BMP280_MODE_MASK, 1094 osrs | BMP280_MODE_SLEEP); 1095 if (ret) { 1096 dev_err(data->dev, "failed to write ctrl_meas register\n"); 1097 return ret; 1098 } 1099 1100 ret = regmap_update_bits(data->regmap, BMP280_REG_CONFIG, 1101 BMP280_FILTER_MASK, 1102 BMP280_FILTER_4X); 1103 if (ret) { 1104 dev_err(data->dev, "failed to write config register\n"); 1105 return ret; 1106 } 1107 1108 return ret; 1109 } 1110 1111 static irqreturn_t bmp280_trigger_handler(int irq, void *p) 1112 { 1113 struct iio_poll_func *pf = p; 1114 struct iio_dev *indio_dev = pf->indio_dev; 1115 struct bmp280_data *data = iio_priv(indio_dev); 1116 u32 adc_temp, adc_press; 1117 s32 t_fine; 1118 struct { 1119 u32 comp_press; 1120 s32 comp_temp; 1121 aligned_s64 timestamp; 1122 } buffer; 1123 int ret; 1124 1125 guard(mutex)(&data->lock); 1126 1127 /* Burst read data registers */ 1128 ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB, 1129 data->buf, BMP280_BURST_READ_BYTES); 1130 if (ret) { 1131 dev_err(data->dev, "failed to burst read sensor data\n"); 1132 goto out; 1133 } 1134 1135 /* Temperature calculations */ 1136 adc_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[3])); 1137 if (adc_temp == BMP280_TEMP_SKIPPED) { 1138 dev_err(data->dev, "reading temperature skipped\n"); 1139 goto out; 1140 } 1141 1142 buffer.comp_temp = bmp280_compensate_temp(data, adc_temp); 1143 1144 /* Pressure calculations */ 1145 adc_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[0])); 1146 if (adc_press == BMP280_PRESS_SKIPPED) { 1147 dev_err(data->dev, "reading pressure skipped\n"); 1148 goto out; 1149 } 1150 1151 t_fine = bmp280_calc_t_fine(data, adc_temp); 1152 buffer.comp_press = bmp280_compensate_press(data, adc_press, t_fine); 1153 1154 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer), 1155 iio_get_time_ns(indio_dev)); 1156 1157 out: 1158 iio_trigger_notify_done(indio_dev->trig); 1159 1160 return IRQ_HANDLED; 1161 } 1162 1163 static const int bmp280_oversampling_avail[] = { 1, 2, 4, 8, 16 }; 1164 static const u8 bmp280_chip_ids[] = { BMP280_CHIP_ID }; 1165 static const int bmp280_temp_coeffs[] = { 10, 1 }; 1166 static const int bmp280_press_coeffs[] = { 1, 256000 }; 1167 1168 const struct bmp280_chip_info bmp280_chip_info = { 1169 .id_reg = BMP280_REG_ID, 1170 .chip_id = bmp280_chip_ids, 1171 .num_chip_id = ARRAY_SIZE(bmp280_chip_ids), 1172 .regmap_config = &bmp280_regmap_config, 1173 .start_up_time_us = 2000, 1174 .channels = bmp280_channels, 1175 .num_channels = ARRAY_SIZE(bmp280_channels), 1176 .avail_scan_masks = bmp280_avail_scan_masks, 1177 1178 .oversampling_temp_avail = bmp280_oversampling_avail, 1179 .num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail), 1180 /* 1181 * Oversampling config values on BMx280 have one additional setting 1182 * that other generations of the family don't: 1183 * The value 0 means the measurement is bypassed instead of 1184 * oversampling set to x1. 1185 * 1186 * To account for this difference, and preserve the same common 1187 * config logic, this is handled later on chip_config callback 1188 * incrementing one unit the oversampling setting. 1189 */ 1190 .oversampling_temp_default = BMP280_OSRS_TEMP_2X - 1, 1191 1192 .oversampling_press_avail = bmp280_oversampling_avail, 1193 .num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail), 1194 .oversampling_press_default = BMP280_OSRS_PRESS_16X - 1, 1195 1196 .temp_coeffs = bmp280_temp_coeffs, 1197 .temp_coeffs_type = IIO_VAL_FRACTIONAL, 1198 .press_coeffs = bmp280_press_coeffs, 1199 .press_coeffs_type = IIO_VAL_FRACTIONAL, 1200 1201 .chip_config = bmp280_chip_config, 1202 .read_temp = bmp280_read_temp, 1203 .read_press = bmp280_read_press, 1204 .read_calib = bmp280_read_calib, 1205 .set_mode = bmp280_set_mode, 1206 .wait_conv = bmp280_wait_conv, 1207 .preinit = bmp280_preinit, 1208 1209 .trigger_handler = bmp280_trigger_handler, 1210 }; 1211 EXPORT_SYMBOL_NS(bmp280_chip_info, "IIO_BMP280"); 1212 1213 static int bme280_chip_config(struct bmp280_data *data) 1214 { 1215 u8 osrs = FIELD_PREP(BME280_OSRS_HUMIDITY_MASK, data->oversampling_humid + 1); 1216 int ret; 1217 1218 /* 1219 * Oversampling of humidity must be set before oversampling of 1220 * temperature/pressure is set to become effective. 1221 */ 1222 ret = regmap_update_bits(data->regmap, BME280_REG_CTRL_HUMIDITY, 1223 BME280_OSRS_HUMIDITY_MASK, osrs); 1224 if (ret) { 1225 dev_err(data->dev, "failed to set humidity oversampling"); 1226 return ret; 1227 } 1228 1229 return bmp280_chip_config(data); 1230 } 1231 1232 static irqreturn_t bme280_trigger_handler(int irq, void *p) 1233 { 1234 struct iio_poll_func *pf = p; 1235 struct iio_dev *indio_dev = pf->indio_dev; 1236 struct bmp280_data *data = iio_priv(indio_dev); 1237 u32 adc_temp, adc_press, adc_humidity; 1238 s32 t_fine; 1239 struct { 1240 u32 comp_press; 1241 s32 comp_temp; 1242 u32 comp_humidity; 1243 aligned_s64 timestamp; 1244 } buffer = { }; /* Don't leak uninitialized stack to userspace. */ 1245 int ret; 1246 1247 guard(mutex)(&data->lock); 1248 1249 /* Burst read data registers */ 1250 ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB, 1251 data->buf, BME280_BURST_READ_BYTES); 1252 if (ret) { 1253 dev_err(data->dev, "failed to burst read sensor data\n"); 1254 goto out; 1255 } 1256 1257 /* Temperature calculations */ 1258 adc_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[3])); 1259 if (adc_temp == BMP280_TEMP_SKIPPED) { 1260 dev_err(data->dev, "reading temperature skipped\n"); 1261 goto out; 1262 } 1263 1264 buffer.comp_temp = bmp280_compensate_temp(data, adc_temp); 1265 1266 /* Pressure calculations */ 1267 adc_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[0])); 1268 if (adc_press == BMP280_PRESS_SKIPPED) { 1269 dev_err(data->dev, "reading pressure skipped\n"); 1270 goto out; 1271 } 1272 1273 t_fine = bmp280_calc_t_fine(data, adc_temp); 1274 buffer.comp_press = bmp280_compensate_press(data, adc_press, t_fine); 1275 1276 /* Humidity calculations */ 1277 adc_humidity = get_unaligned_be16(&data->buf[6]); 1278 1279 if (adc_humidity == BMP280_HUMIDITY_SKIPPED) { 1280 dev_err(data->dev, "reading humidity skipped\n"); 1281 goto out; 1282 } 1283 1284 buffer.comp_humidity = bme280_compensate_humidity(data, adc_humidity, 1285 t_fine); 1286 1287 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer), 1288 iio_get_time_ns(indio_dev)); 1289 1290 out: 1291 iio_trigger_notify_done(indio_dev->trig); 1292 1293 return IRQ_HANDLED; 1294 } 1295 1296 static int __bmp280_trigger_probe(struct iio_dev *indio_dev, 1297 const struct iio_trigger_ops *trigger_ops, 1298 int (*int_pin_config)(struct bmp280_data *data), 1299 irq_handler_t irq_thread_handler) 1300 { 1301 struct bmp280_data *data = iio_priv(indio_dev); 1302 struct device *dev = data->dev; 1303 u32 irq_type; 1304 int ret, irq; 1305 1306 irq = fwnode_irq_get(dev_fwnode(dev), 0); 1307 if (irq < 0) 1308 return dev_err_probe(dev, irq, "No interrupt found.\n"); 1309 1310 irq_type = irq_get_trigger_type(irq); 1311 switch (irq_type) { 1312 case IRQF_TRIGGER_RISING: 1313 data->trig_active_high = true; 1314 break; 1315 case IRQF_TRIGGER_FALLING: 1316 data->trig_active_high = false; 1317 break; 1318 default: 1319 return dev_err_probe(dev, -EINVAL, "Invalid interrupt type specified.\n"); 1320 } 1321 1322 data->trig_open_drain = 1323 fwnode_property_read_bool(dev_fwnode(dev), "int-open-drain"); 1324 1325 ret = int_pin_config(data); 1326 if (ret) 1327 return ret; 1328 1329 data->trig = devm_iio_trigger_alloc(data->dev, "%s-dev%d", 1330 indio_dev->name, 1331 iio_device_id(indio_dev)); 1332 if (!data->trig) 1333 return -ENOMEM; 1334 1335 data->trig->ops = trigger_ops; 1336 iio_trigger_set_drvdata(data->trig, data); 1337 1338 ret = devm_request_threaded_irq(data->dev, irq, NULL, 1339 irq_thread_handler, IRQF_ONESHOT, 1340 indio_dev->name, indio_dev); 1341 if (ret) 1342 return ret; 1343 1344 ret = devm_iio_trigger_register(data->dev, data->trig); 1345 if (ret) 1346 return dev_err_probe(dev, ret, "iio trigger register failed.\n"); 1347 1348 indio_dev->trig = iio_trigger_get(data->trig); 1349 1350 return 0; 1351 } 1352 1353 static const u8 bme280_chip_ids[] = { BME280_CHIP_ID }; 1354 static const int bme280_humid_coeffs[] = { 1000, 1024 }; 1355 1356 const struct bmp280_chip_info bme280_chip_info = { 1357 .id_reg = BMP280_REG_ID, 1358 .chip_id = bme280_chip_ids, 1359 .num_chip_id = ARRAY_SIZE(bme280_chip_ids), 1360 .regmap_config = &bme280_regmap_config, 1361 .start_up_time_us = 2000, 1362 .channels = bme280_channels, 1363 .num_channels = ARRAY_SIZE(bme280_channels), 1364 .avail_scan_masks = bme280_avail_scan_masks, 1365 1366 .oversampling_temp_avail = bmp280_oversampling_avail, 1367 .num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail), 1368 .oversampling_temp_default = BMP280_OSRS_TEMP_2X - 1, 1369 1370 .oversampling_press_avail = bmp280_oversampling_avail, 1371 .num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail), 1372 .oversampling_press_default = BMP280_OSRS_PRESS_16X - 1, 1373 1374 .oversampling_humid_avail = bmp280_oversampling_avail, 1375 .num_oversampling_humid_avail = ARRAY_SIZE(bmp280_oversampling_avail), 1376 .oversampling_humid_default = BME280_OSRS_HUMIDITY_16X - 1, 1377 1378 .temp_coeffs = bmp280_temp_coeffs, 1379 .temp_coeffs_type = IIO_VAL_FRACTIONAL, 1380 .press_coeffs = bmp280_press_coeffs, 1381 .press_coeffs_type = IIO_VAL_FRACTIONAL, 1382 .humid_coeffs = bme280_humid_coeffs, 1383 .humid_coeffs_type = IIO_VAL_FRACTIONAL, 1384 1385 .chip_config = bme280_chip_config, 1386 .read_temp = bmp280_read_temp, 1387 .read_press = bmp280_read_press, 1388 .read_humid = bme280_read_humid, 1389 .read_calib = bme280_read_calib, 1390 .set_mode = bmp280_set_mode, 1391 .wait_conv = bmp280_wait_conv, 1392 .preinit = bmp280_preinit, 1393 1394 .trigger_handler = bme280_trigger_handler, 1395 }; 1396 EXPORT_SYMBOL_NS(bme280_chip_info, "IIO_BMP280"); 1397 1398 /* 1399 * Helper function to send a command to BMP3XX sensors. 1400 * 1401 * Sensor processes commands written to the CMD register and signals 1402 * execution result through "cmd_rdy" and "cmd_error" flags available on 1403 * STATUS and ERROR registers. 1404 */ 1405 static int bmp380_cmd(struct bmp280_data *data, u8 cmd) 1406 { 1407 unsigned int reg; 1408 int ret; 1409 1410 /* Check if device is ready to process a command */ 1411 ret = regmap_read(data->regmap, BMP380_REG_STATUS, ®); 1412 if (ret) { 1413 dev_err(data->dev, "failed to read error register\n"); 1414 return ret; 1415 } 1416 if (!(reg & BMP380_STATUS_CMD_RDY_MASK)) { 1417 dev_err(data->dev, "device is not ready to accept commands\n"); 1418 return -EBUSY; 1419 } 1420 1421 /* Send command to process */ 1422 ret = regmap_write(data->regmap, BMP380_REG_CMD, cmd); 1423 if (ret) { 1424 dev_err(data->dev, "failed to send command to device\n"); 1425 return ret; 1426 } 1427 /* Wait for 2ms for command to be processed */ 1428 fsleep(data->start_up_time_us); 1429 /* Check for command processing error */ 1430 ret = regmap_read(data->regmap, BMP380_REG_ERROR, ®); 1431 if (ret) { 1432 dev_err(data->dev, "error reading ERROR reg\n"); 1433 return ret; 1434 } 1435 if (reg & BMP380_ERR_CMD_MASK) { 1436 dev_err(data->dev, "error processing command 0x%X\n", cmd); 1437 return -EINVAL; 1438 } 1439 1440 return 0; 1441 } 1442 1443 static int bmp380_read_temp_adc(struct bmp280_data *data, u32 *adc_temp) 1444 { 1445 u32 value_temp; 1446 int ret; 1447 1448 ret = regmap_bulk_read(data->regmap, BMP380_REG_TEMP_XLSB, 1449 data->buf, BMP280_NUM_TEMP_BYTES); 1450 if (ret) { 1451 dev_err(data->dev, "failed to read temperature\n"); 1452 return ret; 1453 } 1454 1455 value_temp = get_unaligned_le24(data->buf); 1456 if (value_temp == BMP380_TEMP_SKIPPED) { 1457 dev_err(data->dev, "reading temperature skipped\n"); 1458 return -EIO; 1459 } 1460 *adc_temp = value_temp; 1461 1462 return 0; 1463 } 1464 1465 /* 1466 * Returns temperature in Celsius degrees, resolution is 0.01º C. Output value 1467 * of "5123" equals 51.2º C. t_fine carries fine temperature as global value. 1468 * 1469 * Taken from datasheet, Section Appendix 9, "Compensation formula" and repo 1470 * https://github.com/BoschSensortec/BMP3-Sensor-API. 1471 */ 1472 static s32 bmp380_calc_t_fine(struct bmp280_data *data, u32 adc_temp) 1473 { 1474 s64 var1, var2, var3, var4, var5, var6; 1475 struct bmp380_calib *calib = &data->calib.bmp380; 1476 1477 var1 = ((s64) adc_temp) - (((s64) calib->T1) << 8); 1478 var2 = var1 * ((s64) calib->T2); 1479 var3 = var1 * var1; 1480 var4 = var3 * ((s64) calib->T3); 1481 var5 = (var2 << 18) + var4; 1482 var6 = var5 >> 32; 1483 return (s32)var6; /* t_fine = var6 */ 1484 } 1485 1486 static int bmp380_get_t_fine(struct bmp280_data *data, s32 *t_fine) 1487 { 1488 s32 adc_temp; 1489 int ret; 1490 1491 ret = bmp380_read_temp_adc(data, &adc_temp); 1492 if (ret) 1493 return ret; 1494 1495 *t_fine = bmp380_calc_t_fine(data, adc_temp); 1496 1497 return 0; 1498 } 1499 1500 static int bmp380_compensate_temp(struct bmp280_data *data, u32 adc_temp) 1501 { 1502 s64 comp_temp; 1503 s32 var6; 1504 1505 var6 = bmp380_calc_t_fine(data, adc_temp); 1506 comp_temp = (var6 * 25) >> 14; 1507 1508 comp_temp = clamp_val(comp_temp, BMP380_MIN_TEMP, BMP380_MAX_TEMP); 1509 return (s32) comp_temp; 1510 } 1511 1512 static int bmp380_read_press_adc(struct bmp280_data *data, u32 *adc_press) 1513 { 1514 u32 value_press; 1515 int ret; 1516 1517 ret = regmap_bulk_read(data->regmap, BMP380_REG_PRESS_XLSB, 1518 data->buf, BMP280_NUM_PRESS_BYTES); 1519 if (ret) { 1520 dev_err(data->dev, "failed to read pressure\n"); 1521 return ret; 1522 } 1523 1524 value_press = get_unaligned_le24(data->buf); 1525 if (value_press == BMP380_PRESS_SKIPPED) { 1526 dev_err(data->dev, "reading pressure skipped\n"); 1527 return -EIO; 1528 } 1529 *adc_press = value_press; 1530 1531 return 0; 1532 } 1533 1534 /* 1535 * Returns pressure in Pa as an unsigned 32 bit integer in fractional Pascal. 1536 * Output value of "9528709" represents 9528709/100 = 95287.09 Pa = 952.8709 hPa. 1537 * 1538 * Taken from datasheet, Section 9.3. "Pressure compensation" and repository 1539 * https://github.com/BoschSensortec/BMP3-Sensor-API. 1540 */ 1541 static u32 bmp380_compensate_press(struct bmp280_data *data, 1542 u32 adc_press, s32 t_fine) 1543 { 1544 s64 var1, var2, var3, var4, var5, var6, offset, sensitivity; 1545 struct bmp380_calib *calib = &data->calib.bmp380; 1546 u32 comp_press; 1547 1548 var1 = (s64)t_fine * (s64)t_fine; 1549 var2 = var1 >> 6; 1550 var3 = (var2 * ((s64)t_fine)) >> 8; 1551 var4 = ((s64)calib->P8 * var3) >> 5; 1552 var5 = ((s64)calib->P7 * var1) << 4; 1553 var6 = ((s64)calib->P6 * (s64)t_fine) << 22; 1554 offset = ((s64)calib->P5 << 47) + var4 + var5 + var6; 1555 var2 = ((s64)calib->P4 * var3) >> 5; 1556 var4 = ((s64)calib->P3 * var1) << 2; 1557 var5 = ((s64)calib->P2 - ((s64)1 << 14)) * 1558 ((s64)t_fine << 21); 1559 sensitivity = (((s64) calib->P1 - ((s64) 1 << 14)) << 46) + 1560 var2 + var4 + var5; 1561 var1 = (sensitivity >> 24) * (s64)adc_press; 1562 var2 = (s64)calib->P10 * (s64)t_fine; 1563 var3 = var2 + ((s64)calib->P9 << 16); 1564 var4 = (var3 * (s64)adc_press) >> 13; 1565 1566 /* 1567 * Dividing by 10 followed by multiplying by 10 to avoid 1568 * possible overflow caused by (uncomp_data->pressure * partial_data4). 1569 */ 1570 var5 = ((s64)adc_press * div_s64(var4, 10)) >> 9; 1571 var5 *= 10; 1572 var6 = (s64)adc_press * (s64)adc_press; 1573 var2 = ((s64)calib->P11 * var6) >> 16; 1574 var3 = (var2 * (s64)adc_press) >> 7; 1575 var4 = (offset >> 2) + var1 + var5 + var3; 1576 comp_press = ((u64)var4 * 25) >> 40; 1577 1578 comp_press = clamp_val(comp_press, BMP380_MIN_PRES, BMP380_MAX_PRES); 1579 return comp_press; 1580 } 1581 1582 static int bmp380_read_temp(struct bmp280_data *data, s32 *comp_temp) 1583 { 1584 u32 adc_temp; 1585 int ret; 1586 1587 ret = bmp380_read_temp_adc(data, &adc_temp); 1588 if (ret) 1589 return ret; 1590 1591 *comp_temp = bmp380_compensate_temp(data, adc_temp); 1592 1593 return 0; 1594 } 1595 1596 static int bmp380_read_press(struct bmp280_data *data, u32 *comp_press) 1597 { 1598 u32 adc_press, t_fine; 1599 int ret; 1600 1601 ret = bmp380_get_t_fine(data, &t_fine); 1602 if (ret) 1603 return ret; 1604 1605 ret = bmp380_read_press_adc(data, &adc_press); 1606 if (ret) 1607 return ret; 1608 1609 *comp_press = bmp380_compensate_press(data, adc_press, t_fine); 1610 1611 return 0; 1612 } 1613 1614 static int bmp380_read_calib(struct bmp280_data *data) 1615 { 1616 struct bmp380_calib *calib = &data->calib.bmp380; 1617 int ret; 1618 1619 /* Read temperature and pressure calibration data */ 1620 ret = regmap_bulk_read(data->regmap, BMP380_REG_CALIB_TEMP_START, 1621 data->bmp380_cal_buf, 1622 sizeof(data->bmp380_cal_buf)); 1623 if (ret) { 1624 dev_err(data->dev, 1625 "failed to read calibration parameters\n"); 1626 return ret; 1627 } 1628 1629 /* Toss the temperature calibration data into the entropy pool */ 1630 add_device_randomness(data->bmp380_cal_buf, 1631 sizeof(data->bmp380_cal_buf)); 1632 1633 /* Parse calibration values */ 1634 calib->T1 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_T1]); 1635 calib->T2 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_T2]); 1636 calib->T3 = data->bmp380_cal_buf[BMP380_T3]; 1637 calib->P1 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P1]); 1638 calib->P2 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P2]); 1639 calib->P3 = data->bmp380_cal_buf[BMP380_P3]; 1640 calib->P4 = data->bmp380_cal_buf[BMP380_P4]; 1641 calib->P5 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P5]); 1642 calib->P6 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P6]); 1643 calib->P7 = data->bmp380_cal_buf[BMP380_P7]; 1644 calib->P8 = data->bmp380_cal_buf[BMP380_P8]; 1645 calib->P9 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P9]); 1646 calib->P10 = data->bmp380_cal_buf[BMP380_P10]; 1647 calib->P11 = data->bmp380_cal_buf[BMP380_P11]; 1648 1649 return 0; 1650 } 1651 1652 static const int bmp380_odr_table[][2] = { 1653 [BMP380_ODR_200HZ] = {200, 0}, 1654 [BMP380_ODR_100HZ] = {100, 0}, 1655 [BMP380_ODR_50HZ] = {50, 0}, 1656 [BMP380_ODR_25HZ] = {25, 0}, 1657 [BMP380_ODR_12_5HZ] = {12, 500000}, 1658 [BMP380_ODR_6_25HZ] = {6, 250000}, 1659 [BMP380_ODR_3_125HZ] = {3, 125000}, 1660 [BMP380_ODR_1_5625HZ] = {1, 562500}, 1661 [BMP380_ODR_0_78HZ] = {0, 781250}, 1662 [BMP380_ODR_0_39HZ] = {0, 390625}, 1663 [BMP380_ODR_0_2HZ] = {0, 195313}, 1664 [BMP380_ODR_0_1HZ] = {0, 97656}, 1665 [BMP380_ODR_0_05HZ] = {0, 48828}, 1666 [BMP380_ODR_0_02HZ] = {0, 24414}, 1667 [BMP380_ODR_0_01HZ] = {0, 12207}, 1668 [BMP380_ODR_0_006HZ] = {0, 6104}, 1669 [BMP380_ODR_0_003HZ] = {0, 3052}, 1670 [BMP380_ODR_0_0015HZ] = {0, 1526}, 1671 }; 1672 1673 static int bmp380_preinit(struct bmp280_data *data) 1674 { 1675 /* BMP3xx requires soft-reset as part of initialization */ 1676 return bmp380_cmd(data, BMP380_CMD_SOFT_RESET); 1677 } 1678 1679 static const u8 bmp380_operation_mode[] = { 1680 [BMP280_SLEEP] = BMP380_MODE_SLEEP, 1681 [BMP280_FORCED] = BMP380_MODE_FORCED, 1682 [BMP280_NORMAL] = BMP380_MODE_NORMAL, 1683 }; 1684 1685 static int bmp380_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode) 1686 { 1687 int ret; 1688 1689 ret = regmap_write_bits(data->regmap, BMP380_REG_POWER_CONTROL, 1690 BMP380_MODE_MASK, 1691 FIELD_PREP(BMP380_MODE_MASK, 1692 bmp380_operation_mode[mode])); 1693 if (ret) { 1694 dev_err(data->dev, "failed to write power control register.\n"); 1695 return ret; 1696 } 1697 1698 data->op_mode = mode; 1699 1700 return 0; 1701 } 1702 1703 static int bmp380_wait_conv(struct bmp280_data *data) 1704 { 1705 unsigned int reg; 1706 int ret, meas_time_us; 1707 1708 /* Offset measurement time */ 1709 meas_time_us = BMP380_MEAS_OFFSET; 1710 1711 /* Pressure measurement time */ 1712 meas_time_us += BMP380_PRESS_MEAS_OFFSET + 1713 BIT(data->oversampling_press) * BMP380_MEAS_DUR; 1714 1715 /* Temperature measurement time */ 1716 meas_time_us += BMP380_TEMP_MEAS_OFFSET + 1717 BIT(data->oversampling_temp) * BMP380_MEAS_DUR; 1718 1719 /* Measurement time defined in Datasheet Section 3.9.2 */ 1720 fsleep(meas_time_us); 1721 1722 ret = regmap_read(data->regmap, BMP380_REG_STATUS, ®); 1723 if (ret) { 1724 dev_err(data->dev, "failed to read status register.\n"); 1725 return ret; 1726 } 1727 1728 if (!((reg & BMP380_STATUS_DRDY_PRESS_MASK) && 1729 (reg & BMP380_STATUS_DRDY_TEMP_MASK))) { 1730 dev_err(data->dev, "Measurement cycle didn't complete.\n"); 1731 return -EBUSY; 1732 } 1733 1734 return 0; 1735 } 1736 1737 static int bmp380_chip_config(struct bmp280_data *data) 1738 { 1739 bool change = false, aux; 1740 unsigned int tmp; 1741 u8 osrs; 1742 int ret; 1743 1744 /* Configure power control register */ 1745 ret = regmap_update_bits(data->regmap, BMP380_REG_POWER_CONTROL, 1746 BMP380_CTRL_SENSORS_MASK, 1747 BMP380_CTRL_SENSORS_PRESS_EN | 1748 BMP380_CTRL_SENSORS_TEMP_EN); 1749 if (ret) { 1750 dev_err(data->dev, 1751 "failed to write operation control register\n"); 1752 return ret; 1753 } 1754 1755 /* Configure oversampling */ 1756 osrs = FIELD_PREP(BMP380_OSRS_TEMP_MASK, data->oversampling_temp) | 1757 FIELD_PREP(BMP380_OSRS_PRESS_MASK, data->oversampling_press); 1758 1759 ret = regmap_update_bits_check(data->regmap, BMP380_REG_OSR, 1760 BMP380_OSRS_TEMP_MASK | 1761 BMP380_OSRS_PRESS_MASK, 1762 osrs, &aux); 1763 if (ret) { 1764 dev_err(data->dev, "failed to write oversampling register\n"); 1765 return ret; 1766 } 1767 change = change || aux; 1768 1769 /* Configure output data rate */ 1770 ret = regmap_update_bits_check(data->regmap, BMP380_REG_ODR, 1771 BMP380_ODRS_MASK, data->sampling_freq, 1772 &aux); 1773 if (ret) { 1774 dev_err(data->dev, "failed to write ODR selection register\n"); 1775 return ret; 1776 } 1777 change = change || aux; 1778 1779 /* Set filter data */ 1780 ret = regmap_update_bits(data->regmap, BMP380_REG_CONFIG, BMP380_FILTER_MASK, 1781 FIELD_PREP(BMP380_FILTER_MASK, data->iir_filter_coeff)); 1782 if (ret) { 1783 dev_err(data->dev, "failed to write config register\n"); 1784 return ret; 1785 } 1786 1787 if (change) { 1788 /* 1789 * The configurations errors are detected on the fly during a 1790 * measurement cycle. If the sampling frequency is too low, it's 1791 * faster to reset the measurement loop than wait until the next 1792 * measurement is due. 1793 * 1794 * Resets sensor measurement loop toggling between sleep and 1795 * normal operating modes. 1796 */ 1797 ret = bmp380_set_mode(data, BMP280_SLEEP); 1798 if (ret) { 1799 dev_err(data->dev, "failed to set sleep mode\n"); 1800 return ret; 1801 } 1802 1803 /* 1804 * According to the BMP3 Sensor API, the sensor needs 5ms 1805 * in order to go to the sleep mode. 1806 */ 1807 fsleep(5 * USEC_PER_MSEC); 1808 1809 ret = bmp380_set_mode(data, BMP280_NORMAL); 1810 if (ret) { 1811 dev_err(data->dev, "failed to set normal mode\n"); 1812 return ret; 1813 } 1814 /* 1815 * Waits for measurement before checking configuration error 1816 * flag. Selected longest measurement time, calculated from 1817 * formula in datasheet section 3.9.2 with an offset of ~+15% 1818 * as it seen as well in table 3.9.1. 1819 */ 1820 fsleep(150 * USEC_PER_MSEC); 1821 1822 /* Check config error flag */ 1823 ret = regmap_read(data->regmap, BMP380_REG_ERROR, &tmp); 1824 if (ret) { 1825 dev_err(data->dev, "failed to read error register\n"); 1826 return ret; 1827 } 1828 if (tmp & BMP380_ERR_CONF_MASK) { 1829 dev_warn(data->dev, 1830 "sensor flagged configuration as incompatible\n"); 1831 return -EINVAL; 1832 } 1833 } 1834 1835 /* Dummy read to empty data registers. */ 1836 ret = bmp380_read_press(data, &tmp); 1837 if (ret) 1838 return ret; 1839 1840 ret = bmp380_set_mode(data, BMP280_SLEEP); 1841 if (ret) 1842 dev_err(data->dev, "failed to set sleep mode.\n"); 1843 1844 return ret; 1845 } 1846 1847 static int bmp380_data_rdy_trigger_set_state(struct iio_trigger *trig, 1848 bool state) 1849 { 1850 struct bmp280_data *data = iio_trigger_get_drvdata(trig); 1851 int ret; 1852 1853 guard(mutex)(&data->lock); 1854 1855 ret = regmap_update_bits(data->regmap, BMP380_REG_INT_CONTROL, 1856 BMP380_INT_CTRL_DRDY_EN, 1857 FIELD_PREP(BMP380_INT_CTRL_DRDY_EN, !!state)); 1858 if (ret) 1859 dev_err(data->dev, 1860 "Could not %s interrupt.\n", str_enable_disable(state)); 1861 return ret; 1862 } 1863 1864 static const struct iio_trigger_ops bmp380_trigger_ops = { 1865 .set_trigger_state = &bmp380_data_rdy_trigger_set_state, 1866 }; 1867 1868 static int bmp380_int_pin_config(struct bmp280_data *data) 1869 { 1870 int pin_drive_cfg = FIELD_PREP(BMP380_INT_CTRL_OPEN_DRAIN, 1871 data->trig_open_drain); 1872 int pin_level_cfg = FIELD_PREP(BMP380_INT_CTRL_LEVEL, 1873 data->trig_active_high); 1874 int ret, int_pin_cfg = pin_drive_cfg | pin_level_cfg; 1875 1876 ret = regmap_update_bits(data->regmap, BMP380_REG_INT_CONTROL, 1877 BMP380_INT_CTRL_SETTINGS_MASK, int_pin_cfg); 1878 if (ret) 1879 dev_err(data->dev, "Could not set interrupt settings.\n"); 1880 1881 return ret; 1882 } 1883 1884 static irqreturn_t bmp380_irq_thread_handler(int irq, void *p) 1885 { 1886 struct iio_dev *indio_dev = p; 1887 struct bmp280_data *data = iio_priv(indio_dev); 1888 unsigned int int_ctrl; 1889 int ret; 1890 1891 ret = regmap_read(data->regmap, BMP380_REG_INT_STATUS, &int_ctrl); 1892 if (ret) 1893 return IRQ_NONE; 1894 1895 if (FIELD_GET(BMP380_INT_STATUS_DRDY, int_ctrl)) 1896 iio_trigger_poll_nested(data->trig); 1897 1898 return IRQ_HANDLED; 1899 } 1900 1901 static int bmp380_trigger_probe(struct iio_dev *indio_dev) 1902 { 1903 return __bmp280_trigger_probe(indio_dev, &bmp380_trigger_ops, 1904 bmp380_int_pin_config, 1905 bmp380_irq_thread_handler); 1906 } 1907 1908 static irqreturn_t bmp380_trigger_handler(int irq, void *p) 1909 { 1910 struct iio_poll_func *pf = p; 1911 struct iio_dev *indio_dev = pf->indio_dev; 1912 struct bmp280_data *data = iio_priv(indio_dev); 1913 u32 adc_temp, adc_press; 1914 s32 t_fine; 1915 struct { 1916 u32 comp_press; 1917 s32 comp_temp; 1918 aligned_s64 timestamp; 1919 } buffer = { }; 1920 int ret; 1921 1922 guard(mutex)(&data->lock); 1923 1924 /* Burst read data registers */ 1925 ret = regmap_bulk_read(data->regmap, BMP380_REG_PRESS_XLSB, 1926 data->buf, BMP280_BURST_READ_BYTES); 1927 if (ret) { 1928 dev_err(data->dev, "failed to burst read sensor data\n"); 1929 goto out; 1930 } 1931 1932 /* Temperature calculations */ 1933 adc_temp = get_unaligned_le24(&data->buf[3]); 1934 if (adc_temp == BMP380_TEMP_SKIPPED) { 1935 dev_err(data->dev, "reading temperature skipped\n"); 1936 goto out; 1937 } 1938 1939 buffer.comp_temp = bmp380_compensate_temp(data, adc_temp); 1940 1941 /* Pressure calculations */ 1942 adc_press = get_unaligned_le24(&data->buf[0]); 1943 if (adc_press == BMP380_PRESS_SKIPPED) { 1944 dev_err(data->dev, "reading pressure skipped\n"); 1945 goto out; 1946 } 1947 1948 t_fine = bmp380_calc_t_fine(data, adc_temp); 1949 buffer.comp_press = bmp380_compensate_press(data, adc_press, t_fine); 1950 1951 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer), 1952 iio_get_time_ns(indio_dev)); 1953 1954 out: 1955 iio_trigger_notify_done(indio_dev->trig); 1956 1957 return IRQ_HANDLED; 1958 } 1959 1960 static const int bmp380_oversampling_avail[] = { 1, 2, 4, 8, 16, 32 }; 1961 static const int bmp380_iir_filter_coeffs_avail[] = { 1, 2, 4, 8, 16, 32, 64, 128}; 1962 static const u8 bmp380_chip_ids[] = { BMP380_CHIP_ID, BMP390_CHIP_ID }; 1963 static const int bmp380_temp_coeffs[] = { 10, 1 }; 1964 static const int bmp380_press_coeffs[] = { 1, 100000 }; 1965 1966 const struct bmp280_chip_info bmp380_chip_info = { 1967 .id_reg = BMP380_REG_ID, 1968 .chip_id = bmp380_chip_ids, 1969 .num_chip_id = ARRAY_SIZE(bmp380_chip_ids), 1970 .regmap_config = &bmp380_regmap_config, 1971 .spi_read_extra_byte = true, 1972 .start_up_time_us = 2000, 1973 .channels = bmp380_channels, 1974 .num_channels = ARRAY_SIZE(bmp380_channels), 1975 .avail_scan_masks = bmp280_avail_scan_masks, 1976 1977 .oversampling_temp_avail = bmp380_oversampling_avail, 1978 .num_oversampling_temp_avail = ARRAY_SIZE(bmp380_oversampling_avail), 1979 .oversampling_temp_default = ilog2(1), 1980 1981 .oversampling_press_avail = bmp380_oversampling_avail, 1982 .num_oversampling_press_avail = ARRAY_SIZE(bmp380_oversampling_avail), 1983 .oversampling_press_default = ilog2(4), 1984 1985 .sampling_freq_avail = bmp380_odr_table, 1986 .num_sampling_freq_avail = ARRAY_SIZE(bmp380_odr_table) * 2, 1987 .sampling_freq_default = BMP380_ODR_50HZ, 1988 1989 .iir_filter_coeffs_avail = bmp380_iir_filter_coeffs_avail, 1990 .num_iir_filter_coeffs_avail = ARRAY_SIZE(bmp380_iir_filter_coeffs_avail), 1991 .iir_filter_coeff_default = 2, 1992 1993 .temp_coeffs = bmp380_temp_coeffs, 1994 .temp_coeffs_type = IIO_VAL_FRACTIONAL, 1995 .press_coeffs = bmp380_press_coeffs, 1996 .press_coeffs_type = IIO_VAL_FRACTIONAL, 1997 1998 .chip_config = bmp380_chip_config, 1999 .read_temp = bmp380_read_temp, 2000 .read_press = bmp380_read_press, 2001 .read_calib = bmp380_read_calib, 2002 .set_mode = bmp380_set_mode, 2003 .wait_conv = bmp380_wait_conv, 2004 .preinit = bmp380_preinit, 2005 2006 .trigger_probe = bmp380_trigger_probe, 2007 .trigger_handler = bmp380_trigger_handler, 2008 }; 2009 EXPORT_SYMBOL_NS(bmp380_chip_info, "IIO_BMP280"); 2010 2011 static int bmp580_soft_reset(struct bmp280_data *data) 2012 { 2013 unsigned int reg; 2014 int ret; 2015 2016 ret = regmap_write(data->regmap, BMP580_REG_CMD, BMP580_CMD_SOFT_RESET); 2017 if (ret) { 2018 dev_err(data->dev, "failed to send reset command to device\n"); 2019 return ret; 2020 } 2021 /* From datasheet's table 4: electrical characteristics */ 2022 fsleep(2000); 2023 2024 /* Dummy read of chip_id */ 2025 ret = regmap_read(data->regmap, BMP580_REG_CHIP_ID, ®); 2026 if (ret) { 2027 dev_err(data->dev, "failed to reestablish comms after reset\n"); 2028 return ret; 2029 } 2030 2031 ret = regmap_read(data->regmap, BMP580_REG_INT_STATUS, ®); 2032 if (ret) { 2033 dev_err(data->dev, "error reading interrupt status register\n"); 2034 return ret; 2035 } 2036 if (!(reg & BMP580_INT_STATUS_POR_MASK)) { 2037 dev_err(data->dev, "error resetting sensor\n"); 2038 return -EINVAL; 2039 } 2040 2041 return 0; 2042 } 2043 2044 /** 2045 * bmp580_nvm_operation() - Helper function to commit NVM memory operations 2046 * @data: sensor data struct 2047 * @is_write: flag to signal write operation 2048 */ 2049 static int bmp580_nvm_operation(struct bmp280_data *data, bool is_write) 2050 { 2051 unsigned long timeout, poll; 2052 unsigned int reg; 2053 int ret; 2054 2055 /* Check NVM ready flag */ 2056 ret = regmap_read(data->regmap, BMP580_REG_STATUS, ®); 2057 if (ret) { 2058 dev_err(data->dev, "failed to check nvm status\n"); 2059 return ret; 2060 } 2061 if (!(reg & BMP580_STATUS_NVM_RDY_MASK)) { 2062 dev_err(data->dev, "sensor's nvm is not ready\n"); 2063 return -EIO; 2064 } 2065 2066 /* Start NVM operation sequence */ 2067 ret = regmap_write(data->regmap, BMP580_REG_CMD, 2068 BMP580_CMD_NVM_OP_SEQ_0); 2069 if (ret) { 2070 dev_err(data->dev, 2071 "failed to send nvm operation's first sequence\n"); 2072 return ret; 2073 } 2074 if (is_write) { 2075 /* Send NVM write sequence */ 2076 ret = regmap_write(data->regmap, BMP580_REG_CMD, 2077 BMP580_CMD_NVM_WRITE_SEQ_1); 2078 if (ret) { 2079 dev_err(data->dev, 2080 "failed to send nvm write sequence\n"); 2081 return ret; 2082 } 2083 /* Datasheet says on 4.8.1.2 it takes approximately 10ms */ 2084 poll = 2000; 2085 timeout = 12000; 2086 } else { 2087 /* Send NVM read sequence */ 2088 ret = regmap_write(data->regmap, BMP580_REG_CMD, 2089 BMP580_CMD_NVM_READ_SEQ_1); 2090 if (ret) { 2091 dev_err(data->dev, 2092 "failed to send nvm read sequence\n"); 2093 return ret; 2094 } 2095 /* Datasheet says on 4.8.1.1 it takes approximately 200us */ 2096 poll = 50; 2097 timeout = 400; 2098 } 2099 2100 /* Wait until NVM is ready again */ 2101 ret = regmap_read_poll_timeout(data->regmap, BMP580_REG_STATUS, reg, 2102 (reg & BMP580_STATUS_NVM_RDY_MASK), 2103 poll, timeout); 2104 if (ret) { 2105 dev_err(data->dev, "error checking nvm operation status\n"); 2106 return ret; 2107 } 2108 2109 /* Check NVM error flags */ 2110 if ((reg & BMP580_STATUS_NVM_ERR_MASK) || (reg & BMP580_STATUS_NVM_CMD_ERR_MASK)) { 2111 dev_err(data->dev, "error processing nvm operation\n"); 2112 return -EIO; 2113 } 2114 2115 return 0; 2116 } 2117 2118 /* 2119 * Contrary to previous sensors families, compensation algorithm is builtin. 2120 * We are only required to read the register raw data and adapt the ranges 2121 * for what is expected on IIO ABI. 2122 */ 2123 2124 static int bmp580_read_temp(struct bmp280_data *data, s32 *raw_temp) 2125 { 2126 s32 value_temp; 2127 int ret; 2128 2129 ret = regmap_bulk_read(data->regmap, BMP580_REG_TEMP_XLSB, 2130 data->buf, BMP280_NUM_TEMP_BYTES); 2131 if (ret) { 2132 dev_err(data->dev, "failed to read temperature\n"); 2133 return ret; 2134 } 2135 2136 value_temp = get_unaligned_le24(data->buf); 2137 if (value_temp == BMP580_TEMP_SKIPPED) { 2138 dev_err(data->dev, "reading temperature skipped\n"); 2139 return -EIO; 2140 } 2141 *raw_temp = sign_extend32(value_temp, 23); 2142 2143 return 0; 2144 } 2145 2146 static int bmp580_read_press(struct bmp280_data *data, u32 *raw_press) 2147 { 2148 u32 value_press; 2149 int ret; 2150 2151 ret = regmap_bulk_read(data->regmap, BMP580_REG_PRESS_XLSB, 2152 data->buf, BMP280_NUM_PRESS_BYTES); 2153 if (ret) { 2154 dev_err(data->dev, "failed to read pressure\n"); 2155 return ret; 2156 } 2157 2158 value_press = get_unaligned_le24(data->buf); 2159 if (value_press == BMP580_PRESS_SKIPPED) { 2160 dev_err(data->dev, "reading pressure skipped\n"); 2161 return -EIO; 2162 } 2163 *raw_press = value_press; 2164 2165 return 0; 2166 } 2167 2168 static const int bmp580_odr_table[][2] = { 2169 [BMP580_ODR_240HZ] = {240, 0}, 2170 [BMP580_ODR_218HZ] = {218, 0}, 2171 [BMP580_ODR_199HZ] = {199, 0}, 2172 [BMP580_ODR_179HZ] = {179, 0}, 2173 [BMP580_ODR_160HZ] = {160, 0}, 2174 [BMP580_ODR_149HZ] = {149, 0}, 2175 [BMP580_ODR_140HZ] = {140, 0}, 2176 [BMP580_ODR_129HZ] = {129, 0}, 2177 [BMP580_ODR_120HZ] = {120, 0}, 2178 [BMP580_ODR_110HZ] = {110, 0}, 2179 [BMP580_ODR_100HZ] = {100, 0}, 2180 [BMP580_ODR_89HZ] = {89, 0}, 2181 [BMP580_ODR_80HZ] = {80, 0}, 2182 [BMP580_ODR_70HZ] = {70, 0}, 2183 [BMP580_ODR_60HZ] = {60, 0}, 2184 [BMP580_ODR_50HZ] = {50, 0}, 2185 [BMP580_ODR_45HZ] = {45, 0}, 2186 [BMP580_ODR_40HZ] = {40, 0}, 2187 [BMP580_ODR_35HZ] = {35, 0}, 2188 [BMP580_ODR_30HZ] = {30, 0}, 2189 [BMP580_ODR_25HZ] = {25, 0}, 2190 [BMP580_ODR_20HZ] = {20, 0}, 2191 [BMP580_ODR_15HZ] = {15, 0}, 2192 [BMP580_ODR_10HZ] = {10, 0}, 2193 [BMP580_ODR_5HZ] = {5, 0}, 2194 [BMP580_ODR_4HZ] = {4, 0}, 2195 [BMP580_ODR_3HZ] = {3, 0}, 2196 [BMP580_ODR_2HZ] = {2, 0}, 2197 [BMP580_ODR_1HZ] = {1, 0}, 2198 [BMP580_ODR_0_5HZ] = {0, 500000}, 2199 [BMP580_ODR_0_25HZ] = {0, 250000}, 2200 [BMP580_ODR_0_125HZ] = {0, 125000}, 2201 }; 2202 2203 static const int bmp580_nvmem_addrs[] = { 0x20, 0x21, 0x22 }; 2204 2205 static int bmp580_nvmem_read_impl(void *priv, unsigned int offset, void *val, 2206 size_t bytes) 2207 { 2208 struct bmp280_data *data = priv; 2209 u16 *dst = val; 2210 int ret, addr; 2211 2212 guard(mutex)(&data->lock); 2213 2214 /* Set sensor in standby mode */ 2215 ret = regmap_update_bits(data->regmap, BMP580_REG_ODR_CONFIG, 2216 BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS, 2217 BMP580_ODR_DEEPSLEEP_DIS | 2218 FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP)); 2219 if (ret) { 2220 dev_err(data->dev, "failed to change sensor to standby mode\n"); 2221 goto exit; 2222 } 2223 /* Wait standby transition time */ 2224 fsleep(2500); 2225 2226 while (bytes >= sizeof(*dst)) { 2227 addr = bmp580_nvmem_addrs[offset / sizeof(*dst)]; 2228 2229 ret = regmap_write(data->regmap, BMP580_REG_NVM_ADDR, 2230 FIELD_PREP(BMP580_NVM_ROW_ADDR_MASK, addr)); 2231 if (ret) { 2232 dev_err(data->dev, "error writing nvm address\n"); 2233 goto exit; 2234 } 2235 2236 ret = bmp580_nvm_operation(data, false); 2237 if (ret) 2238 goto exit; 2239 2240 ret = regmap_bulk_read(data->regmap, BMP580_REG_NVM_DATA_LSB, 2241 &data->le16, sizeof(data->le16)); 2242 if (ret) { 2243 dev_err(data->dev, "error reading nvm data regs\n"); 2244 goto exit; 2245 } 2246 2247 *dst++ = le16_to_cpu(data->le16); 2248 bytes -= sizeof(*dst); 2249 offset += sizeof(*dst); 2250 } 2251 exit: 2252 /* Restore chip config */ 2253 data->chip_info->chip_config(data); 2254 return ret; 2255 } 2256 2257 static int bmp580_nvmem_read(void *priv, unsigned int offset, void *val, 2258 size_t bytes) 2259 { 2260 struct bmp280_data *data = priv; 2261 int ret; 2262 2263 ret = pm_runtime_resume_and_get(data->dev); 2264 if (ret < 0) 2265 return ret; 2266 2267 ret = bmp580_nvmem_read_impl(priv, offset, val, bytes); 2268 pm_runtime_put_autosuspend(data->dev); 2269 2270 return ret; 2271 } 2272 2273 static int bmp580_nvmem_write_impl(void *priv, unsigned int offset, void *val, 2274 size_t bytes) 2275 { 2276 struct bmp280_data *data = priv; 2277 u16 *buf = val; 2278 int ret, addr; 2279 2280 guard(mutex)(&data->lock); 2281 2282 /* Set sensor in standby mode */ 2283 ret = regmap_update_bits(data->regmap, BMP580_REG_ODR_CONFIG, 2284 BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS, 2285 BMP580_ODR_DEEPSLEEP_DIS | 2286 FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP)); 2287 if (ret) { 2288 dev_err(data->dev, "failed to change sensor to standby mode\n"); 2289 goto exit; 2290 } 2291 /* Wait standby transition time */ 2292 fsleep(2500); 2293 2294 while (bytes >= sizeof(*buf)) { 2295 addr = bmp580_nvmem_addrs[offset / sizeof(*buf)]; 2296 2297 ret = regmap_write(data->regmap, BMP580_REG_NVM_ADDR, 2298 BMP580_NVM_PROG_EN | 2299 FIELD_PREP(BMP580_NVM_ROW_ADDR_MASK, addr)); 2300 if (ret) { 2301 dev_err(data->dev, "error writing nvm address\n"); 2302 goto exit; 2303 } 2304 data->le16 = cpu_to_le16(*buf++); 2305 2306 ret = regmap_bulk_write(data->regmap, BMP580_REG_NVM_DATA_LSB, 2307 &data->le16, sizeof(data->le16)); 2308 if (ret) { 2309 dev_err(data->dev, "error writing LSB NVM data regs\n"); 2310 goto exit; 2311 } 2312 2313 ret = bmp580_nvm_operation(data, true); 2314 if (ret) 2315 goto exit; 2316 2317 /* Disable programming mode bit */ 2318 ret = regmap_clear_bits(data->regmap, BMP580_REG_NVM_ADDR, 2319 BMP580_NVM_PROG_EN); 2320 if (ret) { 2321 dev_err(data->dev, "error resetting nvm write\n"); 2322 goto exit; 2323 } 2324 2325 bytes -= sizeof(*buf); 2326 offset += sizeof(*buf); 2327 } 2328 exit: 2329 /* Restore chip config */ 2330 data->chip_info->chip_config(data); 2331 return ret; 2332 } 2333 2334 static int bmp580_nvmem_write(void *priv, unsigned int offset, void *val, 2335 size_t bytes) 2336 { 2337 struct bmp280_data *data = priv; 2338 int ret; 2339 2340 ret = pm_runtime_resume_and_get(data->dev); 2341 if (ret < 0) 2342 return ret; 2343 2344 ret = bmp580_nvmem_write_impl(priv, offset, val, bytes); 2345 pm_runtime_put_autosuspend(data->dev); 2346 2347 return ret; 2348 } 2349 2350 static int bmp580_preinit(struct bmp280_data *data) 2351 { 2352 struct nvmem_config config = { 2353 .dev = data->dev, 2354 .priv = data, 2355 .name = "bmp580_nvmem", 2356 .word_size = sizeof(u16), 2357 .stride = sizeof(u16), 2358 .size = 3 * sizeof(u16), 2359 .reg_read = bmp580_nvmem_read, 2360 .reg_write = bmp580_nvmem_write, 2361 }; 2362 unsigned int reg; 2363 int ret; 2364 2365 /* Issue soft-reset command */ 2366 ret = bmp580_soft_reset(data); 2367 if (ret) 2368 return ret; 2369 2370 /* Post powerup sequence */ 2371 ret = regmap_read(data->regmap, BMP580_REG_CHIP_ID, ®); 2372 if (ret) { 2373 dev_err(data->dev, "failed to establish comms with the chip\n"); 2374 return ret; 2375 } 2376 2377 /* Print warn message if we don't know the chip id */ 2378 if (reg != BMP580_CHIP_ID && reg != BMP580_CHIP_ID_ALT) 2379 dev_warn(data->dev, "unexpected chip_id\n"); 2380 2381 ret = regmap_read(data->regmap, BMP580_REG_STATUS, ®); 2382 if (ret) { 2383 dev_err(data->dev, "failed to read nvm status\n"); 2384 return ret; 2385 } 2386 2387 /* Check nvm status */ 2388 if (!(reg & BMP580_STATUS_NVM_RDY_MASK) || (reg & BMP580_STATUS_NVM_ERR_MASK)) { 2389 dev_err(data->dev, "nvm error on powerup sequence\n"); 2390 return -EIO; 2391 } 2392 2393 /* Register nvmem device */ 2394 return PTR_ERR_OR_ZERO(devm_nvmem_register(config.dev, &config)); 2395 } 2396 2397 static const u8 bmp580_operation_mode[] = { 2398 [BMP280_SLEEP] = BMP580_MODE_SLEEP, 2399 [BMP280_FORCED] = BMP580_MODE_FORCED, 2400 [BMP280_NORMAL] = BMP580_MODE_NORMAL, 2401 }; 2402 2403 static int bmp580_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode) 2404 { 2405 struct device *dev = data->dev; 2406 int ret; 2407 2408 if (mode == BMP280_FORCED) { 2409 ret = regmap_set_bits(data->regmap, BMP580_REG_DSP_CONFIG, 2410 BMP580_DSP_IIR_FORCED_FLUSH); 2411 if (ret) { 2412 dev_err(dev, "Could not flush IIR filter constants.\n"); 2413 return ret; 2414 } 2415 } 2416 2417 ret = regmap_write_bits(data->regmap, BMP580_REG_ODR_CONFIG, 2418 BMP580_MODE_MASK, 2419 FIELD_PREP(BMP580_MODE_MASK, 2420 bmp580_operation_mode[mode])); 2421 if (ret) { 2422 dev_err(dev, "failed to write power control register.\n"); 2423 return ret; 2424 } 2425 2426 data->op_mode = mode; 2427 2428 return 0; 2429 } 2430 2431 static int bmp580_wait_conv(struct bmp280_data *data) 2432 { 2433 /* 2434 * Taken from datasheet, Section 2 "Specification, Table 3 "Electrical 2435 * characteristics. 2436 */ 2437 static const int time_conv_press[] = { 2438 0, 1050, 1785, 3045, 5670, 10920, 21420, 42420, 2439 84420, 2440 }; 2441 static const int time_conv_temp[] = { 2442 0, 1050, 1105, 1575, 2205, 3465, 6090, 11340, 2443 21840, 2444 }; 2445 int meas_time_us; 2446 2447 meas_time_us = 4 * USEC_PER_MSEC + 2448 time_conv_temp[data->oversampling_temp] + 2449 time_conv_press[data->oversampling_press]; 2450 2451 /* 2452 * Measurement time mentioned in Chapter 2, Table 4 of the datasheet. 2453 * The extra 4ms is the required mode change to start of measurement 2454 * time. 2455 */ 2456 fsleep(meas_time_us); 2457 2458 return 0; 2459 } 2460 2461 static int bmp580_chip_config(struct bmp280_data *data) 2462 { 2463 bool change = false, aux; 2464 unsigned int tmp; 2465 u8 reg_val; 2466 int ret; 2467 2468 /* Sets sensor in standby mode */ 2469 ret = regmap_update_bits(data->regmap, BMP580_REG_ODR_CONFIG, 2470 BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS, 2471 BMP580_ODR_DEEPSLEEP_DIS | 2472 FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP)); 2473 if (ret) { 2474 dev_err(data->dev, "failed to change sensor to standby mode\n"); 2475 return ret; 2476 } 2477 /* From datasheet's table 4: electrical characteristics */ 2478 fsleep(2500); 2479 2480 /* Set default DSP mode settings */ 2481 reg_val = FIELD_PREP(BMP580_DSP_COMP_MASK, BMP580_DSP_PRESS_TEMP_COMP_EN) | 2482 BMP580_DSP_SHDW_IIR_TEMP_EN | BMP580_DSP_SHDW_IIR_PRESS_EN; 2483 2484 ret = regmap_update_bits(data->regmap, BMP580_REG_DSP_CONFIG, 2485 BMP580_DSP_COMP_MASK | 2486 BMP580_DSP_SHDW_IIR_TEMP_EN | 2487 BMP580_DSP_SHDW_IIR_PRESS_EN, reg_val); 2488 if (ret) { 2489 dev_err(data->dev, "failed to change DSP mode settings\n"); 2490 return ret; 2491 } 2492 2493 /* Configure oversampling */ 2494 reg_val = FIELD_PREP(BMP580_OSR_TEMP_MASK, data->oversampling_temp) | 2495 FIELD_PREP(BMP580_OSR_PRESS_MASK, data->oversampling_press) | 2496 BMP580_OSR_PRESS_EN; 2497 2498 ret = regmap_update_bits_check(data->regmap, BMP580_REG_OSR_CONFIG, 2499 BMP580_OSR_TEMP_MASK | 2500 BMP580_OSR_PRESS_MASK | 2501 BMP580_OSR_PRESS_EN, 2502 reg_val, &aux); 2503 if (ret) { 2504 dev_err(data->dev, "failed to write oversampling register\n"); 2505 return ret; 2506 } 2507 change = change || aux; 2508 2509 /* Configure output data rate */ 2510 ret = regmap_update_bits_check(data->regmap, BMP580_REG_ODR_CONFIG, BMP580_ODR_MASK, 2511 FIELD_PREP(BMP580_ODR_MASK, data->sampling_freq), 2512 &aux); 2513 if (ret) { 2514 dev_err(data->dev, "failed to write ODR configuration register\n"); 2515 return ret; 2516 } 2517 change = change || aux; 2518 2519 /* Set filter data */ 2520 reg_val = FIELD_PREP(BMP580_DSP_IIR_PRESS_MASK, data->iir_filter_coeff) | 2521 FIELD_PREP(BMP580_DSP_IIR_TEMP_MASK, data->iir_filter_coeff); 2522 2523 ret = regmap_update_bits(data->regmap, BMP580_REG_DSP_IIR, 2524 BMP580_DSP_IIR_PRESS_MASK | BMP580_DSP_IIR_TEMP_MASK, 2525 reg_val); 2526 if (ret) { 2527 dev_err(data->dev, "failed to write config register\n"); 2528 return ret; 2529 } 2530 2531 if (change) { 2532 /* 2533 * Check if ODR and OSR settings are valid or we are 2534 * operating in a degraded mode. 2535 */ 2536 ret = regmap_read(data->regmap, BMP580_REG_EFF_OSR, &tmp); 2537 if (ret) { 2538 dev_err(data->dev, 2539 "error reading effective OSR register\n"); 2540 return ret; 2541 } 2542 if (!(tmp & BMP580_EFF_OSR_VALID_ODR)) { 2543 dev_warn(data->dev, "OSR and ODR incompatible settings detected\n"); 2544 /* Set current OSR settings from data on effective OSR */ 2545 data->oversampling_temp = FIELD_GET(BMP580_EFF_OSR_TEMP_MASK, tmp); 2546 data->oversampling_press = FIELD_GET(BMP580_EFF_OSR_PRESS_MASK, tmp); 2547 return -EINVAL; 2548 } 2549 } 2550 2551 return 0; 2552 } 2553 2554 static int bmp580_data_rdy_trigger_set_state(struct iio_trigger *trig, 2555 bool state) 2556 { 2557 struct bmp280_data *data = iio_trigger_get_drvdata(trig); 2558 int ret; 2559 2560 guard(mutex)(&data->lock); 2561 2562 ret = regmap_update_bits(data->regmap, BMP580_REG_INT_CONFIG, 2563 BMP580_INT_CONFIG_INT_EN, 2564 FIELD_PREP(BMP580_INT_CONFIG_INT_EN, !!state)); 2565 if (ret) 2566 dev_err(data->dev, 2567 "Could not %s interrupt.\n", str_enable_disable(state)); 2568 return ret; 2569 } 2570 2571 static const struct iio_trigger_ops bmp580_trigger_ops = { 2572 .set_trigger_state = &bmp580_data_rdy_trigger_set_state, 2573 }; 2574 2575 static int bmp580_int_pin_config(struct bmp280_data *data) 2576 { 2577 int pin_drive_cfg = FIELD_PREP(BMP580_INT_CONFIG_OPEN_DRAIN, 2578 data->trig_open_drain); 2579 int pin_level_cfg = FIELD_PREP(BMP580_INT_CONFIG_LEVEL, 2580 data->trig_active_high); 2581 int ret, int_pin_cfg = pin_drive_cfg | pin_level_cfg; 2582 2583 ret = regmap_update_bits(data->regmap, BMP580_REG_INT_CONFIG, 2584 BMP580_INT_CONFIG_MASK, int_pin_cfg); 2585 if (ret) { 2586 dev_err(data->dev, "Could not set interrupt settings.\n"); 2587 return ret; 2588 } 2589 2590 ret = regmap_set_bits(data->regmap, BMP580_REG_INT_SOURCE, 2591 BMP580_INT_SOURCE_DRDY); 2592 if (ret) 2593 dev_err(data->dev, "Could not set interrupt source.\n"); 2594 2595 return ret; 2596 } 2597 2598 static irqreturn_t bmp580_irq_thread_handler(int irq, void *p) 2599 { 2600 struct iio_dev *indio_dev = p; 2601 struct bmp280_data *data = iio_priv(indio_dev); 2602 unsigned int int_ctrl; 2603 int ret; 2604 2605 ret = regmap_read(data->regmap, BMP580_REG_INT_STATUS, &int_ctrl); 2606 if (ret) 2607 return IRQ_NONE; 2608 2609 if (FIELD_GET(BMP580_INT_STATUS_DRDY_MASK, int_ctrl)) 2610 iio_trigger_poll_nested(data->trig); 2611 2612 return IRQ_HANDLED; 2613 } 2614 2615 static int bmp580_trigger_probe(struct iio_dev *indio_dev) 2616 { 2617 return __bmp280_trigger_probe(indio_dev, &bmp580_trigger_ops, 2618 bmp580_int_pin_config, 2619 bmp580_irq_thread_handler); 2620 } 2621 2622 static irqreturn_t bmp580_trigger_handler(int irq, void *p) 2623 { 2624 struct iio_poll_func *pf = p; 2625 struct iio_dev *indio_dev = pf->indio_dev; 2626 struct bmp280_data *data = iio_priv(indio_dev); 2627 struct { 2628 __le32 comp_temp; 2629 __le32 comp_press; 2630 aligned_s64 timestamp; 2631 } buffer = { }; 2632 int ret; 2633 2634 guard(mutex)(&data->lock); 2635 2636 /* Burst read data registers */ 2637 ret = regmap_bulk_read(data->regmap, BMP580_REG_TEMP_XLSB, 2638 data->buf, BMP280_BURST_READ_BYTES); 2639 if (ret) { 2640 dev_err(data->dev, "failed to burst read sensor data\n"); 2641 goto out; 2642 } 2643 2644 /* Pressure calculations */ 2645 memcpy(&buffer.comp_press, &data->buf[3], 3); 2646 2647 /* Temperature calculations */ 2648 memcpy(&buffer.comp_temp, &data->buf[0], 3); 2649 2650 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer), 2651 iio_get_time_ns(indio_dev)); 2652 2653 out: 2654 iio_trigger_notify_done(indio_dev->trig); 2655 2656 return IRQ_HANDLED; 2657 } 2658 2659 static const int bmp580_oversampling_avail[] = { 1, 2, 4, 8, 16, 32, 64, 128 }; 2660 static const u8 bmp580_chip_ids[] = { BMP580_CHIP_ID, BMP580_CHIP_ID_ALT }; 2661 /* Instead of { 1000, 16 } we do this, to avoid overflow issues */ 2662 static const int bmp580_temp_coeffs[] = { 125, 13 }; 2663 static const int bmp580_press_coeffs[] = { 1, 64000}; 2664 2665 const struct bmp280_chip_info bmp580_chip_info = { 2666 .id_reg = BMP580_REG_CHIP_ID, 2667 .chip_id = bmp580_chip_ids, 2668 .num_chip_id = ARRAY_SIZE(bmp580_chip_ids), 2669 .regmap_config = &bmp580_regmap_config, 2670 .start_up_time_us = 2000, 2671 .channels = bmp580_channels, 2672 .num_channels = ARRAY_SIZE(bmp580_channels), 2673 .avail_scan_masks = bmp280_avail_scan_masks, 2674 2675 .oversampling_temp_avail = bmp580_oversampling_avail, 2676 .num_oversampling_temp_avail = ARRAY_SIZE(bmp580_oversampling_avail), 2677 .oversampling_temp_default = ilog2(1), 2678 2679 .oversampling_press_avail = bmp580_oversampling_avail, 2680 .num_oversampling_press_avail = ARRAY_SIZE(bmp580_oversampling_avail), 2681 .oversampling_press_default = ilog2(4), 2682 2683 .sampling_freq_avail = bmp580_odr_table, 2684 .num_sampling_freq_avail = ARRAY_SIZE(bmp580_odr_table) * 2, 2685 .sampling_freq_default = BMP580_ODR_50HZ, 2686 2687 .iir_filter_coeffs_avail = bmp380_iir_filter_coeffs_avail, 2688 .num_iir_filter_coeffs_avail = ARRAY_SIZE(bmp380_iir_filter_coeffs_avail), 2689 .iir_filter_coeff_default = 2, 2690 2691 .temp_coeffs = bmp580_temp_coeffs, 2692 .temp_coeffs_type = IIO_VAL_FRACTIONAL_LOG2, 2693 .press_coeffs = bmp580_press_coeffs, 2694 .press_coeffs_type = IIO_VAL_FRACTIONAL, 2695 2696 .chip_config = bmp580_chip_config, 2697 .read_temp = bmp580_read_temp, 2698 .read_press = bmp580_read_press, 2699 .set_mode = bmp580_set_mode, 2700 .wait_conv = bmp580_wait_conv, 2701 .preinit = bmp580_preinit, 2702 2703 .trigger_probe = bmp580_trigger_probe, 2704 .trigger_handler = bmp580_trigger_handler, 2705 }; 2706 EXPORT_SYMBOL_NS(bmp580_chip_info, "IIO_BMP280"); 2707 2708 static int bmp180_wait_for_eoc(struct bmp280_data *data, u8 ctrl_meas) 2709 { 2710 static const int conversion_time_max[] = { 4500, 7500, 13500, 25500 }; 2711 unsigned int delay_us; 2712 unsigned int ctrl; 2713 int ret; 2714 2715 if (data->use_eoc) 2716 reinit_completion(&data->done); 2717 2718 ret = regmap_write(data->regmap, BMP280_REG_CTRL_MEAS, ctrl_meas); 2719 if (ret) { 2720 dev_err(data->dev, "failed to write crtl_meas register\n"); 2721 return ret; 2722 } 2723 2724 if (data->use_eoc) { 2725 /* 2726 * If we have a completion interrupt, use it, wait up to 2727 * 100ms. The longest conversion time listed is 76.5 ms for 2728 * advanced resolution mode. 2729 */ 2730 ret = wait_for_completion_timeout(&data->done, 2731 1 + msecs_to_jiffies(100)); 2732 if (!ret) 2733 dev_err(data->dev, "timeout waiting for completion\n"); 2734 } else { 2735 if (FIELD_GET(BMP180_MEAS_CTRL_MASK, ctrl_meas) == BMP180_MEAS_TEMP) 2736 delay_us = 4500; 2737 else 2738 delay_us = 2739 conversion_time_max[data->oversampling_press]; 2740 2741 fsleep(delay_us); 2742 } 2743 2744 ret = regmap_read(data->regmap, BMP280_REG_CTRL_MEAS, &ctrl); 2745 if (ret) { 2746 dev_err(data->dev, "failed to read ctrl_meas register\n"); 2747 return ret; 2748 } 2749 2750 /* The value of this bit reset to "0" after conversion is complete */ 2751 if (ctrl & BMP180_MEAS_SCO) { 2752 dev_err(data->dev, "conversion didn't complete\n"); 2753 return -EIO; 2754 } 2755 2756 return 0; 2757 } 2758 2759 static int bmp180_read_temp_adc(struct bmp280_data *data, u32 *adc_temp) 2760 { 2761 int ret; 2762 2763 ret = bmp180_wait_for_eoc(data, 2764 FIELD_PREP(BMP180_MEAS_CTRL_MASK, BMP180_MEAS_TEMP) | 2765 BMP180_MEAS_SCO); 2766 if (ret) 2767 return ret; 2768 2769 ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB, 2770 &data->be16, sizeof(data->be16)); 2771 if (ret) { 2772 dev_err(data->dev, "failed to read temperature\n"); 2773 return ret; 2774 } 2775 2776 *adc_temp = be16_to_cpu(data->be16); 2777 2778 return 0; 2779 } 2780 2781 static int bmp180_read_calib(struct bmp280_data *data) 2782 { 2783 struct bmp180_calib *calib = &data->calib.bmp180; 2784 int ret; 2785 int i; 2786 2787 ret = regmap_bulk_read(data->regmap, BMP180_REG_CALIB_START, 2788 data->bmp180_cal_buf, sizeof(data->bmp180_cal_buf)); 2789 if (ret) { 2790 dev_err(data->dev, "failed to read calibration parameters\n"); 2791 return ret; 2792 } 2793 2794 /* None of the words has the value 0 or 0xFFFF */ 2795 for (i = 0; i < ARRAY_SIZE(data->bmp180_cal_buf); i++) { 2796 if (data->bmp180_cal_buf[i] == cpu_to_be16(0) || 2797 data->bmp180_cal_buf[i] == cpu_to_be16(0xffff)) 2798 return -EIO; 2799 } 2800 2801 /* Toss the calibration data into the entropy pool */ 2802 add_device_randomness(data->bmp180_cal_buf, 2803 sizeof(data->bmp180_cal_buf)); 2804 2805 calib->AC1 = be16_to_cpu(data->bmp180_cal_buf[AC1]); 2806 calib->AC2 = be16_to_cpu(data->bmp180_cal_buf[AC2]); 2807 calib->AC3 = be16_to_cpu(data->bmp180_cal_buf[AC3]); 2808 calib->AC4 = be16_to_cpu(data->bmp180_cal_buf[AC4]); 2809 calib->AC5 = be16_to_cpu(data->bmp180_cal_buf[AC5]); 2810 calib->AC6 = be16_to_cpu(data->bmp180_cal_buf[AC6]); 2811 calib->B1 = be16_to_cpu(data->bmp180_cal_buf[B1]); 2812 calib->B2 = be16_to_cpu(data->bmp180_cal_buf[B2]); 2813 calib->MB = be16_to_cpu(data->bmp180_cal_buf[MB]); 2814 calib->MC = be16_to_cpu(data->bmp180_cal_buf[MC]); 2815 calib->MD = be16_to_cpu(data->bmp180_cal_buf[MD]); 2816 2817 return 0; 2818 } 2819 2820 /* 2821 * Returns temperature in DegC, resolution is 0.1 DegC. 2822 * t_fine carries fine temperature as global value. 2823 * 2824 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature". 2825 */ 2826 2827 static s32 bmp180_calc_t_fine(struct bmp280_data *data, u32 adc_temp) 2828 { 2829 struct bmp180_calib *calib = &data->calib.bmp180; 2830 s32 x1, x2; 2831 2832 x1 = ((((s32)adc_temp) - calib->AC6) * calib->AC5) >> 15; 2833 x2 = (calib->MC << 11) / (x1 + calib->MD); 2834 return x1 + x2; /* t_fine = x1 + x2; */ 2835 } 2836 2837 static int bmp180_get_t_fine(struct bmp280_data *data, s32 *t_fine) 2838 { 2839 s32 adc_temp; 2840 int ret; 2841 2842 ret = bmp180_read_temp_adc(data, &adc_temp); 2843 if (ret) 2844 return ret; 2845 2846 *t_fine = bmp180_calc_t_fine(data, adc_temp); 2847 2848 return 0; 2849 } 2850 2851 static s32 bmp180_compensate_temp(struct bmp280_data *data, u32 adc_temp) 2852 { 2853 return (bmp180_calc_t_fine(data, adc_temp) + 8) / 16; 2854 } 2855 2856 static int bmp180_read_temp(struct bmp280_data *data, s32 *comp_temp) 2857 { 2858 u32 adc_temp; 2859 int ret; 2860 2861 ret = bmp180_read_temp_adc(data, &adc_temp); 2862 if (ret) 2863 return ret; 2864 2865 *comp_temp = bmp180_compensate_temp(data, adc_temp); 2866 2867 return 0; 2868 } 2869 2870 static int bmp180_read_press_adc(struct bmp280_data *data, u32 *adc_press) 2871 { 2872 u8 oss = data->oversampling_press; 2873 int ret; 2874 2875 ret = bmp180_wait_for_eoc(data, 2876 FIELD_PREP(BMP180_MEAS_CTRL_MASK, BMP180_MEAS_PRESS) | 2877 FIELD_PREP(BMP180_OSRS_PRESS_MASK, oss) | 2878 BMP180_MEAS_SCO); 2879 if (ret) 2880 return ret; 2881 2882 ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB, 2883 data->buf, BMP280_NUM_PRESS_BYTES); 2884 if (ret) { 2885 dev_err(data->dev, "failed to read pressure\n"); 2886 return ret; 2887 } 2888 2889 *adc_press = get_unaligned_be24(data->buf) >> (8 - oss); 2890 2891 return 0; 2892 } 2893 2894 /* 2895 * Returns pressure in Pa, resolution is 1 Pa. 2896 * 2897 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature". 2898 */ 2899 static u32 bmp180_compensate_press(struct bmp280_data *data, u32 adc_press, 2900 s32 t_fine) 2901 { 2902 struct bmp180_calib *calib = &data->calib.bmp180; 2903 s32 oss = data->oversampling_press; 2904 s32 x1, x2, x3, p; 2905 s32 b3, b6; 2906 u32 b4, b7; 2907 2908 b6 = t_fine - 4000; 2909 x1 = (calib->B2 * (b6 * b6 >> 12)) >> 11; 2910 x2 = calib->AC2 * b6 >> 11; 2911 x3 = x1 + x2; 2912 b3 = ((((s32)calib->AC1 * 4 + x3) << oss) + 2) / 4; 2913 x1 = calib->AC3 * b6 >> 13; 2914 x2 = (calib->B1 * ((b6 * b6) >> 12)) >> 16; 2915 x3 = (x1 + x2 + 2) >> 2; 2916 b4 = calib->AC4 * (u32)(x3 + 32768) >> 15; 2917 b7 = (adc_press - b3) * (50000 >> oss); 2918 if (b7 < 0x80000000) 2919 p = (b7 * 2) / b4; 2920 else 2921 p = (b7 / b4) * 2; 2922 2923 x1 = (p >> 8) * (p >> 8); 2924 x1 = (x1 * 3038) >> 16; 2925 x2 = (-7357 * p) >> 16; 2926 2927 return p + ((x1 + x2 + 3791) >> 4); 2928 } 2929 2930 static int bmp180_read_press(struct bmp280_data *data, u32 *comp_press) 2931 { 2932 u32 adc_press; 2933 s32 t_fine; 2934 int ret; 2935 2936 ret = bmp180_get_t_fine(data, &t_fine); 2937 if (ret) 2938 return ret; 2939 2940 ret = bmp180_read_press_adc(data, &adc_press); 2941 if (ret) 2942 return ret; 2943 2944 *comp_press = bmp180_compensate_press(data, adc_press, t_fine); 2945 2946 return 0; 2947 } 2948 2949 /* Keep compatibility with newer generations of the sensor */ 2950 static int bmp180_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode) 2951 { 2952 return 0; 2953 } 2954 2955 /* Keep compatibility with newer generations of the sensor */ 2956 static int bmp180_wait_conv(struct bmp280_data *data) 2957 { 2958 return 0; 2959 } 2960 2961 /* Keep compatibility with newer generations of the sensor */ 2962 static int bmp180_chip_config(struct bmp280_data *data) 2963 { 2964 return 0; 2965 } 2966 2967 static irqreturn_t bmp180_trigger_handler(int irq, void *p) 2968 { 2969 struct iio_poll_func *pf = p; 2970 struct iio_dev *indio_dev = pf->indio_dev; 2971 struct bmp280_data *data = iio_priv(indio_dev); 2972 struct { 2973 u32 comp_press; 2974 s32 comp_temp; 2975 aligned_s64 timestamp; 2976 } buffer; 2977 int ret; 2978 2979 guard(mutex)(&data->lock); 2980 2981 ret = bmp180_read_temp(data, &buffer.comp_temp); 2982 if (ret) 2983 goto out; 2984 2985 2986 ret = bmp180_read_press(data, &buffer.comp_press); 2987 if (ret) 2988 goto out; 2989 2990 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer), 2991 iio_get_time_ns(indio_dev)); 2992 2993 out: 2994 iio_trigger_notify_done(indio_dev->trig); 2995 2996 return IRQ_HANDLED; 2997 } 2998 2999 static const int bmp180_oversampling_temp_avail[] = { 1 }; 3000 static const int bmp180_oversampling_press_avail[] = { 1, 2, 4, 8 }; 3001 static const u8 bmp180_chip_ids[] = { BMP180_CHIP_ID }; 3002 static const int bmp180_temp_coeffs[] = { 100, 1 }; 3003 static const int bmp180_press_coeffs[] = { 1, 1000 }; 3004 3005 const struct bmp280_chip_info bmp180_chip_info = { 3006 .id_reg = BMP280_REG_ID, 3007 .chip_id = bmp180_chip_ids, 3008 .num_chip_id = ARRAY_SIZE(bmp180_chip_ids), 3009 .regmap_config = &bmp180_regmap_config, 3010 .start_up_time_us = 2000, 3011 .channels = bmp280_channels, 3012 .num_channels = ARRAY_SIZE(bmp280_channels), 3013 .avail_scan_masks = bmp280_avail_scan_masks, 3014 3015 .oversampling_temp_avail = bmp180_oversampling_temp_avail, 3016 .num_oversampling_temp_avail = 3017 ARRAY_SIZE(bmp180_oversampling_temp_avail), 3018 .oversampling_temp_default = 0, 3019 3020 .oversampling_press_avail = bmp180_oversampling_press_avail, 3021 .num_oversampling_press_avail = 3022 ARRAY_SIZE(bmp180_oversampling_press_avail), 3023 .oversampling_press_default = BMP180_MEAS_PRESS_8X, 3024 3025 .temp_coeffs = bmp180_temp_coeffs, 3026 .temp_coeffs_type = IIO_VAL_FRACTIONAL, 3027 .press_coeffs = bmp180_press_coeffs, 3028 .press_coeffs_type = IIO_VAL_FRACTIONAL, 3029 3030 .chip_config = bmp180_chip_config, 3031 .read_temp = bmp180_read_temp, 3032 .read_press = bmp180_read_press, 3033 .read_calib = bmp180_read_calib, 3034 .set_mode = bmp180_set_mode, 3035 .wait_conv = bmp180_wait_conv, 3036 3037 .trigger_handler = bmp180_trigger_handler, 3038 }; 3039 EXPORT_SYMBOL_NS(bmp180_chip_info, "IIO_BMP280"); 3040 3041 static irqreturn_t bmp085_eoc_irq(int irq, void *d) 3042 { 3043 struct bmp280_data *data = d; 3044 3045 complete(&data->done); 3046 3047 return IRQ_HANDLED; 3048 } 3049 3050 static int bmp085_trigger_probe(struct iio_dev *indio_dev) 3051 { 3052 struct bmp280_data *data = iio_priv(indio_dev); 3053 struct device *dev = data->dev; 3054 unsigned long irq_trig; 3055 int ret, irq; 3056 3057 irq = fwnode_irq_get(dev_fwnode(dev), 0); 3058 if (irq < 0) 3059 return dev_err_probe(dev, irq, "No interrupt found.\n"); 3060 3061 irq_trig = irq_get_trigger_type(irq); 3062 if (irq_trig != IRQF_TRIGGER_RISING) { 3063 dev_err(dev, "non-rising trigger given for EOC interrupt, trying to enforce it\n"); 3064 irq_trig = IRQF_TRIGGER_RISING; 3065 } 3066 3067 init_completion(&data->done); 3068 3069 ret = devm_request_irq(dev, irq, bmp085_eoc_irq, irq_trig, 3070 indio_dev->name, data); 3071 if (ret) { 3072 /* Bail out without IRQ but keep the driver in place */ 3073 dev_err(dev, "unable to request DRDY IRQ\n"); 3074 return 0; 3075 } 3076 3077 data->use_eoc = true; 3078 3079 return 0; 3080 } 3081 3082 /* Identical to bmp180_chip_info + bmp085_trigger_probe */ 3083 const struct bmp280_chip_info bmp085_chip_info = { 3084 .id_reg = BMP280_REG_ID, 3085 .chip_id = bmp180_chip_ids, 3086 .num_chip_id = ARRAY_SIZE(bmp180_chip_ids), 3087 .regmap_config = &bmp180_regmap_config, 3088 .start_up_time_us = 2000, 3089 .channels = bmp280_channels, 3090 .num_channels = ARRAY_SIZE(bmp280_channels), 3091 .avail_scan_masks = bmp280_avail_scan_masks, 3092 3093 .oversampling_temp_avail = bmp180_oversampling_temp_avail, 3094 .num_oversampling_temp_avail = 3095 ARRAY_SIZE(bmp180_oversampling_temp_avail), 3096 .oversampling_temp_default = 0, 3097 3098 .oversampling_press_avail = bmp180_oversampling_press_avail, 3099 .num_oversampling_press_avail = 3100 ARRAY_SIZE(bmp180_oversampling_press_avail), 3101 .oversampling_press_default = BMP180_MEAS_PRESS_8X, 3102 3103 .temp_coeffs = bmp180_temp_coeffs, 3104 .temp_coeffs_type = IIO_VAL_FRACTIONAL, 3105 .press_coeffs = bmp180_press_coeffs, 3106 .press_coeffs_type = IIO_VAL_FRACTIONAL, 3107 3108 .chip_config = bmp180_chip_config, 3109 .read_temp = bmp180_read_temp, 3110 .read_press = bmp180_read_press, 3111 .read_calib = bmp180_read_calib, 3112 .set_mode = bmp180_set_mode, 3113 .wait_conv = bmp180_wait_conv, 3114 3115 .trigger_probe = bmp085_trigger_probe, 3116 .trigger_handler = bmp180_trigger_handler, 3117 }; 3118 EXPORT_SYMBOL_NS(bmp085_chip_info, "IIO_BMP280"); 3119 3120 static int bmp280_buffer_preenable(struct iio_dev *indio_dev) 3121 { 3122 struct bmp280_data *data = iio_priv(indio_dev); 3123 int ret; 3124 3125 ret = pm_runtime_resume_and_get(data->dev); 3126 if (ret < 0) 3127 return ret; 3128 3129 ret = data->chip_info->set_mode(data, BMP280_NORMAL); 3130 if (ret) 3131 pm_runtime_put_autosuspend(data->dev); 3132 3133 return ret; 3134 } 3135 3136 static int bmp280_buffer_postdisable(struct iio_dev *indio_dev) 3137 { 3138 struct bmp280_data *data = iio_priv(indio_dev); 3139 3140 pm_runtime_put_autosuspend(data->dev); 3141 3142 return 0; 3143 } 3144 3145 static const struct iio_buffer_setup_ops bmp280_buffer_setup_ops = { 3146 .preenable = bmp280_buffer_preenable, 3147 .postdisable = bmp280_buffer_postdisable, 3148 }; 3149 3150 static void bmp280_pm_disable(void *data) 3151 { 3152 struct device *dev = data; 3153 3154 pm_runtime_get_sync(dev); 3155 pm_runtime_put_noidle(dev); 3156 pm_runtime_disable(dev); 3157 } 3158 3159 static void bmp280_regulators_disable(void *data) 3160 { 3161 struct regulator_bulk_data *supplies = data; 3162 3163 regulator_bulk_disable(BMP280_NUM_SUPPLIES, supplies); 3164 } 3165 3166 int bmp280_common_probe(struct device *dev, 3167 struct regmap *regmap, 3168 const struct bmp280_chip_info *chip_info, 3169 const char *name, 3170 int irq) 3171 { 3172 struct iio_dev *indio_dev; 3173 struct bmp280_data *data; 3174 struct gpio_desc *gpiod; 3175 unsigned int chip_id; 3176 unsigned int i; 3177 int ret; 3178 3179 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 3180 if (!indio_dev) 3181 return -ENOMEM; 3182 3183 data = iio_priv(indio_dev); 3184 mutex_init(&data->lock); 3185 data->dev = dev; 3186 3187 indio_dev->name = name; 3188 indio_dev->info = &bmp280_info; 3189 indio_dev->modes = INDIO_DIRECT_MODE; 3190 3191 data->chip_info = chip_info; 3192 3193 /* Apply initial values from chip info structure */ 3194 indio_dev->channels = chip_info->channels; 3195 indio_dev->num_channels = chip_info->num_channels; 3196 indio_dev->available_scan_masks = chip_info->avail_scan_masks; 3197 data->oversampling_press = chip_info->oversampling_press_default; 3198 data->oversampling_humid = chip_info->oversampling_humid_default; 3199 data->oversampling_temp = chip_info->oversampling_temp_default; 3200 data->iir_filter_coeff = chip_info->iir_filter_coeff_default; 3201 data->sampling_freq = chip_info->sampling_freq_default; 3202 data->start_up_time_us = chip_info->start_up_time_us; 3203 3204 /* Bring up regulators */ 3205 regulator_bulk_set_supply_names(data->supplies, 3206 bmp280_supply_names, 3207 BMP280_NUM_SUPPLIES); 3208 3209 ret = devm_regulator_bulk_get(dev, 3210 BMP280_NUM_SUPPLIES, data->supplies); 3211 if (ret) { 3212 dev_err(dev, "failed to get regulators\n"); 3213 return ret; 3214 } 3215 3216 ret = regulator_bulk_enable(BMP280_NUM_SUPPLIES, data->supplies); 3217 if (ret) { 3218 dev_err(dev, "failed to enable regulators\n"); 3219 return ret; 3220 } 3221 3222 ret = devm_add_action_or_reset(dev, bmp280_regulators_disable, 3223 data->supplies); 3224 if (ret) 3225 return ret; 3226 3227 /* Wait to make sure we started up properly */ 3228 fsleep(data->start_up_time_us); 3229 3230 /* Bring chip out of reset if there is an assigned GPIO line */ 3231 gpiod = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); 3232 if (IS_ERR(gpiod)) 3233 return dev_err_probe(dev, PTR_ERR(gpiod), "failed to get reset GPIO\n"); 3234 3235 /* Deassert the signal */ 3236 gpiod_set_value_cansleep(gpiod, 0); 3237 3238 data->regmap = regmap; 3239 3240 ret = regmap_read(regmap, data->chip_info->id_reg, &chip_id); 3241 if (ret) { 3242 dev_err(data->dev, "failed to read chip id\n"); 3243 return ret; 3244 } 3245 3246 for (i = 0; i < data->chip_info->num_chip_id; i++) { 3247 if (chip_id == data->chip_info->chip_id[i]) { 3248 dev_info(dev, "0x%x is a known chip id for %s\n", chip_id, name); 3249 break; 3250 } 3251 } 3252 3253 if (i == data->chip_info->num_chip_id) 3254 dev_warn(dev, "bad chip id: 0x%x is not a known chip id\n", chip_id); 3255 3256 if (data->chip_info->preinit) { 3257 ret = data->chip_info->preinit(data); 3258 if (ret) 3259 return dev_err_probe(data->dev, ret, 3260 "error running preinit tasks\n"); 3261 } 3262 3263 ret = data->chip_info->chip_config(data); 3264 if (ret) 3265 return ret; 3266 3267 dev_set_drvdata(dev, indio_dev); 3268 3269 /* 3270 * Some chips have calibration parameters "programmed into the devices' 3271 * non-volatile memory during production". Let's read them out at probe 3272 * time once. They will not change. 3273 */ 3274 3275 if (data->chip_info->read_calib) { 3276 ret = data->chip_info->read_calib(data); 3277 if (ret) 3278 return dev_err_probe(data->dev, ret, 3279 "failed to read calibration coefficients\n"); 3280 } 3281 3282 ret = devm_iio_triggered_buffer_setup(data->dev, indio_dev, 3283 iio_pollfunc_store_time, 3284 data->chip_info->trigger_handler, 3285 &bmp280_buffer_setup_ops); 3286 if (ret) 3287 return dev_err_probe(data->dev, ret, 3288 "iio triggered buffer setup failed\n"); 3289 3290 /* 3291 * Attempt to grab an optional EOC IRQ - only the BMP085 has this 3292 * however as it happens, the BMP085 shares the chip ID of BMP180 3293 * so we look for an IRQ if we have that. 3294 */ 3295 if (irq > 0) { 3296 if (data->chip_info->trigger_probe) 3297 ret = data->chip_info->trigger_probe(indio_dev); 3298 if (ret) 3299 return ret; 3300 } 3301 3302 ret = data->chip_info->set_mode(data, BMP280_SLEEP); 3303 if (ret) 3304 return dev_err_probe(dev, ret, "Failed to set sleep mode\n"); 3305 3306 /* Enable runtime PM */ 3307 pm_runtime_get_noresume(dev); 3308 pm_runtime_set_active(dev); 3309 pm_runtime_enable(dev); 3310 /* 3311 * Set autosuspend to two orders of magnitude larger than the 3312 * start-up time. 3313 */ 3314 pm_runtime_set_autosuspend_delay(dev, data->start_up_time_us / 10); 3315 pm_runtime_use_autosuspend(dev); 3316 pm_runtime_put(dev); 3317 3318 ret = devm_add_action_or_reset(dev, bmp280_pm_disable, dev); 3319 if (ret) 3320 return ret; 3321 3322 return devm_iio_device_register(dev, indio_dev); 3323 } 3324 EXPORT_SYMBOL_NS(bmp280_common_probe, "IIO_BMP280"); 3325 3326 static int bmp280_runtime_suspend(struct device *dev) 3327 { 3328 struct iio_dev *indio_dev = dev_get_drvdata(dev); 3329 struct bmp280_data *data = iio_priv(indio_dev); 3330 3331 data->chip_info->set_mode(data, BMP280_SLEEP); 3332 3333 fsleep(data->start_up_time_us); 3334 return regulator_bulk_disable(BMP280_NUM_SUPPLIES, data->supplies); 3335 } 3336 3337 static int bmp280_runtime_resume(struct device *dev) 3338 { 3339 struct iio_dev *indio_dev = dev_get_drvdata(dev); 3340 struct bmp280_data *data = iio_priv(indio_dev); 3341 int ret; 3342 3343 ret = regulator_bulk_enable(BMP280_NUM_SUPPLIES, data->supplies); 3344 if (ret) 3345 return ret; 3346 3347 fsleep(data->start_up_time_us); 3348 3349 ret = data->chip_info->chip_config(data); 3350 if (ret) 3351 return ret; 3352 3353 return data->chip_info->set_mode(data, data->op_mode); 3354 } 3355 3356 EXPORT_RUNTIME_DEV_PM_OPS(bmp280_dev_pm_ops, bmp280_runtime_suspend, 3357 bmp280_runtime_resume, NULL); 3358 3359 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>"); 3360 MODULE_DESCRIPTION("Driver for Bosch Sensortec BMP180/BMP280 pressure and temperature sensor"); 3361 MODULE_LICENSE("GPL v2"); 3362