Skip to content

L
linux
Commit 5d6e6c6e authored by Vasileios Amoiridis's avatar Vasileios Amoiridis Committed by Jonathan Cameron
Browse files
Options

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: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
Signed-off-by: default avatarVasileios Amoiridis <vassilisamir@gmail.com>
Link: https://lore.kernel.org/r/20240512230524.53990-2-vassilisamir@gmail.comSigned-off-by: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
parent f0fcd87e
Hide whitespace changes
Inline Side-by-side
Showing with 224 additions and 133 deletions
drivers/iio/pressure/bmp280-core.c
View file @ 5d6e6c6e
......@@ -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;
......
drivers/iio/pressure/bmp280.h
View file @ 5d6e6c6e
......@@ -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.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7