LinuxLists.cc - [PATCH v2 4/5] iio: pressure: bmp280: Add support for BMP380 sensor family

2022-07-04 00:41:20

Subject: [PATCH v2 4/5] iio: pressure: bmp280: Add support for BMP380 sensor family

Adds compatibility with the new generation of this sensor, the BMP380

Includes basic sensor initialization to do pressure and temp
measurements and allows tuning oversampling settings for each channel
The compensation algorithms are adapted from the device datasheet and
the repository https://github.com/BoschSensortec/BMP3-Sensor-API

Signed-off-by: Angel Iglesias <[email protected]>
---
drivers/iio/pressure/bmp280-core.c | 354 +++++++++++++++++++++++++++
drivers/iio/pressure/bmp280-i2c.c | 5 +
drivers/iio/pressure/bmp280-regmap.c | 55 +++++
drivers/iio/pressure/bmp280-spi.c | 5 +
drivers/iio/pressure/bmp280.h | 101 ++++++++
5 files changed, 520 insertions(+)

diff --git a/drivers/iio/pressure/bmp280-core.c b/drivers/iio/pressure/bmp280-core.c
index f39160b17cb3..0d2395a28df8 100644
--- a/drivers/iio/pressure/bmp280-core.c
+++ b/drivers/iio/pressure/bmp280-core.c
@@ -12,10 +12,12 @@
* https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP180-DS000-121.pdf
* https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP280-DS001-12.pdf
* https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BME280_DS001-11.pdf
+ * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf
*/

#define pr_fmt(fmt) "bmp280: " fmt

+#include <linux/bitops.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/regmap.h>
@@ -29,6 +31,7 @@
#include <linux/completion.h>
#include <linux/pm_runtime.h>
#include <linux/random.h>
+#include <asm/unaligned.h>

#include "bmp280.h"

@@ -74,6 +77,24 @@ struct bmp280_calib {
s8 H6;
};

+/* See datasheet Section 3.11.1. */
+struct bmp380_calib {
+ u16 T1;
+ u16 T2;
+ s8 T3;
+ s16 P1;
+ s16 P2;
+ s8 P3;
+ s8 P4;
+ u16 P5;
+ u16 P6;
+ s8 P7;
+ s8 P8;
+ s16 P9;
+ s8 P10;
+ s8 P11;
+};
+
static const char *const bmp280_supply_names[] = {
"vddd", "vdda"
};
@@ -90,6 +111,7 @@ struct bmp280_data {
union {
struct bmp180_calib bmp180;
struct bmp280_calib bmp280;
+ struct bmp380_calib bmp380;
} calib;
struct regulator_bulk_data supplies[BMP280_NUM_SUPPLIES];
unsigned int start_up_time; /* in microseconds */
@@ -138,6 +160,25 @@ struct bmp280_chip_info {
enum { T1, T2, T3 };
enum { P1, P2, P3, P4, P5, P6, P7, P8, P9 };

+enum {
+ /* Temperature calib indexes */
+ BMP380_T1 = 0,
+ BMP380_T2 = 2,
+ BMP380_T3 = 4,
+ /* Pressure calib indexes */
+ BMP380_P1 = 5,
+ BMP380_P2 = 7,
+ BMP380_P3 = 9,
+ BMP380_P4 = 10,
+ BMP380_P5 = 11,
+ BMP380_P6 = 13,
+ BMP380_P7 = 15,
+ BMP380_P8 = 16,
+ BMP380_P9 = 17,
+ BMP380_P10 = 19,
+ BMP380_P11 = 20
+};
+
static const struct iio_chan_spec bmp280_channels[] = {
{
.type = IIO_PRESSURE,
@@ -708,6 +749,309 @@ static const struct bmp280_chip_info bme280_chip_info = {
.read_calib = bmp280_read_calib,
};

+/* Send a command to BMP3XX sensors */
+static int bmp380_cmd(struct bmp280_data *data, u8 cmd)
+{
+ int ret;
+ unsigned int reg;
+
+ /* check if device is ready to process a command */
+ ret = regmap_read(data->regmap, BMP380_REG_STATUS, &reg);
+ if (ret) {
+ dev_err(data->dev, "failed to read error register\n");
+ return ret;
+ }
+ if (!(cmd & BMP380_STATUS_CMD_RDY_MASK)) {
+ dev_err(data->dev, "device is not ready to accept commands\n");
+ return -EBUSY;
+ }
+
+ /* send command to process */
+ ret = regmap_write(data->regmap, BMP380_REG_CMD, cmd);
+ if (ret) {
+ dev_err(data->dev, "failed to send command to device\n");
+ return ret;
+ }
+ /* wait for 2ms for command to be proccessed */
+ usleep_range(data->start_up_time, data->start_up_time + 100);
+ /* check for command processing error */
+ ret = regmap_read(data->regmap, BMP380_REG_ERROR, &reg);
+ if (ret) {
+ dev_err(data->dev, "error reading ERROR reg\n");
+ return ret;
+ }
+ if (reg & BMP380_ERR_CMD_MASK) {
+ dev_err(data->dev, "error processing command 0x%X\n", cmd);
+ return -EINVAL;
+ }
+ dev_dbg(data->dev, "Command 0x%X proccessed successfully\n", cmd);
+
+ 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
+ * value.
+ *
+ * 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)
+{
+ s64 var1, var2, var3, var4, var5, var6, comp_temp;
+ struct bmp380_calib *calib = &data->calib.bmp380;
+
+ var1 = ((s64) adc_temp) - (((s64) calib->T1) << 8);
+ var2 = var1 * ((s64) calib->T2);
+ var3 = var1 * var1;
+ var4 = var3 * ((s64) calib->T3);
+ var5 = (var2 << 18) + var4;
+ var6 = var5 >> 32;
+ data->t_fine = (s32) var6;
+ comp_temp = (var6 * 25) >> 14;
+
+ comp_temp = clamp_val(comp_temp, BMP380_MIN_TEMP, BMP380_MAX_TEMP);
+ return (s32) comp_temp;
+}
+
+/*
+ * Returns pressure in Pa as unsigned 32 bit integer in fractional Pascal.
+ * Output value of "9528709" represents 9528709/100 = 95287.09 Pa = 952.8709 hPa
+ *
+ * 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)
+{
+ s64 var1, var2, var3, var4, var5, var6, offset, sensitivity;
+ u64 comp_press;
+ struct bmp380_calib *calib = &data->calib.bmp380;
+
+ var1 = ((s64)data->t_fine) * ((s64)data->t_fine);
+ var2 = var1 >> 6;
+ var3 = (var2 * ((s64) data->t_fine)) >> 8;
+ var4 = (((s64)calib->P8) * var3) >> 5;
+ var5 = (((s64) calib->P7) * var1) << 4;
+ var6 = (((s64) calib->P6) * ((s64)data->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);
+ 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);
+ var3 = var2 + (((s64) calib->P9) << 16);
+ var4 = (var3 * ((s64)adc_press)) >> 13;
+
+ /* dividing by 10 followed by multiplying by 10
+ * To avoid overflow caused by (uncomp_data->pressure * partial_data4)
+ */
+ var5 = (((s64)adc_press) * (var4 / 10)) >> 9;
+ var5 *= 10;
+ var6 = ((s64)adc_press) * ((s64)adc_press);
+ var2 = (((s64)calib->P11) * var6) >> 16;
+ var3 = (var2 * ((s64)adc_press)) >> 7;
+ var4 = (offset >> 2) + var1 + var5 + var3;
+ comp_press = ((u64)var4 * 25) >> 40;
+
+ comp_press = clamp_val(comp_press, BMP380_MIN_PRES, BMP380_MAX_PRES);
+ return (u32)comp_press;
+}
+
+static int bmp380_read_temp(struct bmp280_data *data, int *val)
+{
+ int ret;
+ u8 tmp[3];
+ u32 adc_temp;
+ s32 comp_temp;
+
+ ret = regmap_bulk_read(data->regmap, BMP380_REG_TEMP_XLSB, tmp, 3);
+ if (ret < 0) {
+ dev_err(data->dev, "failed to read temperature\n");
+ return ret;
+ }
+
+ adc_temp = get_unaligned_le24(tmp);
+ if (adc_temp == BMP380_TEMP_SKIPPED) {
+ /* reading was 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 mC */
+ *val = comp_temp * 10;
+ return IIO_VAL_INT;
+ }
+
+ return 0;
+}
+
+static int bmp380_read_press(struct bmp280_data *data, int *val, int *val2)
+{
+ int ret;
+ u8 tmp[3];
+ u32 adc_press;
+ s32 comp_press;
+
+ /* Read and compensate temperature so we get a reading of t_fine. */
+ ret = bmp380_read_temp(data, NULL);
+ if (ret < 0)
+ return ret;
+
+ ret = regmap_bulk_read(data->regmap, BMP380_REG_PRESS_XLSB, tmp, 3);
+ if (ret < 0) {
+ dev_err(data->dev, "failed to read pressure\n");
+ return ret;
+ }
+
+ adc_press = get_unaligned_le24(tmp);
+ if (adc_press == BMP380_PRESS_SKIPPED) {
+ /* reading was skipped */
+ dev_err(data->dev, "reading pressure skipped\n");
+ return -EIO;
+ }
+ comp_press = bmp380_compensate_press(data, adc_press);
+
+ *val = comp_press;
+ /* Compensated pressure is in cPa (centipascals) */
+ *val2 = 100000;
+
+ return IIO_VAL_FRACTIONAL;
+}
+
+static int bmp380_read_calib(struct bmp280_data *data, unsigned int chip)
+{
+ int ret;
+ struct bmp380_calib *calib = &data->calib.bmp380;
+ u8 buf[BMP380_CALIB_REG_COUNT];
+
+ /* Read temperature calibration values. */
+ ret = regmap_bulk_read(data->regmap, BMP380_REG_CALIB_TEMP_START, buf,
+ BMP380_CALIB_REG_COUNT);
+ if (ret < 0) {
+ dev_err(data->dev,
+ "failed to read temperature calibration parameters\n");
+ return ret;
+ }
+
+ /* Toss the temperature calibration data into the entropy pool */
+ add_device_randomness(buf, sizeof(buf));
+
+ /* Parse calibration data */
+ calib->T1 = get_unaligned_le16(&buf[BMP380_T1]);
+ calib->T2 = get_unaligned_le16(&buf[BMP380_T2]);
+ calib->T3 = buf[BMP380_T3];
+ calib->P1 = get_unaligned_le16(&buf[BMP380_P1]);
+ calib->P2 = get_unaligned_le16(&buf[BMP380_P2]);
+ calib->P3 = buf[BMP380_P3];
+ calib->P4 = buf[BMP380_P4];
+ calib->P5 = get_unaligned_le16(&buf[BMP380_P5]);
+ calib->P6 = get_unaligned_le16(&buf[BMP380_P6]);
+ calib->P7 = buf[BMP380_P7];
+ calib->P8 = buf[BMP380_P8];
+ calib->P9 = get_unaligned_le16(&buf[BMP380_P9]);
+ calib->P10 = buf[BMP380_P10];
+ calib->P11 = buf[BMP380_P11];
+
+ return 0;
+}
+
+static int bmp380_chip_config(struct bmp280_data *data)
+{
+ u8 osrs;
+ unsigned int tmp;
+ int ret;
+
+ /* configure power control register */
+ ret = regmap_write_bits(data->regmap, BMP380_REG_POWER_CONTROL,
+ BMP380_CTRL_SENSORS_MASK | BMP380_MODE_MASK,
+ BMP380_CTRL_SENSORS_PRESS_EN |
+ BMP380_CTRL_SENSORS_TEMP_EN |
+ FIELD_PREP(BMP380_MODE_MASK, BMP380_MODE_NORMAL));
+ if (ret < 0) {
+ dev_err(data->dev,
+ "failed to write operation control register\n");
+ return ret;
+ }
+
+ /* configure oversampling */
+ osrs = FIELD_PREP(BMP380_OSRS_TEMP_MASK, data->oversampling_temp) |
+ FIELD_PREP(BMP380_OSRS_PRESS_MASK, data->oversampling_press);
+
+ ret = regmap_write_bits(data->regmap, BMP380_REG_OSR,
+ BMP380_OSRS_TEMP_MASK | BMP380_OSRS_PRESS_MASK,
+ osrs);
+ if (ret < 0) {
+ dev_err(data->dev, "failed to write oversampling register\n");
+ return ret;
+ }
+
+ /* configure output data rate */
+ ret = regmap_write_bits(data->regmap, BMP380_REG_ODR,
+ BMP380_ODRS_MASK, BMP380_ODRS_50HZ);
+ if (ret < 0) {
+ dev_err(data->dev, "failed to write ODR selection register\n");
+ return ret;
+ }
+
+ /* set filter data */
+ ret = regmap_update_bits(data->regmap, BMP380_REG_CONFIG,
+ BMP380_FILTER_MASK,
+ FIELD_PREP(BMP380_FILTER_MASK, BMP380_FILTER_3X));
+ if (ret < 0) {
+ dev_err(data->dev, "failed to write config register\n");
+ return ret;
+ }
+
+ /* wait startup_time before verifying config changes */
+ usleep_range(data->start_up_time, data->start_up_time + 100);
+
+ /* check config error flag */
+ ret = regmap_read(data->regmap, BMP380_REG_ERROR, &tmp);
+ if (ret < 0) {
+ dev_err(data->dev,
+ "failed to read error register\n");
+ return ret;
+ }
+ if (tmp & BMP380_ERR_CONF_MASK) {
+ dev_warn(data->dev,
+ "sensor flagged configuration as incompatible\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static const int bmp380_oversampling_avail[] = { 1, 2, 4, 8, 16, 32 };
+
+static const struct bmp280_chip_info bmp380_chip_info = {
+ .id_reg = BMP380_REG_ID,
+ .start_up_time = 2000,
+ .num_channels = 2,
+
+ .oversampling_temp_avail = bmp380_oversampling_avail,
+ .num_oversampling_temp_avail = ARRAY_SIZE(bmp380_oversampling_avail),
+ .oversampling_temp_default = ilog2(1),
+
+ .oversampling_press_avail = bmp380_oversampling_avail,
+ .num_oversampling_press_avail = ARRAY_SIZE(bmp380_oversampling_avail),
+ .oversampling_press_default = ilog2(4),
+
+ .chip_config = bmp380_chip_config,
+ .read_temp = bmp380_read_temp,
+ .read_press = bmp380_read_press,
+ .read_calib = bmp380_read_calib,
+};
+
static int bmp180_measure(struct bmp280_data *data, u8 ctrl_meas)
{
int ret;
@@ -1050,6 +1394,9 @@ int bmp280_common_probe(struct device *dev,
case BME280_CHIP_ID:
chip_info = &bme280_chip_info;
break;
+ case BMP380_CHIP_ID:
+ chip_info = &bmp380_chip_info;
+ break;
default:
return -EINVAL;
}
@@ -1107,6 +1454,13 @@ int bmp280_common_probe(struct device *dev,
return -EINVAL;
}

+ /* BMP3xx requires soft-reset as part of initialization */
+ if (chip_id == BMP380_CHIP_ID) {
+ ret = bmp380_cmd(data, BMP380_CMD_SOFT_RESET);
+ if (ret < 0)
+ return ret;
+ }
+
ret = data->chip_info->chip_config(data);
if (ret < 0)
return ret;
diff --git a/drivers/iio/pressure/bmp280-i2c.c b/drivers/iio/pressure/bmp280-i2c.c
index 35045bd92846..31a8a0daa39a 100644
--- a/drivers/iio/pressure/bmp280-i2c.c
+++ b/drivers/iio/pressure/bmp280-i2c.c
@@ -19,6 +19,9 @@ static int bmp280_i2c_probe(struct i2c_client *client,
case BME280_CHIP_ID:
regmap_config = &bmp280_regmap_config;
break;
+ case BMP380_CHIP_ID:
+ regmap_config = &bmp380_regmap_config;
+ break;
default:
return -EINVAL;
}
@@ -37,6 +40,7 @@ static int bmp280_i2c_probe(struct i2c_client *client,
}

static const struct of_device_id bmp280_of_i2c_match[] = {
+ { .compatible = "bosch,bmp380", .data = (void *)BMP380_CHIP_ID },
{ .compatible = "bosch,bme280", .data = (void *)BME280_CHIP_ID },
{ .compatible = "bosch,bmp280", .data = (void *)BMP280_CHIP_ID },
{ .compatible = "bosch,bmp180", .data = (void *)BMP180_CHIP_ID },
@@ -46,6 +50,7 @@ static const struct of_device_id bmp280_of_i2c_match[] = {
MODULE_DEVICE_TABLE(of, bmp280_of_i2c_match);

static const struct i2c_device_id bmp280_i2c_id[] = {
+ {"bmp380", BMP380_CHIP_ID },
{"bmp280", BMP280_CHIP_ID },
{"bmp180", BMP180_CHIP_ID },
{"bmp085", BMP180_CHIP_ID },
diff --git a/drivers/iio/pressure/bmp280-regmap.c b/drivers/iio/pressure/bmp280-regmap.c
index da136dbadc8f..b440fa41bf12 100644
--- a/drivers/iio/pressure/bmp280-regmap.c
+++ b/drivers/iio/pressure/bmp280-regmap.c
@@ -72,6 +72,49 @@ static bool bmp280_is_volatile_reg(struct device *dev, unsigned int reg)
}
}

+static bool bmp380_is_writeable_reg(struct device *dev, unsigned int reg)
+{
+ switch (reg) {
+ case BMP380_REG_CMD:
+ case BMP380_REG_CONFIG:
+ case BMP380_REG_FIFO_CONFIG_1:
+ case BMP380_REG_FIFO_CONFIG_2:
+ case BMP380_REG_FIFO_WATERMARK_LSB:
+ case BMP380_REG_FIFO_WATERMARK_MSB:
+ case BMP380_REG_POWER_CONTROL:
+ case BMP380_REG_INT_CONTROL:
+ case BMP380_REG_IF_CONFIG:
+ case BMP380_REG_ODR:
+ case BMP380_REG_OSR:
+ return true;
+ default:
+ return false;
+ }
+}
+
+static bool bmp380_is_volatile_reg(struct device *dev, unsigned int reg)
+{
+ switch (reg) {
+ case BMP380_REG_TEMP_XLSB:
+ case BMP380_REG_TEMP_LSB:
+ case BMP380_REG_TEMP_MSB:
+ case BMP380_REG_PRESS_XLSB:
+ case BMP380_REG_PRESS_LSB:
+ case BMP380_REG_PRESS_MSB:
+ case BMP380_REG_SENSOR_TIME_XLSB:
+ case BMP380_REG_SENSOR_TIME_LSB:
+ case BMP380_REG_SENSOR_TIME_MSB:
+ case BMP380_REG_INT_STATUS:
+ case BMP380_REG_FIFO_DATA:
+ case BMP380_REG_STATUS:
+ case BMP380_REG_ERROR:
+ case BMP380_REG_EVENT:
+ return true;
+ default:
+ return false;
+ }
+}
+
const struct regmap_config bmp280_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
@@ -83,3 +126,15 @@ const struct regmap_config bmp280_regmap_config = {
.volatile_reg = bmp280_is_volatile_reg,
};
EXPORT_SYMBOL(bmp280_regmap_config);
+
+const struct regmap_config bmp380_regmap_config = {
+ .reg_bits = 8,
+ .val_bits = 8,
+
+ .max_register = BMP380_REG_CMD,
+ .cache_type = REGCACHE_RBTREE,
+
+ .writeable_reg = bmp380_is_writeable_reg,
+ .volatile_reg = bmp380_is_volatile_reg,
+};
+EXPORT_SYMBOL(bmp380_regmap_config);
diff --git a/drivers/iio/pressure/bmp280-spi.c b/drivers/iio/pressure/bmp280-spi.c
index 41f6cc56d229..303c41130343 100644
--- a/drivers/iio/pressure/bmp280-spi.c
+++ b/drivers/iio/pressure/bmp280-spi.c
@@ -66,6 +66,9 @@ static int bmp280_spi_probe(struct spi_device *spi)
case BME280_CHIP_ID:
regmap_config = &bmp280_regmap_config;
break;
+ case BMP380_CHIP_ID:
+ regmap_config = &bmp380_regmap_config;
+ break;
default:
return -EINVAL;
}
@@ -92,6 +95,7 @@ static const struct of_device_id bmp280_of_spi_match[] = {
{ .compatible = "bosch,bmp181", },
{ .compatible = "bosch,bmp280", },
{ .compatible = "bosch,bme280", },
+ { .compatible = "bosch,bmp380", },
{ },
};
MODULE_DEVICE_TABLE(of, bmp280_of_spi_match);
@@ -101,6 +105,7 @@ static const struct spi_device_id bmp280_spi_id[] = {
{ "bmp181", BMP180_CHIP_ID },
{ "bmp280", BMP280_CHIP_ID },
{ "bme280", BME280_CHIP_ID },
+ { "bmp380", BMP380_CHIP_ID },
{ }
};
MODULE_DEVICE_TABLE(spi, bmp280_spi_id);
diff --git a/drivers/iio/pressure/bmp280.h b/drivers/iio/pressure/bmp280.h
index 57ba0e85db91..fd38906c889c 100644
--- a/drivers/iio/pressure/bmp280.h
+++ b/drivers/iio/pressure/bmp280.h
@@ -3,6 +3,105 @@
#include <linux/device.h>
#include <linux/regmap.h>

+/* BMP380 specific registers */
+#define BMP380_REG_CMD 0x7E
+#define BMP380_REG_CONFIG 0x1F
+#define BMP380_REG_ODR 0X1D
+#define BMP380_REG_OSR 0X1C
+#define BMP380_REG_POWER_CONTROL 0X1B
+#define BMP380_REG_IF_CONFIG 0X1A
+#define BMP380_REG_INT_CONTROL 0X19
+#define BMP380_REG_INT_STATUS 0X11
+#define BMP380_REG_EVENT 0X10
+#define BMP380_REG_STATUS 0X03
+#define BMP380_REG_ERROR 0X02
+#define BMP380_REG_ID 0X00
+
+#define BMP380_REG_FIFO_CONFIG_1 0X18
+#define BMP380_REG_FIFO_CONFIG_2 0X17
+#define BMP380_REG_FIFO_WATERMARK_MSB 0X16
+#define BMP380_REG_FIFO_WATERMARK_LSB 0X15
+#define BMP380_REG_FIFO_DATA 0X14
+#define BMP380_REG_FIFO_LENGTH_MSB 0X13
+#define BMP380_REG_FIFO_LENGTH_LSB 0X12
+
+#define BMP380_REG_SENSOR_TIME_MSB 0X0E
+#define BMP380_REG_SENSOR_TIME_LSB 0X0D
+#define BMP380_REG_SENSOR_TIME_XLSB 0X0C
+
+#define BMP380_REG_TEMP_MSB 0X09
+#define BMP380_REG_TEMP_LSB 0X08
+#define BMP380_REG_TEMP_XLSB 0X07
+
+#define BMP380_REG_PRESS_MSB 0X06
+#define BMP380_REG_PRESS_LSB 0X05
+#define BMP380_REG_PRESS_XLSB 0X04
+
+#define BMP380_REG_CALIB_TEMP_START 0x31
+#define BMP380_CALIB_REG_COUNT 21
+
+#define BMP380_FILTER_MASK GENMASK(3, 1)
+#define BMP380_FILTER_OFF 0
+#define BMP380_FILTER_1X 1
+#define BMP380_FILTER_3X 2
+#define BMP380_FILTER_7X 3
+#define BMP380_FILTER_15X 4
+#define BMP380_FILTER_31X 5
+#define BMP380_FILTER_63X 6
+#define BMP380_FILTER_127X 7
+
+#define BMP380_OSRS_TEMP_MASK GENMASK(5, 3)
+#define BMP380_OSRS_PRESS_MASK GENMASK(2, 0)
+
+#define BMP380_ODRS_MASK GENMASK(4, 0)
+#define BMP380_ODRS_200HZ 0x00
+#define BMP380_ODRS_100HZ 0x01
+#define BMP380_ODRS_50HZ 0x02
+#define BMP380_ODRS_25HZ 0x03
+#define BMP380_ODRS_12_5HZ 0x04
+#define BMP380_ODRS_6_25HZ 0x05
+#define BMP380_ODRS_3_1HZ 0x06
+#define BMP380_ODRS_1_5HZ 0x07
+#define BMP380_ODRS_0_78HZ 0x08
+#define BMP380_ODRS_0_39HZ 0x09
+#define BMP380_ODRS_0_2HZ 0x0A
+#define BMP380_ODRS_0_1HZ 0x0B
+#define BMP380_ODRS_0_05HZ 0x0C
+#define BMP380_ODRS_0_02HZ 0x0D
+#define BMP380_ODRS_0_01HZ 0x0E
+#define BMP380_ODRS_0_006HZ 0x0F
+#define BMP380_ODRS_0_003HZ 0x10
+#define BMP380_ODRS_0_0015HZ 0x11
+
+#define BMP380_CTRL_SENSORS_MASK GENMASK(1, 0)
+#define BMP380_CTRL_SENSORS_PRESS_EN BIT(0)
+#define BMP380_CTRL_SENSORS_TEMP_EN BIT(1)
+#define BMP380_MODE_MASK GENMASK(5, 4)
+#define BMP380_MODE_SLEEP 0
+#define BMP380_MODE_FORCED 1
+#define BMP380_MODE_NORMAL 3
+
+#define BMP380_MIN_TEMP -4000
+#define BMP380_MAX_TEMP 8500
+#define BMP380_MIN_PRES 3000000
+#define BMP380_MAX_PRES 12500000
+
+#define BMP380_CMD_NOOP 0X00
+#define BMP380_CMD_EXTMODE_EN_MID 0x34
+#define BMP380_CMD_FIFO_FLUSH 0XB0
+#define BMP380_CMD_SOFT_RESET 0xB6
+
+#define BMP380_STATUS_CMD_RDY_MASK BIT(4)
+#define BMP380_STATUS_DRDY_PRESS_MASK BIT(5)
+#define BMP380_STATUS_DRDY_TEMP_MASK BIT(6)
+
+#define BMP380_ERR_FATAL_MASK BIT(0)
+#define BMP380_ERR_CMD_MASK BIT(1)
+#define BMP380_ERR_CONF_MASK BIT(2)
+
+#define BMP380_TEMP_SKIPPED 0x800000
+#define BMP380_PRESS_SKIPPED 0x800000
+
/* BMP280 specific registers */
#define BMP280_REG_HUMIDITY_LSB 0xFE
#define BMP280_REG_HUMIDITY_MSB 0xFD
@@ -92,6 +191,7 @@
#define BMP280_REG_RESET 0xE0
#define BMP280_REG_ID 0xD0

+#define BMP380_CHIP_ID 0x50
#define BMP180_CHIP_ID 0x55
#define BMP280_CHIP_ID 0x58
#define BME280_CHIP_ID 0x60
@@ -105,6 +205,7 @@
/* Regmap configurations */
extern const struct regmap_config bmp180_regmap_config;
extern const struct regmap_config bmp280_regmap_config;
+extern const struct regmap_config bmp380_regmap_config;

/* Probe called from different transports */
int bmp280_common_probe(struct device *dev,
--
2.36.1

2022-07-04 02:06:19

by kernel test robot

[permalink] [raw]

Subject: Re: [PATCH v2 4/5] iio: pressure: bmp280: Add support for BMP380 sensor family

2022-07-04 02:14:18

by kernel test robot

[permalink] [raw]

Subject: Re: [PATCH v2 4/5] iio: pressure: bmp280: Add support for BMP380 sensor family

Hi Angel,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on 69cb6c6556ad89620547318439d6be8bb1629a5a]

url: https://github.com/intel-lab-lkp/linux/commits/Angel-Iglesias/Add-support-for-pressure-sensor-Bosch-BMP380/20220704-083456
base: 69cb6c6556ad89620547318439d6be8bb1629a5a
config: s390-randconfig-r031-20220703 (https://download.01.org/0day-ci/archive/20220704/[email protected]/config)
compiler: clang version 15.0.0 (https://github.com/llvm/llvm-project 134363208b9272a967c911f7b56c255a72a6f0a0)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# install s390 cross compiling tool for clang build
# apt-get install binutils-s390x-linux-gnu
# https://github.com/intel-lab-lkp/linux/commit/3003e6a1c75431265ca5bc938166239ce722c2df
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Angel-Iglesias/Add-support-for-pressure-sensor-Bosch-BMP380/20220704-083456
git checkout 3003e6a1c75431265ca5bc938166239ce722c2df
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=s390 SHELL=/bin/bash drivers/iio/pressure/

If you fix the issue, kindly add following tag where applicable
Reported-by: kernel test robot <[email protected]>

All errors (new ones prefixed by >>):

In file included from drivers/iio/pressure/bmp280-core.c:23:
In file included from include/linux/regmap.h:20:
In file included from include/linux/iopoll.h:14:
In file included from include/linux/io.h:13:
In file included from arch/s390/include/asm/io.h:75:
include/asm-generic/io.h:464:31: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __raw_readb(PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr));
~~~~~~~~~~ ^
include/uapi/linux/byteorder/big_endian.h:37:59: note: expanded from macro '__le16_to_cpu'
#define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x))
^
include/uapi/linux/swab.h:102:54: note: expanded from macro '__swab16'
#define __swab16(x) (__u16)__builtin_bswap16((__u16)(x))
^
In file included from drivers/iio/pressure/bmp280-core.c:23:
In file included from include/linux/regmap.h:20:
In file included from include/linux/iopoll.h:14:
In file included from include/linux/io.h:13:
In file included from arch/s390/include/asm/io.h:75:
include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
~~~~~~~~~~ ^
include/uapi/linux/byteorder/big_endian.h:35:59: note: expanded from macro '__le32_to_cpu'
#define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
^
include/uapi/linux/swab.h:115:54: note: expanded from macro '__swab32'
#define __swab32(x) (__u32)__builtin_bswap32((__u32)(x))
^
In file included from drivers/iio/pressure/bmp280-core.c:23:
In file included from include/linux/regmap.h:20:
In file included from include/linux/iopoll.h:14:
In file included from include/linux/io.h:13:
In file included from arch/s390/include/asm/io.h:75:
include/asm-generic/io.h:501:33: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writeb(value, PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:511:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:521:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:609:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsb(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:617:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsw(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:625:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsl(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:634:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesb(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:643:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesw(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:652:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesl(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
>> drivers/iio/pressure/bmp280-core.c:979:5: error: call to undeclared function 'FIELD_PREP'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
FIELD_PREP(BMP380_MODE_MASK, BMP380_MODE_NORMAL));
^
12 warnings and 1 error generated.

vim +/FIELD_PREP +979 drivers/iio/pressure/bmp280-core.c

967
968 static int bmp380_chip_config(struct bmp280_data *data)
969 {
970 u8 osrs;
971 unsigned int tmp;
972 int ret;
973
974 /* configure power control register */
975 ret = regmap_write_bits(data->regmap, BMP380_REG_POWER_CONTROL,
976 BMP380_CTRL_SENSORS_MASK | BMP380_MODE_MASK,
977 BMP380_CTRL_SENSORS_PRESS_EN |
978 BMP380_CTRL_SENSORS_TEMP_EN |
> 979 FIELD_PREP(BMP380_MODE_MASK, BMP380_MODE_NORMAL));
980 if (ret < 0) {
981 dev_err(data->dev,
982 "failed to write operation control register\n");
983 return ret;
984 }
985
986 /* configure oversampling */
987 osrs = FIELD_PREP(BMP380_OSRS_TEMP_MASK, data->oversampling_temp) |
988 FIELD_PREP(BMP380_OSRS_PRESS_MASK, data->oversampling_press);
989
990 ret = regmap_write_bits(data->regmap, BMP380_REG_OSR,
991 BMP380_OSRS_TEMP_MASK | BMP380_OSRS_PRESS_MASK,
992 osrs);
993 if (ret < 0) {
994 dev_err(data->dev, "failed to write oversampling register\n");
995 return ret;
996 }
997
998 /* configure output data rate */
999 ret = regmap_write_bits(data->regmap, BMP380_REG_ODR,
1000 BMP380_ODRS_MASK, BMP380_ODRS_50HZ);
1001 if (ret < 0) {
1002 dev_err(data->dev, "failed to write ODR selection register\n");
1003 return ret;
1004 }
1005
1006 /* set filter data */
1007 ret = regmap_update_bits(data->regmap, BMP380_REG_CONFIG,
1008 BMP380_FILTER_MASK,
1009 FIELD_PREP(BMP380_FILTER_MASK, BMP380_FILTER_3X));
1010 if (ret < 0) {
1011 dev_err(data->dev, "failed to write config register\n");
1012 return ret;
1013 }
1014
1015 /* wait startup_time before verifying config changes */
1016 usleep_range(data->start_up_time, data->start_up_time + 100);
1017
1018 /* check config error flag */
1019 ret = regmap_read(data->regmap, BMP380_REG_ERROR, &tmp);
1020 if (ret < 0) {
1021 dev_err(data->dev,
1022 "failed to read error register\n");
1023 return ret;
1024 }
1025 if (tmp & BMP380_ERR_CONF_MASK) {
1026 dev_warn(data->dev,
1027 "sensor flagged configuration as incompatible\n");
1028 return -EINVAL;
1029 }
1030
1031 return 0;
1032 }
1033

--
0-DAY CI Kernel Test Service
https://01.org/lkp

2022-07-04 05:00:42

by Dan Carpenter

[permalink] [raw]

Subject: Re: [PATCH v2 4/5] iio: pressure: bmp280: Add support for BMP380 sensor family

On Mon, Jul 04, 2022 at 02:32:09AM +0200, Angel Iglesias wrote:
> +/* Send a command to BMP3XX sensors */
> +static int bmp380_cmd(struct bmp280_data *data, u8 cmd)
> +{
> + int ret;
> + unsigned int reg;
> +
> + /* check if device is ready to process a command */
> + ret = regmap_read(data->regmap, BMP380_REG_STATUS, &reg);
> + if (ret) {
> + dev_err(data->dev, "failed to read error register\n");
> + return ret;
> + }
> + if (!(cmd & BMP380_STATUS_CMD_RDY_MASK)) {

This looks like it should be "reg" instead of command?

> + dev_err(data->dev, "device is not ready to accept commands\n");
> + return -EBUSY;
> + }
> +
> + /* send command to process */
> + ret = regmap_write(data->regmap, BMP380_REG_CMD, cmd);
> + if (ret) {
> + dev_err(data->dev, "failed to send command to device\n");
> + return ret;
> + }
> + /* wait for 2ms for command to be proccessed */
> + usleep_range(data->start_up_time, data->start_up_time + 100);
> + /* check for command processing error */
> + ret = regmap_read(data->regmap, BMP380_REG_ERROR, &reg);
> + if (ret) {
> + dev_err(data->dev, "error reading ERROR reg\n");
> + return ret;
> + }
> + if (reg & BMP380_ERR_CMD_MASK) {
> + dev_err(data->dev, "error processing command 0x%X\n", cmd);
> + return -EINVAL;
> + }
> + dev_dbg(data->dev, "Command 0x%X proccessed successfully\n", cmd);
> +
> + return 0;
> +}

regards,
dan carpenter

2022-07-04 07:40:34

by Angel Iglesias

[permalink] [raw]

Subject: Re: [PATCH v2 4/5] iio: pressure: bmp280: Add support for BMP380 sensor family

On lun, 2022-07-04 at 07:52 +0300, Dan Carpenter wrote:
> On Mon, Jul 04, 2022 at 02:32:09AM +0200, Angel Iglesias wrote:
> > +/* Send a command to BMP3XX sensors */
> > +static int bmp380_cmd(struct bmp280_data *data, u8 cmd)
> > +{
> > +       int ret;
> > +       unsigned int reg;
> > +
> > +       /* check if device is ready to process a command */
> > +       ret = regmap_read(data->regmap, BMP380_REG_STATUS, &reg);
> > +       if (ret) {
> > +               dev_err(data->dev, "failed to read error
> > register\n");
> > +               return ret;
> > +       }
> > +       if (!(cmd & BMP380_STATUS_CMD_RDY_MASK)) {
>
> This looks like it should be "reg" instead of command?

Yes, it should. Thanks for the catch!

> > +               dev_err(data->dev, "device is not ready to accept
> > commands\n");
> > +               return -EBUSY;
> > +       }
> > +
> > +       /* send command to process */
> > +       ret = regmap_write(data->regmap, BMP380_REG_CMD, cmd);
> > +       if (ret) {
> > +               dev_err(data->dev, "failed to send command to
> > device\n");
> > +               return ret;
> > +       }
> > +       /* wait for 2ms for command to be proccessed */
> > +       usleep_range(data->start_up_time, data->start_up_time +
> > 100);
> > +       /* check for command processing error */
> > +       ret = regmap_read(data->regmap, BMP380_REG_ERROR, &reg);
> > +       if (ret) {
> > +               dev_err(data->dev, "error reading ERROR reg\n");
> > +               return ret;
> > +       }
> > +       if (reg & BMP380_ERR_CMD_MASK) {
> > +               dev_err(data->dev, "error processing command
> > 0x%X\n", cmd);
> > +               return -EINVAL;
> > +       }
> > +       dev_dbg(data->dev, "Command 0x%X proccessed
> > successfully\n", cmd);
> > +
> > +       return 0;
> > +}
>
> regards,
> dan carpenter