iio: pressure: bmp280: Refactorize reading functions

For BMP18x, BMP28x, BME280, BMP38x the reading of the pressure
value requires an update of the t_fine variable which happens
through reading the temperature value.

So all the bmpxxx_read_press() functions of the above sensors
are internally calling the equivalent bmpxxx_read_temp() function
in order to update the t_fine value. By just looking at the code
this functionality is a bit hidden and is not easy to understand
why those channels are not independent.

This commit tries to clear these things a bit by splitting the
bmpxxx_{read/compensate}_{temp/press/humid}() to the following:

i. bmpxxx_read_{temp/press/humid}_adc(): read the raw value from
the sensor.

ii. bmpxx_calc_t_fine(): calculate the t_fine variable.

iii. bmpxxx_get_t_fine(): get the t_fine variable.

iv. bmpxxx_compensate_{temp/press/humid}(): compensate the adc
values and return the calculated value.

v. bmpxxx_read_{temp/press/humid}(): combine calls of the
aforementioned functions to return the requested value.

Suggested-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Signed-off-by: Vasileios Amoiridis <vassilisamir@gmail.com>
Link: https://lore.kernel.org/r/20240512230524.53990-2-vassilisamir@gmail.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/pressure/bmp280-core.c b/drivers/iio/pressure/bmp280-core.c
index dd5c526dacbdb56b683e05d891b249f2f9661ad0..3bb099c55db54eff7a1a9e4efd79053e3a3f4167 100644 (file)
--- a/drivers/iio/pressure/bmp280-core.c
+++ b/drivers/iio/pressure/bmp280-core.c
@@ -282,6 +282,28 @@ static int bme280_read_calib(struct bmp280_data *data)
        return 0;
 }
 
+static int bme280_read_humid_adc(struct bmp280_data *data, u16 *adc_humidity)
+{
+       u16 value_humidity;
+       int ret;
+
+       ret = regmap_bulk_read(data->regmap, BME280_REG_HUMIDITY_MSB,
+                              &data->be16, sizeof(data->be16));
+       if (ret) {
+               dev_err(data->dev, "failed to read humidity\n");
+               return ret;
+       }
+
+       value_humidity = be16_to_cpu(data->be16);
+       if (value_humidity == BMP280_HUMIDITY_SKIPPED) {
+               dev_err(data->dev, "reading humidity skipped\n");
+               return -EIO;
+       }
+       *adc_humidity = value_humidity;
+
+       return 0;
+}
+
 /*
  * Returns humidity in percent, resolution is 0.01 percent. Output value of
  * "47445" represents 47445/1024 = 46.333 %RH.
@@ -289,12 +311,12 @@ static int bme280_read_calib(struct bmp280_data *data)
  * Taken from BME280 datasheet, Section 4.2.3, "Compensation formula".
  */
 static u32 bme280_compensate_humidity(struct bmp280_data *data,
-                                     u16 adc_humidity)
+                                     u16 adc_humidity, s32 t_fine)
 {
        struct bmp280_calib *calib = &data->calib.bmp280;
        s32 var;
 
-       var = data->t_fine - (s32)76800;
+       var = t_fine - (s32)76800;
        var = (((((s32)adc_humidity << 14) - (calib->H4 << 20) - (calib->H5 * var))
                + (s32)16384) >> 15) * (((((((var * calib->H6) >> 10)
                * (((var * (s32)calib->H3) >> 11) + (s32)32768)) >> 10)
@@ -306,6 +328,28 @@ static u32 bme280_compensate_humidity(struct bmp280_data *data,
        return var >> 12;
 }
 
+static int bmp280_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
+{
+       u32 value_temp;
+       int ret;
+
+       ret = regmap_bulk_read(data->regmap, BMP280_REG_TEMP_MSB,
+                              data->buf, sizeof(data->buf));
+       if (ret) {
+               dev_err(data->dev, "failed to read temperature\n");
+               return ret;
+       }
+
+       value_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf));
+       if (value_temp == BMP280_TEMP_SKIPPED) {
+               dev_err(data->dev, "reading temperature skipped\n");
+               return -EIO;
+       }
+       *adc_temp = value_temp;
+
+       return 0;
+}
+
 /*
  * Returns temperature in DegC, resolution is 0.01 DegC.  Output value of
  * "5123" equals 51.23 DegC.  t_fine carries fine temperature as global
@@ -313,8 +357,7 @@ static u32 bme280_compensate_humidity(struct bmp280_data *data,
  *
  * Taken from datasheet, Section 3.11.3, "Compensation formula".
  */
-static s32 bmp280_compensate_temp(struct bmp280_data *data,
-                                 u32 adc_temp)
+static s32 bmp280_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
 {
        struct bmp280_calib *calib = &data->calib.bmp280;
        s32 var1, var2;
@@ -324,9 +367,48 @@ static s32 bmp280_compensate_temp(struct bmp280_data *data,
        var2 = (((((((s32)adc_temp) >> 4) - ((s32)calib->T1)) *
                  ((((s32)adc_temp >> 4) - ((s32)calib->T1))) >> 12) *
                ((s32)calib->T3))) >> 14;
-       data->t_fine = var1 + var2;
+       return var1 + var2; /* t_fine = var1 + var2 */
+}
+
+static int bmp280_get_t_fine(struct bmp280_data *data, s32 *t_fine)
+{
+       u32 adc_temp;
+       int ret;
+
+       ret = bmp280_read_temp_adc(data, &adc_temp);
+       if (ret)
+               return ret;
+
+       *t_fine = bmp280_calc_t_fine(data, adc_temp);
+
+       return 0;
+}
+
+static s32 bmp280_compensate_temp(struct bmp280_data *data, u32 adc_temp)
+{
+       return (bmp280_calc_t_fine(data, adc_temp) * 5 + 128) / 256;
+}
+
+static int bmp280_read_press_adc(struct bmp280_data *data, u32 *adc_press)
+{
+       u32 value_press;
+       int ret;
+
+       ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB,
+                              data->buf, sizeof(data->buf));
+       if (ret) {
+               dev_err(data->dev, "failed to read pressure\n");
+               return ret;
+       }
+
+       value_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf));
+       if (value_press == BMP280_PRESS_SKIPPED) {
+               dev_err(data->dev, "reading pressure skipped\n");
+               return -EIO;
+       }
+       *adc_press = value_press;
 
-       return (data->t_fine * 5 + 128) >> 8;
+       return 0;
 }
 
 /*
@@ -337,12 +419,12 @@ static s32 bmp280_compensate_temp(struct bmp280_data *data,
  * Taken from datasheet, Section 3.11.3, "Compensation formula".
  */
 static u32 bmp280_compensate_press(struct bmp280_data *data,
-                                  u32 adc_press)
+                                  u32 adc_press, s32 t_fine)
 {
        struct bmp280_calib *calib = &data->calib.bmp280;
        s64 var1, var2, p;
 
-       var1 = ((s64)data->t_fine) - 128000;
+       var1 = ((s64)t_fine) - 128000;
        var2 = var1 * var1 * (s64)calib->P6;
        var2 += (var1 * (s64)calib->P5) << 17;
        var2 += ((s64)calib->P4) << 35;
@@ -369,58 +451,31 @@ static int bmp280_read_temp(struct bmp280_data *data,
        u32 adc_temp;
        int ret;
 
-       ret = regmap_bulk_read(data->regmap, BMP280_REG_TEMP_MSB,
-                              data->buf, sizeof(data->buf));
-       if (ret) {
-               dev_err(data->dev, "failed to read temperature\n");
+       ret = bmp280_read_temp_adc(data, &adc_temp);
+       if (ret)
                return ret;
-       }
 
-       adc_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf));
-       if (adc_temp == BMP280_TEMP_SKIPPED) {
-               /* reading was skipped */
-               dev_err(data->dev, "reading temperature skipped\n");
-               return -EIO;
-       }
        comp_temp = bmp280_compensate_temp(data, adc_temp);
 
-       /*
-        * val might be NULL if we're called by the read_press routine,
-        * who only cares about the carry over t_fine value.
-        */
-       if (val) {
-               *val = comp_temp * 10;
-               return IIO_VAL_INT;
-       }
-
-       return 0;
+       *val = comp_temp * 10;
+       return IIO_VAL_INT;
 }
 
 static int bmp280_read_press(struct bmp280_data *data,
                             int *val, int *val2)
 {
-       u32 comp_press, adc_press;
+       u32 comp_press, adc_press, t_fine;
        int ret;
 
-       /* Read and compensate temperature so we get a reading of t_fine. */
-       ret = bmp280_read_temp(data, NULL, NULL);
+       ret = bmp280_get_t_fine(data, &t_fine);
        if (ret)
                return ret;
 
-       ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB,
-                              data->buf, sizeof(data->buf));
-       if (ret) {
-               dev_err(data->dev, "failed to read pressure\n");
+       ret = bmp280_read_press_adc(data, &adc_press);
+       if (ret)
                return ret;
-       }
 
-       adc_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf));
-       if (adc_press == BMP280_PRESS_SKIPPED) {
-               /* reading was skipped */
-               dev_err(data->dev, "reading pressure skipped\n");
-               return -EIO;
-       }
-       comp_press = bmp280_compensate_press(data, adc_press);
+       comp_press = bmp280_compensate_press(data, adc_press, t_fine);
 
        *val = comp_press;
        *val2 = 256000;
@@ -432,27 +487,18 @@ static int bme280_read_humid(struct bmp280_data *data, int *val, int *val2)
 {
        u32 comp_humidity;
        u16 adc_humidity;
+       s32 t_fine;
        int ret;
 
-       /* Read and compensate temperature so we get a reading of t_fine. */
-       ret = bmp280_read_temp(data, NULL, NULL);
+       ret = bmp280_get_t_fine(data, &t_fine);
        if (ret)
                return ret;
 
-       ret = regmap_bulk_read(data->regmap, BME280_REG_HUMIDITY_MSB,
-                              &data->be16, sizeof(data->be16));
-       if (ret) {
-               dev_err(data->dev, "failed to read humidity\n");
+       ret = bme280_read_humid_adc(data, &adc_humidity);
+       if (ret)
                return ret;
-       }
 
-       adc_humidity = be16_to_cpu(data->be16);
-       if (adc_humidity == BMP280_HUMIDITY_SKIPPED) {
-               /* reading was skipped */
-               dev_err(data->dev, "reading humidity skipped\n");
-               return -EIO;
-       }
-       comp_humidity = bme280_compensate_humidity(data, adc_humidity);
+       comp_humidity = bme280_compensate_humidity(data, adc_humidity, t_fine);
 
        *val = comp_humidity * 1000 / 1024;
 
@@ -923,6 +969,28 @@ static int bmp380_cmd(struct bmp280_data *data, u8 cmd)
        return 0;
 }
 
+static int bmp380_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
+{
+       u32 value_temp;
+       int ret;
+
+       ret = regmap_bulk_read(data->regmap, BMP380_REG_TEMP_XLSB,
+                              data->buf, sizeof(data->buf));
+       if (ret) {
+               dev_err(data->dev, "failed to read temperature\n");
+               return ret;
+       }
+
+       value_temp = get_unaligned_le24(data->buf);
+       if (value_temp == BMP380_TEMP_SKIPPED) {
+               dev_err(data->dev, "reading temperature skipped\n");
+               return -EIO;
+       }
+       *adc_temp = value_temp;
+
+       return 0;
+}
+
 /*
  * Returns temperature in Celsius degrees, resolution is 0.01º C. Output value
  * of "5123" equals 51.2º C. t_fine carries fine temperature as global value.
@@ -930,9 +998,9 @@ static int bmp380_cmd(struct bmp280_data *data, u8 cmd)
  * Taken from datasheet, Section Appendix 9, "Compensation formula" and repo
  * https://github.com/BoschSensortec/BMP3-Sensor-API.
  */
-static s32 bmp380_compensate_temp(struct bmp280_data *data, u32 adc_temp)
+static s32 bmp380_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
 {
-       s64 var1, var2, var3, var4, var5, var6, comp_temp;
+       s64 var1, var2, var3, var4, var5, var6;
        struct bmp380_calib *calib = &data->calib.bmp380;
 
        var1 = ((s64) adc_temp) - (((s64) calib->T1) << 8);
@@ -941,13 +1009,57 @@ static s32 bmp380_compensate_temp(struct bmp280_data *data, u32 adc_temp)
        var4 = var3 * ((s64) calib->T3);
        var5 = (var2 << 18) + var4;
        var6 = var5 >> 32;
-       data->t_fine = (s32) var6;
+       return (s32)var6; /* t_fine = var6 */
+}
+
+static int bmp380_get_t_fine(struct bmp280_data *data, s32 *t_fine)
+{
+       s32 adc_temp;
+       int ret;
+
+       ret = bmp380_read_temp_adc(data, &adc_temp);
+       if (ret)
+               return ret;
+
+       *t_fine = bmp380_calc_t_fine(data, adc_temp);
+
+       return 0;
+}
+
+static int bmp380_compensate_temp(struct bmp280_data *data, u32 adc_temp)
+{
+       s64 comp_temp;
+       s32 var6;
+
+       var6 = bmp380_calc_t_fine(data, adc_temp);
        comp_temp = (var6 * 25) >> 14;
 
        comp_temp = clamp_val(comp_temp, BMP380_MIN_TEMP, BMP380_MAX_TEMP);
        return (s32) comp_temp;
 }
 
+static int bmp380_read_press_adc(struct bmp280_data *data, u32 *adc_press)
+{
+       u32 value_press;
+       int ret;
+
+       ret = regmap_bulk_read(data->regmap, BMP380_REG_PRESS_XLSB,
+                              data->buf, sizeof(data->buf));
+       if (ret) {
+               dev_err(data->dev, "failed to read pressure\n");
+               return ret;
+       }
+
+       value_press = get_unaligned_le24(data->buf);
+       if (value_press == BMP380_PRESS_SKIPPED) {
+               dev_err(data->dev, "reading pressure skipped\n");
+               return -EIO;
+       }
+       *adc_press = value_press;
+
+       return 0;
+}
+
 /*
  * Returns pressure in Pa as an unsigned 32 bit integer in fractional Pascal.
  * Output value of "9528709" represents 9528709/100 = 95287.09 Pa = 952.8709 hPa.
@@ -955,27 +1067,28 @@ static s32 bmp380_compensate_temp(struct bmp280_data *data, u32 adc_temp)
  * Taken from datasheet, Section 9.3. "Pressure compensation" and repository
  * https://github.com/BoschSensortec/BMP3-Sensor-API.
  */
-static u32 bmp380_compensate_press(struct bmp280_data *data, u32 adc_press)
+static u32 bmp380_compensate_press(struct bmp280_data *data,
+                                  u32 adc_press, s32 t_fine)
 {
        s64 var1, var2, var3, var4, var5, var6, offset, sensitivity;
        struct bmp380_calib *calib = &data->calib.bmp380;
        u32 comp_press;
 
-       var1 = (s64)data->t_fine * (s64)data->t_fine;
+       var1 = (s64)t_fine * (s64)t_fine;
        var2 = var1 >> 6;
-       var3 = (var2 * ((s64) data->t_fine)) >> 8;
+       var3 = (var2 * ((s64)t_fine)) >> 8;
        var4 = ((s64)calib->P8 * var3) >> 5;
        var5 = ((s64)calib->P7 * var1) << 4;
-       var6 = ((s64)calib->P6 * (s64)data->t_fine) << 22;
+       var6 = ((s64)calib->P6 * (s64)t_fine) << 22;
        offset = ((s64)calib->P5 << 47) + var4 + var5 + var6;
        var2 = ((s64)calib->P4 * var3) >> 5;
        var4 = ((s64)calib->P3 * var1) << 2;
        var5 = ((s64)calib->P2 - ((s64)1 << 14)) *
-              ((s64)data->t_fine << 21);
+              ((s64)t_fine << 21);
        sensitivity = (((s64) calib->P1 - ((s64) 1 << 14)) << 46) +
                        var2 + var4 + var5;
        var1 = (sensitivity >> 24) * (s64)adc_press;
-       var2 = (s64)calib->P10 * (s64)data->t_fine;
+       var2 = (s64)calib->P10 * (s64)t_fine;
        var3 = var2 + ((s64)calib->P9 << 16);
        var4 = (var3 * (s64)adc_press) >> 13;
 
@@ -1001,59 +1114,32 @@ static int bmp380_read_temp(struct bmp280_data *data, int *val, int *val2)
        u32 adc_temp;
        int ret;
 
-       ret = regmap_bulk_read(data->regmap, BMP380_REG_TEMP_XLSB,
-                              data->buf, sizeof(data->buf));
-       if (ret) {
-               dev_err(data->dev, "failed to read temperature\n");
+       ret = bmp380_read_temp_adc(data, &adc_temp);
+       if (ret)
                return ret;
-       }
 
-       adc_temp = get_unaligned_le24(data->buf);
-       if (adc_temp == BMP380_TEMP_SKIPPED) {
-               dev_err(data->dev, "reading temperature skipped\n");
-               return -EIO;
-       }
        comp_temp = bmp380_compensate_temp(data, adc_temp);
 
-       /*
-        * Val might be NULL if we're called by the read_press routine,
-        * who only cares about the carry over t_fine value.
-        */
-       if (val) {
-               /* IIO reports temperatures in milli Celsius */
-               *val = comp_temp * 10;
-               return IIO_VAL_INT;
-       }
-
-       return 0;
+       *val = comp_temp * 10;
+       return IIO_VAL_INT;
 }
 
 static int bmp380_read_press(struct bmp280_data *data, int *val, int *val2)
 {
-       u32 adc_press, comp_press;
+       u32 adc_press, comp_press, t_fine;
        int ret;
 
-       /* Read and compensate for temperature so we get a reading of t_fine */
-       ret = bmp380_read_temp(data, NULL, NULL);
+       ret = bmp380_get_t_fine(data, &t_fine);
        if (ret)
                return ret;
 
-       ret = regmap_bulk_read(data->regmap, BMP380_REG_PRESS_XLSB,
-                              data->buf, sizeof(data->buf));
-       if (ret) {
-               dev_err(data->dev, "failed to read pressure\n");
+       ret = bmp380_read_press_adc(data, &adc_press);
+       if (ret)
                return ret;
-       }
 
-       adc_press = get_unaligned_le24(data->buf);
-       if (adc_press == BMP380_PRESS_SKIPPED) {
-               dev_err(data->dev, "reading pressure skipped\n");
-               return -EIO;
-       }
-       comp_press = bmp380_compensate_press(data, adc_press);
+       comp_press = bmp380_compensate_press(data, adc_press, t_fine);
 
        *val = comp_press;
-       /* Compensated pressure is in cPa (centipascals) */
        *val2 = 100000;
 
        return IIO_VAL_FRACTIONAL;
@@ -1825,7 +1911,7 @@ static int bmp180_wait_for_eoc(struct bmp280_data *data, u8 ctrl_meas)
        return 0;
 }
 
-static int bmp180_read_adc_temp(struct bmp280_data *data, int *val)
+static int bmp180_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
 {
        int ret;
 
@@ -1842,7 +1928,7 @@ static int bmp180_read_adc_temp(struct bmp280_data *data, int *val)
                return ret;
        }
 
-       *val = be16_to_cpu(data->be16);
+       *adc_temp = be16_to_cpu(data->be16);
 
        return 0;
 }
@@ -1892,16 +1978,34 @@ static int bmp180_read_calib(struct bmp280_data *data)
  *
  * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
  */
-static s32 bmp180_compensate_temp(struct bmp280_data *data, u32 adc_temp)
+
+static s32 bmp180_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
 {
        struct bmp180_calib *calib = &data->calib.bmp180;
        s32 x1, x2;
 
        x1 = ((((s32)adc_temp) - calib->AC6) * calib->AC5) >> 15;
        x2 = (calib->MC << 11) / (x1 + calib->MD);
-       data->t_fine = x1 + x2;
+       return x1 + x2; /* t_fine = x1 + x2; */
+}
+
+static int bmp180_get_t_fine(struct bmp280_data *data, s32 *t_fine)
+{
+       s32 adc_temp;
+       int ret;
+
+       ret = bmp180_read_temp_adc(data, &adc_temp);
+       if (ret)
+               return ret;
+
+       *t_fine = bmp180_calc_t_fine(data, adc_temp);
 
-       return (data->t_fine + 8) >> 4;
+       return 0;
+}
+
+static s32 bmp180_compensate_temp(struct bmp280_data *data, u32 adc_temp)
+{
+       return (bmp180_calc_t_fine(data, adc_temp) + 8) / 16;
 }
 
 static int bmp180_read_temp(struct bmp280_data *data, int *val, int *val2)
@@ -1910,25 +2014,17 @@ static int bmp180_read_temp(struct bmp280_data *data, int *val, int *val2)
        u32 adc_temp;
        int ret;
 
-       ret = bmp180_read_adc_temp(data, &adc_temp);
+       ret = bmp180_read_temp_adc(data, &adc_temp);
        if (ret)
                return ret;
 
        comp_temp = bmp180_compensate_temp(data, adc_temp);
 
-       /*
-        * val might be NULL if we're called by the read_press routine,
-        * who only cares about the carry over t_fine value.
-        */
-       if (val) {
-               *val = comp_temp * 100;
-               return IIO_VAL_INT;
-       }
-
-       return 0;
+       *val = comp_temp * 100;
+       return IIO_VAL_INT;
 }
 
-static int bmp180_read_adc_press(struct bmp280_data *data, int *val)
+static int bmp180_read_press_adc(struct bmp280_data *data, u32 *adc_press)
 {
        u8 oss = data->oversampling_press;
        int ret;
@@ -1947,7 +2043,7 @@ static int bmp180_read_adc_press(struct bmp280_data *data, int *val)
                return ret;
        }
 
-       *val = get_unaligned_be24(data->buf) >> (8 - oss);
+       *adc_press = get_unaligned_be24(data->buf) >> (8 - oss);
 
        return 0;
 }
@@ -1957,7 +2053,8 @@ static int bmp180_read_adc_press(struct bmp280_data *data, int *val)
  *
  * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
  */
-static u32 bmp180_compensate_press(struct bmp280_data *data, u32 adc_press)
+static u32 bmp180_compensate_press(struct bmp280_data *data, u32 adc_press,
+                                  s32 t_fine)
 {
        struct bmp180_calib *calib = &data->calib.bmp180;
        s32 oss = data->oversampling_press;
@@ -1965,7 +2062,7 @@ static u32 bmp180_compensate_press(struct bmp280_data *data, u32 adc_press)
        s32 b3, b6;
        u32 b4, b7;
 
-       b6 = data->t_fine - 4000;
+       b6 = t_fine - 4000;
        x1 = (calib->B2 * (b6 * b6 >> 12)) >> 11;
        x2 = calib->AC2 * b6 >> 11;
        x3 = x1 + x2;
@@ -1990,18 +2087,18 @@ static u32 bmp180_compensate_press(struct bmp280_data *data, u32 adc_press)
 static int bmp180_read_press(struct bmp280_data *data, int *val, int *val2)
 {
        u32 comp_press, adc_press;
+       s32 t_fine;
        int ret;
 
-       /* Read and compensate temperature so we get a reading of t_fine. */
-       ret = bmp180_read_temp(data, NULL, NULL);
+       ret = bmp180_get_t_fine(data, &t_fine);
        if (ret)
                return ret;
 
-       ret = bmp180_read_adc_press(data, &adc_press);
+       ret = bmp180_read_press_adc(data, &adc_press);
        if (ret)
                return ret;
 
-       comp_press = bmp180_compensate_press(data, adc_press);
+       comp_press = bmp180_compensate_press(data, adc_press, t_fine);
 
        *val = comp_press;
        *val2 = 1000;

diff --git a/drivers/iio/pressure/bmp280.h b/drivers/iio/pressure/bmp280.h
index fe4d3f12795446fd4f5a71b51e26562d352ffedb..7c30e4d523beb6461b22a26ed1fcbdb27e1ab17b 100644 (file)
--- a/drivers/iio/pressure/bmp280.h
+++ b/drivers/iio/pressure/bmp280.h
@@ -397,12 +397,6 @@ struct bmp280_data {
         */
        int sampling_freq;
 
-       /*
-        * Carryover value from temperature conversion, used in pressure
-        * calculation.
-        */
-       s32 t_fine;
-
        /*
         * DMA (thus cache coherency maintenance) may require the
         * transfer buffers to live in their own cache lines.