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 const int bme680_oversampling_avail[] = { 1, 2, 4, 8, 16 };
 109
 110 static int bme680_read_calib(struct bme680_data *data,
 111                              struct bme680_calib *calib)
 112 {
 113         struct device *dev = regmap_get_device(data->regmap);
 114         unsigned int tmp, tmp_msb, tmp_lsb;
 115         int ret;
 116         __le16 buf;
 117
 118         /* Temperature related coefficients */
 119         ret = regmap_bulk_read(data->regmap, BME680_T1_LSB_REG,
 120                                (u8 *) &buf, 2);
 121         if (ret < 0) {
 122                 dev_err(dev, "failed to read BME680_T1_LSB_REG\n");
 123                 return ret;
 124         }
 125         calib->par_t1 = le16_to_cpu(buf);
 126
 127         ret = regmap_bulk_read(data->regmap, BME680_T2_LSB_REG,
 128                                (u8 *) &buf, 2);
 129         if (ret < 0) {
 130                 dev_err(dev, "failed to read BME680_T2_LSB_REG\n");
 131                 return ret;
 132         }
 133         calib->par_t2 = le16_to_cpu(buf);
 134
 135         ret = regmap_read(data->regmap, BME680_T3_REG, &tmp);
 136         if (ret < 0) {
 137                 dev_err(dev, "failed to read BME680_T3_REG\n");
 138                 return ret;
 139         }
 140         calib->par_t3 = tmp;
 141
 142         /* Pressure related coefficients */
 143         ret = regmap_bulk_read(data->regmap, BME680_P1_LSB_REG,
 144                                (u8 *) &buf, 2);
 145         if (ret < 0) {
 146                 dev_err(dev, "failed to read BME680_P1_LSB_REG\n");
 147                 return ret;
 148         }
 149         calib->par_p1 = le16_to_cpu(buf);
 150
 151         ret = regmap_bulk_read(data->regmap, BME680_P2_LSB_REG,
 152                                (u8 *) &buf, 2);
 153         if (ret < 0) {
 154                 dev_err(dev, "failed to read BME680_P2_LSB_REG\n");
 155                 return ret;
 156         }
 157         calib->par_p2 = le16_to_cpu(buf);
 158
 159         ret = regmap_read(data->regmap, BME680_P3_REG, &tmp);
 160         if (ret < 0) {
 161                 dev_err(dev, "failed to read BME680_P3_REG\n");
 162                 return ret;
 163         }
 164         calib->par_p3 = tmp;
 165
 166         ret = regmap_bulk_read(data->regmap, BME680_P4_LSB_REG,
 167                                (u8 *) &buf, 2);
 168         if (ret < 0) {
 169                 dev_err(dev, "failed to read BME680_P4_LSB_REG\n");
 170                 return ret;
 171         }
 172         calib->par_p4 = le16_to_cpu(buf);
 173
 174         ret = regmap_bulk_read(data->regmap, BME680_P5_LSB_REG,
 175                                (u8 *) &buf, 2);
 176         if (ret < 0) {
 177                 dev_err(dev, "failed to read BME680_P5_LSB_REG\n");
 178                 return ret;
 179         }
 180         calib->par_p5 = le16_to_cpu(buf);
 181
 182         ret = regmap_read(data->regmap, BME680_P6_REG, &tmp);
 183         if (ret < 0) {
 184                 dev_err(dev, "failed to read BME680_P6_REG\n");
 185                 return ret;
 186         }
 187         calib->par_p6 = tmp;
 188
 189         ret = regmap_read(data->regmap, BME680_P7_REG, &tmp);
 190         if (ret < 0) {
 191                 dev_err(dev, "failed to read BME680_P7_REG\n");
 192                 return ret;
 193         }
 194         calib->par_p7 = tmp;
 195
 196         ret = regmap_bulk_read(data->regmap, BME680_P8_LSB_REG,
 197                                (u8 *) &buf, 2);
 198         if (ret < 0) {
 199                 dev_err(dev, "failed to read BME680_P8_LSB_REG\n");
 200                 return ret;
 201         }
 202         calib->par_p8 = le16_to_cpu(buf);
 203
 204         ret = regmap_bulk_read(data->regmap, BME680_P9_LSB_REG,
 205                                (u8 *) &buf, 2);
 206         if (ret < 0) {
 207                 dev_err(dev, "failed to read BME680_P9_LSB_REG\n");
 208                 return ret;
 209         }
 210         calib->par_p9 = le16_to_cpu(buf);
 211
 212         ret = regmap_read(data->regmap, BME680_P10_REG, &tmp);
 213         if (ret < 0) {
 214                 dev_err(dev, "failed to read BME680_P10_REG\n");
 215                 return ret;
 216         }
 217         calib->par_p10 = tmp;
 218
 219         /* Humidity related coefficients */
 220         ret = regmap_read(data->regmap, BME680_H1_MSB_REG, &tmp_msb);
 221         if (ret < 0) {
 222                 dev_err(dev, "failed to read BME680_H1_MSB_REG\n");
 223                 return ret;
 224         }
 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
 232         calib->par_h1 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) |
 233                                 (tmp_lsb & BME680_BIT_H1_DATA_MSK);
 234
 235         ret = regmap_read(data->regmap, BME680_H2_MSB_REG, &tmp_msb);
 236         if (ret < 0) {
 237                 dev_err(dev, "failed to read BME680_H2_MSB_REG\n");
 238                 return ret;
 239         }
 240
 241         ret = regmap_read(data->regmap, BME680_H2_LSB_REG, &tmp_lsb);
 242         if (ret < 0) {
 243                 dev_err(dev, "failed to read BME680_H2_LSB_REG\n");
 244                 return ret;
 245         }
 246
 247         calib->par_h2 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) |
 248                                 (tmp_lsb >> BME680_HUM_REG_SHIFT_VAL);
 249
 250         ret = regmap_read(data->regmap, BME680_H3_REG, &tmp);
 251         if (ret < 0) {
 252                 dev_err(dev, "failed to read BME680_H3_REG\n");
 253                 return ret;
 254         }
 255         calib->par_h3 = tmp;
 256
 257         ret = regmap_read(data->regmap, BME680_H4_REG, &tmp);
 258         if (ret < 0) {
 259                 dev_err(dev, "failed to read BME680_H4_REG\n");
 260                 return ret;
 261         }
 262         calib->par_h4 = tmp;
 263
 264         ret = regmap_read(data->regmap, BME680_H5_REG, &tmp);
 265         if (ret < 0) {
 266                 dev_err(dev, "failed to read BME680_H5_REG\n");
 267                 return ret;
 268         }
 269         calib->par_h5 = tmp;
 270
 271         ret = regmap_read(data->regmap, BME680_H6_REG, &tmp);
 272         if (ret < 0) {
 273                 dev_err(dev, "failed to read BME680_H6_REG\n");
 274                 return ret;
 275         }
 276         calib->par_h6 = tmp;
 277
 278         ret = regmap_read(data->regmap, BME680_H7_REG, &tmp);
 279         if (ret < 0) {
 280                 dev_err(dev, "failed to read BME680_H7_REG\n");
 281                 return ret;
 282         }
 283         calib->par_h7 = tmp;
 284
 285         /* Gas heater related coefficients */
 286         ret = regmap_read(data->regmap, BME680_GH1_REG, &tmp);
 287         if (ret < 0) {
 288                 dev_err(dev, "failed to read BME680_GH1_REG\n");
 289                 return ret;
 290         }
 291         calib->par_gh1 = tmp;
 292
 293         ret = regmap_bulk_read(data->regmap, BME680_GH2_LSB_REG,
 294                                (u8 *) &buf, 2);
 295         if (ret < 0) {
 296                 dev_err(dev, "failed to read BME680_GH2_LSB_REG\n");
 297                 return ret;
 298         }
 299         calib->par_gh2 = le16_to_cpu(buf);
 300
 301         ret = regmap_read(data->regmap, BME680_GH3_REG, &tmp);
 302         if (ret < 0) {
 303                 dev_err(dev, "failed to read BME680_GH3_REG\n");
 304                 return ret;
 305         }
 306         calib->par_gh3 = tmp;
 307
 308         /* Other coefficients */
 309         ret = regmap_read(data->regmap, BME680_REG_RES_HEAT_RANGE, &tmp);
 310         if (ret < 0) {
 311                 dev_err(dev, "failed to read resistance heat range\n");
 312                 return ret;
 313         }
 314         calib->res_heat_range = (tmp & BME680_RHRANGE_MSK) / 16;
 315
 316         ret = regmap_read(data->regmap, BME680_REG_RES_HEAT_VAL, &tmp);
 317         if (ret < 0) {
 318                 dev_err(dev, "failed to read resistance heat value\n");
 319                 return ret;
 320         }
 321         calib->res_heat_val = tmp;
 322
 323         ret = regmap_read(data->regmap, BME680_REG_RANGE_SW_ERR, &tmp);
 324         if (ret < 0) {
 325                 dev_err(dev, "failed to read range software error\n");
 326                 return ret;
 327         }
 328         calib->range_sw_err = (tmp & BME680_RSERROR_MSK) / 16;
 329
 330         return 0;
 331 }
 332
 333 /*
 334  * Taken from Bosch BME680 API:
 335  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L876
 336  *
 337  * Returns temperature measurement in DegC, resolutions is 0.01 DegC. Therefore,
 338  * output value of "3233" represents 32.33 DegC.
 339  */
 340 static s16 bme680_compensate_temp(struct bme680_data *data,
 341                                   s32 adc_temp)
 342 {
 343         struct bme680_calib *calib = &data->bme680;
 344         s64 var1, var2, var3;
 345         s16 calc_temp;
 346
 347         /* If the calibration is invalid, attempt to reload it */
 348         if (!calib->par_t2)
 349                 bme680_read_calib(data, calib);
 350
 351         var1 = (adc_temp >> 3) - (calib->par_t1 << 1);
 352         var2 = (var1 * calib->par_t2) >> 11;
 353         var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
 354         var3 = (var3 * (calib->par_t3 << 4)) >> 14;
 355         data->t_fine = var2 + var3;
 356         calc_temp = (data->t_fine * 5 + 128) >> 8;
 357
 358         return calc_temp;
 359 }
 360
 361 /*
 362  * Taken from Bosch BME680 API:
 363  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L896
 364  *
 365  * Returns pressure measurement in Pa. Output value of "97356" represents
 366  * 97356 Pa = 973.56 hPa.
 367  */
 368 static u32 bme680_compensate_press(struct bme680_data *data,
 369                                    u32 adc_press)
 370 {
 371         struct bme680_calib *calib = &data->bme680;
 372         s32 var1, var2, var3, press_comp;
 373
 374         var1 = (data->t_fine >> 1) - 64000;
 375         var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) * calib->par_p6) >> 2;
 376         var2 = var2 + (var1 * calib->par_p5 << 1);
 377         var2 = (var2 >> 2) + (calib->par_p4 << 16);
 378         var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
 379                         (calib->par_p3 << 5)) >> 3) +
 380                         ((calib->par_p2 * var1) >> 1);
 381         var1 = var1 >> 18;
 382         var1 = ((32768 + var1) * calib->par_p1) >> 15;
 383         press_comp = 1048576 - adc_press;
 384         press_comp = ((press_comp - (var2 >> 12)) * 3125);
 385
 386         if (press_comp >= BME680_MAX_OVERFLOW_VAL)
 387                 press_comp = ((press_comp / (u32)var1) << 1);
 388         else
 389                 press_comp = ((press_comp << 1) / (u32)var1);
 390
 391         var1 = (calib->par_p9 * (((press_comp >> 3) *
 392                         (press_comp >> 3)) >> 13)) >> 12;
 393         var2 = ((press_comp >> 2) * calib->par_p8) >> 13;
 394         var3 = ((press_comp >> 8) * (press_comp >> 8) *
 395                         (press_comp >> 8) * calib->par_p10) >> 17;
 396
 397         press_comp += (var1 + var2 + var3 + (calib->par_p7 << 7)) >> 4;
 398
 399         return press_comp;
 400 }
 401
 402 /*
 403  * Taken from Bosch BME680 API:
 404  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L937
 405  *
 406  * Returns humidity measurement in percent, resolution is 0.001 percent. Output
 407  * value of "43215" represents 43.215 %rH.
 408  */
 409 static u32 bme680_compensate_humid(struct bme680_data *data,
 410                                    u16 adc_humid)
 411 {
 412         struct bme680_calib *calib = &data->bme680;
 413         s32 var1, var2, var3, var4, var5, var6, temp_scaled, calc_hum;
 414
 415         temp_scaled = (data->t_fine * 5 + 128) >> 8;
 416         var1 = (adc_humid - ((s32) ((s32) calib->par_h1 * 16))) -
 417                 (((temp_scaled * (s32) calib->par_h3) / 100) >> 1);
 418         var2 = ((s32) calib->par_h2 *
 419                 (((temp_scaled * calib->par_h4) / 100) +
 420                  (((temp_scaled * ((temp_scaled * calib->par_h5) / 100))
 421                    >> 6) / 100) + (1 << 14))) >> 10;
 422         var3 = var1 * var2;
 423         var4 = calib->par_h6 << 7;
 424         var4 = (var4 + ((temp_scaled * calib->par_h7) / 100)) >> 4;
 425         var5 = ((var3 >> 14) * (var3 >> 14)) >> 10;
 426         var6 = (var4 * var5) >> 1;
 427         calc_hum = (((var3 + var6) >> 10) * 1000) >> 12;
 428
 429         if (calc_hum > 100000) /* Cap at 100%rH */
 430                 calc_hum = 100000;
 431         else if (calc_hum < 0)
 432                 calc_hum = 0;
 433
 434         return calc_hum;
 435 }
 436
 437 /*
 438  * Taken from Bosch BME680 API:
 439  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L973
 440  *
 441  * Returns gas measurement in Ohm. Output value of "82986" represent 82986 ohms.
 442  */
 443 static u32 bme680_compensate_gas(struct bme680_data *data, u16 gas_res_adc,
 444                                  u8 gas_range)
 445 {
 446         struct bme680_calib *calib = &data->bme680;
 447         s64 var1;
 448         u64 var2;
 449         s64 var3;
 450         u32 calc_gas_res;
 451
 452         /* Look up table for the possible gas range values */
 453         const u32 lookupTable[16] = {2147483647u, 2147483647u,
 454                                 2147483647u, 2147483647u, 2147483647u,
 455                                 2126008810u, 2147483647u, 2130303777u,
 456                                 2147483647u, 2147483647u, 2143188679u,
 457                                 2136746228u, 2147483647u, 2126008810u,
 458                                 2147483647u, 2147483647u};
 459
 460         var1 = ((1340 + (5 * (s64) calib->range_sw_err)) *
 461                         ((s64) lookupTable[gas_range])) >> 16;
 462         var2 = ((gas_res_adc << 15) - 16777216) + var1;
 463         var3 = ((125000 << (15 - gas_range)) * var1) >> 9;
 464         var3 += (var2 >> 1);
 465         calc_gas_res = div64_s64(var3, (s64) var2);
 466
 467         return calc_gas_res;
 468 }
 469
 470 /*
 471  * Taken from Bosch BME680 API:
 472  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1002
 473  */
 474 static u8 bme680_calc_heater_res(struct bme680_data *data, u16 temp)
 475 {
 476         struct bme680_calib *calib = &data->bme680;
 477         s32 var1, var2, var3, var4, var5, heatr_res_x100;
 478         u8 heatr_res;
 479
 480         if (temp > 400) /* Cap temperature */
 481                 temp = 400;
 482
 483         var1 = (((s32) BME680_AMB_TEMP * calib->par_gh3) / 1000) * 256;
 484         var2 = (calib->par_gh1 + 784) * (((((calib->par_gh2 + 154009) *
 485                                                 temp * 5) / 100)
 486                                                 + 3276800) / 10);
 487         var3 = var1 + (var2 / 2);
 488         var4 = (var3 / (calib->res_heat_range + 4));
 489         var5 = 131 * calib->res_heat_val + 65536;
 490         heatr_res_x100 = ((var4 / var5) - 250) * 34;
 491         heatr_res = (heatr_res_x100 + 50) / 100;
 492
 493         return heatr_res;
 494 }
 495
 496 /*
 497  * Taken from Bosch BME680 API:
 498  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1188
 499  */
 500 static u8 bme680_calc_heater_dur(u16 dur)
 501 {
 502         u8 durval, factor = 0;
 503
 504         if (dur >= 0xfc0) {
 505                 durval = 0xff; /* Max duration */
 506         } else {
 507                 while (dur > 0x3F) {
 508                         dur = dur / 4;
 509                         factor += 1;
 510                 }
 511                 durval = dur + (factor * 64);
 512         }
 513
 514         return durval;
 515 }
 516
 517 static int bme680_set_mode(struct bme680_data *data, bool mode)
 518 {
 519         struct device *dev = regmap_get_device(data->regmap);
 520         int ret;
 521
 522         if (mode) {
 523                 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
 524                                         BME680_MODE_MASK, BME680_MODE_FORCED);
 525                 if (ret < 0)
 526                         dev_err(dev, "failed to set forced mode\n");
 527
 528         } else {
 529                 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
 530                                         BME680_MODE_MASK, BME680_MODE_SLEEP);
 531                 if (ret < 0)
 532                         dev_err(dev, "failed to set sleep mode\n");
 533
 534         }
 535
 536         return ret;
 537 }
 538
 539 static int bme680_chip_config(struct bme680_data *data)
 540 {
 541         struct device *dev = regmap_get_device(data->regmap);
 542         int ret;
 543         u8 osrs = FIELD_PREP(BME680_OSRS_HUMIDITY_MASK,
 544                              data->oversampling_humid + 1);
 545         /*
 546          * Highly recommended to set oversampling of humidity before
 547          * temperature/pressure oversampling.
 548          */
 549         ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_HUMIDITY,
 550                                  BME680_OSRS_HUMIDITY_MASK, osrs);
 551         if (ret < 0) {
 552                 dev_err(dev, "failed to write ctrl_hum register\n");
 553                 return ret;
 554         }
 555
 556         /* IIR filter settings */
 557         ret = regmap_update_bits(data->regmap, BME680_REG_CONFIG,
 558                                  BME680_FILTER_MASK,
 559                                  BME680_FILTER_COEFF_VAL);
 560         if (ret < 0) {
 561                 dev_err(dev, "failed to write config register\n");
 562                 return ret;
 563         }
 564
 565         osrs = FIELD_PREP(BME680_OSRS_TEMP_MASK, data->oversampling_temp + 1) |
 566                FIELD_PREP(BME680_OSRS_PRESS_MASK, data->oversampling_press + 1);
 567
 568         ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
 569                                 BME680_OSRS_TEMP_MASK |
 570                                 BME680_OSRS_PRESS_MASK,
 571                                 osrs);
 572         if (ret < 0)
 573                 dev_err(dev, "failed to write ctrl_meas register\n");
 574
 575         return ret;
 576 }
 577
 578 static int bme680_gas_config(struct bme680_data *data)
 579 {
 580         struct device *dev = regmap_get_device(data->regmap);
 581         int ret;
 582         u8 heatr_res, heatr_dur;
 583
 584         heatr_res = bme680_calc_heater_res(data, data->heater_temp);
 585
 586         /* set target heater temperature */
 587         ret = regmap_write(data->regmap, BME680_REG_RES_HEAT_0, heatr_res);
 588         if (ret < 0) {
 589                 dev_err(dev, "failed to write res_heat_0 register\n");
 590                 return ret;
 591         }
 592
 593         heatr_dur = bme680_calc_heater_dur(data->heater_dur);
 594
 595         /* set target heating duration */
 596         ret = regmap_write(data->regmap, BME680_REG_GAS_WAIT_0, heatr_dur);
 597         if (ret < 0) {
 598                 dev_err(dev, "failted to write gas_wait_0 register\n");
 599                 return ret;
 600         }
 601
 602         /* Selecting the runGas and NB conversion settings for the sensor */
 603         ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_GAS_1,
 604                                  BME680_RUN_GAS_MASK | BME680_NB_CONV_MASK,
 605                                  BME680_RUN_GAS_EN_BIT | BME680_NB_CONV_0_VAL);
 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                                (u8 *) &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                                (u8 *) &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                                (u8 *) &tmp, 2);
 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                                (u8 *) &tmp, 2);
 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 = 1 << data->oversampling_temp;
 802                         return IIO_VAL_INT;
 803                 case IIO_PRESSURE:
 804                         *val = 1 << data->oversampling_press;
 805                         return IIO_VAL_INT;
 806                 case IIO_HUMIDITYRELATIVE:
 807                         *val = 1 << data->oversampling_humid;
 808                         return IIO_VAL_INT;
 809                 default:
 810                         return -EINVAL;
 811                 }
 812         default:
 813                 return -EINVAL;
 814         }
 815 }
 816
 817 static int bme680_write_oversampling_ratio_temp(struct bme680_data *data,
 818                                                 int val)
 819 {
 820         int i;
 821
 822         for (i = 0; i < ARRAY_SIZE(bme680_oversampling_avail); i++) {
 823                 if (bme680_oversampling_avail[i] == val) {
 824                         data->oversampling_temp = ilog2(val);
 825
 826                         return bme680_chip_config(data);
 827                 }
 828         }
 829
 830         return -EINVAL;
 831 }
 832
 833 static int bme680_write_oversampling_ratio_press(struct bme680_data *data,
 834                                                  int val)
 835 {
 836         int i;
 837
 838         for (i = 0; i < ARRAY_SIZE(bme680_oversampling_avail); i++) {
 839                 if (bme680_oversampling_avail[i] == val) {
 840                         data->oversampling_press = ilog2(val);
 841
 842                         return bme680_chip_config(data);
 843                 }
 844         }
 845
 846         return -EINVAL;
 847 }
 848
 849 static int bme680_write_oversampling_ratio_humid(struct bme680_data *data,
 850                                                  int val)
 851 {
 852         int i;
 853
 854         for (i = 0; i < ARRAY_SIZE(bme680_oversampling_avail); i++) {
 855                 if (bme680_oversampling_avail[i] == val) {
 856                         data->oversampling_humid = ilog2(val);
 857
 858                         return bme680_chip_config(data);
 859                 }
 860         }
 861
 862         return -EINVAL;
 863 }
 864
 865 static int bme680_write_raw(struct iio_dev *indio_dev,
 866                             struct iio_chan_spec const *chan,
 867                             int val, int val2, long mask)
 868 {
 869         struct bme680_data *data = iio_priv(indio_dev);
 870
 871         switch (mask) {
 872         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
 873                 switch (chan->type) {
 874                 case IIO_TEMP:
 875                         return bme680_write_oversampling_ratio_temp(data, val);
 876                 case IIO_PRESSURE:
 877                         return bme680_write_oversampling_ratio_press(data, val);
 878                 case IIO_HUMIDITYRELATIVE:
 879                         return bme680_write_oversampling_ratio_humid(data, val);
 880                 default:
 881                         return -EINVAL;
 882                 }
 883         default:
 884                 return -EINVAL;
 885         }
 886 }
 887
 888 static const char bme680_oversampling_ratio_show[] = "1 2 4 8 16";
 889
 890 static IIO_CONST_ATTR(oversampling_ratio_available,
 891                       bme680_oversampling_ratio_show);
 892
 893 static struct attribute *bme680_attributes[] = {
 894         &iio_const_attr_oversampling_ratio_available.dev_attr.attr,
 895         NULL,
 896 };
 897
 898 static const struct attribute_group bme680_attribute_group = {
 899         .attrs = bme680_attributes,
 900 };
 901
 902 static const struct iio_info bme680_info = {
 903         .read_raw = &bme680_read_raw,
 904         .write_raw = &bme680_write_raw,
 905         .attrs = &bme680_attribute_group,
 906 };
 907
 908 static const char *bme680_match_acpi_device(struct device *dev)
 909 {
 910         const struct acpi_device_id *id;
 911
 912         id = acpi_match_device(dev->driver->acpi_match_table, dev);
 913         if (!id)
 914                 return NULL;
 915
 916         return dev_name(dev);
 917 }
 918
 919 int bme680_core_probe(struct device *dev, struct regmap *regmap,
 920                       const char *name)
 921 {
 922         struct iio_dev *indio_dev;
 923         struct bme680_data *data;
 924         unsigned int val;
 925         int ret;
 926
 927         ret = regmap_write(regmap, BME680_REG_SOFT_RESET,
 928                            BME680_CMD_SOFTRESET);
 929         if (ret < 0) {
 930                 dev_err(dev, "Failed to reset chip\n");
 931                 return ret;
 932         }
 933
 934         ret = regmap_read(regmap, BME680_REG_CHIP_ID, &val);
 935         if (ret < 0) {
 936                 dev_err(dev, "Error reading chip ID\n");
 937                 return ret;
 938         }
 939
 940         if (val != BME680_CHIP_ID_VAL) {
 941                 dev_err(dev, "Wrong chip ID, got %x expected %x\n",
 942                                 val, BME680_CHIP_ID_VAL);
 943                 return -ENODEV;
 944         }
 945
 946         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
 947         if (!indio_dev)
 948                 return -ENOMEM;
 949
 950         if (!name && ACPI_HANDLE(dev))
 951                 name = bme680_match_acpi_device(dev);
 952
 953         data = iio_priv(indio_dev);
 954         dev_set_drvdata(dev, indio_dev);
 955         data->regmap = regmap;
 956         indio_dev->dev.parent = dev;
 957         indio_dev->name = name;
 958         indio_dev->channels = bme680_channels;
 959         indio_dev->num_channels = ARRAY_SIZE(bme680_channels);
 960         indio_dev->info = &bme680_info;
 961         indio_dev->modes = INDIO_DIRECT_MODE;
 962
 963         /* default values for the sensor */
 964         data->oversampling_humid = ilog2(2); /* 2X oversampling rate */
 965         data->oversampling_press = ilog2(4); /* 4X oversampling rate */
 966         data->oversampling_temp = ilog2(8);  /* 8X oversampling rate */
 967         data->heater_temp = 320; /* degree Celsius */
 968         data->heater_dur = 150;  /* milliseconds */
 969
 970         ret = bme680_chip_config(data);
 971         if (ret < 0) {
 972                 dev_err(dev, "failed to set chip_config data\n");
 973                 return ret;
 974         }
 975
 976         ret = bme680_gas_config(data);
 977         if (ret < 0) {
 978                 dev_err(dev, "failed to set gas config data\n");
 979                 return ret;
 980         }
 981
 982         ret = bme680_read_calib(data, &data->bme680);
 983         if (ret < 0) {
 984                 dev_err(dev,
 985                         "failed to read calibration coefficients at probe\n");
 986                 return ret;
 987         }
 988
 989         return devm_iio_device_register(dev, indio_dev);
 990 }
 991 EXPORT_SYMBOL_GPL(bme680_core_probe);
 992
 993 MODULE_AUTHOR("Himanshu Jha <himanshujha199640@gmail.com>");
 994 MODULE_DESCRIPTION("Bosch BME680 Driver");
 995 MODULE_LICENSE("GPL v2");