Commit 5d6e6c6e authored May 13, 2024 by Vasileios Amoiridis Committed by Jonathan Cameron May 27, 2024

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>

parent f0fcd87e

drivers/iio/pressure/bmp280-core.c

+224 −127

Original line number	Diff line number	Diff line
		@@ -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;
		}

		return (data->t_fine * 5 + 128) >> 8;
		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 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;
		}

		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;
		}

		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;

		return (data->t_fine + 8) >> 4;
		*t_fine = bmp180_calc_t_fine(data, adc_temp);

		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;
		}

		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;

drivers/iio/pressure/bmp280.h

+0 −6

Original line number	Diff line number	Diff line
		@@ -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.