1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Bosch BME680 - Temperature, Pressure, Humidity & Gas Sensor 4 * 5 * Copyright (C) 2017 - 2018 Bosch Sensortec GmbH 6 * Copyright (C) 2018 Himanshu Jha <himanshujha199640@gmail.com> 7 * 8 * Datasheet: 9 * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BME680-DS001-00.pdf 10 */ 11 #include <linux/acpi.h> 12 #include <linux/bitfield.h> 13 #include <linux/cleanup.h> 14 #include <linux/delay.h> 15 #include <linux/device.h> 16 #include <linux/module.h> 17 #include <linux/log2.h> 18 #include <linux/regmap.h> 19 #include <linux/iio/iio.h> 20 #include <linux/iio/sysfs.h> 21 22 #include "bme680.h" 23 24 struct bme680_calib { 25 u16 par_t1; 26 s16 par_t2; 27 s8 par_t3; 28 u16 par_p1; 29 s16 par_p2; 30 s8 par_p3; 31 s16 par_p4; 32 s16 par_p5; 33 s8 par_p6; 34 s8 par_p7; 35 s16 par_p8; 36 s16 par_p9; 37 u8 par_p10; 38 u16 par_h1; 39 u16 par_h2; 40 s8 par_h3; 41 s8 par_h4; 42 s8 par_h5; 43 u8 par_h6; 44 s8 par_h7; 45 s8 par_gh1; 46 s16 par_gh2; 47 s8 par_gh3; 48 u8 res_heat_range; 49 s8 res_heat_val; 50 s8 range_sw_err; 51 }; 52 53 struct bme680_data { 54 struct regmap *regmap; 55 struct bme680_calib bme680; 56 struct mutex lock; /* Protect multiple serial R/W ops to device. */ 57 u8 oversampling_temp; 58 u8 oversampling_press; 59 u8 oversampling_humid; 60 u16 heater_dur; 61 u16 heater_temp; 62 /* 63 * Carryover value from temperature conversion, used in pressure 64 * and humidity compensation calculations. 65 */ 66 s32 t_fine; 67 }; 68 69 static const struct regmap_range bme680_volatile_ranges[] = { 70 regmap_reg_range(BME680_REG_MEAS_STAT_0, BME680_REG_GAS_R_LSB), 71 regmap_reg_range(BME680_REG_STATUS, BME680_REG_STATUS), 72 regmap_reg_range(BME680_T2_LSB_REG, BME680_GH3_REG), 73 }; 74 75 static const struct regmap_access_table bme680_volatile_table = { 76 .yes_ranges = bme680_volatile_ranges, 77 .n_yes_ranges = ARRAY_SIZE(bme680_volatile_ranges), 78 }; 79 80 const struct regmap_config bme680_regmap_config = { 81 .reg_bits = 8, 82 .val_bits = 8, 83 .max_register = 0xef, 84 .volatile_table = &bme680_volatile_table, 85 .cache_type = REGCACHE_RBTREE, 86 }; 87 EXPORT_SYMBOL_NS(bme680_regmap_config, IIO_BME680); 88 89 static const struct iio_chan_spec bme680_channels[] = { 90 { 91 .type = IIO_TEMP, 92 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 93 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 94 }, 95 { 96 .type = IIO_PRESSURE, 97 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 98 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 99 }, 100 { 101 .type = IIO_HUMIDITYRELATIVE, 102 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 103 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 104 }, 105 { 106 .type = IIO_RESISTANCE, 107 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 108 }, 109 }; 110 bme680_read_calib(struct bme680_data * data,struct bme680_calib * calib)111 static int bme680_read_calib(struct bme680_data *data, 112 struct bme680_calib *calib) 113 { 114 struct device *dev = regmap_get_device(data->regmap); 115 unsigned int tmp, tmp_msb, tmp_lsb; 116 int ret; 117 __le16 buf; 118 119 /* Temperature related coefficients */ 120 ret = regmap_bulk_read(data->regmap, BME680_T1_LSB_REG, 121 &buf, sizeof(buf)); 122 if (ret < 0) { 123 dev_err(dev, "failed to read BME680_T1_LSB_REG\n"); 124 return ret; 125 } 126 calib->par_t1 = le16_to_cpu(buf); 127 128 ret = regmap_bulk_read(data->regmap, BME680_T2_LSB_REG, 129 &buf, sizeof(buf)); 130 if (ret < 0) { 131 dev_err(dev, "failed to read BME680_T2_LSB_REG\n"); 132 return ret; 133 } 134 calib->par_t2 = le16_to_cpu(buf); 135 136 ret = regmap_read(data->regmap, BME680_T3_REG, &tmp); 137 if (ret < 0) { 138 dev_err(dev, "failed to read BME680_T3_REG\n"); 139 return ret; 140 } 141 calib->par_t3 = tmp; 142 143 /* Pressure related coefficients */ 144 ret = regmap_bulk_read(data->regmap, BME680_P1_LSB_REG, 145 &buf, sizeof(buf)); 146 if (ret < 0) { 147 dev_err(dev, "failed to read BME680_P1_LSB_REG\n"); 148 return ret; 149 } 150 calib->par_p1 = le16_to_cpu(buf); 151 152 ret = regmap_bulk_read(data->regmap, BME680_P2_LSB_REG, 153 &buf, sizeof(buf)); 154 if (ret < 0) { 155 dev_err(dev, "failed to read BME680_P2_LSB_REG\n"); 156 return ret; 157 } 158 calib->par_p2 = le16_to_cpu(buf); 159 160 ret = regmap_read(data->regmap, BME680_P3_REG, &tmp); 161 if (ret < 0) { 162 dev_err(dev, "failed to read BME680_P3_REG\n"); 163 return ret; 164 } 165 calib->par_p3 = tmp; 166 167 ret = regmap_bulk_read(data->regmap, BME680_P4_LSB_REG, 168 &buf, sizeof(buf)); 169 if (ret < 0) { 170 dev_err(dev, "failed to read BME680_P4_LSB_REG\n"); 171 return ret; 172 } 173 calib->par_p4 = le16_to_cpu(buf); 174 175 ret = regmap_bulk_read(data->regmap, BME680_P5_LSB_REG, 176 &buf, sizeof(buf)); 177 if (ret < 0) { 178 dev_err(dev, "failed to read BME680_P5_LSB_REG\n"); 179 return ret; 180 } 181 calib->par_p5 = le16_to_cpu(buf); 182 183 ret = regmap_read(data->regmap, BME680_P6_REG, &tmp); 184 if (ret < 0) { 185 dev_err(dev, "failed to read BME680_P6_REG\n"); 186 return ret; 187 } 188 calib->par_p6 = tmp; 189 190 ret = regmap_read(data->regmap, BME680_P7_REG, &tmp); 191 if (ret < 0) { 192 dev_err(dev, "failed to read BME680_P7_REG\n"); 193 return ret; 194 } 195 calib->par_p7 = tmp; 196 197 ret = regmap_bulk_read(data->regmap, BME680_P8_LSB_REG, 198 &buf, sizeof(buf)); 199 if (ret < 0) { 200 dev_err(dev, "failed to read BME680_P8_LSB_REG\n"); 201 return ret; 202 } 203 calib->par_p8 = le16_to_cpu(buf); 204 205 ret = regmap_bulk_read(data->regmap, BME680_P9_LSB_REG, 206 &buf, sizeof(buf)); 207 if (ret < 0) { 208 dev_err(dev, "failed to read BME680_P9_LSB_REG\n"); 209 return ret; 210 } 211 calib->par_p9 = le16_to_cpu(buf); 212 213 ret = regmap_read(data->regmap, BME680_P10_REG, &tmp); 214 if (ret < 0) { 215 dev_err(dev, "failed to read BME680_P10_REG\n"); 216 return ret; 217 } 218 calib->par_p10 = tmp; 219 220 /* Humidity related coefficients */ 221 ret = regmap_read(data->regmap, BME680_H1_MSB_REG, &tmp_msb); 222 if (ret < 0) { 223 dev_err(dev, "failed to read BME680_H1_MSB_REG\n"); 224 return ret; 225 } 226 ret = regmap_read(data->regmap, BME680_H1_LSB_REG, &tmp_lsb); 227 if (ret < 0) { 228 dev_err(dev, "failed to read BME680_H1_LSB_REG\n"); 229 return ret; 230 } 231 calib->par_h1 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) | 232 (tmp_lsb & BME680_BIT_H1_DATA_MASK); 233 234 ret = regmap_read(data->regmap, BME680_H2_MSB_REG, &tmp_msb); 235 if (ret < 0) { 236 dev_err(dev, "failed to read BME680_H2_MSB_REG\n"); 237 return ret; 238 } 239 ret = regmap_read(data->regmap, BME680_H2_LSB_REG, &tmp_lsb); 240 if (ret < 0) { 241 dev_err(dev, "failed to read BME680_H2_LSB_REG\n"); 242 return ret; 243 } 244 calib->par_h2 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) | 245 (tmp_lsb >> BME680_HUM_REG_SHIFT_VAL); 246 247 ret = regmap_read(data->regmap, BME680_H3_REG, &tmp); 248 if (ret < 0) { 249 dev_err(dev, "failed to read BME680_H3_REG\n"); 250 return ret; 251 } 252 calib->par_h3 = tmp; 253 254 ret = regmap_read(data->regmap, BME680_H4_REG, &tmp); 255 if (ret < 0) { 256 dev_err(dev, "failed to read BME680_H4_REG\n"); 257 return ret; 258 } 259 calib->par_h4 = tmp; 260 261 ret = regmap_read(data->regmap, BME680_H5_REG, &tmp); 262 if (ret < 0) { 263 dev_err(dev, "failed to read BME680_H5_REG\n"); 264 return ret; 265 } 266 calib->par_h5 = tmp; 267 268 ret = regmap_read(data->regmap, BME680_H6_REG, &tmp); 269 if (ret < 0) { 270 dev_err(dev, "failed to read BME680_H6_REG\n"); 271 return ret; 272 } 273 calib->par_h6 = tmp; 274 275 ret = regmap_read(data->regmap, BME680_H7_REG, &tmp); 276 if (ret < 0) { 277 dev_err(dev, "failed to read BME680_H7_REG\n"); 278 return ret; 279 } 280 calib->par_h7 = tmp; 281 282 /* Gas heater related coefficients */ 283 ret = regmap_read(data->regmap, BME680_GH1_REG, &tmp); 284 if (ret < 0) { 285 dev_err(dev, "failed to read BME680_GH1_REG\n"); 286 return ret; 287 } 288 calib->par_gh1 = tmp; 289 290 ret = regmap_bulk_read(data->regmap, BME680_GH2_LSB_REG, 291 &buf, sizeof(buf)); 292 if (ret < 0) { 293 dev_err(dev, "failed to read BME680_GH2_LSB_REG\n"); 294 return ret; 295 } 296 calib->par_gh2 = le16_to_cpu(buf); 297 298 ret = regmap_read(data->regmap, BME680_GH3_REG, &tmp); 299 if (ret < 0) { 300 dev_err(dev, "failed to read BME680_GH3_REG\n"); 301 return ret; 302 } 303 calib->par_gh3 = tmp; 304 305 /* Other coefficients */ 306 ret = regmap_read(data->regmap, BME680_REG_RES_HEAT_RANGE, &tmp); 307 if (ret < 0) { 308 dev_err(dev, "failed to read resistance heat range\n"); 309 return ret; 310 } 311 calib->res_heat_range = FIELD_GET(BME680_RHRANGE_MASK, tmp); 312 313 ret = regmap_read(data->regmap, BME680_REG_RES_HEAT_VAL, &tmp); 314 if (ret < 0) { 315 dev_err(dev, "failed to read resistance heat value\n"); 316 return ret; 317 } 318 calib->res_heat_val = tmp; 319 320 ret = regmap_read(data->regmap, BME680_REG_RANGE_SW_ERR, &tmp); 321 if (ret < 0) { 322 dev_err(dev, "failed to read range software error\n"); 323 return ret; 324 } 325 calib->range_sw_err = FIELD_GET(BME680_RSERROR_MASK, tmp); 326 327 return 0; 328 } 329 330 /* 331 * Taken from Bosch BME680 API: 332 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L876 333 * 334 * Returns temperature measurement in DegC, resolutions is 0.01 DegC. Therefore, 335 * output value of "3233" represents 32.33 DegC. 336 */ bme680_compensate_temp(struct bme680_data * data,s32 adc_temp)337 static s16 bme680_compensate_temp(struct bme680_data *data, 338 s32 adc_temp) 339 { 340 struct bme680_calib *calib = &data->bme680; 341 s64 var1, var2, var3; 342 s16 calc_temp; 343 344 /* If the calibration is invalid, attempt to reload it */ 345 if (!calib->par_t2) 346 bme680_read_calib(data, calib); 347 348 var1 = (adc_temp >> 3) - ((s32)calib->par_t1 << 1); 349 var2 = (var1 * calib->par_t2) >> 11; 350 var3 = ((var1 >> 1) * (var1 >> 1)) >> 12; 351 var3 = (var3 * ((s32)calib->par_t3 << 4)) >> 14; 352 data->t_fine = var2 + var3; 353 calc_temp = (data->t_fine * 5 + 128) >> 8; 354 355 return calc_temp; 356 } 357 358 /* 359 * Taken from Bosch BME680 API: 360 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L896 361 * 362 * Returns pressure measurement in Pa. Output value of "97356" represents 363 * 97356 Pa = 973.56 hPa. 364 */ bme680_compensate_press(struct bme680_data * data,u32 adc_press)365 static u32 bme680_compensate_press(struct bme680_data *data, 366 u32 adc_press) 367 { 368 struct bme680_calib *calib = &data->bme680; 369 s32 var1, var2, var3, press_comp; 370 371 var1 = (data->t_fine >> 1) - 64000; 372 var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) * calib->par_p6) >> 2; 373 var2 = var2 + (var1 * calib->par_p5 << 1); 374 var2 = (var2 >> 2) + ((s32)calib->par_p4 << 16); 375 var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) * 376 ((s32)calib->par_p3 << 5)) >> 3) + 377 ((calib->par_p2 * var1) >> 1); 378 var1 = var1 >> 18; 379 var1 = ((32768 + var1) * calib->par_p1) >> 15; 380 press_comp = 1048576 - adc_press; 381 press_comp = ((press_comp - (var2 >> 12)) * 3125); 382 383 if (press_comp >= BME680_MAX_OVERFLOW_VAL) 384 press_comp = ((press_comp / (u32)var1) << 1); 385 else 386 press_comp = ((press_comp << 1) / (u32)var1); 387 388 var1 = (calib->par_p9 * (((press_comp >> 3) * 389 (press_comp >> 3)) >> 13)) >> 12; 390 var2 = ((press_comp >> 2) * calib->par_p8) >> 13; 391 var3 = ((press_comp >> 8) * (press_comp >> 8) * 392 (press_comp >> 8) * calib->par_p10) >> 17; 393 394 press_comp += (var1 + var2 + var3 + ((s32)calib->par_p7 << 7)) >> 4; 395 396 return press_comp; 397 } 398 399 /* 400 * Taken from Bosch BME680 API: 401 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L937 402 * 403 * Returns humidity measurement in percent, resolution is 0.001 percent. Output 404 * value of "43215" represents 43.215 %rH. 405 */ bme680_compensate_humid(struct bme680_data * data,u16 adc_humid)406 static u32 bme680_compensate_humid(struct bme680_data *data, 407 u16 adc_humid) 408 { 409 struct bme680_calib *calib = &data->bme680; 410 s32 var1, var2, var3, var4, var5, var6, temp_scaled, calc_hum; 411 412 temp_scaled = (data->t_fine * 5 + 128) >> 8; 413 var1 = (adc_humid - ((s32) ((s32) calib->par_h1 * 16))) - 414 (((temp_scaled * (s32) calib->par_h3) / 100) >> 1); 415 var2 = ((s32) calib->par_h2 * 416 (((temp_scaled * calib->par_h4) / 100) + 417 (((temp_scaled * ((temp_scaled * calib->par_h5) / 100)) 418 >> 6) / 100) + (1 << 14))) >> 10; 419 var3 = var1 * var2; 420 var4 = (s32)calib->par_h6 << 7; 421 var4 = (var4 + ((temp_scaled * calib->par_h7) / 100)) >> 4; 422 var5 = ((var3 >> 14) * (var3 >> 14)) >> 10; 423 var6 = (var4 * var5) >> 1; 424 calc_hum = (((var3 + var6) >> 10) * 1000) >> 12; 425 426 calc_hum = clamp(calc_hum, 0, 100000); /* clamp between 0-100 %rH */ 427 428 return calc_hum; 429 } 430 431 /* 432 * Taken from Bosch BME680 API: 433 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L973 434 * 435 * Returns gas measurement in Ohm. Output value of "82986" represent 82986 ohms. 436 */ bme680_compensate_gas(struct bme680_data * data,u16 gas_res_adc,u8 gas_range)437 static u32 bme680_compensate_gas(struct bme680_data *data, u16 gas_res_adc, 438 u8 gas_range) 439 { 440 struct bme680_calib *calib = &data->bme680; 441 s64 var1; 442 u64 var2; 443 s64 var3; 444 u32 calc_gas_res; 445 446 /* Look up table for the possible gas range values */ 447 const u32 lookupTable[16] = {2147483647u, 2147483647u, 448 2147483647u, 2147483647u, 2147483647u, 449 2126008810u, 2147483647u, 2130303777u, 450 2147483647u, 2147483647u, 2143188679u, 451 2136746228u, 2147483647u, 2126008810u, 452 2147483647u, 2147483647u}; 453 454 var1 = ((1340 + (5 * (s64) calib->range_sw_err)) * 455 ((s64) lookupTable[gas_range])) >> 16; 456 var2 = ((gas_res_adc << 15) - 16777216) + var1; 457 var3 = ((125000 << (15 - gas_range)) * var1) >> 9; 458 var3 += (var2 >> 1); 459 calc_gas_res = div64_s64(var3, (s64) var2); 460 461 return calc_gas_res; 462 } 463 464 /* 465 * Taken from Bosch BME680 API: 466 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1002 467 */ bme680_calc_heater_res(struct bme680_data * data,u16 temp)468 static u8 bme680_calc_heater_res(struct bme680_data *data, u16 temp) 469 { 470 struct bme680_calib *calib = &data->bme680; 471 s32 var1, var2, var3, var4, var5, heatr_res_x100; 472 u8 heatr_res; 473 474 if (temp > 400) /* Cap temperature */ 475 temp = 400; 476 477 var1 = (((s32) BME680_AMB_TEMP * calib->par_gh3) / 1000) * 256; 478 var2 = (calib->par_gh1 + 784) * (((((calib->par_gh2 + 154009) * 479 temp * 5) / 100) 480 + 3276800) / 10); 481 var3 = var1 + (var2 / 2); 482 var4 = (var3 / (calib->res_heat_range + 4)); 483 var5 = 131 * calib->res_heat_val + 65536; 484 heatr_res_x100 = ((var4 / var5) - 250) * 34; 485 heatr_res = DIV_ROUND_CLOSEST(heatr_res_x100, 100); 486 487 return heatr_res; 488 } 489 490 /* 491 * Taken from Bosch BME680 API: 492 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1188 493 */ bme680_calc_heater_dur(u16 dur)494 static u8 bme680_calc_heater_dur(u16 dur) 495 { 496 u8 durval, factor = 0; 497 498 if (dur >= 0xfc0) { 499 durval = 0xff; /* Max duration */ 500 } else { 501 while (dur > 0x3F) { 502 dur = dur / 4; 503 factor += 1; 504 } 505 durval = dur + (factor * 64); 506 } 507 508 return durval; 509 } 510 bme680_set_mode(struct bme680_data * data,bool mode)511 static int bme680_set_mode(struct bme680_data *data, bool mode) 512 { 513 struct device *dev = regmap_get_device(data->regmap); 514 int ret; 515 516 if (mode) { 517 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS, 518 BME680_MODE_MASK, BME680_MODE_FORCED); 519 if (ret < 0) 520 dev_err(dev, "failed to set forced mode\n"); 521 522 } else { 523 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS, 524 BME680_MODE_MASK, BME680_MODE_SLEEP); 525 if (ret < 0) 526 dev_err(dev, "failed to set sleep mode\n"); 527 528 } 529 530 return ret; 531 } 532 bme680_oversampling_to_reg(u8 val)533 static u8 bme680_oversampling_to_reg(u8 val) 534 { 535 return ilog2(val) + 1; 536 } 537 538 /* 539 * Taken from Bosch BME680 API: 540 * https://github.com/boschsensortec/BME68x_SensorAPI/blob/v4.4.8/bme68x.c#L490 541 */ bme680_wait_for_eoc(struct bme680_data * data)542 static int bme680_wait_for_eoc(struct bme680_data *data) 543 { 544 struct device *dev = regmap_get_device(data->regmap); 545 unsigned int check; 546 int ret; 547 /* 548 * (Sum of oversampling ratios * time per oversampling) + 549 * TPH measurement + gas measurement + wait transition from forced mode 550 * + heater duration 551 */ 552 int wait_eoc_us = ((data->oversampling_temp + data->oversampling_press + 553 data->oversampling_humid) * 1936) + (477 * 4) + 554 (477 * 5) + 1000 + (data->heater_dur * 1000); 555 556 usleep_range(wait_eoc_us, wait_eoc_us + 100); 557 558 ret = regmap_read(data->regmap, BME680_REG_MEAS_STAT_0, &check); 559 if (ret) { 560 dev_err(dev, "failed to read measurement status register.\n"); 561 return ret; 562 } 563 if (check & BME680_MEAS_BIT) { 564 dev_err(dev, "Device measurement cycle incomplete.\n"); 565 return -EBUSY; 566 } 567 if (!(check & BME680_NEW_DATA_BIT)) { 568 dev_err(dev, "No new data available from the device.\n"); 569 return -ENODATA; 570 } 571 572 return 0; 573 } 574 bme680_chip_config(struct bme680_data * data)575 static int bme680_chip_config(struct bme680_data *data) 576 { 577 struct device *dev = regmap_get_device(data->regmap); 578 int ret; 579 u8 osrs; 580 581 osrs = FIELD_PREP( 582 BME680_OSRS_HUMIDITY_MASK, 583 bme680_oversampling_to_reg(data->oversampling_humid)); 584 /* 585 * Highly recommended to set oversampling of humidity before 586 * temperature/pressure oversampling. 587 */ 588 ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_HUMIDITY, 589 BME680_OSRS_HUMIDITY_MASK, osrs); 590 if (ret < 0) { 591 dev_err(dev, "failed to write ctrl_hum register\n"); 592 return ret; 593 } 594 595 /* IIR filter settings */ 596 ret = regmap_update_bits(data->regmap, BME680_REG_CONFIG, 597 BME680_FILTER_MASK, 598 BME680_FILTER_COEFF_VAL); 599 if (ret < 0) { 600 dev_err(dev, "failed to write config register\n"); 601 return ret; 602 } 603 604 osrs = FIELD_PREP(BME680_OSRS_TEMP_MASK, 605 bme680_oversampling_to_reg(data->oversampling_temp)) | 606 FIELD_PREP(BME680_OSRS_PRESS_MASK, 607 bme680_oversampling_to_reg(data->oversampling_press)); 608 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS, 609 BME680_OSRS_TEMP_MASK | BME680_OSRS_PRESS_MASK, 610 osrs); 611 if (ret < 0) 612 dev_err(dev, "failed to write ctrl_meas register\n"); 613 614 return ret; 615 } 616 bme680_gas_config(struct bme680_data * data)617 static int bme680_gas_config(struct bme680_data *data) 618 { 619 struct device *dev = regmap_get_device(data->regmap); 620 int ret; 621 u8 heatr_res, heatr_dur; 622 623 heatr_res = bme680_calc_heater_res(data, data->heater_temp); 624 625 /* set target heater temperature */ 626 ret = regmap_write(data->regmap, BME680_REG_RES_HEAT_0, heatr_res); 627 if (ret < 0) { 628 dev_err(dev, "failed to write res_heat_0 register\n"); 629 return ret; 630 } 631 632 heatr_dur = bme680_calc_heater_dur(data->heater_dur); 633 634 /* set target heating duration */ 635 ret = regmap_write(data->regmap, BME680_REG_GAS_WAIT_0, heatr_dur); 636 if (ret < 0) { 637 dev_err(dev, "failed to write gas_wait_0 register\n"); 638 return ret; 639 } 640 641 /* Enable the gas sensor and select heater profile set-point 0 */ 642 ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_GAS_1, 643 BME680_RUN_GAS_MASK | BME680_NB_CONV_MASK, 644 FIELD_PREP(BME680_RUN_GAS_MASK, 1) | 645 FIELD_PREP(BME680_NB_CONV_MASK, 0)); 646 if (ret < 0) 647 dev_err(dev, "failed to write ctrl_gas_1 register\n"); 648 649 return ret; 650 } 651 bme680_read_temp(struct bme680_data * data,int * val)652 static int bme680_read_temp(struct bme680_data *data, int *val) 653 { 654 struct device *dev = regmap_get_device(data->regmap); 655 int ret; 656 __be32 tmp = 0; 657 s32 adc_temp; 658 s16 comp_temp; 659 660 /* set forced mode to trigger measurement */ 661 ret = bme680_set_mode(data, true); 662 if (ret < 0) 663 return ret; 664 665 ret = bme680_wait_for_eoc(data); 666 if (ret) 667 return ret; 668 669 ret = regmap_bulk_read(data->regmap, BME680_REG_TEMP_MSB, 670 &tmp, 3); 671 if (ret < 0) { 672 dev_err(dev, "failed to read temperature\n"); 673 return ret; 674 } 675 676 adc_temp = be32_to_cpu(tmp) >> 12; 677 if (adc_temp == BME680_MEAS_SKIPPED) { 678 /* reading was skipped */ 679 dev_err(dev, "reading temperature skipped\n"); 680 return -EINVAL; 681 } 682 comp_temp = bme680_compensate_temp(data, adc_temp); 683 /* 684 * val might be NULL if we're called by the read_press/read_humid 685 * routine which is called to get t_fine value used in 686 * compensate_press/compensate_humid to get compensated 687 * pressure/humidity readings. 688 */ 689 if (val) { 690 *val = comp_temp * 10; /* Centidegrees to millidegrees */ 691 return IIO_VAL_INT; 692 } 693 694 return ret; 695 } 696 bme680_read_press(struct bme680_data * data,int * val,int * val2)697 static int bme680_read_press(struct bme680_data *data, 698 int *val, int *val2) 699 { 700 struct device *dev = regmap_get_device(data->regmap); 701 int ret; 702 __be32 tmp = 0; 703 s32 adc_press; 704 705 /* Read and compensate temperature to get a reading of t_fine */ 706 ret = bme680_read_temp(data, NULL); 707 if (ret < 0) 708 return ret; 709 710 ret = regmap_bulk_read(data->regmap, BME680_REG_PRESS_MSB, 711 &tmp, 3); 712 if (ret < 0) { 713 dev_err(dev, "failed to read pressure\n"); 714 return ret; 715 } 716 717 adc_press = be32_to_cpu(tmp) >> 12; 718 if (adc_press == BME680_MEAS_SKIPPED) { 719 /* reading was skipped */ 720 dev_err(dev, "reading pressure skipped\n"); 721 return -EINVAL; 722 } 723 724 *val = bme680_compensate_press(data, adc_press); 725 *val2 = 1000; 726 return IIO_VAL_FRACTIONAL; 727 } 728 bme680_read_humid(struct bme680_data * data,int * val,int * val2)729 static int bme680_read_humid(struct bme680_data *data, 730 int *val, int *val2) 731 { 732 struct device *dev = regmap_get_device(data->regmap); 733 int ret; 734 __be16 tmp = 0; 735 s32 adc_humidity; 736 u32 comp_humidity; 737 738 /* Read and compensate temperature to get a reading of t_fine */ 739 ret = bme680_read_temp(data, NULL); 740 if (ret < 0) 741 return ret; 742 743 ret = regmap_bulk_read(data->regmap, BM6880_REG_HUMIDITY_MSB, 744 &tmp, sizeof(tmp)); 745 if (ret < 0) { 746 dev_err(dev, "failed to read humidity\n"); 747 return ret; 748 } 749 750 adc_humidity = be16_to_cpu(tmp); 751 if (adc_humidity == BME680_MEAS_SKIPPED) { 752 /* reading was skipped */ 753 dev_err(dev, "reading humidity skipped\n"); 754 return -EINVAL; 755 } 756 comp_humidity = bme680_compensate_humid(data, adc_humidity); 757 758 *val = comp_humidity; 759 *val2 = 1000; 760 return IIO_VAL_FRACTIONAL; 761 } 762 bme680_read_gas(struct bme680_data * data,int * val)763 static int bme680_read_gas(struct bme680_data *data, 764 int *val) 765 { 766 struct device *dev = regmap_get_device(data->regmap); 767 int ret; 768 __be16 tmp = 0; 769 unsigned int check; 770 u16 adc_gas_res; 771 u8 gas_range; 772 773 /* Set heater settings */ 774 ret = bme680_gas_config(data); 775 if (ret < 0) { 776 dev_err(dev, "failed to set gas config\n"); 777 return ret; 778 } 779 780 /* set forced mode to trigger measurement */ 781 ret = bme680_set_mode(data, true); 782 if (ret < 0) 783 return ret; 784 785 ret = bme680_wait_for_eoc(data); 786 if (ret) 787 return ret; 788 789 ret = regmap_read(data->regmap, BME680_REG_MEAS_STAT_0, &check); 790 if (check & BME680_GAS_MEAS_BIT) { 791 dev_err(dev, "gas measurement incomplete\n"); 792 return -EBUSY; 793 } 794 795 ret = regmap_read(data->regmap, BME680_REG_GAS_R_LSB, &check); 796 if (ret < 0) { 797 dev_err(dev, "failed to read gas_r_lsb register\n"); 798 return ret; 799 } 800 801 /* 802 * occurs if either the gas heating duration was insuffient 803 * to reach the target heater temperature or the target 804 * heater temperature was too high for the heater sink to 805 * reach. 806 */ 807 if ((check & BME680_GAS_STAB_BIT) == 0) { 808 dev_err(dev, "heater failed to reach the target temperature\n"); 809 return -EINVAL; 810 } 811 812 ret = regmap_bulk_read(data->regmap, BME680_REG_GAS_MSB, 813 &tmp, sizeof(tmp)); 814 if (ret < 0) { 815 dev_err(dev, "failed to read gas resistance\n"); 816 return ret; 817 } 818 819 gas_range = check & BME680_GAS_RANGE_MASK; 820 adc_gas_res = be16_to_cpu(tmp) >> BME680_ADC_GAS_RES_SHIFT; 821 822 *val = bme680_compensate_gas(data, adc_gas_res, gas_range); 823 return IIO_VAL_INT; 824 } 825 bme680_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)826 static int bme680_read_raw(struct iio_dev *indio_dev, 827 struct iio_chan_spec const *chan, 828 int *val, int *val2, long mask) 829 { 830 struct bme680_data *data = iio_priv(indio_dev); 831 832 guard(mutex)(&data->lock); 833 834 switch (mask) { 835 case IIO_CHAN_INFO_PROCESSED: 836 switch (chan->type) { 837 case IIO_TEMP: 838 return bme680_read_temp(data, val); 839 case IIO_PRESSURE: 840 return bme680_read_press(data, val, val2); 841 case IIO_HUMIDITYRELATIVE: 842 return bme680_read_humid(data, val, val2); 843 case IIO_RESISTANCE: 844 return bme680_read_gas(data, val); 845 default: 846 return -EINVAL; 847 } 848 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 849 switch (chan->type) { 850 case IIO_TEMP: 851 *val = data->oversampling_temp; 852 return IIO_VAL_INT; 853 case IIO_PRESSURE: 854 *val = data->oversampling_press; 855 return IIO_VAL_INT; 856 case IIO_HUMIDITYRELATIVE: 857 *val = data->oversampling_humid; 858 return IIO_VAL_INT; 859 default: 860 return -EINVAL; 861 } 862 default: 863 return -EINVAL; 864 } 865 } 866 bme680_is_valid_oversampling(int rate)867 static bool bme680_is_valid_oversampling(int rate) 868 { 869 return (rate > 0 && rate <= 16 && is_power_of_2(rate)); 870 } 871 bme680_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)872 static int bme680_write_raw(struct iio_dev *indio_dev, 873 struct iio_chan_spec const *chan, 874 int val, int val2, long mask) 875 { 876 struct bme680_data *data = iio_priv(indio_dev); 877 878 guard(mutex)(&data->lock); 879 880 if (val2 != 0) 881 return -EINVAL; 882 883 switch (mask) { 884 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 885 { 886 if (!bme680_is_valid_oversampling(val)) 887 return -EINVAL; 888 889 switch (chan->type) { 890 case IIO_TEMP: 891 data->oversampling_temp = val; 892 break; 893 case IIO_PRESSURE: 894 data->oversampling_press = val; 895 break; 896 case IIO_HUMIDITYRELATIVE: 897 data->oversampling_humid = val; 898 break; 899 default: 900 return -EINVAL; 901 } 902 903 return bme680_chip_config(data); 904 } 905 default: 906 return -EINVAL; 907 } 908 } 909 910 static const char bme680_oversampling_ratio_show[] = "1 2 4 8 16"; 911 912 static IIO_CONST_ATTR(oversampling_ratio_available, 913 bme680_oversampling_ratio_show); 914 915 static struct attribute *bme680_attributes[] = { 916 &iio_const_attr_oversampling_ratio_available.dev_attr.attr, 917 NULL, 918 }; 919 920 static const struct attribute_group bme680_attribute_group = { 921 .attrs = bme680_attributes, 922 }; 923 924 static const struct iio_info bme680_info = { 925 .read_raw = &bme680_read_raw, 926 .write_raw = &bme680_write_raw, 927 .attrs = &bme680_attribute_group, 928 }; 929 bme680_match_acpi_device(struct device * dev)930 static const char *bme680_match_acpi_device(struct device *dev) 931 { 932 const struct acpi_device_id *id; 933 934 id = acpi_match_device(dev->driver->acpi_match_table, dev); 935 if (!id) 936 return NULL; 937 938 return dev_name(dev); 939 } 940 bme680_core_probe(struct device * dev,struct regmap * regmap,const char * name)941 int bme680_core_probe(struct device *dev, struct regmap *regmap, 942 const char *name) 943 { 944 struct iio_dev *indio_dev; 945 struct bme680_data *data; 946 unsigned int val; 947 int ret; 948 949 ret = regmap_write(regmap, BME680_REG_SOFT_RESET, 950 BME680_CMD_SOFTRESET); 951 if (ret < 0) { 952 dev_err(dev, "Failed to reset chip\n"); 953 return ret; 954 } 955 956 ret = regmap_read(regmap, BME680_REG_CHIP_ID, &val); 957 if (ret < 0) { 958 dev_err(dev, "Error reading chip ID\n"); 959 return ret; 960 } 961 962 if (val != BME680_CHIP_ID_VAL) { 963 dev_err(dev, "Wrong chip ID, got %x expected %x\n", 964 val, BME680_CHIP_ID_VAL); 965 return -ENODEV; 966 } 967 968 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 969 if (!indio_dev) 970 return -ENOMEM; 971 972 if (!name && ACPI_HANDLE(dev)) 973 name = bme680_match_acpi_device(dev); 974 975 data = iio_priv(indio_dev); 976 mutex_init(&data->lock); 977 dev_set_drvdata(dev, indio_dev); 978 data->regmap = regmap; 979 indio_dev->name = name; 980 indio_dev->channels = bme680_channels; 981 indio_dev->num_channels = ARRAY_SIZE(bme680_channels); 982 indio_dev->info = &bme680_info; 983 indio_dev->modes = INDIO_DIRECT_MODE; 984 985 /* default values for the sensor */ 986 data->oversampling_humid = 2; /* 2X oversampling rate */ 987 data->oversampling_press = 4; /* 4X oversampling rate */ 988 data->oversampling_temp = 8; /* 8X oversampling rate */ 989 data->heater_temp = 320; /* degree Celsius */ 990 data->heater_dur = 150; /* milliseconds */ 991 992 ret = bme680_chip_config(data); 993 if (ret < 0) { 994 dev_err(dev, "failed to set chip_config data\n"); 995 return ret; 996 } 997 998 ret = bme680_gas_config(data); 999 if (ret < 0) { 1000 dev_err(dev, "failed to set gas config data\n"); 1001 return ret; 1002 } 1003 1004 ret = bme680_read_calib(data, &data->bme680); 1005 if (ret < 0) { 1006 dev_err(dev, 1007 "failed to read calibration coefficients at probe\n"); 1008 return ret; 1009 } 1010 1011 return devm_iio_device_register(dev, indio_dev); 1012 } 1013 EXPORT_SYMBOL_NS_GPL(bme680_core_probe, IIO_BME680); 1014 1015 MODULE_AUTHOR("Himanshu Jha <himanshujha199640@gmail.com>"); 1016 MODULE_DESCRIPTION("Bosch BME680 Driver"); 1017 MODULE_LICENSE("GPL v2"); 1018