2 * Copyright (c) 2014 Intel Corporation
4 * Driver for Bosch Sensortec BMP180 and BMP280 digital pressure sensor.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP180-DS000-121.pdf
12 * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP280-DS001-12.pdf
15 #define pr_fmt(fmt) "bmp280: " fmt
17 #include <linux/module.h>
18 #include <linux/i2c.h>
19 #include <linux/acpi.h>
20 #include <linux/regmap.h>
21 #include <linux/delay.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/sysfs.h>
25 /* BMP280 specific registers */
26 #define BMP280_REG_TEMP_XLSB 0xFC
27 #define BMP280_REG_TEMP_LSB 0xFB
28 #define BMP280_REG_TEMP_MSB 0xFA
29 #define BMP280_REG_PRESS_XLSB 0xF9
30 #define BMP280_REG_PRESS_LSB 0xF8
31 #define BMP280_REG_PRESS_MSB 0xF7
33 #define BMP280_REG_CONFIG 0xF5
34 #define BMP280_REG_STATUS 0xF3
36 #define BMP280_REG_COMP_TEMP_START 0x88
37 #define BMP280_COMP_TEMP_REG_COUNT 6
39 #define BMP280_REG_COMP_PRESS_START 0x8E
40 #define BMP280_COMP_PRESS_REG_COUNT 18
42 #define BMP280_FILTER_MASK (BIT(4) | BIT(3) | BIT(2))
43 #define BMP280_FILTER_OFF 0
44 #define BMP280_FILTER_2X BIT(2)
45 #define BMP280_FILTER_4X BIT(3)
46 #define BMP280_FILTER_8X (BIT(3) | BIT(2))
47 #define BMP280_FILTER_16X BIT(4)
49 #define BMP280_OSRS_TEMP_MASK (BIT(7) | BIT(6) | BIT(5))
50 #define BMP280_OSRS_TEMP_SKIP 0
51 #define BMP280_OSRS_TEMP_1X BIT(5)
52 #define BMP280_OSRS_TEMP_2X BIT(6)
53 #define BMP280_OSRS_TEMP_4X (BIT(6) | BIT(5))
54 #define BMP280_OSRS_TEMP_8X BIT(7)
55 #define BMP280_OSRS_TEMP_16X (BIT(7) | BIT(5))
57 #define BMP280_OSRS_PRESS_MASK (BIT(4) | BIT(3) | BIT(2))
58 #define BMP280_OSRS_PRESS_SKIP 0
59 #define BMP280_OSRS_PRESS_1X BIT(2)
60 #define BMP280_OSRS_PRESS_2X BIT(3)
61 #define BMP280_OSRS_PRESS_4X (BIT(3) | BIT(2))
62 #define BMP280_OSRS_PRESS_8X BIT(4)
63 #define BMP280_OSRS_PRESS_16X (BIT(4) | BIT(2))
65 #define BMP280_MODE_MASK (BIT(1) | BIT(0))
66 #define BMP280_MODE_SLEEP 0
67 #define BMP280_MODE_FORCED BIT(0)
68 #define BMP280_MODE_NORMAL (BIT(1) | BIT(0))
70 /* BMP180 specific registers */
71 #define BMP180_REG_OUT_XLSB 0xF8
72 #define BMP180_REG_OUT_LSB 0xF7
73 #define BMP180_REG_OUT_MSB 0xF6
75 #define BMP180_REG_CALIB_START 0xAA
76 #define BMP180_REG_CALIB_COUNT 22
78 #define BMP180_MEAS_SCO BIT(5)
79 #define BMP180_MEAS_TEMP (0x0E | BMP180_MEAS_SCO)
80 #define BMP180_MEAS_PRESS_X(oss) ((oss) << 6 | 0x14 | BMP180_MEAS_SCO)
81 #define BMP180_MEAS_PRESS_1X BMP180_MEAS_PRESS_X(0)
82 #define BMP180_MEAS_PRESS_2X BMP180_MEAS_PRESS_X(1)
83 #define BMP180_MEAS_PRESS_4X BMP180_MEAS_PRESS_X(2)
84 #define BMP180_MEAS_PRESS_8X BMP180_MEAS_PRESS_X(3)
86 /* BMP180 and BMP280 common registers */
87 #define BMP280_REG_CTRL_MEAS 0xF4
88 #define BMP280_REG_RESET 0xE0
89 #define BMP280_REG_ID 0xD0
91 #define BMP180_CHIP_ID 0x55
92 #define BMP280_CHIP_ID 0x58
93 #define BMP280_SOFT_RESET_VAL 0xB6
96 struct i2c_client
*client
;
98 struct regmap
*regmap
;
99 const struct bmp280_chip_info
*chip_info
;
102 * Carryover value from temperature conversion, used in pressure
108 struct bmp280_chip_info
{
109 const struct regmap_config
*regmap_config
;
111 int (*chip_config
)(struct bmp280_data
*);
112 int (*read_temp
)(struct bmp280_data
*, int *);
113 int (*read_press
)(struct bmp280_data
*, int *, int *);
117 * These enums are used for indexing into the array of compensation
118 * parameters for BMP280.
121 enum { P1
, P2
, P3
, P4
, P5
, P6
, P7
, P8
, P9
};
123 static const struct iio_chan_spec bmp280_channels
[] = {
125 .type
= IIO_PRESSURE
,
126 .info_mask_separate
= BIT(IIO_CHAN_INFO_PROCESSED
),
130 .info_mask_separate
= BIT(IIO_CHAN_INFO_PROCESSED
),
134 static bool bmp280_is_writeable_reg(struct device
*dev
, unsigned int reg
)
137 case BMP280_REG_CONFIG
:
138 case BMP280_REG_CTRL_MEAS
:
139 case BMP280_REG_RESET
:
146 static bool bmp280_is_volatile_reg(struct device
*dev
, unsigned int reg
)
149 case BMP280_REG_TEMP_XLSB
:
150 case BMP280_REG_TEMP_LSB
:
151 case BMP280_REG_TEMP_MSB
:
152 case BMP280_REG_PRESS_XLSB
:
153 case BMP280_REG_PRESS_LSB
:
154 case BMP280_REG_PRESS_MSB
:
155 case BMP280_REG_STATUS
:
162 static const struct regmap_config bmp280_regmap_config
= {
166 .max_register
= BMP280_REG_TEMP_XLSB
,
167 .cache_type
= REGCACHE_RBTREE
,
169 .writeable_reg
= bmp280_is_writeable_reg
,
170 .volatile_reg
= bmp280_is_volatile_reg
,
174 * Returns temperature in DegC, resolution is 0.01 DegC. Output value of
175 * "5123" equals 51.23 DegC. t_fine carries fine temperature as global
178 * Taken from datasheet, Section 3.11.3, "Compensation formula".
180 static s32
bmp280_compensate_temp(struct bmp280_data
*data
,
185 __le16 buf
[BMP280_COMP_TEMP_REG_COUNT
/ 2];
187 ret
= regmap_bulk_read(data
->regmap
, BMP280_REG_COMP_TEMP_START
,
188 buf
, BMP280_COMP_TEMP_REG_COUNT
);
190 dev_err(&data
->client
->dev
,
191 "failed to read temperature calibration parameters\n");
196 * The double casts are necessary because le16_to_cpu returns an
197 * unsigned 16-bit value. Casting that value directly to a
198 * signed 32-bit will not do proper sign extension.
200 * Conversely, T1 and P1 are unsigned values, so they can be
201 * cast straight to the larger type.
203 var1
= (((adc_temp
>> 3) - ((s32
)le16_to_cpu(buf
[T1
]) << 1)) *
204 ((s32
)(s16
)le16_to_cpu(buf
[T2
]))) >> 11;
205 var2
= (((((adc_temp
>> 4) - ((s32
)le16_to_cpu(buf
[T1
]))) *
206 ((adc_temp
>> 4) - ((s32
)le16_to_cpu(buf
[T1
])))) >> 12) *
207 ((s32
)(s16
)le16_to_cpu(buf
[T3
]))) >> 14;
208 data
->t_fine
= var1
+ var2
;
210 return (data
->t_fine
* 5 + 128) >> 8;
214 * Returns pressure in Pa as unsigned 32 bit integer in Q24.8 format (24
215 * integer bits and 8 fractional bits). Output value of "24674867"
216 * represents 24674867/256 = 96386.2 Pa = 963.862 hPa
218 * Taken from datasheet, Section 3.11.3, "Compensation formula".
220 static u32
bmp280_compensate_press(struct bmp280_data
*data
,
225 __le16 buf
[BMP280_COMP_PRESS_REG_COUNT
/ 2];
227 ret
= regmap_bulk_read(data
->regmap
, BMP280_REG_COMP_PRESS_START
,
228 buf
, BMP280_COMP_PRESS_REG_COUNT
);
230 dev_err(&data
->client
->dev
,
231 "failed to read pressure calibration parameters\n");
235 var1
= ((s64
)data
->t_fine
) - 128000;
236 var2
= var1
* var1
* (s64
)(s16
)le16_to_cpu(buf
[P6
]);
237 var2
+= (var1
* (s64
)(s16
)le16_to_cpu(buf
[P5
])) << 17;
238 var2
+= ((s64
)(s16
)le16_to_cpu(buf
[P4
])) << 35;
239 var1
= ((var1
* var1
* (s64
)(s16
)le16_to_cpu(buf
[P3
])) >> 8) +
240 ((var1
* (s64
)(s16
)le16_to_cpu(buf
[P2
])) << 12);
241 var1
= ((((s64
)1) << 47) + var1
) * ((s64
)le16_to_cpu(buf
[P1
])) >> 33;
246 p
= ((((s64
)1048576 - adc_press
) << 31) - var2
) * 3125;
247 p
= div64_s64(p
, var1
);
248 var1
= (((s64
)(s16
)le16_to_cpu(buf
[P9
])) * (p
>> 13) * (p
>> 13)) >> 25;
249 var2
= (((s64
)(s16
)le16_to_cpu(buf
[P8
])) * p
) >> 19;
250 p
= ((p
+ var1
+ var2
) >> 8) + (((s64
)(s16
)le16_to_cpu(buf
[P7
])) << 4);
255 static int bmp280_read_temp(struct bmp280_data
*data
,
260 s32 adc_temp
, comp_temp
;
262 ret
= regmap_bulk_read(data
->regmap
, BMP280_REG_TEMP_MSB
,
265 dev_err(&data
->client
->dev
, "failed to read temperature\n");
269 adc_temp
= be32_to_cpu(tmp
) >> 12;
270 comp_temp
= bmp280_compensate_temp(data
, adc_temp
);
273 * val might be NULL if we're called by the read_press routine,
274 * who only cares about the carry over t_fine value.
277 *val
= comp_temp
* 10;
284 static int bmp280_read_press(struct bmp280_data
*data
,
292 /* Read and compensate temperature so we get a reading of t_fine. */
293 ret
= bmp280_read_temp(data
, NULL
);
297 ret
= regmap_bulk_read(data
->regmap
, BMP280_REG_PRESS_MSB
,
300 dev_err(&data
->client
->dev
, "failed to read pressure\n");
304 adc_press
= be32_to_cpu(tmp
) >> 12;
305 comp_press
= bmp280_compensate_press(data
, adc_press
);
310 return IIO_VAL_FRACTIONAL
;
313 static int bmp280_read_raw(struct iio_dev
*indio_dev
,
314 struct iio_chan_spec
const *chan
,
315 int *val
, int *val2
, long mask
)
318 struct bmp280_data
*data
= iio_priv(indio_dev
);
320 mutex_lock(&data
->lock
);
323 case IIO_CHAN_INFO_PROCESSED
:
324 switch (chan
->type
) {
326 ret
= data
->chip_info
->read_press(data
, val
, val2
);
329 ret
= data
->chip_info
->read_temp(data
, val
);
341 mutex_unlock(&data
->lock
);
346 static const struct iio_info bmp280_info
= {
347 .driver_module
= THIS_MODULE
,
348 .read_raw
= &bmp280_read_raw
,
351 static int bmp280_chip_config(struct bmp280_data
*data
)
355 ret
= regmap_update_bits(data
->regmap
, BMP280_REG_CTRL_MEAS
,
356 BMP280_OSRS_TEMP_MASK
|
357 BMP280_OSRS_PRESS_MASK
|
359 BMP280_OSRS_TEMP_2X
|
360 BMP280_OSRS_PRESS_16X
|
363 dev_err(&data
->client
->dev
,
364 "failed to write ctrl_meas register\n");
368 ret
= regmap_update_bits(data
->regmap
, BMP280_REG_CONFIG
,
372 dev_err(&data
->client
->dev
,
373 "failed to write config register\n");
380 static const struct bmp280_chip_info bmp280_chip_info
= {
381 .regmap_config
= &bmp280_regmap_config
,
382 .chip_config
= bmp280_chip_config
,
383 .read_temp
= bmp280_read_temp
,
384 .read_press
= bmp280_read_press
,
387 static bool bmp180_is_writeable_reg(struct device
*dev
, unsigned int reg
)
390 case BMP280_REG_CTRL_MEAS
:
391 case BMP280_REG_RESET
:
398 static bool bmp180_is_volatile_reg(struct device
*dev
, unsigned int reg
)
401 case BMP180_REG_OUT_XLSB
:
402 case BMP180_REG_OUT_LSB
:
403 case BMP180_REG_OUT_MSB
:
404 case BMP280_REG_CTRL_MEAS
:
411 static const struct regmap_config bmp180_regmap_config
= {
415 .max_register
= BMP180_REG_OUT_XLSB
,
416 .cache_type
= REGCACHE_RBTREE
,
418 .writeable_reg
= bmp180_is_writeable_reg
,
419 .volatile_reg
= bmp180_is_volatile_reg
,
422 static int bmp180_measure(struct bmp280_data
*data
, u8 ctrl_meas
)
425 const int conversion_time_max
[] = { 4500, 7500, 13500, 25500 };
426 unsigned int delay_us
;
429 ret
= regmap_write(data
->regmap
, BMP280_REG_CTRL_MEAS
, ctrl_meas
);
433 if (ctrl_meas
== BMP180_MEAS_TEMP
)
436 delay_us
= conversion_time_max
[ilog2(8)];
438 usleep_range(delay_us
, delay_us
+ 1000);
440 ret
= regmap_read(data
->regmap
, BMP280_REG_CTRL_MEAS
, &ctrl
);
444 /* The value of this bit reset to "0" after conversion is complete */
445 if (ctrl
& BMP180_MEAS_SCO
)
451 static int bmp180_read_adc_temp(struct bmp280_data
*data
, int *val
)
456 ret
= bmp180_measure(data
, BMP180_MEAS_TEMP
);
460 ret
= regmap_bulk_read(data
->regmap
, BMP180_REG_OUT_MSB
, (u8
*)&tmp
, 2);
464 *val
= be16_to_cpu(tmp
);
470 * These enums are used for indexing into the array of calibration
471 * coefficients for BMP180.
473 enum { AC1
, AC2
, AC3
, AC4
, AC5
, AC6
, B1
, B2
, MB
, MC
, MD
};
475 struct bmp180_calib
{
489 static int bmp180_read_calib(struct bmp280_data
*data
,
490 struct bmp180_calib
*calib
)
494 __be16 buf
[BMP180_REG_CALIB_COUNT
/ 2];
496 ret
= regmap_bulk_read(data
->regmap
, BMP180_REG_CALIB_START
, buf
,
502 /* None of the words has the value 0 or 0xFFFF */
503 for (i
= 0; i
< ARRAY_SIZE(buf
); i
++) {
504 if (buf
[i
] == cpu_to_be16(0) || buf
[i
] == cpu_to_be16(0xffff))
508 calib
->AC1
= be16_to_cpu(buf
[AC1
]);
509 calib
->AC2
= be16_to_cpu(buf
[AC2
]);
510 calib
->AC3
= be16_to_cpu(buf
[AC3
]);
511 calib
->AC4
= be16_to_cpu(buf
[AC4
]);
512 calib
->AC5
= be16_to_cpu(buf
[AC5
]);
513 calib
->AC6
= be16_to_cpu(buf
[AC6
]);
514 calib
->B1
= be16_to_cpu(buf
[B1
]);
515 calib
->B2
= be16_to_cpu(buf
[B2
]);
516 calib
->MB
= be16_to_cpu(buf
[MB
]);
517 calib
->MC
= be16_to_cpu(buf
[MC
]);
518 calib
->MD
= be16_to_cpu(buf
[MD
]);
524 * Returns temperature in DegC, resolution is 0.1 DegC.
525 * t_fine carries fine temperature as global value.
527 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
529 static s32
bmp180_compensate_temp(struct bmp280_data
*data
, s32 adc_temp
)
533 struct bmp180_calib calib
;
535 ret
= bmp180_read_calib(data
, &calib
);
537 dev_err(&data
->client
->dev
,
538 "failed to read calibration coefficients\n");
542 x1
= ((adc_temp
- calib
.AC6
) * calib
.AC5
) >> 15;
543 x2
= (calib
.MC
<< 11) / (x1
+ calib
.MD
);
544 data
->t_fine
= x1
+ x2
;
546 return (data
->t_fine
+ 8) >> 4;
549 static int bmp180_read_temp(struct bmp280_data
*data
, int *val
)
552 s32 adc_temp
, comp_temp
;
554 ret
= bmp180_read_adc_temp(data
, &adc_temp
);
558 comp_temp
= bmp180_compensate_temp(data
, adc_temp
);
561 * val might be NULL if we're called by the read_press routine,
562 * who only cares about the carry over t_fine value.
565 *val
= comp_temp
* 100;
572 static int bmp180_read_adc_press(struct bmp280_data
*data
, int *val
)
578 ret
= bmp180_measure(data
, BMP180_MEAS_PRESS_X(oss
));
582 ret
= regmap_bulk_read(data
->regmap
, BMP180_REG_OUT_MSB
, (u8
*)&tmp
, 3);
586 *val
= (be32_to_cpu(tmp
) >> 8) >> (8 - oss
);
592 * Returns pressure in Pa, resolution is 1 Pa.
594 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
596 static u32
bmp180_compensate_press(struct bmp280_data
*data
, s32 adc_press
)
603 struct bmp180_calib calib
;
605 ret
= bmp180_read_calib(data
, &calib
);
607 dev_err(&data
->client
->dev
,
608 "failed to read calibration coefficients\n");
612 b6
= data
->t_fine
- 4000;
613 x1
= (calib
.B2
* (b6
* b6
>> 12)) >> 11;
614 x2
= calib
.AC2
* b6
>> 11;
616 b3
= ((((s32
)calib
.AC1
* 4 + x3
) << oss
) + 2) / 4;
617 x1
= calib
.AC3
* b6
>> 13;
618 x2
= (calib
.B1
* ((b6
* b6
) >> 12)) >> 16;
619 x3
= (x1
+ x2
+ 2) >> 2;
620 b4
= calib
.AC4
* (u32
)(x3
+ 32768) >> 15;
621 b7
= ((u32
)adc_press
- b3
) * (50000 >> oss
);
627 x1
= (p
>> 8) * (p
>> 8);
628 x1
= (x1
* 3038) >> 16;
629 x2
= (-7357 * p
) >> 16;
631 return p
+ ((x1
+ x2
+ 3791) >> 4);
634 static int bmp180_read_press(struct bmp280_data
*data
,
641 /* Read and compensate temperature so we get a reading of t_fine. */
642 ret
= bmp180_read_temp(data
, NULL
);
646 ret
= bmp180_read_adc_press(data
, &adc_press
);
650 comp_press
= bmp180_compensate_press(data
, adc_press
);
655 return IIO_VAL_FRACTIONAL
;
658 static int bmp180_chip_config(struct bmp280_data
*data
)
663 static const struct bmp280_chip_info bmp180_chip_info
= {
664 .regmap_config
= &bmp180_regmap_config
,
665 .chip_config
= bmp180_chip_config
,
666 .read_temp
= bmp180_read_temp
,
667 .read_press
= bmp180_read_press
,
670 static int bmp280_probe(struct i2c_client
*client
,
671 const struct i2c_device_id
*id
)
674 struct iio_dev
*indio_dev
;
675 struct bmp280_data
*data
;
676 unsigned int chip_id
;
678 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*data
));
682 data
= iio_priv(indio_dev
);
683 mutex_init(&data
->lock
);
684 data
->client
= client
;
686 indio_dev
->dev
.parent
= &client
->dev
;
687 indio_dev
->name
= id
->name
;
688 indio_dev
->channels
= bmp280_channels
;
689 indio_dev
->num_channels
= ARRAY_SIZE(bmp280_channels
);
690 indio_dev
->info
= &bmp280_info
;
691 indio_dev
->modes
= INDIO_DIRECT_MODE
;
693 switch (id
->driver_data
) {
695 data
->chip_info
= &bmp180_chip_info
;
698 data
->chip_info
= &bmp280_chip_info
;
704 data
->regmap
= devm_regmap_init_i2c(client
,
705 data
->chip_info
->regmap_config
);
706 if (IS_ERR(data
->regmap
)) {
707 dev_err(&client
->dev
, "failed to allocate register map\n");
708 return PTR_ERR(data
->regmap
);
711 ret
= regmap_read(data
->regmap
, BMP280_REG_ID
, &chip_id
);
714 if (chip_id
!= id
->driver_data
) {
715 dev_err(&client
->dev
, "bad chip id. expected %x got %x\n",
716 BMP280_CHIP_ID
, chip_id
);
720 ret
= data
->chip_info
->chip_config(data
);
724 return devm_iio_device_register(&client
->dev
, indio_dev
);
727 static const struct acpi_device_id bmp280_acpi_match
[] = {
728 {"BMP0280", BMP280_CHIP_ID
},
729 {"BMP0180", BMP180_CHIP_ID
},
730 {"BMP0085", BMP180_CHIP_ID
},
733 MODULE_DEVICE_TABLE(acpi
, bmp280_acpi_match
);
735 static const struct i2c_device_id bmp280_id
[] = {
736 {"bmp280", BMP280_CHIP_ID
},
737 {"bmp180", BMP180_CHIP_ID
},
738 {"bmp085", BMP180_CHIP_ID
},
741 MODULE_DEVICE_TABLE(i2c
, bmp280_id
);
743 static struct i2c_driver bmp280_driver
= {
746 .acpi_match_table
= ACPI_PTR(bmp280_acpi_match
),
748 .probe
= bmp280_probe
,
749 .id_table
= bmp280_id
,
751 module_i2c_driver(bmp280_driver
);
753 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
754 MODULE_DESCRIPTION("Driver for Bosch Sensortec BMP180/BMP280 pressure and temperature sensor");
755 MODULE_LICENSE("GPL v2");