Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Bosch BME680 - Temperature, Pressure, Humidity & Gas Sensor
0004  *
0005  * Copyright (C) 2017 - 2018 Bosch Sensortec GmbH
0006  * Copyright (C) 2018 Himanshu Jha <himanshujha199640@gmail.com>
0007  *
0008  * Datasheet:
0009  * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BME680-DS001-00.pdf
0010  */
0011 #include <linux/acpi.h>
0012 #include <linux/bitfield.h>
0013 #include <linux/device.h>
0014 #include <linux/module.h>
0015 #include <linux/log2.h>
0016 #include <linux/regmap.h>
0017 #include <linux/iio/iio.h>
0018 #include <linux/iio/sysfs.h>
0019 
0020 #include "bme680.h"
0021 
0022 struct bme680_calib {
0023     u16 par_t1;
0024     s16 par_t2;
0025     s8  par_t3;
0026     u16 par_p1;
0027     s16 par_p2;
0028     s8  par_p3;
0029     s16 par_p4;
0030     s16 par_p5;
0031     s8  par_p6;
0032     s8  par_p7;
0033     s16 par_p8;
0034     s16 par_p9;
0035     u8  par_p10;
0036     u16 par_h1;
0037     u16 par_h2;
0038     s8  par_h3;
0039     s8  par_h4;
0040     s8  par_h5;
0041     s8  par_h6;
0042     s8  par_h7;
0043     s8  par_gh1;
0044     s16 par_gh2;
0045     s8  par_gh3;
0046     u8  res_heat_range;
0047     s8  res_heat_val;
0048     s8  range_sw_err;
0049 };
0050 
0051 struct bme680_data {
0052     struct regmap *regmap;
0053     struct bme680_calib bme680;
0054     u8 oversampling_temp;
0055     u8 oversampling_press;
0056     u8 oversampling_humid;
0057     u16 heater_dur;
0058     u16 heater_temp;
0059     /*
0060      * Carryover value from temperature conversion, used in pressure
0061      * and humidity compensation calculations.
0062      */
0063     s32 t_fine;
0064 };
0065 
0066 static const struct regmap_range bme680_volatile_ranges[] = {
0067     regmap_reg_range(BME680_REG_MEAS_STAT_0, BME680_REG_GAS_R_LSB),
0068     regmap_reg_range(BME680_REG_STATUS, BME680_REG_STATUS),
0069     regmap_reg_range(BME680_T2_LSB_REG, BME680_GH3_REG),
0070 };
0071 
0072 static const struct regmap_access_table bme680_volatile_table = {
0073     .yes_ranges = bme680_volatile_ranges,
0074     .n_yes_ranges   = ARRAY_SIZE(bme680_volatile_ranges),
0075 };
0076 
0077 const struct regmap_config bme680_regmap_config = {
0078     .reg_bits = 8,
0079     .val_bits = 8,
0080     .max_register = 0xef,
0081     .volatile_table = &bme680_volatile_table,
0082     .cache_type = REGCACHE_RBTREE,
0083 };
0084 EXPORT_SYMBOL_NS(bme680_regmap_config, IIO_BME680);
0085 
0086 static const struct iio_chan_spec bme680_channels[] = {
0087     {
0088         .type = IIO_TEMP,
0089         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
0090                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
0091     },
0092     {
0093         .type = IIO_PRESSURE,
0094         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
0095                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
0096     },
0097     {
0098         .type = IIO_HUMIDITYRELATIVE,
0099         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
0100                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
0101     },
0102     {
0103         .type = IIO_RESISTANCE,
0104         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
0105     },
0106 };
0107 
0108 static int bme680_read_calib(struct bme680_data *data,
0109                  struct bme680_calib *calib)
0110 {
0111     struct device *dev = regmap_get_device(data->regmap);
0112     unsigned int tmp, tmp_msb, tmp_lsb;
0113     int ret;
0114     __le16 buf;
0115 
0116     /* Temperature related coefficients */
0117     ret = regmap_bulk_read(data->regmap, BME680_T1_LSB_REG,
0118                    &buf, sizeof(buf));
0119     if (ret < 0) {
0120         dev_err(dev, "failed to read BME680_T1_LSB_REG\n");
0121         return ret;
0122     }
0123     calib->par_t1 = le16_to_cpu(buf);
0124 
0125     ret = regmap_bulk_read(data->regmap, BME680_T2_LSB_REG,
0126                    &buf, sizeof(buf));
0127     if (ret < 0) {
0128         dev_err(dev, "failed to read BME680_T2_LSB_REG\n");
0129         return ret;
0130     }
0131     calib->par_t2 = le16_to_cpu(buf);
0132 
0133     ret = regmap_read(data->regmap, BME680_T3_REG, &tmp);
0134     if (ret < 0) {
0135         dev_err(dev, "failed to read BME680_T3_REG\n");
0136         return ret;
0137     }
0138     calib->par_t3 = tmp;
0139 
0140     /* Pressure related coefficients */
0141     ret = regmap_bulk_read(data->regmap, BME680_P1_LSB_REG,
0142                    &buf, sizeof(buf));
0143     if (ret < 0) {
0144         dev_err(dev, "failed to read BME680_P1_LSB_REG\n");
0145         return ret;
0146     }
0147     calib->par_p1 = le16_to_cpu(buf);
0148 
0149     ret = regmap_bulk_read(data->regmap, BME680_P2_LSB_REG,
0150                    &buf, sizeof(buf));
0151     if (ret < 0) {
0152         dev_err(dev, "failed to read BME680_P2_LSB_REG\n");
0153         return ret;
0154     }
0155     calib->par_p2 = le16_to_cpu(buf);
0156 
0157     ret = regmap_read(data->regmap, BME680_P3_REG, &tmp);
0158     if (ret < 0) {
0159         dev_err(dev, "failed to read BME680_P3_REG\n");
0160         return ret;
0161     }
0162     calib->par_p3 = tmp;
0163 
0164     ret = regmap_bulk_read(data->regmap, BME680_P4_LSB_REG,
0165                    &buf, sizeof(buf));
0166     if (ret < 0) {
0167         dev_err(dev, "failed to read BME680_P4_LSB_REG\n");
0168         return ret;
0169     }
0170     calib->par_p4 = le16_to_cpu(buf);
0171 
0172     ret = regmap_bulk_read(data->regmap, BME680_P5_LSB_REG,
0173                    &buf, sizeof(buf));
0174     if (ret < 0) {
0175         dev_err(dev, "failed to read BME680_P5_LSB_REG\n");
0176         return ret;
0177     }
0178     calib->par_p5 = le16_to_cpu(buf);
0179 
0180     ret = regmap_read(data->regmap, BME680_P6_REG, &tmp);
0181     if (ret < 0) {
0182         dev_err(dev, "failed to read BME680_P6_REG\n");
0183         return ret;
0184     }
0185     calib->par_p6 = tmp;
0186 
0187     ret = regmap_read(data->regmap, BME680_P7_REG, &tmp);
0188     if (ret < 0) {
0189         dev_err(dev, "failed to read BME680_P7_REG\n");
0190         return ret;
0191     }
0192     calib->par_p7 = tmp;
0193 
0194     ret = regmap_bulk_read(data->regmap, BME680_P8_LSB_REG,
0195                    &buf, sizeof(buf));
0196     if (ret < 0) {
0197         dev_err(dev, "failed to read BME680_P8_LSB_REG\n");
0198         return ret;
0199     }
0200     calib->par_p8 = le16_to_cpu(buf);
0201 
0202     ret = regmap_bulk_read(data->regmap, BME680_P9_LSB_REG,
0203                    &buf, sizeof(buf));
0204     if (ret < 0) {
0205         dev_err(dev, "failed to read BME680_P9_LSB_REG\n");
0206         return ret;
0207     }
0208     calib->par_p9 = le16_to_cpu(buf);
0209 
0210     ret = regmap_read(data->regmap, BME680_P10_REG, &tmp);
0211     if (ret < 0) {
0212         dev_err(dev, "failed to read BME680_P10_REG\n");
0213         return ret;
0214     }
0215     calib->par_p10 = tmp;
0216 
0217     /* Humidity related coefficients */
0218     ret = regmap_read(data->regmap, BME680_H1_MSB_REG, &tmp_msb);
0219     if (ret < 0) {
0220         dev_err(dev, "failed to read BME680_H1_MSB_REG\n");
0221         return ret;
0222     }
0223     ret = regmap_read(data->regmap, BME680_H1_LSB_REG, &tmp_lsb);
0224     if (ret < 0) {
0225         dev_err(dev, "failed to read BME680_H1_LSB_REG\n");
0226         return ret;
0227     }
0228     calib->par_h1 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) |
0229             (tmp_lsb & BME680_BIT_H1_DATA_MASK);
0230 
0231     ret = regmap_read(data->regmap, BME680_H2_MSB_REG, &tmp_msb);
0232     if (ret < 0) {
0233         dev_err(dev, "failed to read BME680_H2_MSB_REG\n");
0234         return ret;
0235     }
0236     ret = regmap_read(data->regmap, BME680_H2_LSB_REG, &tmp_lsb);
0237     if (ret < 0) {
0238         dev_err(dev, "failed to read BME680_H2_LSB_REG\n");
0239         return ret;
0240     }
0241     calib->par_h2 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) |
0242             (tmp_lsb >> BME680_HUM_REG_SHIFT_VAL);
0243 
0244     ret = regmap_read(data->regmap, BME680_H3_REG, &tmp);
0245     if (ret < 0) {
0246         dev_err(dev, "failed to read BME680_H3_REG\n");
0247         return ret;
0248     }
0249     calib->par_h3 = tmp;
0250 
0251     ret = regmap_read(data->regmap, BME680_H4_REG, &tmp);
0252     if (ret < 0) {
0253         dev_err(dev, "failed to read BME680_H4_REG\n");
0254         return ret;
0255     }
0256     calib->par_h4 = tmp;
0257 
0258     ret = regmap_read(data->regmap, BME680_H5_REG, &tmp);
0259     if (ret < 0) {
0260         dev_err(dev, "failed to read BME680_H5_REG\n");
0261         return ret;
0262     }
0263     calib->par_h5 = tmp;
0264 
0265     ret = regmap_read(data->regmap, BME680_H6_REG, &tmp);
0266     if (ret < 0) {
0267         dev_err(dev, "failed to read BME680_H6_REG\n");
0268         return ret;
0269     }
0270     calib->par_h6 = tmp;
0271 
0272     ret = regmap_read(data->regmap, BME680_H7_REG, &tmp);
0273     if (ret < 0) {
0274         dev_err(dev, "failed to read BME680_H7_REG\n");
0275         return ret;
0276     }
0277     calib->par_h7 = tmp;
0278 
0279     /* Gas heater related coefficients */
0280     ret = regmap_read(data->regmap, BME680_GH1_REG, &tmp);
0281     if (ret < 0) {
0282         dev_err(dev, "failed to read BME680_GH1_REG\n");
0283         return ret;
0284     }
0285     calib->par_gh1 = tmp;
0286 
0287     ret = regmap_bulk_read(data->regmap, BME680_GH2_LSB_REG,
0288                    &buf, sizeof(buf));
0289     if (ret < 0) {
0290         dev_err(dev, "failed to read BME680_GH2_LSB_REG\n");
0291         return ret;
0292     }
0293     calib->par_gh2 = le16_to_cpu(buf);
0294 
0295     ret = regmap_read(data->regmap, BME680_GH3_REG, &tmp);
0296     if (ret < 0) {
0297         dev_err(dev, "failed to read BME680_GH3_REG\n");
0298         return ret;
0299     }
0300     calib->par_gh3 = tmp;
0301 
0302     /* Other coefficients */
0303     ret = regmap_read(data->regmap, BME680_REG_RES_HEAT_RANGE, &tmp);
0304     if (ret < 0) {
0305         dev_err(dev, "failed to read resistance heat range\n");
0306         return ret;
0307     }
0308     calib->res_heat_range = FIELD_GET(BME680_RHRANGE_MASK, tmp);
0309 
0310     ret = regmap_read(data->regmap, BME680_REG_RES_HEAT_VAL, &tmp);
0311     if (ret < 0) {
0312         dev_err(dev, "failed to read resistance heat value\n");
0313         return ret;
0314     }
0315     calib->res_heat_val = tmp;
0316 
0317     ret = regmap_read(data->regmap, BME680_REG_RANGE_SW_ERR, &tmp);
0318     if (ret < 0) {
0319         dev_err(dev, "failed to read range software error\n");
0320         return ret;
0321     }
0322     calib->range_sw_err = FIELD_GET(BME680_RSERROR_MASK, tmp);
0323 
0324     return 0;
0325 }
0326 
0327 /*
0328  * Taken from Bosch BME680 API:
0329  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L876
0330  *
0331  * Returns temperature measurement in DegC, resolutions is 0.01 DegC. Therefore,
0332  * output value of "3233" represents 32.33 DegC.
0333  */
0334 static s16 bme680_compensate_temp(struct bme680_data *data,
0335                   s32 adc_temp)
0336 {
0337     struct bme680_calib *calib = &data->bme680;
0338     s64 var1, var2, var3;
0339     s16 calc_temp;
0340 
0341     /* If the calibration is invalid, attempt to reload it */
0342     if (!calib->par_t2)
0343         bme680_read_calib(data, calib);
0344 
0345     var1 = (adc_temp >> 3) - (calib->par_t1 << 1);
0346     var2 = (var1 * calib->par_t2) >> 11;
0347     var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
0348     var3 = (var3 * (calib->par_t3 << 4)) >> 14;
0349     data->t_fine = var2 + var3;
0350     calc_temp = (data->t_fine * 5 + 128) >> 8;
0351 
0352     return calc_temp;
0353 }
0354 
0355 /*
0356  * Taken from Bosch BME680 API:
0357  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L896
0358  *
0359  * Returns pressure measurement in Pa. Output value of "97356" represents
0360  * 97356 Pa = 973.56 hPa.
0361  */
0362 static u32 bme680_compensate_press(struct bme680_data *data,
0363                    u32 adc_press)
0364 {
0365     struct bme680_calib *calib = &data->bme680;
0366     s32 var1, var2, var3, press_comp;
0367 
0368     var1 = (data->t_fine >> 1) - 64000;
0369     var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) * calib->par_p6) >> 2;
0370     var2 = var2 + (var1 * calib->par_p5 << 1);
0371     var2 = (var2 >> 2) + (calib->par_p4 << 16);
0372     var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
0373             (calib->par_p3 << 5)) >> 3) +
0374             ((calib->par_p2 * var1) >> 1);
0375     var1 = var1 >> 18;
0376     var1 = ((32768 + var1) * calib->par_p1) >> 15;
0377     press_comp = 1048576 - adc_press;
0378     press_comp = ((press_comp - (var2 >> 12)) * 3125);
0379 
0380     if (press_comp >= BME680_MAX_OVERFLOW_VAL)
0381         press_comp = ((press_comp / (u32)var1) << 1);
0382     else
0383         press_comp = ((press_comp << 1) / (u32)var1);
0384 
0385     var1 = (calib->par_p9 * (((press_comp >> 3) *
0386             (press_comp >> 3)) >> 13)) >> 12;
0387     var2 = ((press_comp >> 2) * calib->par_p8) >> 13;
0388     var3 = ((press_comp >> 8) * (press_comp >> 8) *
0389             (press_comp >> 8) * calib->par_p10) >> 17;
0390 
0391     press_comp += (var1 + var2 + var3 + (calib->par_p7 << 7)) >> 4;
0392 
0393     return press_comp;
0394 }
0395 
0396 /*
0397  * Taken from Bosch BME680 API:
0398  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L937
0399  *
0400  * Returns humidity measurement in percent, resolution is 0.001 percent. Output
0401  * value of "43215" represents 43.215 %rH.
0402  */
0403 static u32 bme680_compensate_humid(struct bme680_data *data,
0404                    u16 adc_humid)
0405 {
0406     struct bme680_calib *calib = &data->bme680;
0407     s32 var1, var2, var3, var4, var5, var6, temp_scaled, calc_hum;
0408 
0409     temp_scaled = (data->t_fine * 5 + 128) >> 8;
0410     var1 = (adc_humid - ((s32) ((s32) calib->par_h1 * 16))) -
0411         (((temp_scaled * (s32) calib->par_h3) / 100) >> 1);
0412     var2 = ((s32) calib->par_h2 *
0413         (((temp_scaled * calib->par_h4) / 100) +
0414          (((temp_scaled * ((temp_scaled * calib->par_h5) / 100))
0415            >> 6) / 100) + (1 << 14))) >> 10;
0416     var3 = var1 * var2;
0417     var4 = calib->par_h6 << 7;
0418     var4 = (var4 + ((temp_scaled * calib->par_h7) / 100)) >> 4;
0419     var5 = ((var3 >> 14) * (var3 >> 14)) >> 10;
0420     var6 = (var4 * var5) >> 1;
0421     calc_hum = (((var3 + var6) >> 10) * 1000) >> 12;
0422 
0423     calc_hum = clamp(calc_hum, 0, 100000); /* clamp between 0-100 %rH */
0424 
0425     return calc_hum;
0426 }
0427 
0428 /*
0429  * Taken from Bosch BME680 API:
0430  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L973
0431  *
0432  * Returns gas measurement in Ohm. Output value of "82986" represent 82986 ohms.
0433  */
0434 static u32 bme680_compensate_gas(struct bme680_data *data, u16 gas_res_adc,
0435                  u8 gas_range)
0436 {
0437     struct bme680_calib *calib = &data->bme680;
0438     s64 var1;
0439     u64 var2;
0440     s64 var3;
0441     u32 calc_gas_res;
0442 
0443     /* Look up table for the possible gas range values */
0444     const u32 lookupTable[16] = {2147483647u, 2147483647u,
0445                 2147483647u, 2147483647u, 2147483647u,
0446                 2126008810u, 2147483647u, 2130303777u,
0447                 2147483647u, 2147483647u, 2143188679u,
0448                 2136746228u, 2147483647u, 2126008810u,
0449                 2147483647u, 2147483647u};
0450 
0451     var1 = ((1340 + (5 * (s64) calib->range_sw_err)) *
0452             ((s64) lookupTable[gas_range])) >> 16;
0453     var2 = ((gas_res_adc << 15) - 16777216) + var1;
0454     var3 = ((125000 << (15 - gas_range)) * var1) >> 9;
0455     var3 += (var2 >> 1);
0456     calc_gas_res = div64_s64(var3, (s64) var2);
0457 
0458     return calc_gas_res;
0459 }
0460 
0461 /*
0462  * Taken from Bosch BME680 API:
0463  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1002
0464  */
0465 static u8 bme680_calc_heater_res(struct bme680_data *data, u16 temp)
0466 {
0467     struct bme680_calib *calib = &data->bme680;
0468     s32 var1, var2, var3, var4, var5, heatr_res_x100;
0469     u8 heatr_res;
0470 
0471     if (temp > 400) /* Cap temperature */
0472         temp = 400;
0473 
0474     var1 = (((s32) BME680_AMB_TEMP * calib->par_gh3) / 1000) * 256;
0475     var2 = (calib->par_gh1 + 784) * (((((calib->par_gh2 + 154009) *
0476                         temp * 5) / 100)
0477                         + 3276800) / 10);
0478     var3 = var1 + (var2 / 2);
0479     var4 = (var3 / (calib->res_heat_range + 4));
0480     var5 = 131 * calib->res_heat_val + 65536;
0481     heatr_res_x100 = ((var4 / var5) - 250) * 34;
0482     heatr_res = DIV_ROUND_CLOSEST(heatr_res_x100, 100);
0483 
0484     return heatr_res;
0485 }
0486 
0487 /*
0488  * Taken from Bosch BME680 API:
0489  * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1188
0490  */
0491 static u8 bme680_calc_heater_dur(u16 dur)
0492 {
0493     u8 durval, factor = 0;
0494 
0495     if (dur >= 0xfc0) {
0496         durval = 0xff; /* Max duration */
0497     } else {
0498         while (dur > 0x3F) {
0499             dur = dur / 4;
0500             factor += 1;
0501         }
0502         durval = dur + (factor * 64);
0503     }
0504 
0505     return durval;
0506 }
0507 
0508 static int bme680_set_mode(struct bme680_data *data, bool mode)
0509 {
0510     struct device *dev = regmap_get_device(data->regmap);
0511     int ret;
0512 
0513     if (mode) {
0514         ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
0515                     BME680_MODE_MASK, BME680_MODE_FORCED);
0516         if (ret < 0)
0517             dev_err(dev, "failed to set forced mode\n");
0518 
0519     } else {
0520         ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
0521                     BME680_MODE_MASK, BME680_MODE_SLEEP);
0522         if (ret < 0)
0523             dev_err(dev, "failed to set sleep mode\n");
0524 
0525     }
0526 
0527     return ret;
0528 }
0529 
0530 static u8 bme680_oversampling_to_reg(u8 val)
0531 {
0532     return ilog2(val) + 1;
0533 }
0534 
0535 static int bme680_chip_config(struct bme680_data *data)
0536 {
0537     struct device *dev = regmap_get_device(data->regmap);
0538     int ret;
0539     u8 osrs;
0540 
0541     osrs = FIELD_PREP(
0542         BME680_OSRS_HUMIDITY_MASK,
0543         bme680_oversampling_to_reg(data->oversampling_humid));
0544     /*
0545      * Highly recommended to set oversampling of humidity before
0546      * temperature/pressure oversampling.
0547      */
0548     ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_HUMIDITY,
0549                  BME680_OSRS_HUMIDITY_MASK, osrs);
0550     if (ret < 0) {
0551         dev_err(dev, "failed to write ctrl_hum register\n");
0552         return ret;
0553     }
0554 
0555     /* IIR filter settings */
0556     ret = regmap_update_bits(data->regmap, BME680_REG_CONFIG,
0557                  BME680_FILTER_MASK,
0558                  BME680_FILTER_COEFF_VAL);
0559     if (ret < 0) {
0560         dev_err(dev, "failed to write config register\n");
0561         return ret;
0562     }
0563 
0564     osrs = FIELD_PREP(BME680_OSRS_TEMP_MASK,
0565               bme680_oversampling_to_reg(data->oversampling_temp)) |
0566            FIELD_PREP(BME680_OSRS_PRESS_MASK,
0567               bme680_oversampling_to_reg(data->oversampling_press));
0568     ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
0569                 BME680_OSRS_TEMP_MASK | BME680_OSRS_PRESS_MASK,
0570                 osrs);
0571     if (ret < 0)
0572         dev_err(dev, "failed to write ctrl_meas register\n");
0573 
0574     return ret;
0575 }
0576 
0577 static int bme680_gas_config(struct bme680_data *data)
0578 {
0579     struct device *dev = regmap_get_device(data->regmap);
0580     int ret;
0581     u8 heatr_res, heatr_dur;
0582 
0583     heatr_res = bme680_calc_heater_res(data, data->heater_temp);
0584 
0585     /* set target heater temperature */
0586     ret = regmap_write(data->regmap, BME680_REG_RES_HEAT_0, heatr_res);
0587     if (ret < 0) {
0588         dev_err(dev, "failed to write res_heat_0 register\n");
0589         return ret;
0590     }
0591 
0592     heatr_dur = bme680_calc_heater_dur(data->heater_dur);
0593 
0594     /* set target heating duration */
0595     ret = regmap_write(data->regmap, BME680_REG_GAS_WAIT_0, heatr_dur);
0596     if (ret < 0) {
0597         dev_err(dev, "failed to write gas_wait_0 register\n");
0598         return ret;
0599     }
0600 
0601     /* Enable the gas sensor and select heater profile set-point 0 */
0602     ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_GAS_1,
0603                  BME680_RUN_GAS_MASK | BME680_NB_CONV_MASK,
0604                  FIELD_PREP(BME680_RUN_GAS_MASK, 1) |
0605                  FIELD_PREP(BME680_NB_CONV_MASK, 0));
0606     if (ret < 0)
0607         dev_err(dev, "failed to write ctrl_gas_1 register\n");
0608 
0609     return ret;
0610 }
0611 
0612 static int bme680_read_temp(struct bme680_data *data, int *val)
0613 {
0614     struct device *dev = regmap_get_device(data->regmap);
0615     int ret;
0616     __be32 tmp = 0;
0617     s32 adc_temp;
0618     s16 comp_temp;
0619 
0620     /* set forced mode to trigger measurement */
0621     ret = bme680_set_mode(data, true);
0622     if (ret < 0)
0623         return ret;
0624 
0625     ret = regmap_bulk_read(data->regmap, BME680_REG_TEMP_MSB,
0626                    &tmp, 3);
0627     if (ret < 0) {
0628         dev_err(dev, "failed to read temperature\n");
0629         return ret;
0630     }
0631 
0632     adc_temp = be32_to_cpu(tmp) >> 12;
0633     if (adc_temp == BME680_MEAS_SKIPPED) {
0634         /* reading was skipped */
0635         dev_err(dev, "reading temperature skipped\n");
0636         return -EINVAL;
0637     }
0638     comp_temp = bme680_compensate_temp(data, adc_temp);
0639     /*
0640      * val might be NULL if we're called by the read_press/read_humid
0641      * routine which is called to get t_fine value used in
0642      * compensate_press/compensate_humid to get compensated
0643      * pressure/humidity readings.
0644      */
0645     if (val) {
0646         *val = comp_temp * 10; /* Centidegrees to millidegrees */
0647         return IIO_VAL_INT;
0648     }
0649 
0650     return ret;
0651 }
0652 
0653 static int bme680_read_press(struct bme680_data *data,
0654                  int *val, int *val2)
0655 {
0656     struct device *dev = regmap_get_device(data->regmap);
0657     int ret;
0658     __be32 tmp = 0;
0659     s32 adc_press;
0660 
0661     /* Read and compensate temperature to get a reading of t_fine */
0662     ret = bme680_read_temp(data, NULL);
0663     if (ret < 0)
0664         return ret;
0665 
0666     ret = regmap_bulk_read(data->regmap, BME680_REG_PRESS_MSB,
0667                    &tmp, 3);
0668     if (ret < 0) {
0669         dev_err(dev, "failed to read pressure\n");
0670         return ret;
0671     }
0672 
0673     adc_press = be32_to_cpu(tmp) >> 12;
0674     if (adc_press == BME680_MEAS_SKIPPED) {
0675         /* reading was skipped */
0676         dev_err(dev, "reading pressure skipped\n");
0677         return -EINVAL;
0678     }
0679 
0680     *val = bme680_compensate_press(data, adc_press);
0681     *val2 = 100;
0682     return IIO_VAL_FRACTIONAL;
0683 }
0684 
0685 static int bme680_read_humid(struct bme680_data *data,
0686                  int *val, int *val2)
0687 {
0688     struct device *dev = regmap_get_device(data->regmap);
0689     int ret;
0690     __be16 tmp = 0;
0691     s32 adc_humidity;
0692     u32 comp_humidity;
0693 
0694     /* Read and compensate temperature to get a reading of t_fine */
0695     ret = bme680_read_temp(data, NULL);
0696     if (ret < 0)
0697         return ret;
0698 
0699     ret = regmap_bulk_read(data->regmap, BM6880_REG_HUMIDITY_MSB,
0700                    &tmp, sizeof(tmp));
0701     if (ret < 0) {
0702         dev_err(dev, "failed to read humidity\n");
0703         return ret;
0704     }
0705 
0706     adc_humidity = be16_to_cpu(tmp);
0707     if (adc_humidity == BME680_MEAS_SKIPPED) {
0708         /* reading was skipped */
0709         dev_err(dev, "reading humidity skipped\n");
0710         return -EINVAL;
0711     }
0712     comp_humidity = bme680_compensate_humid(data, adc_humidity);
0713 
0714     *val = comp_humidity;
0715     *val2 = 1000;
0716     return IIO_VAL_FRACTIONAL;
0717 }
0718 
0719 static int bme680_read_gas(struct bme680_data *data,
0720                int *val)
0721 {
0722     struct device *dev = regmap_get_device(data->regmap);
0723     int ret;
0724     __be16 tmp = 0;
0725     unsigned int check;
0726     u16 adc_gas_res;
0727     u8 gas_range;
0728 
0729     /* Set heater settings */
0730     ret = bme680_gas_config(data);
0731     if (ret < 0) {
0732         dev_err(dev, "failed to set gas config\n");
0733         return ret;
0734     }
0735 
0736     /* set forced mode to trigger measurement */
0737     ret = bme680_set_mode(data, true);
0738     if (ret < 0)
0739         return ret;
0740 
0741     ret = regmap_read(data->regmap, BME680_REG_MEAS_STAT_0, &check);
0742     if (check & BME680_GAS_MEAS_BIT) {
0743         dev_err(dev, "gas measurement incomplete\n");
0744         return -EBUSY;
0745     }
0746 
0747     ret = regmap_read(data->regmap, BME680_REG_GAS_R_LSB, &check);
0748     if (ret < 0) {
0749         dev_err(dev, "failed to read gas_r_lsb register\n");
0750         return ret;
0751     }
0752 
0753     /*
0754      * occurs if either the gas heating duration was insuffient
0755      * to reach the target heater temperature or the target
0756      * heater temperature was too high for the heater sink to
0757      * reach.
0758      */
0759     if ((check & BME680_GAS_STAB_BIT) == 0) {
0760         dev_err(dev, "heater failed to reach the target temperature\n");
0761         return -EINVAL;
0762     }
0763 
0764     ret = regmap_bulk_read(data->regmap, BME680_REG_GAS_MSB,
0765                    &tmp, sizeof(tmp));
0766     if (ret < 0) {
0767         dev_err(dev, "failed to read gas resistance\n");
0768         return ret;
0769     }
0770 
0771     gas_range = check & BME680_GAS_RANGE_MASK;
0772     adc_gas_res = be16_to_cpu(tmp) >> BME680_ADC_GAS_RES_SHIFT;
0773 
0774     *val = bme680_compensate_gas(data, adc_gas_res, gas_range);
0775     return IIO_VAL_INT;
0776 }
0777 
0778 static int bme680_read_raw(struct iio_dev *indio_dev,
0779                struct iio_chan_spec const *chan,
0780                int *val, int *val2, long mask)
0781 {
0782     struct bme680_data *data = iio_priv(indio_dev);
0783 
0784     switch (mask) {
0785     case IIO_CHAN_INFO_PROCESSED:
0786         switch (chan->type) {
0787         case IIO_TEMP:
0788             return bme680_read_temp(data, val);
0789         case IIO_PRESSURE:
0790             return bme680_read_press(data, val, val2);
0791         case IIO_HUMIDITYRELATIVE:
0792             return bme680_read_humid(data, val, val2);
0793         case IIO_RESISTANCE:
0794             return bme680_read_gas(data, val);
0795         default:
0796             return -EINVAL;
0797         }
0798     case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
0799         switch (chan->type) {
0800         case IIO_TEMP:
0801             *val = data->oversampling_temp;
0802             return IIO_VAL_INT;
0803         case IIO_PRESSURE:
0804             *val = data->oversampling_press;
0805             return IIO_VAL_INT;
0806         case IIO_HUMIDITYRELATIVE:
0807             *val = data->oversampling_humid;
0808             return IIO_VAL_INT;
0809         default:
0810             return -EINVAL;
0811         }
0812     default:
0813         return -EINVAL;
0814     }
0815 }
0816 
0817 static bool bme680_is_valid_oversampling(int rate)
0818 {
0819     return (rate > 0 && rate <= 16 && is_power_of_2(rate));
0820 }
0821 
0822 static int bme680_write_raw(struct iio_dev *indio_dev,
0823                 struct iio_chan_spec const *chan,
0824                 int val, int val2, long mask)
0825 {
0826     struct bme680_data *data = iio_priv(indio_dev);
0827 
0828     if (val2 != 0)
0829         return -EINVAL;
0830 
0831     switch (mask) {
0832     case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
0833     {
0834         if (!bme680_is_valid_oversampling(val))
0835             return -EINVAL;
0836 
0837         switch (chan->type) {
0838         case IIO_TEMP:
0839             data->oversampling_temp = val;
0840             break;
0841         case IIO_PRESSURE:
0842             data->oversampling_press = val;
0843             break;
0844         case IIO_HUMIDITYRELATIVE:
0845             data->oversampling_humid = val;
0846             break;
0847         default:
0848             return -EINVAL;
0849         }
0850 
0851         return bme680_chip_config(data);
0852     }
0853     default:
0854         return -EINVAL;
0855     }
0856 }
0857 
0858 static const char bme680_oversampling_ratio_show[] = "1 2 4 8 16";
0859 
0860 static IIO_CONST_ATTR(oversampling_ratio_available,
0861               bme680_oversampling_ratio_show);
0862 
0863 static struct attribute *bme680_attributes[] = {
0864     &iio_const_attr_oversampling_ratio_available.dev_attr.attr,
0865     NULL,
0866 };
0867 
0868 static const struct attribute_group bme680_attribute_group = {
0869     .attrs = bme680_attributes,
0870 };
0871 
0872 static const struct iio_info bme680_info = {
0873     .read_raw = &bme680_read_raw,
0874     .write_raw = &bme680_write_raw,
0875     .attrs = &bme680_attribute_group,
0876 };
0877 
0878 static const char *bme680_match_acpi_device(struct device *dev)
0879 {
0880     const struct acpi_device_id *id;
0881 
0882     id = acpi_match_device(dev->driver->acpi_match_table, dev);
0883     if (!id)
0884         return NULL;
0885 
0886     return dev_name(dev);
0887 }
0888 
0889 int bme680_core_probe(struct device *dev, struct regmap *regmap,
0890               const char *name)
0891 {
0892     struct iio_dev *indio_dev;
0893     struct bme680_data *data;
0894     unsigned int val;
0895     int ret;
0896 
0897     ret = regmap_write(regmap, BME680_REG_SOFT_RESET,
0898                BME680_CMD_SOFTRESET);
0899     if (ret < 0) {
0900         dev_err(dev, "Failed to reset chip\n");
0901         return ret;
0902     }
0903 
0904     ret = regmap_read(regmap, BME680_REG_CHIP_ID, &val);
0905     if (ret < 0) {
0906         dev_err(dev, "Error reading chip ID\n");
0907         return ret;
0908     }
0909 
0910     if (val != BME680_CHIP_ID_VAL) {
0911         dev_err(dev, "Wrong chip ID, got %x expected %x\n",
0912                 val, BME680_CHIP_ID_VAL);
0913         return -ENODEV;
0914     }
0915 
0916     indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
0917     if (!indio_dev)
0918         return -ENOMEM;
0919 
0920     if (!name && ACPI_HANDLE(dev))
0921         name = bme680_match_acpi_device(dev);
0922 
0923     data = iio_priv(indio_dev);
0924     dev_set_drvdata(dev, indio_dev);
0925     data->regmap = regmap;
0926     indio_dev->name = name;
0927     indio_dev->channels = bme680_channels;
0928     indio_dev->num_channels = ARRAY_SIZE(bme680_channels);
0929     indio_dev->info = &bme680_info;
0930     indio_dev->modes = INDIO_DIRECT_MODE;
0931 
0932     /* default values for the sensor */
0933     data->oversampling_humid = 2; /* 2X oversampling rate */
0934     data->oversampling_press = 4; /* 4X oversampling rate */
0935     data->oversampling_temp = 8;  /* 8X oversampling rate */
0936     data->heater_temp = 320; /* degree Celsius */
0937     data->heater_dur = 150;  /* milliseconds */
0938 
0939     ret = bme680_chip_config(data);
0940     if (ret < 0) {
0941         dev_err(dev, "failed to set chip_config data\n");
0942         return ret;
0943     }
0944 
0945     ret = bme680_gas_config(data);
0946     if (ret < 0) {
0947         dev_err(dev, "failed to set gas config data\n");
0948         return ret;
0949     }
0950 
0951     ret = bme680_read_calib(data, &data->bme680);
0952     if (ret < 0) {
0953         dev_err(dev,
0954             "failed to read calibration coefficients at probe\n");
0955         return ret;
0956     }
0957 
0958     return devm_iio_device_register(dev, indio_dev);
0959 }
0960 EXPORT_SYMBOL_NS_GPL(bme680_core_probe, IIO_BME680);
0961 
0962 MODULE_AUTHOR("Himanshu Jha <himanshujha199640@gmail.com>");
0963 MODULE_DESCRIPTION("Bosch BME680 Driver");
0964 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!