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://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP180-DS000-121.pdf 13 * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP280-DS001-12.pdf 14 * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BME280_DS001-11.pdf 15 */ 16 17 #define pr_fmt(fmt) "bmp280: " fmt 18 19 #include <linux/device.h> 20 #include <linux/module.h> 21 #include <linux/regmap.h> 22 #include <linux/delay.h> 23 #include <linux/iio/iio.h> 24 #include <linux/iio/sysfs.h> 25 #include <linux/gpio/consumer.h> 26 #include <linux/regulator/consumer.h> 27 #include <linux/interrupt.h> 28 #include <linux/irq.h> /* For irq_get_irq_data() */ 29 #include <linux/completion.h> 30 #include <linux/pm_runtime.h> 31 #include <linux/random.h> 32 33 #include "bmp280.h" 34 35 /* 36 * These enums are used for indexing into the array of calibration 37 * coefficients for BMP180. 38 */ 39 enum { AC1, AC2, AC3, AC4, AC5, AC6, B1, B2, MB, MC, MD }; 40 41 struct bmp180_calib { 42 s16 AC1; 43 s16 AC2; 44 s16 AC3; 45 u16 AC4; 46 u16 AC5; 47 u16 AC6; 48 s16 B1; 49 s16 B2; 50 s16 MB; 51 s16 MC; 52 s16 MD; 53 }; 54 55 /* See datasheet Section 4.2.2. */ 56 struct bmp280_calib { 57 u16 T1; 58 s16 T2; 59 s16 T3; 60 u16 P1; 61 s16 P2; 62 s16 P3; 63 s16 P4; 64 s16 P5; 65 s16 P6; 66 s16 P7; 67 s16 P8; 68 s16 P9; 69 u8 H1; 70 s16 H2; 71 u8 H3; 72 s16 H4; 73 s16 H5; 74 s8 H6; 75 }; 76 77 struct bmp280_data { 78 struct device *dev; 79 struct mutex lock; 80 struct regmap *regmap; 81 struct completion done; 82 bool use_eoc; 83 const struct bmp280_chip_info *chip_info; 84 union { 85 struct bmp180_calib bmp180; 86 struct bmp280_calib bmp280; 87 } calib; 88 struct regulator *vddd; 89 struct regulator *vdda; 90 unsigned int start_up_time; /* in microseconds */ 91 92 /* log of base 2 of oversampling rate */ 93 u8 oversampling_press; 94 u8 oversampling_temp; 95 u8 oversampling_humid; 96 97 /* 98 * Carryover value from temperature conversion, used in pressure 99 * calculation. 100 */ 101 s32 t_fine; 102 }; 103 104 struct bmp280_chip_info { 105 const int *oversampling_temp_avail; 106 int num_oversampling_temp_avail; 107 108 const int *oversampling_press_avail; 109 int num_oversampling_press_avail; 110 111 const int *oversampling_humid_avail; 112 int num_oversampling_humid_avail; 113 114 int (*chip_config)(struct bmp280_data *); 115 int (*read_temp)(struct bmp280_data *, int *); 116 int (*read_press)(struct bmp280_data *, int *, int *); 117 int (*read_humid)(struct bmp280_data *, int *, int *); 118 }; 119 120 /* 121 * These enums are used for indexing into the array of compensation 122 * parameters for BMP280. 123 */ 124 enum { T1, T2, T3 }; 125 enum { P1, P2, P3, P4, P5, P6, P7, P8, P9 }; 126 127 static const struct iio_chan_spec bmp280_channels[] = { 128 { 129 .type = IIO_PRESSURE, 130 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 131 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 132 }, 133 { 134 .type = IIO_TEMP, 135 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 136 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 137 }, 138 { 139 .type = IIO_HUMIDITYRELATIVE, 140 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 141 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 142 }, 143 }; 144 145 static int bmp280_read_calib(struct bmp280_data *data, 146 struct bmp280_calib *calib, 147 unsigned int chip) 148 { 149 int ret; 150 unsigned int tmp; 151 struct device *dev = data->dev; 152 __le16 t_buf[BMP280_COMP_TEMP_REG_COUNT / 2]; 153 __le16 p_buf[BMP280_COMP_PRESS_REG_COUNT / 2]; 154 155 /* Read temperature calibration values. */ 156 ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_TEMP_START, 157 t_buf, BMP280_COMP_TEMP_REG_COUNT); 158 if (ret < 0) { 159 dev_err(data->dev, 160 "failed to read temperature calibration parameters\n"); 161 return ret; 162 } 163 164 /* Toss the temperature calibration data into the entropy pool */ 165 add_device_randomness(t_buf, sizeof(t_buf)); 166 167 calib->T1 = le16_to_cpu(t_buf[T1]); 168 calib->T2 = le16_to_cpu(t_buf[T2]); 169 calib->T3 = le16_to_cpu(t_buf[T3]); 170 171 /* Read pressure calibration values. */ 172 ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_PRESS_START, 173 p_buf, BMP280_COMP_PRESS_REG_COUNT); 174 if (ret < 0) { 175 dev_err(data->dev, 176 "failed to read pressure calibration parameters\n"); 177 return ret; 178 } 179 180 /* Toss the pressure calibration data into the entropy pool */ 181 add_device_randomness(p_buf, sizeof(p_buf)); 182 183 calib->P1 = le16_to_cpu(p_buf[P1]); 184 calib->P2 = le16_to_cpu(p_buf[P2]); 185 calib->P3 = le16_to_cpu(p_buf[P3]); 186 calib->P4 = le16_to_cpu(p_buf[P4]); 187 calib->P5 = le16_to_cpu(p_buf[P5]); 188 calib->P6 = le16_to_cpu(p_buf[P6]); 189 calib->P7 = le16_to_cpu(p_buf[P7]); 190 calib->P8 = le16_to_cpu(p_buf[P8]); 191 calib->P9 = le16_to_cpu(p_buf[P9]); 192 193 /* 194 * Read humidity calibration values. 195 * Due to some odd register addressing we cannot just 196 * do a big bulk read. Instead, we have to read each Hx 197 * value separately and sometimes do some bit shifting... 198 * Humidity data is only available on BME280. 199 */ 200 if (chip != BME280_CHIP_ID) 201 return 0; 202 203 ret = regmap_read(data->regmap, BMP280_REG_COMP_H1, &tmp); 204 if (ret < 0) { 205 dev_err(dev, "failed to read H1 comp value\n"); 206 return ret; 207 } 208 calib->H1 = tmp; 209 210 ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_H2, &tmp, 2); 211 if (ret < 0) { 212 dev_err(dev, "failed to read H2 comp value\n"); 213 return ret; 214 } 215 calib->H2 = sign_extend32(le16_to_cpu(tmp), 15); 216 217 ret = regmap_read(data->regmap, BMP280_REG_COMP_H3, &tmp); 218 if (ret < 0) { 219 dev_err(dev, "failed to read H3 comp value\n"); 220 return ret; 221 } 222 calib->H3 = tmp; 223 224 ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_H4, &tmp, 2); 225 if (ret < 0) { 226 dev_err(dev, "failed to read H4 comp value\n"); 227 return ret; 228 } 229 calib->H4 = sign_extend32(((be16_to_cpu(tmp) >> 4) & 0xff0) | 230 (be16_to_cpu(tmp) & 0xf), 11); 231 232 ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_H5, &tmp, 2); 233 if (ret < 0) { 234 dev_err(dev, "failed to read H5 comp value\n"); 235 return ret; 236 } 237 calib->H5 = sign_extend32(((le16_to_cpu(tmp) >> 4) & 0xfff), 11); 238 239 ret = regmap_read(data->regmap, BMP280_REG_COMP_H6, &tmp); 240 if (ret < 0) { 241 dev_err(dev, "failed to read H6 comp value\n"); 242 return ret; 243 } 244 calib->H6 = sign_extend32(tmp, 7); 245 246 return 0; 247 } 248 /* 249 * Returns humidity in percent, resolution is 0.01 percent. Output value of 250 * "47445" represents 47445/1024 = 46.333 %RH. 251 * 252 * Taken from BME280 datasheet, Section 4.2.3, "Compensation formula". 253 */ 254 static u32 bmp280_compensate_humidity(struct bmp280_data *data, 255 s32 adc_humidity) 256 { 257 s32 var; 258 struct bmp280_calib *calib = &data->calib.bmp280; 259 260 var = ((s32)data->t_fine) - (s32)76800; 261 var = ((((adc_humidity << 14) - (calib->H4 << 20) - (calib->H5 * var)) 262 + (s32)16384) >> 15) * (((((((var * calib->H6) >> 10) 263 * (((var * (s32)calib->H3) >> 11) + (s32)32768)) >> 10) 264 + (s32)2097152) * calib->H2 + 8192) >> 14); 265 var -= ((((var >> 15) * (var >> 15)) >> 7) * (s32)calib->H1) >> 4; 266 267 return var >> 12; 268 }; 269 270 /* 271 * Returns temperature in DegC, resolution is 0.01 DegC. Output value of 272 * "5123" equals 51.23 DegC. t_fine carries fine temperature as global 273 * value. 274 * 275 * Taken from datasheet, Section 3.11.3, "Compensation formula". 276 */ 277 static s32 bmp280_compensate_temp(struct bmp280_data *data, 278 s32 adc_temp) 279 { 280 s32 var1, var2; 281 struct bmp280_calib *calib = &data->calib.bmp280; 282 283 var1 = (((adc_temp >> 3) - ((s32)calib->T1 << 1)) * 284 ((s32)calib->T2)) >> 11; 285 var2 = (((((adc_temp >> 4) - ((s32)calib->T1)) * 286 ((adc_temp >> 4) - ((s32)calib->T1))) >> 12) * 287 ((s32)calib->T3)) >> 14; 288 data->t_fine = var1 + var2; 289 290 return (data->t_fine * 5 + 128) >> 8; 291 } 292 293 /* 294 * Returns pressure in Pa as unsigned 32 bit integer in Q24.8 format (24 295 * integer bits and 8 fractional bits). Output value of "24674867" 296 * represents 24674867/256 = 96386.2 Pa = 963.862 hPa 297 * 298 * Taken from datasheet, Section 3.11.3, "Compensation formula". 299 */ 300 static u32 bmp280_compensate_press(struct bmp280_data *data, 301 s32 adc_press) 302 { 303 s64 var1, var2, p; 304 struct bmp280_calib *calib = &data->calib.bmp280; 305 306 var1 = ((s64)data->t_fine) - 128000; 307 var2 = var1 * var1 * (s64)calib->P6; 308 var2 += (var1 * (s64)calib->P5) << 17; 309 var2 += ((s64)calib->P4) << 35; 310 var1 = ((var1 * var1 * (s64)calib->P3) >> 8) + 311 ((var1 * (s64)calib->P2) << 12); 312 var1 = ((((s64)1) << 47) + var1) * ((s64)calib->P1) >> 33; 313 314 if (var1 == 0) 315 return 0; 316 317 p = ((((s64)1048576 - adc_press) << 31) - var2) * 3125; 318 p = div64_s64(p, var1); 319 var1 = (((s64)calib->P9) * (p >> 13) * (p >> 13)) >> 25; 320 var2 = ((s64)(calib->P8) * p) >> 19; 321 p = ((p + var1 + var2) >> 8) + (((s64)calib->P7) << 4); 322 323 return (u32)p; 324 } 325 326 static int bmp280_read_temp(struct bmp280_data *data, 327 int *val) 328 { 329 int ret; 330 __be32 tmp = 0; 331 s32 adc_temp, comp_temp; 332 333 ret = regmap_bulk_read(data->regmap, BMP280_REG_TEMP_MSB, 334 (u8 *) &tmp, 3); 335 if (ret < 0) { 336 dev_err(data->dev, "failed to read temperature\n"); 337 return ret; 338 } 339 340 adc_temp = be32_to_cpu(tmp) >> 12; 341 if (adc_temp == BMP280_TEMP_SKIPPED) { 342 /* reading was skipped */ 343 dev_err(data->dev, "reading temperature skipped\n"); 344 return -EIO; 345 } 346 comp_temp = bmp280_compensate_temp(data, adc_temp); 347 348 /* 349 * val might be NULL if we're called by the read_press routine, 350 * who only cares about the carry over t_fine value. 351 */ 352 if (val) { 353 *val = comp_temp * 10; 354 return IIO_VAL_INT; 355 } 356 357 return 0; 358 } 359 360 static int bmp280_read_press(struct bmp280_data *data, 361 int *val, int *val2) 362 { 363 int ret; 364 __be32 tmp = 0; 365 s32 adc_press; 366 u32 comp_press; 367 368 /* Read and compensate temperature so we get a reading of t_fine. */ 369 ret = bmp280_read_temp(data, NULL); 370 if (ret < 0) 371 return ret; 372 373 ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB, 374 (u8 *) &tmp, 3); 375 if (ret < 0) { 376 dev_err(data->dev, "failed to read pressure\n"); 377 return ret; 378 } 379 380 adc_press = be32_to_cpu(tmp) >> 12; 381 if (adc_press == BMP280_PRESS_SKIPPED) { 382 /* reading was skipped */ 383 dev_err(data->dev, "reading pressure skipped\n"); 384 return -EIO; 385 } 386 comp_press = bmp280_compensate_press(data, adc_press); 387 388 *val = comp_press; 389 *val2 = 256000; 390 391 return IIO_VAL_FRACTIONAL; 392 } 393 394 static int bmp280_read_humid(struct bmp280_data *data, int *val, int *val2) 395 { 396 int ret; 397 __be16 tmp = 0; 398 s32 adc_humidity; 399 u32 comp_humidity; 400 401 /* Read and compensate temperature so we get a reading of t_fine. */ 402 ret = bmp280_read_temp(data, NULL); 403 if (ret < 0) 404 return ret; 405 406 ret = regmap_bulk_read(data->regmap, BMP280_REG_HUMIDITY_MSB, 407 (u8 *) &tmp, 2); 408 if (ret < 0) { 409 dev_err(data->dev, "failed to read humidity\n"); 410 return ret; 411 } 412 413 adc_humidity = be16_to_cpu(tmp); 414 if (adc_humidity == BMP280_HUMIDITY_SKIPPED) { 415 /* reading was skipped */ 416 dev_err(data->dev, "reading humidity skipped\n"); 417 return -EIO; 418 } 419 comp_humidity = bmp280_compensate_humidity(data, adc_humidity); 420 421 *val = comp_humidity * 1000 / 1024; 422 423 return IIO_VAL_INT; 424 } 425 426 static int bmp280_read_raw(struct iio_dev *indio_dev, 427 struct iio_chan_spec const *chan, 428 int *val, int *val2, long mask) 429 { 430 int ret; 431 struct bmp280_data *data = iio_priv(indio_dev); 432 433 pm_runtime_get_sync(data->dev); 434 mutex_lock(&data->lock); 435 436 switch (mask) { 437 case IIO_CHAN_INFO_PROCESSED: 438 switch (chan->type) { 439 case IIO_HUMIDITYRELATIVE: 440 ret = data->chip_info->read_humid(data, val, val2); 441 break; 442 case IIO_PRESSURE: 443 ret = data->chip_info->read_press(data, val, val2); 444 break; 445 case IIO_TEMP: 446 ret = data->chip_info->read_temp(data, val); 447 break; 448 default: 449 ret = -EINVAL; 450 break; 451 } 452 break; 453 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 454 switch (chan->type) { 455 case IIO_HUMIDITYRELATIVE: 456 *val = 1 << data->oversampling_humid; 457 ret = IIO_VAL_INT; 458 break; 459 case IIO_PRESSURE: 460 *val = 1 << data->oversampling_press; 461 ret = IIO_VAL_INT; 462 break; 463 case IIO_TEMP: 464 *val = 1 << data->oversampling_temp; 465 ret = IIO_VAL_INT; 466 break; 467 default: 468 ret = -EINVAL; 469 break; 470 } 471 break; 472 default: 473 ret = -EINVAL; 474 break; 475 } 476 477 mutex_unlock(&data->lock); 478 pm_runtime_mark_last_busy(data->dev); 479 pm_runtime_put_autosuspend(data->dev); 480 481 return ret; 482 } 483 484 static int bmp280_write_oversampling_ratio_humid(struct bmp280_data *data, 485 int val) 486 { 487 int i; 488 const int *avail = data->chip_info->oversampling_humid_avail; 489 const int n = data->chip_info->num_oversampling_humid_avail; 490 491 for (i = 0; i < n; i++) { 492 if (avail[i] == val) { 493 data->oversampling_humid = ilog2(val); 494 495 return data->chip_info->chip_config(data); 496 } 497 } 498 return -EINVAL; 499 } 500 501 static int bmp280_write_oversampling_ratio_temp(struct bmp280_data *data, 502 int val) 503 { 504 int i; 505 const int *avail = data->chip_info->oversampling_temp_avail; 506 const int n = data->chip_info->num_oversampling_temp_avail; 507 508 for (i = 0; i < n; i++) { 509 if (avail[i] == val) { 510 data->oversampling_temp = ilog2(val); 511 512 return data->chip_info->chip_config(data); 513 } 514 } 515 return -EINVAL; 516 } 517 518 static int bmp280_write_oversampling_ratio_press(struct bmp280_data *data, 519 int val) 520 { 521 int i; 522 const int *avail = data->chip_info->oversampling_press_avail; 523 const int n = data->chip_info->num_oversampling_press_avail; 524 525 for (i = 0; i < n; i++) { 526 if (avail[i] == val) { 527 data->oversampling_press = ilog2(val); 528 529 return data->chip_info->chip_config(data); 530 } 531 } 532 return -EINVAL; 533 } 534 535 static int bmp280_write_raw(struct iio_dev *indio_dev, 536 struct iio_chan_spec const *chan, 537 int val, int val2, long mask) 538 { 539 int ret = 0; 540 struct bmp280_data *data = iio_priv(indio_dev); 541 542 switch (mask) { 543 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 544 pm_runtime_get_sync(data->dev); 545 mutex_lock(&data->lock); 546 switch (chan->type) { 547 case IIO_HUMIDITYRELATIVE: 548 ret = bmp280_write_oversampling_ratio_humid(data, val); 549 break; 550 case IIO_PRESSURE: 551 ret = bmp280_write_oversampling_ratio_press(data, val); 552 break; 553 case IIO_TEMP: 554 ret = bmp280_write_oversampling_ratio_temp(data, val); 555 break; 556 default: 557 ret = -EINVAL; 558 break; 559 } 560 mutex_unlock(&data->lock); 561 pm_runtime_mark_last_busy(data->dev); 562 pm_runtime_put_autosuspend(data->dev); 563 break; 564 default: 565 return -EINVAL; 566 } 567 568 return ret; 569 } 570 571 static ssize_t bmp280_show_avail(char *buf, const int *vals, const int n) 572 { 573 size_t len = 0; 574 int i; 575 576 for (i = 0; i < n; i++) 577 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ", vals[i]); 578 579 buf[len - 1] = '\n'; 580 581 return len; 582 } 583 584 static ssize_t bmp280_show_temp_oversampling_avail(struct device *dev, 585 struct device_attribute *attr, char *buf) 586 { 587 struct bmp280_data *data = iio_priv(dev_to_iio_dev(dev)); 588 589 return bmp280_show_avail(buf, data->chip_info->oversampling_temp_avail, 590 data->chip_info->num_oversampling_temp_avail); 591 } 592 593 static ssize_t bmp280_show_press_oversampling_avail(struct device *dev, 594 struct device_attribute *attr, char *buf) 595 { 596 struct bmp280_data *data = iio_priv(dev_to_iio_dev(dev)); 597 598 return bmp280_show_avail(buf, data->chip_info->oversampling_press_avail, 599 data->chip_info->num_oversampling_press_avail); 600 } 601 602 static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available, 603 S_IRUGO, bmp280_show_temp_oversampling_avail, NULL, 0); 604 605 static IIO_DEVICE_ATTR(in_pressure_oversampling_ratio_available, 606 S_IRUGO, bmp280_show_press_oversampling_avail, NULL, 0); 607 608 static struct attribute *bmp280_attributes[] = { 609 &iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr, 610 &iio_dev_attr_in_pressure_oversampling_ratio_available.dev_attr.attr, 611 NULL, 612 }; 613 614 static const struct attribute_group bmp280_attrs_group = { 615 .attrs = bmp280_attributes, 616 }; 617 618 static const struct iio_info bmp280_info = { 619 .read_raw = &bmp280_read_raw, 620 .write_raw = &bmp280_write_raw, 621 .attrs = &bmp280_attrs_group, 622 }; 623 624 static int bmp280_chip_config(struct bmp280_data *data) 625 { 626 int ret; 627 u8 osrs = BMP280_OSRS_TEMP_X(data->oversampling_temp + 1) | 628 BMP280_OSRS_PRESS_X(data->oversampling_press + 1); 629 630 ret = regmap_write_bits(data->regmap, BMP280_REG_CTRL_MEAS, 631 BMP280_OSRS_TEMP_MASK | 632 BMP280_OSRS_PRESS_MASK | 633 BMP280_MODE_MASK, 634 osrs | BMP280_MODE_NORMAL); 635 if (ret < 0) { 636 dev_err(data->dev, 637 "failed to write ctrl_meas register\n"); 638 return ret; 639 } 640 641 ret = regmap_update_bits(data->regmap, BMP280_REG_CONFIG, 642 BMP280_FILTER_MASK, 643 BMP280_FILTER_4X); 644 if (ret < 0) { 645 dev_err(data->dev, 646 "failed to write config register\n"); 647 return ret; 648 } 649 650 return ret; 651 } 652 653 static const int bmp280_oversampling_avail[] = { 1, 2, 4, 8, 16 }; 654 655 static const struct bmp280_chip_info bmp280_chip_info = { 656 .oversampling_temp_avail = bmp280_oversampling_avail, 657 .num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail), 658 659 .oversampling_press_avail = bmp280_oversampling_avail, 660 .num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail), 661 662 .chip_config = bmp280_chip_config, 663 .read_temp = bmp280_read_temp, 664 .read_press = bmp280_read_press, 665 }; 666 667 static int bme280_chip_config(struct bmp280_data *data) 668 { 669 int ret; 670 u8 osrs = BMP280_OSRS_HUMIDITIY_X(data->oversampling_humid + 1); 671 672 /* 673 * Oversampling of humidity must be set before oversampling of 674 * temperature/pressure is set to become effective. 675 */ 676 ret = regmap_update_bits(data->regmap, BMP280_REG_CTRL_HUMIDITY, 677 BMP280_OSRS_HUMIDITY_MASK, osrs); 678 679 if (ret < 0) 680 return ret; 681 682 return bmp280_chip_config(data); 683 } 684 685 static const struct bmp280_chip_info bme280_chip_info = { 686 .oversampling_temp_avail = bmp280_oversampling_avail, 687 .num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail), 688 689 .oversampling_press_avail = bmp280_oversampling_avail, 690 .num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail), 691 692 .oversampling_humid_avail = bmp280_oversampling_avail, 693 .num_oversampling_humid_avail = ARRAY_SIZE(bmp280_oversampling_avail), 694 695 .chip_config = bme280_chip_config, 696 .read_temp = bmp280_read_temp, 697 .read_press = bmp280_read_press, 698 .read_humid = bmp280_read_humid, 699 }; 700 701 static int bmp180_measure(struct bmp280_data *data, u8 ctrl_meas) 702 { 703 int ret; 704 const int conversion_time_max[] = { 4500, 7500, 13500, 25500 }; 705 unsigned int delay_us; 706 unsigned int ctrl; 707 708 if (data->use_eoc) 709 init_completion(&data->done); 710 711 ret = regmap_write(data->regmap, BMP280_REG_CTRL_MEAS, ctrl_meas); 712 if (ret) 713 return ret; 714 715 if (data->use_eoc) { 716 /* 717 * If we have a completion interrupt, use it, wait up to 718 * 100ms. The longest conversion time listed is 76.5 ms for 719 * advanced resolution mode. 720 */ 721 ret = wait_for_completion_timeout(&data->done, 722 1 + msecs_to_jiffies(100)); 723 if (!ret) 724 dev_err(data->dev, "timeout waiting for completion\n"); 725 } else { 726 if (ctrl_meas == BMP180_MEAS_TEMP) 727 delay_us = 4500; 728 else 729 delay_us = 730 conversion_time_max[data->oversampling_press]; 731 732 usleep_range(delay_us, delay_us + 1000); 733 } 734 735 ret = regmap_read(data->regmap, BMP280_REG_CTRL_MEAS, &ctrl); 736 if (ret) 737 return ret; 738 739 /* The value of this bit reset to "0" after conversion is complete */ 740 if (ctrl & BMP180_MEAS_SCO) 741 return -EIO; 742 743 return 0; 744 } 745 746 static int bmp180_read_adc_temp(struct bmp280_data *data, int *val) 747 { 748 int ret; 749 __be16 tmp = 0; 750 751 ret = bmp180_measure(data, BMP180_MEAS_TEMP); 752 if (ret) 753 return ret; 754 755 ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB, (u8 *)&tmp, 2); 756 if (ret) 757 return ret; 758 759 *val = be16_to_cpu(tmp); 760 761 return 0; 762 } 763 764 static int bmp180_read_calib(struct bmp280_data *data, 765 struct bmp180_calib *calib) 766 { 767 int ret; 768 int i; 769 __be16 buf[BMP180_REG_CALIB_COUNT / 2]; 770 771 ret = regmap_bulk_read(data->regmap, BMP180_REG_CALIB_START, buf, 772 sizeof(buf)); 773 774 if (ret < 0) 775 return ret; 776 777 /* None of the words has the value 0 or 0xFFFF */ 778 for (i = 0; i < ARRAY_SIZE(buf); i++) { 779 if (buf[i] == cpu_to_be16(0) || buf[i] == cpu_to_be16(0xffff)) 780 return -EIO; 781 } 782 783 /* Toss the calibration data into the entropy pool */ 784 add_device_randomness(buf, sizeof(buf)); 785 786 calib->AC1 = be16_to_cpu(buf[AC1]); 787 calib->AC2 = be16_to_cpu(buf[AC2]); 788 calib->AC3 = be16_to_cpu(buf[AC3]); 789 calib->AC4 = be16_to_cpu(buf[AC4]); 790 calib->AC5 = be16_to_cpu(buf[AC5]); 791 calib->AC6 = be16_to_cpu(buf[AC6]); 792 calib->B1 = be16_to_cpu(buf[B1]); 793 calib->B2 = be16_to_cpu(buf[B2]); 794 calib->MB = be16_to_cpu(buf[MB]); 795 calib->MC = be16_to_cpu(buf[MC]); 796 calib->MD = be16_to_cpu(buf[MD]); 797 798 return 0; 799 } 800 801 /* 802 * Returns temperature in DegC, resolution is 0.1 DegC. 803 * t_fine carries fine temperature as global value. 804 * 805 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature". 806 */ 807 static s32 bmp180_compensate_temp(struct bmp280_data *data, s32 adc_temp) 808 { 809 s32 x1, x2; 810 struct bmp180_calib *calib = &data->calib.bmp180; 811 812 x1 = ((adc_temp - calib->AC6) * calib->AC5) >> 15; 813 x2 = (calib->MC << 11) / (x1 + calib->MD); 814 data->t_fine = x1 + x2; 815 816 return (data->t_fine + 8) >> 4; 817 } 818 819 static int bmp180_read_temp(struct bmp280_data *data, int *val) 820 { 821 int ret; 822 s32 adc_temp, comp_temp; 823 824 ret = bmp180_read_adc_temp(data, &adc_temp); 825 if (ret) 826 return ret; 827 828 comp_temp = bmp180_compensate_temp(data, adc_temp); 829 830 /* 831 * val might be NULL if we're called by the read_press routine, 832 * who only cares about the carry over t_fine value. 833 */ 834 if (val) { 835 *val = comp_temp * 100; 836 return IIO_VAL_INT; 837 } 838 839 return 0; 840 } 841 842 static int bmp180_read_adc_press(struct bmp280_data *data, int *val) 843 { 844 int ret; 845 __be32 tmp = 0; 846 u8 oss = data->oversampling_press; 847 848 ret = bmp180_measure(data, BMP180_MEAS_PRESS_X(oss)); 849 if (ret) 850 return ret; 851 852 ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB, (u8 *)&tmp, 3); 853 if (ret) 854 return ret; 855 856 *val = (be32_to_cpu(tmp) >> 8) >> (8 - oss); 857 858 return 0; 859 } 860 861 /* 862 * Returns pressure in Pa, resolution is 1 Pa. 863 * 864 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature". 865 */ 866 static u32 bmp180_compensate_press(struct bmp280_data *data, s32 adc_press) 867 { 868 s32 x1, x2, x3, p; 869 s32 b3, b6; 870 u32 b4, b7; 871 s32 oss = data->oversampling_press; 872 struct bmp180_calib *calib = &data->calib.bmp180; 873 874 b6 = data->t_fine - 4000; 875 x1 = (calib->B2 * (b6 * b6 >> 12)) >> 11; 876 x2 = calib->AC2 * b6 >> 11; 877 x3 = x1 + x2; 878 b3 = ((((s32)calib->AC1 * 4 + x3) << oss) + 2) / 4; 879 x1 = calib->AC3 * b6 >> 13; 880 x2 = (calib->B1 * ((b6 * b6) >> 12)) >> 16; 881 x3 = (x1 + x2 + 2) >> 2; 882 b4 = calib->AC4 * (u32)(x3 + 32768) >> 15; 883 b7 = ((u32)adc_press - b3) * (50000 >> oss); 884 if (b7 < 0x80000000) 885 p = (b7 * 2) / b4; 886 else 887 p = (b7 / b4) * 2; 888 889 x1 = (p >> 8) * (p >> 8); 890 x1 = (x1 * 3038) >> 16; 891 x2 = (-7357 * p) >> 16; 892 893 return p + ((x1 + x2 + 3791) >> 4); 894 } 895 896 static int bmp180_read_press(struct bmp280_data *data, 897 int *val, int *val2) 898 { 899 int ret; 900 s32 adc_press; 901 u32 comp_press; 902 903 /* Read and compensate temperature so we get a reading of t_fine. */ 904 ret = bmp180_read_temp(data, NULL); 905 if (ret) 906 return ret; 907 908 ret = bmp180_read_adc_press(data, &adc_press); 909 if (ret) 910 return ret; 911 912 comp_press = bmp180_compensate_press(data, adc_press); 913 914 *val = comp_press; 915 *val2 = 1000; 916 917 return IIO_VAL_FRACTIONAL; 918 } 919 920 static int bmp180_chip_config(struct bmp280_data *data) 921 { 922 return 0; 923 } 924 925 static const int bmp180_oversampling_temp_avail[] = { 1 }; 926 static const int bmp180_oversampling_press_avail[] = { 1, 2, 4, 8 }; 927 928 static const struct bmp280_chip_info bmp180_chip_info = { 929 .oversampling_temp_avail = bmp180_oversampling_temp_avail, 930 .num_oversampling_temp_avail = 931 ARRAY_SIZE(bmp180_oversampling_temp_avail), 932 933 .oversampling_press_avail = bmp180_oversampling_press_avail, 934 .num_oversampling_press_avail = 935 ARRAY_SIZE(bmp180_oversampling_press_avail), 936 937 .chip_config = bmp180_chip_config, 938 .read_temp = bmp180_read_temp, 939 .read_press = bmp180_read_press, 940 }; 941 942 static irqreturn_t bmp085_eoc_irq(int irq, void *d) 943 { 944 struct bmp280_data *data = d; 945 946 complete(&data->done); 947 948 return IRQ_HANDLED; 949 } 950 951 static int bmp085_fetch_eoc_irq(struct device *dev, 952 const char *name, 953 int irq, 954 struct bmp280_data *data) 955 { 956 unsigned long irq_trig; 957 int ret; 958 959 irq_trig = irqd_get_trigger_type(irq_get_irq_data(irq)); 960 if (irq_trig != IRQF_TRIGGER_RISING) { 961 dev_err(dev, "non-rising trigger given for EOC interrupt, " 962 "trying to enforce it\n"); 963 irq_trig = IRQF_TRIGGER_RISING; 964 } 965 ret = devm_request_threaded_irq(dev, 966 irq, 967 bmp085_eoc_irq, 968 NULL, 969 irq_trig, 970 name, 971 data); 972 if (ret) { 973 /* Bail out without IRQ but keep the driver in place */ 974 dev_err(dev, "unable to request DRDY IRQ\n"); 975 return 0; 976 } 977 978 data->use_eoc = true; 979 return 0; 980 } 981 982 int bmp280_common_probe(struct device *dev, 983 struct regmap *regmap, 984 unsigned int chip, 985 const char *name, 986 int irq) 987 { 988 int ret; 989 struct iio_dev *indio_dev; 990 struct bmp280_data *data; 991 unsigned int chip_id; 992 struct gpio_desc *gpiod; 993 994 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 995 if (!indio_dev) 996 return -ENOMEM; 997 998 data = iio_priv(indio_dev); 999 mutex_init(&data->lock); 1000 data->dev = dev; 1001 1002 indio_dev->dev.parent = dev; 1003 indio_dev->name = name; 1004 indio_dev->channels = bmp280_channels; 1005 indio_dev->info = &bmp280_info; 1006 indio_dev->modes = INDIO_DIRECT_MODE; 1007 1008 switch (chip) { 1009 case BMP180_CHIP_ID: 1010 indio_dev->num_channels = 2; 1011 data->chip_info = &bmp180_chip_info; 1012 data->oversampling_press = ilog2(8); 1013 data->oversampling_temp = ilog2(1); 1014 data->start_up_time = 10000; 1015 break; 1016 case BMP280_CHIP_ID: 1017 indio_dev->num_channels = 2; 1018 data->chip_info = &bmp280_chip_info; 1019 data->oversampling_press = ilog2(16); 1020 data->oversampling_temp = ilog2(2); 1021 data->start_up_time = 2000; 1022 break; 1023 case BME280_CHIP_ID: 1024 indio_dev->num_channels = 3; 1025 data->chip_info = &bme280_chip_info; 1026 data->oversampling_press = ilog2(16); 1027 data->oversampling_humid = ilog2(16); 1028 data->oversampling_temp = ilog2(2); 1029 data->start_up_time = 2000; 1030 break; 1031 default: 1032 return -EINVAL; 1033 } 1034 1035 /* Bring up regulators */ 1036 data->vddd = devm_regulator_get(dev, "vddd"); 1037 if (IS_ERR(data->vddd)) { 1038 dev_err(dev, "failed to get VDDD regulator\n"); 1039 return PTR_ERR(data->vddd); 1040 } 1041 ret = regulator_enable(data->vddd); 1042 if (ret) { 1043 dev_err(dev, "failed to enable VDDD regulator\n"); 1044 return ret; 1045 } 1046 data->vdda = devm_regulator_get(dev, "vdda"); 1047 if (IS_ERR(data->vdda)) { 1048 dev_err(dev, "failed to get VDDA regulator\n"); 1049 ret = PTR_ERR(data->vdda); 1050 goto out_disable_vddd; 1051 } 1052 ret = regulator_enable(data->vdda); 1053 if (ret) { 1054 dev_err(dev, "failed to enable VDDA regulator\n"); 1055 goto out_disable_vddd; 1056 } 1057 /* Wait to make sure we started up properly */ 1058 usleep_range(data->start_up_time, data->start_up_time + 100); 1059 1060 /* Bring chip out of reset if there is an assigned GPIO line */ 1061 gpiod = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); 1062 /* Deassert the signal */ 1063 if (!IS_ERR(gpiod)) { 1064 dev_info(dev, "release reset\n"); 1065 gpiod_set_value(gpiod, 0); 1066 } 1067 1068 data->regmap = regmap; 1069 ret = regmap_read(regmap, BMP280_REG_ID, &chip_id); 1070 if (ret < 0) 1071 goto out_disable_vdda; 1072 if (chip_id != chip) { 1073 dev_err(dev, "bad chip id: expected %x got %x\n", 1074 chip, chip_id); 1075 ret = -EINVAL; 1076 goto out_disable_vdda; 1077 } 1078 1079 ret = data->chip_info->chip_config(data); 1080 if (ret < 0) 1081 goto out_disable_vdda; 1082 1083 dev_set_drvdata(dev, indio_dev); 1084 1085 /* 1086 * Some chips have calibration parameters "programmed into the devices' 1087 * non-volatile memory during production". Let's read them out at probe 1088 * time once. They will not change. 1089 */ 1090 if (chip_id == BMP180_CHIP_ID) { 1091 ret = bmp180_read_calib(data, &data->calib.bmp180); 1092 if (ret < 0) { 1093 dev_err(data->dev, 1094 "failed to read calibration coefficients\n"); 1095 goto out_disable_vdda; 1096 } 1097 } else if (chip_id == BMP280_CHIP_ID || chip_id == BME280_CHIP_ID) { 1098 ret = bmp280_read_calib(data, &data->calib.bmp280, chip_id); 1099 if (ret < 0) { 1100 dev_err(data->dev, 1101 "failed to read calibration coefficients\n"); 1102 goto out_disable_vdda; 1103 } 1104 } 1105 1106 /* 1107 * Attempt to grab an optional EOC IRQ - only the BMP085 has this 1108 * however as it happens, the BMP085 shares the chip ID of BMP180 1109 * so we look for an IRQ if we have that. 1110 */ 1111 if (irq > 0 || (chip_id == BMP180_CHIP_ID)) { 1112 ret = bmp085_fetch_eoc_irq(dev, name, irq, data); 1113 if (ret) 1114 goto out_disable_vdda; 1115 } 1116 1117 /* Enable runtime PM */ 1118 pm_runtime_get_noresume(dev); 1119 pm_runtime_set_active(dev); 1120 pm_runtime_enable(dev); 1121 /* 1122 * Set autosuspend to two orders of magnitude larger than the 1123 * start-up time. 1124 */ 1125 pm_runtime_set_autosuspend_delay(dev, data->start_up_time / 10); 1126 pm_runtime_use_autosuspend(dev); 1127 pm_runtime_put(dev); 1128 1129 ret = iio_device_register(indio_dev); 1130 if (ret) 1131 goto out_runtime_pm_disable; 1132 1133 1134 return 0; 1135 1136 out_runtime_pm_disable: 1137 pm_runtime_get_sync(data->dev); 1138 pm_runtime_put_noidle(data->dev); 1139 pm_runtime_disable(data->dev); 1140 out_disable_vdda: 1141 regulator_disable(data->vdda); 1142 out_disable_vddd: 1143 regulator_disable(data->vddd); 1144 return ret; 1145 } 1146 EXPORT_SYMBOL(bmp280_common_probe); 1147 1148 int bmp280_common_remove(struct device *dev) 1149 { 1150 struct iio_dev *indio_dev = dev_get_drvdata(dev); 1151 struct bmp280_data *data = iio_priv(indio_dev); 1152 1153 iio_device_unregister(indio_dev); 1154 pm_runtime_get_sync(data->dev); 1155 pm_runtime_put_noidle(data->dev); 1156 pm_runtime_disable(data->dev); 1157 regulator_disable(data->vdda); 1158 regulator_disable(data->vddd); 1159 return 0; 1160 } 1161 EXPORT_SYMBOL(bmp280_common_remove); 1162 1163 #ifdef CONFIG_PM 1164 static int bmp280_runtime_suspend(struct device *dev) 1165 { 1166 struct iio_dev *indio_dev = dev_get_drvdata(dev); 1167 struct bmp280_data *data = iio_priv(indio_dev); 1168 int ret; 1169 1170 ret = regulator_disable(data->vdda); 1171 if (ret) 1172 return ret; 1173 return regulator_disable(data->vddd); 1174 } 1175 1176 static int bmp280_runtime_resume(struct device *dev) 1177 { 1178 struct iio_dev *indio_dev = dev_get_drvdata(dev); 1179 struct bmp280_data *data = iio_priv(indio_dev); 1180 int ret; 1181 1182 ret = regulator_enable(data->vddd); 1183 if (ret) 1184 return ret; 1185 ret = regulator_enable(data->vdda); 1186 if (ret) 1187 return ret; 1188 usleep_range(data->start_up_time, data->start_up_time + 100); 1189 return data->chip_info->chip_config(data); 1190 } 1191 #endif /* CONFIG_PM */ 1192 1193 const struct dev_pm_ops bmp280_dev_pm_ops = { 1194 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 1195 pm_runtime_force_resume) 1196 SET_RUNTIME_PM_OPS(bmp280_runtime_suspend, 1197 bmp280_runtime_resume, NULL) 1198 }; 1199 EXPORT_SYMBOL(bmp280_dev_pm_ops); 1200 1201 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>"); 1202 MODULE_DESCRIPTION("Driver for Bosch Sensortec BMP180/BMP280 pressure and temperature sensor"); 1203 MODULE_LICENSE("GPL v2"); 1204