drivers/iio/chemical/bme680_core.c

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