1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2010 Christoph Mair <christoph.mair@gmail.com>
4 * Copyright (c) 2012 Bosch Sensortec GmbH
5 * Copyright (c) 2012 Unixphere AB
6 * Copyright (c) 2014 Intel Corporation
7 * Copyright (c) 2016 Linus Walleij <linus.walleij@linaro.org>
8 *
9 * Driver for Bosch Sensortec BMP180 and BMP280 digital pressure sensor.
10 *
11 * Datasheet:
12 * https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf
13 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf
14 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bme280-ds002.pdf
15 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf
16 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp390-ds002.pdf
17 * https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp581-ds004.pdf
18 *
19 * Sensor API:
20 * https://github.com/boschsensortec/BME280_SensorAPI
21 * https://github.com/boschsensortec/BMP3_SensorAPI
22 * https://github.com/boschsensortec/BMP5_SensorAPI
23 *
24 * Notice:
25 * The link to the bmp180 datasheet points to an outdated version missing these changes:
26 * - Changed document referral from ANP015 to BST-MPS-AN004-00 on page 26
27 * - Updated equation for B3 param on section 3.5 to ((((long)AC1 * 4 + X3) << oss) + 2) / 4
28 * - Updated RoHS directive to 2011/65/EU effective 8 June 2011 on page 26
29 */
30
31 #define pr_fmt(fmt) "bmp280: " fmt
32
33 #include <linux/bitops.h>
34 #include <linux/bitfield.h>
35 #include <linux/cleanup.h>
36 #include <linux/completion.h>
37 #include <linux/delay.h>
38 #include <linux/device.h>
39 #include <linux/gpio/consumer.h>
40 #include <linux/interrupt.h>
41 #include <linux/irq.h> /* For irq_get_irq_data() */
42 #include <linux/module.h>
43 #include <linux/nvmem-provider.h>
44 #include <linux/pm_runtime.h>
45 #include <linux/property.h>
46 #include <linux/random.h>
47 #include <linux/regmap.h>
48 #include <linux/regulator/consumer.h>
49 #include <linux/types.h>
50
51 #include <linux/iio/buffer.h>
52 #include <linux/iio/iio.h>
53 #include <linux/iio/trigger.h>
54 #include <linux/iio/trigger_consumer.h>
55 #include <linux/iio/triggered_buffer.h>
56
57 #include <linux/unaligned.h>
58
59 #include "bmp280.h"
60
61 /*
62 * These enums are used for indexing into the array of calibration
63 * coefficients for BMP180.
64 */
65 enum { AC1, AC2, AC3, AC4, AC5, AC6, B1, B2, MB, MC, MD };
66
67 enum bmp380_odr {
68 BMP380_ODR_200HZ,
69 BMP380_ODR_100HZ,
70 BMP380_ODR_50HZ,
71 BMP380_ODR_25HZ,
72 BMP380_ODR_12_5HZ,
73 BMP380_ODR_6_25HZ,
74 BMP380_ODR_3_125HZ,
75 BMP380_ODR_1_5625HZ,
76 BMP380_ODR_0_78HZ,
77 BMP380_ODR_0_39HZ,
78 BMP380_ODR_0_2HZ,
79 BMP380_ODR_0_1HZ,
80 BMP380_ODR_0_05HZ,
81 BMP380_ODR_0_02HZ,
82 BMP380_ODR_0_01HZ,
83 BMP380_ODR_0_006HZ,
84 BMP380_ODR_0_003HZ,
85 BMP380_ODR_0_0015HZ,
86 };
87
88 enum bmp580_odr {
89 BMP580_ODR_240HZ,
90 BMP580_ODR_218HZ,
91 BMP580_ODR_199HZ,
92 BMP580_ODR_179HZ,
93 BMP580_ODR_160HZ,
94 BMP580_ODR_149HZ,
95 BMP580_ODR_140HZ,
96 BMP580_ODR_129HZ,
97 BMP580_ODR_120HZ,
98 BMP580_ODR_110HZ,
99 BMP580_ODR_100HZ,
100 BMP580_ODR_89HZ,
101 BMP580_ODR_80HZ,
102 BMP580_ODR_70HZ,
103 BMP580_ODR_60HZ,
104 BMP580_ODR_50HZ,
105 BMP580_ODR_45HZ,
106 BMP580_ODR_40HZ,
107 BMP580_ODR_35HZ,
108 BMP580_ODR_30HZ,
109 BMP580_ODR_25HZ,
110 BMP580_ODR_20HZ,
111 BMP580_ODR_15HZ,
112 BMP580_ODR_10HZ,
113 BMP580_ODR_5HZ,
114 BMP580_ODR_4HZ,
115 BMP580_ODR_3HZ,
116 BMP580_ODR_2HZ,
117 BMP580_ODR_1HZ,
118 BMP580_ODR_0_5HZ,
119 BMP580_ODR_0_25HZ,
120 BMP580_ODR_0_125HZ,
121 };
122
123 /*
124 * These enums are used for indexing into the array of compensation
125 * parameters for BMP280.
126 */
127 enum { T1, T2, T3, P1, P2, P3, P4, P5, P6, P7, P8, P9 };
128
129 enum {
130 /* Temperature calib indexes */
131 BMP380_T1 = 0,
132 BMP380_T2 = 2,
133 BMP380_T3 = 4,
134 /* Pressure calib indexes */
135 BMP380_P1 = 5,
136 BMP380_P2 = 7,
137 BMP380_P3 = 9,
138 BMP380_P4 = 10,
139 BMP380_P5 = 11,
140 BMP380_P6 = 13,
141 BMP380_P7 = 15,
142 BMP380_P8 = 16,
143 BMP380_P9 = 17,
144 BMP380_P10 = 19,
145 BMP380_P11 = 20,
146 };
147
148 enum bmp280_scan {
149 BMP280_PRESS,
150 BMP280_TEMP,
151 BME280_HUMID,
152 };
153
154 static const struct iio_chan_spec bmp280_channels[] = {
155 {
156 .type = IIO_PRESSURE,
157 /* PROCESSED maintained for ABI backwards compatibility */
158 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
159 BIT(IIO_CHAN_INFO_RAW) |
160 BIT(IIO_CHAN_INFO_SCALE) |
161 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
162 .scan_index = 0,
163 .scan_type = {
164 .sign = 'u',
165 .realbits = 32,
166 .storagebits = 32,
167 .endianness = IIO_CPU,
168 },
169 },
170 {
171 .type = IIO_TEMP,
172 /* PROCESSED maintained for ABI backwards compatibility */
173 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
174 BIT(IIO_CHAN_INFO_RAW) |
175 BIT(IIO_CHAN_INFO_SCALE) |
176 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
177 .scan_index = 1,
178 .scan_type = {
179 .sign = 's',
180 .realbits = 32,
181 .storagebits = 32,
182 .endianness = IIO_CPU,
183 },
184 },
185 IIO_CHAN_SOFT_TIMESTAMP(2),
186 };
187
188 static const struct iio_chan_spec bme280_channels[] = {
189 {
190 .type = IIO_PRESSURE,
191 /* PROCESSED maintained for ABI backwards compatibility */
192 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
193 BIT(IIO_CHAN_INFO_RAW) |
194 BIT(IIO_CHAN_INFO_SCALE) |
195 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
196 .scan_index = 0,
197 .scan_type = {
198 .sign = 'u',
199 .realbits = 32,
200 .storagebits = 32,
201 .endianness = IIO_CPU,
202 },
203 },
204 {
205 .type = IIO_TEMP,
206 /* PROCESSED maintained for ABI backwards compatibility */
207 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
208 BIT(IIO_CHAN_INFO_RAW) |
209 BIT(IIO_CHAN_INFO_SCALE) |
210 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
211 .scan_index = 1,
212 .scan_type = {
213 .sign = 's',
214 .realbits = 32,
215 .storagebits = 32,
216 .endianness = IIO_CPU,
217 },
218 },
219 {
220 .type = IIO_HUMIDITYRELATIVE,
221 /* PROCESSED maintained for ABI backwards compatibility */
222 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
223 BIT(IIO_CHAN_INFO_RAW) |
224 BIT(IIO_CHAN_INFO_SCALE) |
225 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
226 .scan_index = 2,
227 .scan_type = {
228 .sign = 'u',
229 .realbits = 32,
230 .storagebits = 32,
231 .endianness = IIO_CPU,
232 },
233 },
234 IIO_CHAN_SOFT_TIMESTAMP(3),
235 };
236
237 static const struct iio_chan_spec bmp380_channels[] = {
238 {
239 .type = IIO_PRESSURE,
240 /* PROCESSED maintained for ABI backwards compatibility */
241 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
242 BIT(IIO_CHAN_INFO_RAW) |
243 BIT(IIO_CHAN_INFO_SCALE) |
244 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
245 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) |
246 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),
247 .scan_index = 0,
248 .scan_type = {
249 .sign = 'u',
250 .realbits = 32,
251 .storagebits = 32,
252 .endianness = IIO_CPU,
253 },
254 },
255 {
256 .type = IIO_TEMP,
257 /* PROCESSED maintained for ABI backwards compatibility */
258 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
259 BIT(IIO_CHAN_INFO_RAW) |
260 BIT(IIO_CHAN_INFO_SCALE) |
261 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
262 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) |
263 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),
264 .scan_index = 1,
265 .scan_type = {
266 .sign = 's',
267 .realbits = 32,
268 .storagebits = 32,
269 .endianness = IIO_CPU,
270 },
271 },
272 IIO_CHAN_SOFT_TIMESTAMP(2),
273 };
274
275 static const struct iio_chan_spec bmp580_channels[] = {
276 {
277 .type = IIO_PRESSURE,
278 /* PROCESSED maintained for ABI backwards compatibility */
279 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
280 BIT(IIO_CHAN_INFO_RAW) |
281 BIT(IIO_CHAN_INFO_SCALE) |
282 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
283 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) |
284 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),
285 .scan_index = 0,
286 .scan_type = {
287 .sign = 'u',
288 .realbits = 24,
289 .storagebits = 32,
290 .endianness = IIO_LE,
291 },
292 },
293 {
294 .type = IIO_TEMP,
295 /* PROCESSED maintained for ABI backwards compatibility */
296 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
297 BIT(IIO_CHAN_INFO_RAW) |
298 BIT(IIO_CHAN_INFO_SCALE) |
299 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
300 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) |
301 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),
302 .scan_index = 1,
303 .scan_type = {
304 .sign = 's',
305 .realbits = 24,
306 .storagebits = 32,
307 .endianness = IIO_LE,
308 },
309 },
310 IIO_CHAN_SOFT_TIMESTAMP(2),
311 };
312
bmp280_read_calib(struct bmp280_data * data)313 static int bmp280_read_calib(struct bmp280_data *data)
314 {
315 struct bmp280_calib *calib = &data->calib.bmp280;
316 int ret;
317
318 /* Read temperature and pressure calibration values. */
319 ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_TEMP_START,
320 data->bmp280_cal_buf,
321 sizeof(data->bmp280_cal_buf));
322 if (ret) {
323 dev_err(data->dev,
324 "failed to read calibration parameters\n");
325 return ret;
326 }
327
328 /* Toss calibration data into the entropy pool */
329 add_device_randomness(data->bmp280_cal_buf,
330 sizeof(data->bmp280_cal_buf));
331
332 /* Parse temperature calibration values. */
333 calib->T1 = le16_to_cpu(data->bmp280_cal_buf[T1]);
334 calib->T2 = le16_to_cpu(data->bmp280_cal_buf[T2]);
335 calib->T3 = le16_to_cpu(data->bmp280_cal_buf[T3]);
336
337 /* Parse pressure calibration values. */
338 calib->P1 = le16_to_cpu(data->bmp280_cal_buf[P1]);
339 calib->P2 = le16_to_cpu(data->bmp280_cal_buf[P2]);
340 calib->P3 = le16_to_cpu(data->bmp280_cal_buf[P3]);
341 calib->P4 = le16_to_cpu(data->bmp280_cal_buf[P4]);
342 calib->P5 = le16_to_cpu(data->bmp280_cal_buf[P5]);
343 calib->P6 = le16_to_cpu(data->bmp280_cal_buf[P6]);
344 calib->P7 = le16_to_cpu(data->bmp280_cal_buf[P7]);
345 calib->P8 = le16_to_cpu(data->bmp280_cal_buf[P8]);
346 calib->P9 = le16_to_cpu(data->bmp280_cal_buf[P9]);
347
348 return 0;
349 }
350
351 /*
352 * These enums are used for indexing into the array of humidity parameters
353 * for BME280. Due to some weird indexing, unaligned BE/LE accesses co-exist in
354 * order to prepare the FIELD_{GET/PREP}() fields. Table 16 in Section 4.2.2 of
355 * the datasheet.
356 */
357 enum { H2 = 0, H3 = 2, H4 = 3, H5 = 4, H6 = 6 };
358
bme280_read_calib(struct bmp280_data * data)359 static int bme280_read_calib(struct bmp280_data *data)
360 {
361 struct bmp280_calib *calib = &data->calib.bmp280;
362 struct device *dev = data->dev;
363 s16 h4_upper, h4_lower, tmp_1, tmp_2, tmp_3;
364 unsigned int tmp;
365 int ret;
366
367 /* Load shared calibration params with bmp280 first */
368 ret = bmp280_read_calib(data);
369 if (ret)
370 return ret;
371
372 ret = regmap_read(data->regmap, BME280_REG_COMP_H1, &tmp);
373 if (ret) {
374 dev_err(dev, "failed to read H1 comp value\n");
375 return ret;
376 }
377 calib->H1 = tmp;
378
379 ret = regmap_bulk_read(data->regmap, BME280_REG_COMP_H2,
380 data->bme280_humid_cal_buf,
381 sizeof(data->bme280_humid_cal_buf));
382 if (ret) {
383 dev_err(dev, "failed to read humidity calibration values\n");
384 return ret;
385 }
386
387 calib->H2 = get_unaligned_le16(&data->bme280_humid_cal_buf[H2]);
388 calib->H3 = data->bme280_humid_cal_buf[H3];
389 tmp_1 = get_unaligned_be16(&data->bme280_humid_cal_buf[H4]);
390 tmp_2 = FIELD_GET(BME280_COMP_H4_GET_MASK_UP, tmp_1);
391 h4_upper = FIELD_PREP(BME280_COMP_H4_PREP_MASK_UP, tmp_2);
392 h4_lower = FIELD_GET(BME280_COMP_H4_MASK_LOW, tmp_1);
393 calib->H4 = sign_extend32(h4_upper | h4_lower, 11);
394 tmp_3 = get_unaligned_le16(&data->bme280_humid_cal_buf[H5]);
395 calib->H5 = sign_extend32(FIELD_GET(BME280_COMP_H5_MASK, tmp_3), 11);
396 calib->H6 = data->bme280_humid_cal_buf[H6];
397
398 return 0;
399 }
400
bme280_read_humid_adc(struct bmp280_data * data,u16 * adc_humidity)401 static int bme280_read_humid_adc(struct bmp280_data *data, u16 *adc_humidity)
402 {
403 u16 value_humidity;
404 int ret;
405
406 ret = regmap_bulk_read(data->regmap, BME280_REG_HUMIDITY_MSB,
407 &data->be16, BME280_NUM_HUMIDITY_BYTES);
408 if (ret) {
409 dev_err(data->dev, "failed to read humidity\n");
410 return ret;
411 }
412
413 value_humidity = be16_to_cpu(data->be16);
414 if (value_humidity == BMP280_HUMIDITY_SKIPPED) {
415 dev_err(data->dev, "reading humidity skipped\n");
416 return -EIO;
417 }
418 *adc_humidity = value_humidity;
419
420 return 0;
421 }
422
423 /*
424 * Returns humidity in percent, resolution is 0.01 percent. Output value of
425 * "47445" represents 47445/1024 = 46.333 %RH.
426 *
427 * Taken from BME280 datasheet, Section 4.2.3, "Compensation formula".
428 */
bme280_compensate_humidity(struct bmp280_data * data,u16 adc_humidity,s32 t_fine)429 static u32 bme280_compensate_humidity(struct bmp280_data *data,
430 u16 adc_humidity, s32 t_fine)
431 {
432 struct bmp280_calib *calib = &data->calib.bmp280;
433 s32 var;
434
435 var = t_fine - (s32)76800;
436 var = (((((s32)adc_humidity << 14) - (calib->H4 << 20) - (calib->H5 * var))
437 + (s32)16384) >> 15) * (((((((var * calib->H6) >> 10)
438 * (((var * (s32)calib->H3) >> 11) + (s32)32768)) >> 10)
439 + (s32)2097152) * calib->H2 + 8192) >> 14);
440 var -= ((((var >> 15) * (var >> 15)) >> 7) * (s32)calib->H1) >> 4;
441
442 var = clamp_val(var, 0, 419430400);
443
444 return var >> 12;
445 }
446
bmp280_read_temp_adc(struct bmp280_data * data,u32 * adc_temp)447 static int bmp280_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
448 {
449 u32 value_temp;
450 int ret;
451
452 ret = regmap_bulk_read(data->regmap, BMP280_REG_TEMP_MSB,
453 data->buf, BMP280_NUM_TEMP_BYTES);
454 if (ret) {
455 dev_err(data->dev, "failed to read temperature\n");
456 return ret;
457 }
458
459 value_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf));
460 if (value_temp == BMP280_TEMP_SKIPPED) {
461 dev_err(data->dev, "reading temperature skipped\n");
462 return -EIO;
463 }
464 *adc_temp = value_temp;
465
466 return 0;
467 }
468
469 /*
470 * Returns temperature in DegC, resolution is 0.01 DegC. Output value of
471 * "5123" equals 51.23 DegC. t_fine carries fine temperature as global
472 * value.
473 *
474 * Taken from datasheet, Section 3.11.3, "Compensation formula".
475 */
bmp280_calc_t_fine(struct bmp280_data * data,u32 adc_temp)476 static s32 bmp280_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
477 {
478 struct bmp280_calib *calib = &data->calib.bmp280;
479 s32 var1, var2;
480
481 var1 = (((((s32)adc_temp) >> 3) - ((s32)calib->T1 << 1)) *
482 ((s32)calib->T2)) >> 11;
483 var2 = (((((((s32)adc_temp) >> 4) - ((s32)calib->T1)) *
484 ((((s32)adc_temp >> 4) - ((s32)calib->T1))) >> 12) *
485 ((s32)calib->T3))) >> 14;
486 return var1 + var2; /* t_fine = var1 + var2 */
487 }
488
bmp280_get_t_fine(struct bmp280_data * data,s32 * t_fine)489 static int bmp280_get_t_fine(struct bmp280_data *data, s32 *t_fine)
490 {
491 u32 adc_temp;
492 int ret;
493
494 ret = bmp280_read_temp_adc(data, &adc_temp);
495 if (ret)
496 return ret;
497
498 *t_fine = bmp280_calc_t_fine(data, adc_temp);
499
500 return 0;
501 }
502
bmp280_compensate_temp(struct bmp280_data * data,u32 adc_temp)503 static s32 bmp280_compensate_temp(struct bmp280_data *data, u32 adc_temp)
504 {
505 return (bmp280_calc_t_fine(data, adc_temp) * 5 + 128) / 256;
506 }
507
bmp280_read_press_adc(struct bmp280_data * data,u32 * adc_press)508 static int bmp280_read_press_adc(struct bmp280_data *data, u32 *adc_press)
509 {
510 u32 value_press;
511 int ret;
512
513 ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB,
514 data->buf, BMP280_NUM_PRESS_BYTES);
515 if (ret) {
516 dev_err(data->dev, "failed to read pressure\n");
517 return ret;
518 }
519
520 value_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf));
521 if (value_press == BMP280_PRESS_SKIPPED) {
522 dev_err(data->dev, "reading pressure skipped\n");
523 return -EIO;
524 }
525 *adc_press = value_press;
526
527 return 0;
528 }
529
530 /*
531 * Returns pressure in Pa as unsigned 32 bit integer in Q24.8 format (24
532 * integer bits and 8 fractional bits). Output value of "24674867"
533 * represents 24674867/256 = 96386.2 Pa = 963.862 hPa
534 *
535 * Taken from datasheet, Section 3.11.3, "Compensation formula".
536 */
bmp280_compensate_press(struct bmp280_data * data,u32 adc_press,s32 t_fine)537 static u32 bmp280_compensate_press(struct bmp280_data *data,
538 u32 adc_press, s32 t_fine)
539 {
540 struct bmp280_calib *calib = &data->calib.bmp280;
541 s64 var1, var2, p;
542
543 var1 = ((s64)t_fine) - 128000;
544 var2 = var1 * var1 * (s64)calib->P6;
545 var2 += (var1 * (s64)calib->P5) << 17;
546 var2 += ((s64)calib->P4) << 35;
547 var1 = ((var1 * var1 * (s64)calib->P3) >> 8) +
548 ((var1 * (s64)calib->P2) << 12);
549 var1 = ((((s64)1) << 47) + var1) * ((s64)calib->P1) >> 33;
550
551 if (var1 == 0)
552 return 0;
553
554 p = ((((s64)1048576 - (s32)adc_press) << 31) - var2) * 3125;
555 p = div64_s64(p, var1);
556 var1 = (((s64)calib->P9) * (p >> 13) * (p >> 13)) >> 25;
557 var2 = ((s64)(calib->P8) * p) >> 19;
558 p = ((p + var1 + var2) >> 8) + (((s64)calib->P7) << 4);
559
560 return (u32)p;
561 }
562
bmp280_read_temp(struct bmp280_data * data,s32 * comp_temp)563 static int bmp280_read_temp(struct bmp280_data *data, s32 *comp_temp)
564 {
565 u32 adc_temp;
566 int ret;
567
568 ret = bmp280_read_temp_adc(data, &adc_temp);
569 if (ret)
570 return ret;
571
572 *comp_temp = bmp280_compensate_temp(data, adc_temp);
573
574 return 0;
575 }
576
bmp280_read_press(struct bmp280_data * data,u32 * comp_press)577 static int bmp280_read_press(struct bmp280_data *data, u32 *comp_press)
578 {
579 u32 adc_press;
580 s32 t_fine;
581 int ret;
582
583 ret = bmp280_get_t_fine(data, &t_fine);
584 if (ret)
585 return ret;
586
587 ret = bmp280_read_press_adc(data, &adc_press);
588 if (ret)
589 return ret;
590
591 *comp_press = bmp280_compensate_press(data, adc_press, t_fine);
592
593 return 0;
594 }
595
bme280_read_humid(struct bmp280_data * data,u32 * comp_humidity)596 static int bme280_read_humid(struct bmp280_data *data, u32 *comp_humidity)
597 {
598 u16 adc_humidity;
599 s32 t_fine;
600 int ret;
601
602 ret = bmp280_get_t_fine(data, &t_fine);
603 if (ret)
604 return ret;
605
606 ret = bme280_read_humid_adc(data, &adc_humidity);
607 if (ret)
608 return ret;
609
610 *comp_humidity = bme280_compensate_humidity(data, adc_humidity, t_fine);
611
612 return 0;
613 }
614
bmp280_read_raw_impl(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)615 static int bmp280_read_raw_impl(struct iio_dev *indio_dev,
616 struct iio_chan_spec const *chan,
617 int *val, int *val2, long mask)
618 {
619 struct bmp280_data *data = iio_priv(indio_dev);
620 int chan_value;
621 int ret;
622
623 guard(mutex)(&data->lock);
624
625 switch (mask) {
626 case IIO_CHAN_INFO_PROCESSED:
627 ret = data->chip_info->set_mode(data, BMP280_FORCED);
628 if (ret)
629 return ret;
630
631 ret = data->chip_info->wait_conv(data);
632 if (ret)
633 return ret;
634
635 switch (chan->type) {
636 case IIO_HUMIDITYRELATIVE:
637 ret = data->chip_info->read_humid(data, &chan_value);
638 if (ret)
639 return ret;
640
641 *val = data->chip_info->humid_coeffs[0] * chan_value;
642 *val2 = data->chip_info->humid_coeffs[1];
643 return data->chip_info->humid_coeffs_type;
644 case IIO_PRESSURE:
645 ret = data->chip_info->read_press(data, &chan_value);
646 if (ret)
647 return ret;
648
649 *val = data->chip_info->press_coeffs[0] * chan_value;
650 *val2 = data->chip_info->press_coeffs[1];
651 return data->chip_info->press_coeffs_type;
652 case IIO_TEMP:
653 ret = data->chip_info->read_temp(data, &chan_value);
654 if (ret)
655 return ret;
656
657 *val = data->chip_info->temp_coeffs[0] * chan_value;
658 *val2 = data->chip_info->temp_coeffs[1];
659 return data->chip_info->temp_coeffs_type;
660 default:
661 return -EINVAL;
662 }
663 case IIO_CHAN_INFO_RAW:
664 ret = data->chip_info->set_mode(data, BMP280_FORCED);
665 if (ret)
666 return ret;
667
668 ret = data->chip_info->wait_conv(data);
669 if (ret)
670 return ret;
671
672 switch (chan->type) {
673 case IIO_HUMIDITYRELATIVE:
674 ret = data->chip_info->read_humid(data, &chan_value);
675 if (ret)
676 return ret;
677
678 *val = chan_value;
679 return IIO_VAL_INT;
680 case IIO_PRESSURE:
681 ret = data->chip_info->read_press(data, &chan_value);
682 if (ret)
683 return ret;
684
685 *val = chan_value;
686 return IIO_VAL_INT;
687 case IIO_TEMP:
688 ret = data->chip_info->read_temp(data, &chan_value);
689 if (ret)
690 return ret;
691
692 *val = chan_value;
693 return IIO_VAL_INT;
694 default:
695 return -EINVAL;
696 }
697 case IIO_CHAN_INFO_SCALE:
698 switch (chan->type) {
699 case IIO_HUMIDITYRELATIVE:
700 *val = data->chip_info->humid_coeffs[0];
701 *val2 = data->chip_info->humid_coeffs[1];
702 return data->chip_info->humid_coeffs_type;
703 case IIO_PRESSURE:
704 *val = data->chip_info->press_coeffs[0];
705 *val2 = data->chip_info->press_coeffs[1];
706 return data->chip_info->press_coeffs_type;
707 case IIO_TEMP:
708 *val = data->chip_info->temp_coeffs[0];
709 *val2 = data->chip_info->temp_coeffs[1];
710 return data->chip_info->temp_coeffs_type;
711 default:
712 return -EINVAL;
713 }
714 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
715 switch (chan->type) {
716 case IIO_HUMIDITYRELATIVE:
717 *val = 1 << data->oversampling_humid;
718 return IIO_VAL_INT;
719 case IIO_PRESSURE:
720 *val = 1 << data->oversampling_press;
721 return IIO_VAL_INT;
722 case IIO_TEMP:
723 *val = 1 << data->oversampling_temp;
724 return IIO_VAL_INT;
725 default:
726 return -EINVAL;
727 }
728 case IIO_CHAN_INFO_SAMP_FREQ:
729 if (!data->chip_info->sampling_freq_avail)
730 return -EINVAL;
731
732 *val = data->chip_info->sampling_freq_avail[data->sampling_freq][0];
733 *val2 = data->chip_info->sampling_freq_avail[data->sampling_freq][1];
734 return IIO_VAL_INT_PLUS_MICRO;
735 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
736 if (!data->chip_info->iir_filter_coeffs_avail)
737 return -EINVAL;
738
739 *val = (1 << data->iir_filter_coeff) - 1;
740 return IIO_VAL_INT;
741 default:
742 return -EINVAL;
743 }
744 }
745
bmp280_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)746 static int bmp280_read_raw(struct iio_dev *indio_dev,
747 struct iio_chan_spec const *chan,
748 int *val, int *val2, long mask)
749 {
750 struct bmp280_data *data = iio_priv(indio_dev);
751 int ret;
752
753 pm_runtime_get_sync(data->dev);
754 ret = bmp280_read_raw_impl(indio_dev, chan, val, val2, mask);
755 pm_runtime_mark_last_busy(data->dev);
756 pm_runtime_put_autosuspend(data->dev);
757
758 return ret;
759 }
760
bme280_write_oversampling_ratio_humid(struct bmp280_data * data,int val)761 static int bme280_write_oversampling_ratio_humid(struct bmp280_data *data,
762 int val)
763 {
764 const int *avail = data->chip_info->oversampling_humid_avail;
765 const int n = data->chip_info->num_oversampling_humid_avail;
766 int ret, prev;
767 int i;
768
769 for (i = 0; i < n; i++) {
770 if (avail[i] == val) {
771 prev = data->oversampling_humid;
772 data->oversampling_humid = ilog2(val);
773
774 ret = data->chip_info->chip_config(data);
775 if (ret) {
776 data->oversampling_humid = prev;
777 data->chip_info->chip_config(data);
778 return ret;
779 }
780 return 0;
781 }
782 }
783 return -EINVAL;
784 }
785
bmp280_write_oversampling_ratio_temp(struct bmp280_data * data,int val)786 static int bmp280_write_oversampling_ratio_temp(struct bmp280_data *data,
787 int val)
788 {
789 const int *avail = data->chip_info->oversampling_temp_avail;
790 const int n = data->chip_info->num_oversampling_temp_avail;
791 int ret, prev;
792 int i;
793
794 for (i = 0; i < n; i++) {
795 if (avail[i] == val) {
796 prev = data->oversampling_temp;
797 data->oversampling_temp = ilog2(val);
798
799 ret = data->chip_info->chip_config(data);
800 if (ret) {
801 data->oversampling_temp = prev;
802 data->chip_info->chip_config(data);
803 return ret;
804 }
805 return 0;
806 }
807 }
808 return -EINVAL;
809 }
810
bmp280_write_oversampling_ratio_press(struct bmp280_data * data,int val)811 static int bmp280_write_oversampling_ratio_press(struct bmp280_data *data,
812 int val)
813 {
814 const int *avail = data->chip_info->oversampling_press_avail;
815 const int n = data->chip_info->num_oversampling_press_avail;
816 int ret, prev;
817 int i;
818
819 for (i = 0; i < n; i++) {
820 if (avail[i] == val) {
821 prev = data->oversampling_press;
822 data->oversampling_press = ilog2(val);
823
824 ret = data->chip_info->chip_config(data);
825 if (ret) {
826 data->oversampling_press = prev;
827 data->chip_info->chip_config(data);
828 return ret;
829 }
830 return 0;
831 }
832 }
833 return -EINVAL;
834 }
835
bmp280_write_sampling_frequency(struct bmp280_data * data,int val,int val2)836 static int bmp280_write_sampling_frequency(struct bmp280_data *data,
837 int val, int val2)
838 {
839 const int (*avail)[2] = data->chip_info->sampling_freq_avail;
840 const int n = data->chip_info->num_sampling_freq_avail;
841 int ret, prev;
842 int i;
843
844 for (i = 0; i < n; i++) {
845 if (avail[i][0] == val && avail[i][1] == val2) {
846 prev = data->sampling_freq;
847 data->sampling_freq = i;
848
849 ret = data->chip_info->chip_config(data);
850 if (ret) {
851 data->sampling_freq = prev;
852 data->chip_info->chip_config(data);
853 return ret;
854 }
855 return 0;
856 }
857 }
858 return -EINVAL;
859 }
860
bmp280_write_iir_filter_coeffs(struct bmp280_data * data,int val)861 static int bmp280_write_iir_filter_coeffs(struct bmp280_data *data, int val)
862 {
863 const int *avail = data->chip_info->iir_filter_coeffs_avail;
864 const int n = data->chip_info->num_iir_filter_coeffs_avail;
865 int ret, prev;
866 int i;
867
868 for (i = 0; i < n; i++) {
869 if (avail[i] - 1 == val) {
870 prev = data->iir_filter_coeff;
871 data->iir_filter_coeff = i;
872
873 ret = data->chip_info->chip_config(data);
874 if (ret) {
875 data->iir_filter_coeff = prev;
876 data->chip_info->chip_config(data);
877 return ret;
878
879 }
880 return 0;
881 }
882 }
883 return -EINVAL;
884 }
885
bmp280_write_raw_impl(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)886 static int bmp280_write_raw_impl(struct iio_dev *indio_dev,
887 struct iio_chan_spec const *chan,
888 int val, int val2, long mask)
889 {
890 struct bmp280_data *data = iio_priv(indio_dev);
891
892 guard(mutex)(&data->lock);
893
894 /*
895 * Helper functions to update sensor running configuration.
896 * If an error happens applying new settings, will try restore
897 * previous parameters to ensure the sensor is left in a known
898 * working configuration.
899 */
900 switch (mask) {
901 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
902 switch (chan->type) {
903 case IIO_HUMIDITYRELATIVE:
904 return bme280_write_oversampling_ratio_humid(data, val);
905 case IIO_PRESSURE:
906 return bmp280_write_oversampling_ratio_press(data, val);
907 case IIO_TEMP:
908 return bmp280_write_oversampling_ratio_temp(data, val);
909 default:
910 return -EINVAL;
911 }
912 case IIO_CHAN_INFO_SAMP_FREQ:
913 return bmp280_write_sampling_frequency(data, val, val2);
914 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
915 return bmp280_write_iir_filter_coeffs(data, val);
916 default:
917 return -EINVAL;
918 }
919 }
920
bmp280_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)921 static int bmp280_write_raw(struct iio_dev *indio_dev,
922 struct iio_chan_spec const *chan,
923 int val, int val2, long mask)
924 {
925 struct bmp280_data *data = iio_priv(indio_dev);
926 int ret;
927
928 pm_runtime_get_sync(data->dev);
929 ret = bmp280_write_raw_impl(indio_dev, chan, val, val2, mask);
930 pm_runtime_mark_last_busy(data->dev);
931 pm_runtime_put_autosuspend(data->dev);
932
933 return ret;
934 }
935
bmp280_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)936 static int bmp280_read_avail(struct iio_dev *indio_dev,
937 struct iio_chan_spec const *chan,
938 const int **vals, int *type, int *length,
939 long mask)
940 {
941 struct bmp280_data *data = iio_priv(indio_dev);
942
943 switch (mask) {
944 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
945 switch (chan->type) {
946 case IIO_PRESSURE:
947 *vals = data->chip_info->oversampling_press_avail;
948 *length = data->chip_info->num_oversampling_press_avail;
949 break;
950 case IIO_TEMP:
951 *vals = data->chip_info->oversampling_temp_avail;
952 *length = data->chip_info->num_oversampling_temp_avail;
953 break;
954 default:
955 return -EINVAL;
956 }
957 *type = IIO_VAL_INT;
958 return IIO_AVAIL_LIST;
959 case IIO_CHAN_INFO_SAMP_FREQ:
960 *vals = (const int *)data->chip_info->sampling_freq_avail;
961 *type = IIO_VAL_INT_PLUS_MICRO;
962 /* Values are stored in a 2D matrix */
963 *length = data->chip_info->num_sampling_freq_avail;
964 return IIO_AVAIL_LIST;
965 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
966 *vals = data->chip_info->iir_filter_coeffs_avail;
967 *type = IIO_VAL_INT;
968 *length = data->chip_info->num_iir_filter_coeffs_avail;
969 return IIO_AVAIL_LIST;
970 default:
971 return -EINVAL;
972 }
973 }
974
975 static const struct iio_info bmp280_info = {
976 .read_raw = &bmp280_read_raw,
977 .read_avail = &bmp280_read_avail,
978 .write_raw = &bmp280_write_raw,
979 };
980
981 static const unsigned long bmp280_avail_scan_masks[] = {
982 BIT(BMP280_TEMP) | BIT(BMP280_PRESS),
983 0
984 };
985
986 static const unsigned long bme280_avail_scan_masks[] = {
987 BIT(BME280_HUMID) | BIT(BMP280_TEMP) | BIT(BMP280_PRESS),
988 0
989 };
990
bmp280_preinit(struct bmp280_data * data)991 static int bmp280_preinit(struct bmp280_data *data)
992 {
993 struct device *dev = data->dev;
994 unsigned int reg;
995 int ret;
996
997 ret = regmap_write(data->regmap, BMP280_REG_RESET, BMP280_RST_SOFT_CMD);
998 if (ret)
999 return dev_err_probe(dev, ret, "Failed to reset device.\n");
1000
1001 /*
1002 * According to the datasheet in Chapter 1: Specification, Table 2,
1003 * after resetting, the device uses the complete power-on sequence so
1004 * it needs to wait for the defined start-up time.
1005 */
1006 fsleep(data->start_up_time_us);
1007
1008 ret = regmap_read(data->regmap, BMP280_REG_STATUS, ®);
1009 if (ret)
1010 return dev_err_probe(dev, ret, "Failed to read status register.\n");
1011
1012 if (reg & BMP280_REG_STATUS_IM_UPDATE)
1013 return dev_err_probe(dev, -EIO, "Failed to copy NVM contents.\n");
1014
1015 return 0;
1016 }
1017
1018 static const u8 bmp280_operation_mode[] = {
1019 [BMP280_SLEEP] = BMP280_MODE_SLEEP,
1020 [BMP280_FORCED] = BMP280_MODE_FORCED,
1021 [BMP280_NORMAL] = BMP280_MODE_NORMAL,
1022 };
1023
bmp280_set_mode(struct bmp280_data * data,enum bmp280_op_mode mode)1024 static int bmp280_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
1025 {
1026 int ret;
1027
1028 ret = regmap_write_bits(data->regmap, BMP280_REG_CTRL_MEAS,
1029 BMP280_MODE_MASK, bmp280_operation_mode[mode]);
1030 if (ret) {
1031 dev_err(data->dev, "failed to write ctrl_meas register.\n");
1032 return ret;
1033 }
1034
1035 data->op_mode = mode;
1036
1037 return 0;
1038 }
1039
bmp280_wait_conv(struct bmp280_data * data)1040 static int bmp280_wait_conv(struct bmp280_data *data)
1041 {
1042 unsigned int reg, meas_time_us;
1043 int ret;
1044
1045 /* Check if we are using a BME280 device */
1046 if (data->oversampling_humid)
1047 meas_time_us = BMP280_PRESS_HUMID_MEAS_OFFSET +
1048 BIT(data->oversampling_humid) * BMP280_MEAS_DUR;
1049
1050 else
1051 meas_time_us = 0;
1052
1053 /* Pressure measurement time */
1054 meas_time_us += BMP280_PRESS_HUMID_MEAS_OFFSET +
1055 BIT(data->oversampling_press) * BMP280_MEAS_DUR;
1056
1057 /* Temperature measurement time */
1058 meas_time_us += BIT(data->oversampling_temp) * BMP280_MEAS_DUR;
1059
1060 /* Waiting time according to the BM(P/E)2 Sensor API */
1061 fsleep(meas_time_us);
1062
1063 ret = regmap_read(data->regmap, BMP280_REG_STATUS, ®);
1064 if (ret) {
1065 dev_err(data->dev, "failed to read status register.\n");
1066 return ret;
1067 }
1068
1069 if (reg & BMP280_REG_STATUS_MEAS_BIT) {
1070 dev_err(data->dev, "Measurement cycle didn't complete.\n");
1071 return -EBUSY;
1072 }
1073
1074 return 0;
1075 }
1076
bmp280_chip_config(struct bmp280_data * data)1077 static int bmp280_chip_config(struct bmp280_data *data)
1078 {
1079 u8 osrs = FIELD_PREP(BMP280_OSRS_TEMP_MASK, data->oversampling_temp + 1) |
1080 FIELD_PREP(BMP280_OSRS_PRESS_MASK, data->oversampling_press + 1);
1081 int ret;
1082
1083 ret = regmap_write_bits(data->regmap, BMP280_REG_CTRL_MEAS,
1084 BMP280_OSRS_TEMP_MASK |
1085 BMP280_OSRS_PRESS_MASK |
1086 BMP280_MODE_MASK,
1087 osrs | BMP280_MODE_SLEEP);
1088 if (ret) {
1089 dev_err(data->dev, "failed to write ctrl_meas register\n");
1090 return ret;
1091 }
1092
1093 ret = regmap_update_bits(data->regmap, BMP280_REG_CONFIG,
1094 BMP280_FILTER_MASK,
1095 BMP280_FILTER_4X);
1096 if (ret) {
1097 dev_err(data->dev, "failed to write config register\n");
1098 return ret;
1099 }
1100
1101 return ret;
1102 }
1103
bmp280_trigger_handler(int irq,void * p)1104 static irqreturn_t bmp280_trigger_handler(int irq, void *p)
1105 {
1106 struct iio_poll_func *pf = p;
1107 struct iio_dev *indio_dev = pf->indio_dev;
1108 struct bmp280_data *data = iio_priv(indio_dev);
1109 u32 adc_temp, adc_press;
1110 s32 t_fine;
1111 struct {
1112 u32 comp_press;
1113 s32 comp_temp;
1114 aligned_s64 timestamp;
1115 } buffer;
1116 int ret;
1117
1118 guard(mutex)(&data->lock);
1119
1120 /* Burst read data registers */
1121 ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB,
1122 data->buf, BMP280_BURST_READ_BYTES);
1123 if (ret) {
1124 dev_err(data->dev, "failed to burst read sensor data\n");
1125 goto out;
1126 }
1127
1128 /* Temperature calculations */
1129 adc_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[3]));
1130 if (adc_temp == BMP280_TEMP_SKIPPED) {
1131 dev_err(data->dev, "reading temperature skipped\n");
1132 goto out;
1133 }
1134
1135 buffer.comp_temp = bmp280_compensate_temp(data, adc_temp);
1136
1137 /* Pressure calculations */
1138 adc_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[0]));
1139 if (adc_press == BMP280_PRESS_SKIPPED) {
1140 dev_err(data->dev, "reading pressure skipped\n");
1141 goto out;
1142 }
1143
1144 t_fine = bmp280_calc_t_fine(data, adc_temp);
1145 buffer.comp_press = bmp280_compensate_press(data, adc_press, t_fine);
1146
1147 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer),
1148 iio_get_time_ns(indio_dev));
1149
1150 out:
1151 iio_trigger_notify_done(indio_dev->trig);
1152
1153 return IRQ_HANDLED;
1154 }
1155
1156 static const int bmp280_oversampling_avail[] = { 1, 2, 4, 8, 16 };
1157 static const u8 bmp280_chip_ids[] = { BMP280_CHIP_ID };
1158 static const int bmp280_temp_coeffs[] = { 10, 1 };
1159 static const int bmp280_press_coeffs[] = { 1, 256000 };
1160
1161 const struct bmp280_chip_info bmp280_chip_info = {
1162 .id_reg = BMP280_REG_ID,
1163 .chip_id = bmp280_chip_ids,
1164 .num_chip_id = ARRAY_SIZE(bmp280_chip_ids),
1165 .regmap_config = &bmp280_regmap_config,
1166 .start_up_time_us = 2000,
1167 .channels = bmp280_channels,
1168 .num_channels = ARRAY_SIZE(bmp280_channels),
1169 .avail_scan_masks = bmp280_avail_scan_masks,
1170
1171 .oversampling_temp_avail = bmp280_oversampling_avail,
1172 .num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1173 /*
1174 * Oversampling config values on BMx280 have one additional setting
1175 * that other generations of the family don't:
1176 * The value 0 means the measurement is bypassed instead of
1177 * oversampling set to x1.
1178 *
1179 * To account for this difference, and preserve the same common
1180 * config logic, this is handled later on chip_config callback
1181 * incrementing one unit the oversampling setting.
1182 */
1183 .oversampling_temp_default = BMP280_OSRS_TEMP_2X - 1,
1184
1185 .oversampling_press_avail = bmp280_oversampling_avail,
1186 .num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1187 .oversampling_press_default = BMP280_OSRS_PRESS_16X - 1,
1188
1189 .temp_coeffs = bmp280_temp_coeffs,
1190 .temp_coeffs_type = IIO_VAL_FRACTIONAL,
1191 .press_coeffs = bmp280_press_coeffs,
1192 .press_coeffs_type = IIO_VAL_FRACTIONAL,
1193
1194 .chip_config = bmp280_chip_config,
1195 .read_temp = bmp280_read_temp,
1196 .read_press = bmp280_read_press,
1197 .read_calib = bmp280_read_calib,
1198 .set_mode = bmp280_set_mode,
1199 .wait_conv = bmp280_wait_conv,
1200 .preinit = bmp280_preinit,
1201
1202 .trigger_handler = bmp280_trigger_handler,
1203 };
1204 EXPORT_SYMBOL_NS(bmp280_chip_info, "IIO_BMP280");
1205
bme280_chip_config(struct bmp280_data * data)1206 static int bme280_chip_config(struct bmp280_data *data)
1207 {
1208 u8 osrs = FIELD_PREP(BME280_OSRS_HUMIDITY_MASK, data->oversampling_humid + 1);
1209 int ret;
1210
1211 /*
1212 * Oversampling of humidity must be set before oversampling of
1213 * temperature/pressure is set to become effective.
1214 */
1215 ret = regmap_update_bits(data->regmap, BME280_REG_CTRL_HUMIDITY,
1216 BME280_OSRS_HUMIDITY_MASK, osrs);
1217 if (ret) {
1218 dev_err(data->dev, "failed to set humidity oversampling");
1219 return ret;
1220 }
1221
1222 return bmp280_chip_config(data);
1223 }
1224
bme280_trigger_handler(int irq,void * p)1225 static irqreturn_t bme280_trigger_handler(int irq, void *p)
1226 {
1227 struct iio_poll_func *pf = p;
1228 struct iio_dev *indio_dev = pf->indio_dev;
1229 struct bmp280_data *data = iio_priv(indio_dev);
1230 u32 adc_temp, adc_press, adc_humidity;
1231 s32 t_fine;
1232 struct {
1233 u32 comp_press;
1234 s32 comp_temp;
1235 u32 comp_humidity;
1236 aligned_s64 timestamp;
1237 } buffer;
1238 int ret;
1239
1240 /* Don't leak uninitialized stack to userspace. */
1241 memset(&buffer, 0, sizeof(buffer));
1242
1243 guard(mutex)(&data->lock);
1244
1245 /* Burst read data registers */
1246 ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB,
1247 data->buf, BME280_BURST_READ_BYTES);
1248 if (ret) {
1249 dev_err(data->dev, "failed to burst read sensor data\n");
1250 goto out;
1251 }
1252
1253 /* Temperature calculations */
1254 adc_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[3]));
1255 if (adc_temp == BMP280_TEMP_SKIPPED) {
1256 dev_err(data->dev, "reading temperature skipped\n");
1257 goto out;
1258 }
1259
1260 buffer.comp_temp = bmp280_compensate_temp(data, adc_temp);
1261
1262 /* Pressure calculations */
1263 adc_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[0]));
1264 if (adc_press == BMP280_PRESS_SKIPPED) {
1265 dev_err(data->dev, "reading pressure skipped\n");
1266 goto out;
1267 }
1268
1269 t_fine = bmp280_calc_t_fine(data, adc_temp);
1270 buffer.comp_press = bmp280_compensate_press(data, adc_press, t_fine);
1271
1272 /* Humidity calculations */
1273 adc_humidity = get_unaligned_be16(&data->buf[6]);
1274
1275 if (adc_humidity == BMP280_HUMIDITY_SKIPPED) {
1276 dev_err(data->dev, "reading humidity skipped\n");
1277 goto out;
1278 }
1279
1280 buffer.comp_humidity = bme280_compensate_humidity(data, adc_humidity,
1281 t_fine);
1282
1283 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer),
1284 iio_get_time_ns(indio_dev));
1285
1286 out:
1287 iio_trigger_notify_done(indio_dev->trig);
1288
1289 return IRQ_HANDLED;
1290 }
1291
__bmp280_trigger_probe(struct iio_dev * indio_dev,const struct iio_trigger_ops * trigger_ops,int (* int_pin_config)(struct bmp280_data * data),irq_handler_t irq_thread_handler)1292 static int __bmp280_trigger_probe(struct iio_dev *indio_dev,
1293 const struct iio_trigger_ops *trigger_ops,
1294 int (*int_pin_config)(struct bmp280_data *data),
1295 irq_handler_t irq_thread_handler)
1296 {
1297 struct bmp280_data *data = iio_priv(indio_dev);
1298 struct device *dev = data->dev;
1299 u32 irq_type;
1300 int ret, irq;
1301
1302 irq = fwnode_irq_get(dev_fwnode(dev), 0);
1303 if (irq < 0)
1304 return dev_err_probe(dev, irq, "No interrupt found.\n");
1305
1306 irq_type = irq_get_trigger_type(irq);
1307 switch (irq_type) {
1308 case IRQF_TRIGGER_RISING:
1309 data->trig_active_high = true;
1310 break;
1311 case IRQF_TRIGGER_FALLING:
1312 data->trig_active_high = false;
1313 break;
1314 default:
1315 return dev_err_probe(dev, -EINVAL, "Invalid interrupt type specified.\n");
1316 }
1317
1318 data->trig_open_drain =
1319 fwnode_property_read_bool(dev_fwnode(dev), "int-open-drain");
1320
1321 ret = int_pin_config(data);
1322 if (ret)
1323 return ret;
1324
1325 data->trig = devm_iio_trigger_alloc(data->dev, "%s-dev%d",
1326 indio_dev->name,
1327 iio_device_id(indio_dev));
1328 if (!data->trig)
1329 return -ENOMEM;
1330
1331 data->trig->ops = trigger_ops;
1332 iio_trigger_set_drvdata(data->trig, data);
1333
1334 ret = devm_request_threaded_irq(data->dev, irq, NULL,
1335 irq_thread_handler, IRQF_ONESHOT,
1336 indio_dev->name, indio_dev);
1337 if (ret)
1338 return dev_err_probe(dev, ret, "request IRQ failed.\n");
1339
1340 ret = devm_iio_trigger_register(data->dev, data->trig);
1341 if (ret)
1342 return dev_err_probe(dev, ret, "iio trigger register failed.\n");
1343
1344 indio_dev->trig = iio_trigger_get(data->trig);
1345
1346 return 0;
1347 }
1348
1349 static const u8 bme280_chip_ids[] = { BME280_CHIP_ID };
1350 static const int bme280_humid_coeffs[] = { 1000, 1024 };
1351
1352 const struct bmp280_chip_info bme280_chip_info = {
1353 .id_reg = BMP280_REG_ID,
1354 .chip_id = bme280_chip_ids,
1355 .num_chip_id = ARRAY_SIZE(bme280_chip_ids),
1356 .regmap_config = &bme280_regmap_config,
1357 .start_up_time_us = 2000,
1358 .channels = bme280_channels,
1359 .num_channels = ARRAY_SIZE(bme280_channels),
1360 .avail_scan_masks = bme280_avail_scan_masks,
1361
1362 .oversampling_temp_avail = bmp280_oversampling_avail,
1363 .num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1364 .oversampling_temp_default = BMP280_OSRS_TEMP_2X - 1,
1365
1366 .oversampling_press_avail = bmp280_oversampling_avail,
1367 .num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1368 .oversampling_press_default = BMP280_OSRS_PRESS_16X - 1,
1369
1370 .oversampling_humid_avail = bmp280_oversampling_avail,
1371 .num_oversampling_humid_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1372 .oversampling_humid_default = BME280_OSRS_HUMIDITY_16X - 1,
1373
1374 .temp_coeffs = bmp280_temp_coeffs,
1375 .temp_coeffs_type = IIO_VAL_FRACTIONAL,
1376 .press_coeffs = bmp280_press_coeffs,
1377 .press_coeffs_type = IIO_VAL_FRACTIONAL,
1378 .humid_coeffs = bme280_humid_coeffs,
1379 .humid_coeffs_type = IIO_VAL_FRACTIONAL,
1380
1381 .chip_config = bme280_chip_config,
1382 .read_temp = bmp280_read_temp,
1383 .read_press = bmp280_read_press,
1384 .read_humid = bme280_read_humid,
1385 .read_calib = bme280_read_calib,
1386 .set_mode = bmp280_set_mode,
1387 .wait_conv = bmp280_wait_conv,
1388 .preinit = bmp280_preinit,
1389
1390 .trigger_handler = bme280_trigger_handler,
1391 };
1392 EXPORT_SYMBOL_NS(bme280_chip_info, "IIO_BMP280");
1393
1394 /*
1395 * Helper function to send a command to BMP3XX sensors.
1396 *
1397 * Sensor processes commands written to the CMD register and signals
1398 * execution result through "cmd_rdy" and "cmd_error" flags available on
1399 * STATUS and ERROR registers.
1400 */
bmp380_cmd(struct bmp280_data * data,u8 cmd)1401 static int bmp380_cmd(struct bmp280_data *data, u8 cmd)
1402 {
1403 unsigned int reg;
1404 int ret;
1405
1406 /* Check if device is ready to process a command */
1407 ret = regmap_read(data->regmap, BMP380_REG_STATUS, ®);
1408 if (ret) {
1409 dev_err(data->dev, "failed to read error register\n");
1410 return ret;
1411 }
1412 if (!(reg & BMP380_STATUS_CMD_RDY_MASK)) {
1413 dev_err(data->dev, "device is not ready to accept commands\n");
1414 return -EBUSY;
1415 }
1416
1417 /* Send command to process */
1418 ret = regmap_write(data->regmap, BMP380_REG_CMD, cmd);
1419 if (ret) {
1420 dev_err(data->dev, "failed to send command to device\n");
1421 return ret;
1422 }
1423 /* Wait for 2ms for command to be processed */
1424 fsleep(data->start_up_time_us);
1425 /* Check for command processing error */
1426 ret = regmap_read(data->regmap, BMP380_REG_ERROR, ®);
1427 if (ret) {
1428 dev_err(data->dev, "error reading ERROR reg\n");
1429 return ret;
1430 }
1431 if (reg & BMP380_ERR_CMD_MASK) {
1432 dev_err(data->dev, "error processing command 0x%X\n", cmd);
1433 return -EINVAL;
1434 }
1435
1436 return 0;
1437 }
1438
bmp380_read_temp_adc(struct bmp280_data * data,u32 * adc_temp)1439 static int bmp380_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
1440 {
1441 u32 value_temp;
1442 int ret;
1443
1444 ret = regmap_bulk_read(data->regmap, BMP380_REG_TEMP_XLSB,
1445 data->buf, BMP280_NUM_TEMP_BYTES);
1446 if (ret) {
1447 dev_err(data->dev, "failed to read temperature\n");
1448 return ret;
1449 }
1450
1451 value_temp = get_unaligned_le24(data->buf);
1452 if (value_temp == BMP380_TEMP_SKIPPED) {
1453 dev_err(data->dev, "reading temperature skipped\n");
1454 return -EIO;
1455 }
1456 *adc_temp = value_temp;
1457
1458 return 0;
1459 }
1460
1461 /*
1462 * Returns temperature in Celsius degrees, resolution is 0.01º C. Output value
1463 * of "5123" equals 51.2º C. t_fine carries fine temperature as global value.
1464 *
1465 * Taken from datasheet, Section Appendix 9, "Compensation formula" and repo
1466 * https://github.com/BoschSensortec/BMP3-Sensor-API.
1467 */
bmp380_calc_t_fine(struct bmp280_data * data,u32 adc_temp)1468 static s32 bmp380_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
1469 {
1470 s64 var1, var2, var3, var4, var5, var6;
1471 struct bmp380_calib *calib = &data->calib.bmp380;
1472
1473 var1 = ((s64) adc_temp) - (((s64) calib->T1) << 8);
1474 var2 = var1 * ((s64) calib->T2);
1475 var3 = var1 * var1;
1476 var4 = var3 * ((s64) calib->T3);
1477 var5 = (var2 << 18) + var4;
1478 var6 = var5 >> 32;
1479 return (s32)var6; /* t_fine = var6 */
1480 }
1481
bmp380_get_t_fine(struct bmp280_data * data,s32 * t_fine)1482 static int bmp380_get_t_fine(struct bmp280_data *data, s32 *t_fine)
1483 {
1484 s32 adc_temp;
1485 int ret;
1486
1487 ret = bmp380_read_temp_adc(data, &adc_temp);
1488 if (ret)
1489 return ret;
1490
1491 *t_fine = bmp380_calc_t_fine(data, adc_temp);
1492
1493 return 0;
1494 }
1495
bmp380_compensate_temp(struct bmp280_data * data,u32 adc_temp)1496 static int bmp380_compensate_temp(struct bmp280_data *data, u32 adc_temp)
1497 {
1498 s64 comp_temp;
1499 s32 var6;
1500
1501 var6 = bmp380_calc_t_fine(data, adc_temp);
1502 comp_temp = (var6 * 25) >> 14;
1503
1504 comp_temp = clamp_val(comp_temp, BMP380_MIN_TEMP, BMP380_MAX_TEMP);
1505 return (s32) comp_temp;
1506 }
1507
bmp380_read_press_adc(struct bmp280_data * data,u32 * adc_press)1508 static int bmp380_read_press_adc(struct bmp280_data *data, u32 *adc_press)
1509 {
1510 u32 value_press;
1511 int ret;
1512
1513 ret = regmap_bulk_read(data->regmap, BMP380_REG_PRESS_XLSB,
1514 data->buf, BMP280_NUM_PRESS_BYTES);
1515 if (ret) {
1516 dev_err(data->dev, "failed to read pressure\n");
1517 return ret;
1518 }
1519
1520 value_press = get_unaligned_le24(data->buf);
1521 if (value_press == BMP380_PRESS_SKIPPED) {
1522 dev_err(data->dev, "reading pressure skipped\n");
1523 return -EIO;
1524 }
1525 *adc_press = value_press;
1526
1527 return 0;
1528 }
1529
1530 /*
1531 * Returns pressure in Pa as an unsigned 32 bit integer in fractional Pascal.
1532 * Output value of "9528709" represents 9528709/100 = 95287.09 Pa = 952.8709 hPa.
1533 *
1534 * Taken from datasheet, Section 9.3. "Pressure compensation" and repository
1535 * https://github.com/BoschSensortec/BMP3-Sensor-API.
1536 */
bmp380_compensate_press(struct bmp280_data * data,u32 adc_press,s32 t_fine)1537 static u32 bmp380_compensate_press(struct bmp280_data *data,
1538 u32 adc_press, s32 t_fine)
1539 {
1540 s64 var1, var2, var3, var4, var5, var6, offset, sensitivity;
1541 struct bmp380_calib *calib = &data->calib.bmp380;
1542 u32 comp_press;
1543
1544 var1 = (s64)t_fine * (s64)t_fine;
1545 var2 = var1 >> 6;
1546 var3 = (var2 * ((s64)t_fine)) >> 8;
1547 var4 = ((s64)calib->P8 * var3) >> 5;
1548 var5 = ((s64)calib->P7 * var1) << 4;
1549 var6 = ((s64)calib->P6 * (s64)t_fine) << 22;
1550 offset = ((s64)calib->P5 << 47) + var4 + var5 + var6;
1551 var2 = ((s64)calib->P4 * var3) >> 5;
1552 var4 = ((s64)calib->P3 * var1) << 2;
1553 var5 = ((s64)calib->P2 - ((s64)1 << 14)) *
1554 ((s64)t_fine << 21);
1555 sensitivity = (((s64) calib->P1 - ((s64) 1 << 14)) << 46) +
1556 var2 + var4 + var5;
1557 var1 = (sensitivity >> 24) * (s64)adc_press;
1558 var2 = (s64)calib->P10 * (s64)t_fine;
1559 var3 = var2 + ((s64)calib->P9 << 16);
1560 var4 = (var3 * (s64)adc_press) >> 13;
1561
1562 /*
1563 * Dividing by 10 followed by multiplying by 10 to avoid
1564 * possible overflow caused by (uncomp_data->pressure * partial_data4).
1565 */
1566 var5 = ((s64)adc_press * div_s64(var4, 10)) >> 9;
1567 var5 *= 10;
1568 var6 = (s64)adc_press * (s64)adc_press;
1569 var2 = ((s64)calib->P11 * var6) >> 16;
1570 var3 = (var2 * (s64)adc_press) >> 7;
1571 var4 = (offset >> 2) + var1 + var5 + var3;
1572 comp_press = ((u64)var4 * 25) >> 40;
1573
1574 comp_press = clamp_val(comp_press, BMP380_MIN_PRES, BMP380_MAX_PRES);
1575 return comp_press;
1576 }
1577
bmp380_read_temp(struct bmp280_data * data,s32 * comp_temp)1578 static int bmp380_read_temp(struct bmp280_data *data, s32 *comp_temp)
1579 {
1580 u32 adc_temp;
1581 int ret;
1582
1583 ret = bmp380_read_temp_adc(data, &adc_temp);
1584 if (ret)
1585 return ret;
1586
1587 *comp_temp = bmp380_compensate_temp(data, adc_temp);
1588
1589 return 0;
1590 }
1591
bmp380_read_press(struct bmp280_data * data,u32 * comp_press)1592 static int bmp380_read_press(struct bmp280_data *data, u32 *comp_press)
1593 {
1594 u32 adc_press, t_fine;
1595 int ret;
1596
1597 ret = bmp380_get_t_fine(data, &t_fine);
1598 if (ret)
1599 return ret;
1600
1601 ret = bmp380_read_press_adc(data, &adc_press);
1602 if (ret)
1603 return ret;
1604
1605 *comp_press = bmp380_compensate_press(data, adc_press, t_fine);
1606
1607 return 0;
1608 }
1609
bmp380_read_calib(struct bmp280_data * data)1610 static int bmp380_read_calib(struct bmp280_data *data)
1611 {
1612 struct bmp380_calib *calib = &data->calib.bmp380;
1613 int ret;
1614
1615 /* Read temperature and pressure calibration data */
1616 ret = regmap_bulk_read(data->regmap, BMP380_REG_CALIB_TEMP_START,
1617 data->bmp380_cal_buf,
1618 sizeof(data->bmp380_cal_buf));
1619 if (ret) {
1620 dev_err(data->dev,
1621 "failed to read calibration parameters\n");
1622 return ret;
1623 }
1624
1625 /* Toss the temperature calibration data into the entropy pool */
1626 add_device_randomness(data->bmp380_cal_buf,
1627 sizeof(data->bmp380_cal_buf));
1628
1629 /* Parse calibration values */
1630 calib->T1 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_T1]);
1631 calib->T2 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_T2]);
1632 calib->T3 = data->bmp380_cal_buf[BMP380_T3];
1633 calib->P1 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P1]);
1634 calib->P2 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P2]);
1635 calib->P3 = data->bmp380_cal_buf[BMP380_P3];
1636 calib->P4 = data->bmp380_cal_buf[BMP380_P4];
1637 calib->P5 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P5]);
1638 calib->P6 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P6]);
1639 calib->P7 = data->bmp380_cal_buf[BMP380_P7];
1640 calib->P8 = data->bmp380_cal_buf[BMP380_P8];
1641 calib->P9 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P9]);
1642 calib->P10 = data->bmp380_cal_buf[BMP380_P10];
1643 calib->P11 = data->bmp380_cal_buf[BMP380_P11];
1644
1645 return 0;
1646 }
1647
1648 static const int bmp380_odr_table[][2] = {
1649 [BMP380_ODR_200HZ] = {200, 0},
1650 [BMP380_ODR_100HZ] = {100, 0},
1651 [BMP380_ODR_50HZ] = {50, 0},
1652 [BMP380_ODR_25HZ] = {25, 0},
1653 [BMP380_ODR_12_5HZ] = {12, 500000},
1654 [BMP380_ODR_6_25HZ] = {6, 250000},
1655 [BMP380_ODR_3_125HZ] = {3, 125000},
1656 [BMP380_ODR_1_5625HZ] = {1, 562500},
1657 [BMP380_ODR_0_78HZ] = {0, 781250},
1658 [BMP380_ODR_0_39HZ] = {0, 390625},
1659 [BMP380_ODR_0_2HZ] = {0, 195313},
1660 [BMP380_ODR_0_1HZ] = {0, 97656},
1661 [BMP380_ODR_0_05HZ] = {0, 48828},
1662 [BMP380_ODR_0_02HZ] = {0, 24414},
1663 [BMP380_ODR_0_01HZ] = {0, 12207},
1664 [BMP380_ODR_0_006HZ] = {0, 6104},
1665 [BMP380_ODR_0_003HZ] = {0, 3052},
1666 [BMP380_ODR_0_0015HZ] = {0, 1526},
1667 };
1668
bmp380_preinit(struct bmp280_data * data)1669 static int bmp380_preinit(struct bmp280_data *data)
1670 {
1671 /* BMP3xx requires soft-reset as part of initialization */
1672 return bmp380_cmd(data, BMP380_CMD_SOFT_RESET);
1673 }
1674
1675 static const u8 bmp380_operation_mode[] = {
1676 [BMP280_SLEEP] = BMP380_MODE_SLEEP,
1677 [BMP280_FORCED] = BMP380_MODE_FORCED,
1678 [BMP280_NORMAL] = BMP380_MODE_NORMAL,
1679 };
1680
bmp380_set_mode(struct bmp280_data * data,enum bmp280_op_mode mode)1681 static int bmp380_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
1682 {
1683 int ret;
1684
1685 ret = regmap_write_bits(data->regmap, BMP380_REG_POWER_CONTROL,
1686 BMP380_MODE_MASK,
1687 FIELD_PREP(BMP380_MODE_MASK,
1688 bmp380_operation_mode[mode]));
1689 if (ret) {
1690 dev_err(data->dev, "failed to write power control register.\n");
1691 return ret;
1692 }
1693
1694 data->op_mode = mode;
1695
1696 return 0;
1697 }
1698
bmp380_wait_conv(struct bmp280_data * data)1699 static int bmp380_wait_conv(struct bmp280_data *data)
1700 {
1701 unsigned int reg;
1702 int ret, meas_time_us;
1703
1704 /* Offset measurement time */
1705 meas_time_us = BMP380_MEAS_OFFSET;
1706
1707 /* Pressure measurement time */
1708 meas_time_us += BMP380_PRESS_MEAS_OFFSET +
1709 BIT(data->oversampling_press) * BMP380_MEAS_DUR;
1710
1711 /* Temperature measurement time */
1712 meas_time_us += BMP380_TEMP_MEAS_OFFSET +
1713 BIT(data->oversampling_temp) * BMP380_MEAS_DUR;
1714
1715 /* Measurement time defined in Datasheet Section 3.9.2 */
1716 fsleep(meas_time_us);
1717
1718 ret = regmap_read(data->regmap, BMP380_REG_STATUS, ®);
1719 if (ret) {
1720 dev_err(data->dev, "failed to read status register.\n");
1721 return ret;
1722 }
1723
1724 if (!((reg & BMP380_STATUS_DRDY_PRESS_MASK) &&
1725 (reg & BMP380_STATUS_DRDY_TEMP_MASK))) {
1726 dev_err(data->dev, "Measurement cycle didn't complete.\n");
1727 return -EBUSY;
1728 }
1729
1730 return 0;
1731 }
1732
bmp380_chip_config(struct bmp280_data * data)1733 static int bmp380_chip_config(struct bmp280_data *data)
1734 {
1735 bool change = false, aux;
1736 unsigned int tmp;
1737 u8 osrs;
1738 int ret;
1739
1740 /* Configure power control register */
1741 ret = regmap_update_bits(data->regmap, BMP380_REG_POWER_CONTROL,
1742 BMP380_CTRL_SENSORS_MASK,
1743 BMP380_CTRL_SENSORS_PRESS_EN |
1744 BMP380_CTRL_SENSORS_TEMP_EN);
1745 if (ret) {
1746 dev_err(data->dev,
1747 "failed to write operation control register\n");
1748 return ret;
1749 }
1750
1751 /* Configure oversampling */
1752 osrs = FIELD_PREP(BMP380_OSRS_TEMP_MASK, data->oversampling_temp) |
1753 FIELD_PREP(BMP380_OSRS_PRESS_MASK, data->oversampling_press);
1754
1755 ret = regmap_update_bits_check(data->regmap, BMP380_REG_OSR,
1756 BMP380_OSRS_TEMP_MASK |
1757 BMP380_OSRS_PRESS_MASK,
1758 osrs, &aux);
1759 if (ret) {
1760 dev_err(data->dev, "failed to write oversampling register\n");
1761 return ret;
1762 }
1763 change = change || aux;
1764
1765 /* Configure output data rate */
1766 ret = regmap_update_bits_check(data->regmap, BMP380_REG_ODR,
1767 BMP380_ODRS_MASK, data->sampling_freq,
1768 &aux);
1769 if (ret) {
1770 dev_err(data->dev, "failed to write ODR selection register\n");
1771 return ret;
1772 }
1773 change = change || aux;
1774
1775 /* Set filter data */
1776 ret = regmap_update_bits(data->regmap, BMP380_REG_CONFIG, BMP380_FILTER_MASK,
1777 FIELD_PREP(BMP380_FILTER_MASK, data->iir_filter_coeff));
1778 if (ret) {
1779 dev_err(data->dev, "failed to write config register\n");
1780 return ret;
1781 }
1782
1783 if (change) {
1784 /*
1785 * The configurations errors are detected on the fly during a
1786 * measurement cycle. If the sampling frequency is too low, it's
1787 * faster to reset the measurement loop than wait until the next
1788 * measurement is due.
1789 *
1790 * Resets sensor measurement loop toggling between sleep and
1791 * normal operating modes.
1792 */
1793 ret = bmp380_set_mode(data, BMP280_SLEEP);
1794 if (ret) {
1795 dev_err(data->dev, "failed to set sleep mode\n");
1796 return ret;
1797 }
1798
1799 /*
1800 * According to the BMP3 Sensor API, the sensor needs 5ms
1801 * in order to go to the sleep mode.
1802 */
1803 fsleep(5 * USEC_PER_MSEC);
1804
1805 ret = bmp380_set_mode(data, BMP280_NORMAL);
1806 if (ret) {
1807 dev_err(data->dev, "failed to set normal mode\n");
1808 return ret;
1809 }
1810 /*
1811 * Waits for measurement before checking configuration error
1812 * flag. Selected longest measurement time, calculated from
1813 * formula in datasheet section 3.9.2 with an offset of ~+15%
1814 * as it seen as well in table 3.9.1.
1815 */
1816 fsleep(150 * USEC_PER_MSEC);
1817
1818 /* Check config error flag */
1819 ret = regmap_read(data->regmap, BMP380_REG_ERROR, &tmp);
1820 if (ret) {
1821 dev_err(data->dev, "failed to read error register\n");
1822 return ret;
1823 }
1824 if (tmp & BMP380_ERR_CONF_MASK) {
1825 dev_warn(data->dev,
1826 "sensor flagged configuration as incompatible\n");
1827 return -EINVAL;
1828 }
1829 }
1830
1831 /* Dummy read to empty data registers. */
1832 ret = bmp380_read_press(data, &tmp);
1833 if (ret)
1834 return ret;
1835
1836 ret = bmp380_set_mode(data, BMP280_SLEEP);
1837 if (ret)
1838 dev_err(data->dev, "failed to set sleep mode.\n");
1839
1840 return ret;
1841 }
1842
bmp380_data_rdy_trigger_set_state(struct iio_trigger * trig,bool state)1843 static int bmp380_data_rdy_trigger_set_state(struct iio_trigger *trig,
1844 bool state)
1845 {
1846 struct bmp280_data *data = iio_trigger_get_drvdata(trig);
1847 int ret;
1848
1849 guard(mutex)(&data->lock);
1850
1851 ret = regmap_update_bits(data->regmap, BMP380_REG_INT_CONTROL,
1852 BMP380_INT_CTRL_DRDY_EN,
1853 FIELD_PREP(BMP380_INT_CTRL_DRDY_EN, !!state));
1854 if (ret)
1855 dev_err(data->dev,
1856 "Could not %s interrupt.\n", str_enable_disable(state));
1857 return ret;
1858 }
1859
1860 static const struct iio_trigger_ops bmp380_trigger_ops = {
1861 .set_trigger_state = &bmp380_data_rdy_trigger_set_state,
1862 };
1863
bmp380_int_pin_config(struct bmp280_data * data)1864 static int bmp380_int_pin_config(struct bmp280_data *data)
1865 {
1866 int pin_drive_cfg = FIELD_PREP(BMP380_INT_CTRL_OPEN_DRAIN,
1867 data->trig_open_drain);
1868 int pin_level_cfg = FIELD_PREP(BMP380_INT_CTRL_LEVEL,
1869 data->trig_active_high);
1870 int ret, int_pin_cfg = pin_drive_cfg | pin_level_cfg;
1871
1872 ret = regmap_update_bits(data->regmap, BMP380_REG_INT_CONTROL,
1873 BMP380_INT_CTRL_SETTINGS_MASK, int_pin_cfg);
1874 if (ret)
1875 dev_err(data->dev, "Could not set interrupt settings.\n");
1876
1877 return ret;
1878 }
1879
bmp380_irq_thread_handler(int irq,void * p)1880 static irqreturn_t bmp380_irq_thread_handler(int irq, void *p)
1881 {
1882 struct iio_dev *indio_dev = p;
1883 struct bmp280_data *data = iio_priv(indio_dev);
1884 unsigned int int_ctrl;
1885 int ret;
1886
1887 ret = regmap_read(data->regmap, BMP380_REG_INT_STATUS, &int_ctrl);
1888 if (ret)
1889 return IRQ_NONE;
1890
1891 if (FIELD_GET(BMP380_INT_STATUS_DRDY, int_ctrl))
1892 iio_trigger_poll_nested(data->trig);
1893
1894 return IRQ_HANDLED;
1895 }
1896
bmp380_trigger_probe(struct iio_dev * indio_dev)1897 static int bmp380_trigger_probe(struct iio_dev *indio_dev)
1898 {
1899 return __bmp280_trigger_probe(indio_dev, &bmp380_trigger_ops,
1900 bmp380_int_pin_config,
1901 bmp380_irq_thread_handler);
1902 }
1903
bmp380_trigger_handler(int irq,void * p)1904 static irqreturn_t bmp380_trigger_handler(int irq, void *p)
1905 {
1906 struct iio_poll_func *pf = p;
1907 struct iio_dev *indio_dev = pf->indio_dev;
1908 struct bmp280_data *data = iio_priv(indio_dev);
1909 u32 adc_temp, adc_press;
1910 s32 t_fine;
1911 struct {
1912 u32 comp_press;
1913 s32 comp_temp;
1914 aligned_s64 timestamp;
1915 } buffer;
1916 int ret;
1917
1918 guard(mutex)(&data->lock);
1919
1920 /* Burst read data registers */
1921 ret = regmap_bulk_read(data->regmap, BMP380_REG_PRESS_XLSB,
1922 data->buf, BMP280_BURST_READ_BYTES);
1923 if (ret) {
1924 dev_err(data->dev, "failed to burst read sensor data\n");
1925 goto out;
1926 }
1927
1928 /* Temperature calculations */
1929 adc_temp = get_unaligned_le24(&data->buf[3]);
1930 if (adc_temp == BMP380_TEMP_SKIPPED) {
1931 dev_err(data->dev, "reading temperature skipped\n");
1932 goto out;
1933 }
1934
1935 buffer.comp_temp = bmp380_compensate_temp(data, adc_temp);
1936
1937 /* Pressure calculations */
1938 adc_press = get_unaligned_le24(&data->buf[0]);
1939 if (adc_press == BMP380_PRESS_SKIPPED) {
1940 dev_err(data->dev, "reading pressure skipped\n");
1941 goto out;
1942 }
1943
1944 t_fine = bmp380_calc_t_fine(data, adc_temp);
1945 buffer.comp_press = bmp380_compensate_press(data, adc_press, t_fine);
1946
1947 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer),
1948 iio_get_time_ns(indio_dev));
1949
1950 out:
1951 iio_trigger_notify_done(indio_dev->trig);
1952
1953 return IRQ_HANDLED;
1954 }
1955
1956 static const int bmp380_oversampling_avail[] = { 1, 2, 4, 8, 16, 32 };
1957 static const int bmp380_iir_filter_coeffs_avail[] = { 1, 2, 4, 8, 16, 32, 64, 128};
1958 static const u8 bmp380_chip_ids[] = { BMP380_CHIP_ID, BMP390_CHIP_ID };
1959 static const int bmp380_temp_coeffs[] = { 10, 1 };
1960 static const int bmp380_press_coeffs[] = { 1, 100000 };
1961
1962 const struct bmp280_chip_info bmp380_chip_info = {
1963 .id_reg = BMP380_REG_ID,
1964 .chip_id = bmp380_chip_ids,
1965 .num_chip_id = ARRAY_SIZE(bmp380_chip_ids),
1966 .regmap_config = &bmp380_regmap_config,
1967 .spi_read_extra_byte = true,
1968 .start_up_time_us = 2000,
1969 .channels = bmp380_channels,
1970 .num_channels = ARRAY_SIZE(bmp380_channels),
1971 .avail_scan_masks = bmp280_avail_scan_masks,
1972
1973 .oversampling_temp_avail = bmp380_oversampling_avail,
1974 .num_oversampling_temp_avail = ARRAY_SIZE(bmp380_oversampling_avail),
1975 .oversampling_temp_default = ilog2(1),
1976
1977 .oversampling_press_avail = bmp380_oversampling_avail,
1978 .num_oversampling_press_avail = ARRAY_SIZE(bmp380_oversampling_avail),
1979 .oversampling_press_default = ilog2(4),
1980
1981 .sampling_freq_avail = bmp380_odr_table,
1982 .num_sampling_freq_avail = ARRAY_SIZE(bmp380_odr_table) * 2,
1983 .sampling_freq_default = BMP380_ODR_50HZ,
1984
1985 .iir_filter_coeffs_avail = bmp380_iir_filter_coeffs_avail,
1986 .num_iir_filter_coeffs_avail = ARRAY_SIZE(bmp380_iir_filter_coeffs_avail),
1987 .iir_filter_coeff_default = 2,
1988
1989 .temp_coeffs = bmp380_temp_coeffs,
1990 .temp_coeffs_type = IIO_VAL_FRACTIONAL,
1991 .press_coeffs = bmp380_press_coeffs,
1992 .press_coeffs_type = IIO_VAL_FRACTIONAL,
1993
1994 .chip_config = bmp380_chip_config,
1995 .read_temp = bmp380_read_temp,
1996 .read_press = bmp380_read_press,
1997 .read_calib = bmp380_read_calib,
1998 .set_mode = bmp380_set_mode,
1999 .wait_conv = bmp380_wait_conv,
2000 .preinit = bmp380_preinit,
2001
2002 .trigger_probe = bmp380_trigger_probe,
2003 .trigger_handler = bmp380_trigger_handler,
2004 };
2005 EXPORT_SYMBOL_NS(bmp380_chip_info, "IIO_BMP280");
2006
bmp580_soft_reset(struct bmp280_data * data)2007 static int bmp580_soft_reset(struct bmp280_data *data)
2008 {
2009 unsigned int reg;
2010 int ret;
2011
2012 ret = regmap_write(data->regmap, BMP580_REG_CMD, BMP580_CMD_SOFT_RESET);
2013 if (ret) {
2014 dev_err(data->dev, "failed to send reset command to device\n");
2015 return ret;
2016 }
2017 /* From datasheet's table 4: electrical characteristics */
2018 fsleep(2000);
2019
2020 /* Dummy read of chip_id */
2021 ret = regmap_read(data->regmap, BMP580_REG_CHIP_ID, ®);
2022 if (ret) {
2023 dev_err(data->dev, "failed to reestablish comms after reset\n");
2024 return ret;
2025 }
2026
2027 ret = regmap_read(data->regmap, BMP580_REG_INT_STATUS, ®);
2028 if (ret) {
2029 dev_err(data->dev, "error reading interrupt status register\n");
2030 return ret;
2031 }
2032 if (!(reg & BMP580_INT_STATUS_POR_MASK)) {
2033 dev_err(data->dev, "error resetting sensor\n");
2034 return -EINVAL;
2035 }
2036
2037 return 0;
2038 }
2039
2040 /**
2041 * bmp580_nvm_operation() - Helper function to commit NVM memory operations
2042 * @data: sensor data struct
2043 * @is_write: flag to signal write operation
2044 */
bmp580_nvm_operation(struct bmp280_data * data,bool is_write)2045 static int bmp580_nvm_operation(struct bmp280_data *data, bool is_write)
2046 {
2047 unsigned long timeout, poll;
2048 unsigned int reg;
2049 int ret;
2050
2051 /* Check NVM ready flag */
2052 ret = regmap_read(data->regmap, BMP580_REG_STATUS, ®);
2053 if (ret) {
2054 dev_err(data->dev, "failed to check nvm status\n");
2055 return ret;
2056 }
2057 if (!(reg & BMP580_STATUS_NVM_RDY_MASK)) {
2058 dev_err(data->dev, "sensor's nvm is not ready\n");
2059 return -EIO;
2060 }
2061
2062 /* Start NVM operation sequence */
2063 ret = regmap_write(data->regmap, BMP580_REG_CMD,
2064 BMP580_CMD_NVM_OP_SEQ_0);
2065 if (ret) {
2066 dev_err(data->dev,
2067 "failed to send nvm operation's first sequence\n");
2068 return ret;
2069 }
2070 if (is_write) {
2071 /* Send NVM write sequence */
2072 ret = regmap_write(data->regmap, BMP580_REG_CMD,
2073 BMP580_CMD_NVM_WRITE_SEQ_1);
2074 if (ret) {
2075 dev_err(data->dev,
2076 "failed to send nvm write sequence\n");
2077 return ret;
2078 }
2079 /* Datasheet says on 4.8.1.2 it takes approximately 10ms */
2080 poll = 2000;
2081 timeout = 12000;
2082 } else {
2083 /* Send NVM read sequence */
2084 ret = regmap_write(data->regmap, BMP580_REG_CMD,
2085 BMP580_CMD_NVM_READ_SEQ_1);
2086 if (ret) {
2087 dev_err(data->dev,
2088 "failed to send nvm read sequence\n");
2089 return ret;
2090 }
2091 /* Datasheet says on 4.8.1.1 it takes approximately 200us */
2092 poll = 50;
2093 timeout = 400;
2094 }
2095
2096 /* Wait until NVM is ready again */
2097 ret = regmap_read_poll_timeout(data->regmap, BMP580_REG_STATUS, reg,
2098 (reg & BMP580_STATUS_NVM_RDY_MASK),
2099 poll, timeout);
2100 if (ret) {
2101 dev_err(data->dev, "error checking nvm operation status\n");
2102 return ret;
2103 }
2104
2105 /* Check NVM error flags */
2106 if ((reg & BMP580_STATUS_NVM_ERR_MASK) || (reg & BMP580_STATUS_NVM_CMD_ERR_MASK)) {
2107 dev_err(data->dev, "error processing nvm operation\n");
2108 return -EIO;
2109 }
2110
2111 return 0;
2112 }
2113
2114 /*
2115 * Contrary to previous sensors families, compensation algorithm is builtin.
2116 * We are only required to read the register raw data and adapt the ranges
2117 * for what is expected on IIO ABI.
2118 */
2119
bmp580_read_temp(struct bmp280_data * data,s32 * raw_temp)2120 static int bmp580_read_temp(struct bmp280_data *data, s32 *raw_temp)
2121 {
2122 s32 value_temp;
2123 int ret;
2124
2125 ret = regmap_bulk_read(data->regmap, BMP580_REG_TEMP_XLSB,
2126 data->buf, BMP280_NUM_TEMP_BYTES);
2127 if (ret) {
2128 dev_err(data->dev, "failed to read temperature\n");
2129 return ret;
2130 }
2131
2132 value_temp = get_unaligned_le24(data->buf);
2133 if (value_temp == BMP580_TEMP_SKIPPED) {
2134 dev_err(data->dev, "reading temperature skipped\n");
2135 return -EIO;
2136 }
2137 *raw_temp = sign_extend32(value_temp, 23);
2138
2139 return 0;
2140 }
2141
bmp580_read_press(struct bmp280_data * data,u32 * raw_press)2142 static int bmp580_read_press(struct bmp280_data *data, u32 *raw_press)
2143 {
2144 u32 value_press;
2145 int ret;
2146
2147 ret = regmap_bulk_read(data->regmap, BMP580_REG_PRESS_XLSB,
2148 data->buf, BMP280_NUM_PRESS_BYTES);
2149 if (ret) {
2150 dev_err(data->dev, "failed to read pressure\n");
2151 return ret;
2152 }
2153
2154 value_press = get_unaligned_le24(data->buf);
2155 if (value_press == BMP580_PRESS_SKIPPED) {
2156 dev_err(data->dev, "reading pressure skipped\n");
2157 return -EIO;
2158 }
2159 *raw_press = value_press;
2160
2161 return 0;
2162 }
2163
2164 static const int bmp580_odr_table[][2] = {
2165 [BMP580_ODR_240HZ] = {240, 0},
2166 [BMP580_ODR_218HZ] = {218, 0},
2167 [BMP580_ODR_199HZ] = {199, 0},
2168 [BMP580_ODR_179HZ] = {179, 0},
2169 [BMP580_ODR_160HZ] = {160, 0},
2170 [BMP580_ODR_149HZ] = {149, 0},
2171 [BMP580_ODR_140HZ] = {140, 0},
2172 [BMP580_ODR_129HZ] = {129, 0},
2173 [BMP580_ODR_120HZ] = {120, 0},
2174 [BMP580_ODR_110HZ] = {110, 0},
2175 [BMP580_ODR_100HZ] = {100, 0},
2176 [BMP580_ODR_89HZ] = {89, 0},
2177 [BMP580_ODR_80HZ] = {80, 0},
2178 [BMP580_ODR_70HZ] = {70, 0},
2179 [BMP580_ODR_60HZ] = {60, 0},
2180 [BMP580_ODR_50HZ] = {50, 0},
2181 [BMP580_ODR_45HZ] = {45, 0},
2182 [BMP580_ODR_40HZ] = {40, 0},
2183 [BMP580_ODR_35HZ] = {35, 0},
2184 [BMP580_ODR_30HZ] = {30, 0},
2185 [BMP580_ODR_25HZ] = {25, 0},
2186 [BMP580_ODR_20HZ] = {20, 0},
2187 [BMP580_ODR_15HZ] = {15, 0},
2188 [BMP580_ODR_10HZ] = {10, 0},
2189 [BMP580_ODR_5HZ] = {5, 0},
2190 [BMP580_ODR_4HZ] = {4, 0},
2191 [BMP580_ODR_3HZ] = {3, 0},
2192 [BMP580_ODR_2HZ] = {2, 0},
2193 [BMP580_ODR_1HZ] = {1, 0},
2194 [BMP580_ODR_0_5HZ] = {0, 500000},
2195 [BMP580_ODR_0_25HZ] = {0, 250000},
2196 [BMP580_ODR_0_125HZ] = {0, 125000},
2197 };
2198
2199 static const int bmp580_nvmem_addrs[] = { 0x20, 0x21, 0x22 };
2200
bmp580_nvmem_read_impl(void * priv,unsigned int offset,void * val,size_t bytes)2201 static int bmp580_nvmem_read_impl(void *priv, unsigned int offset, void *val,
2202 size_t bytes)
2203 {
2204 struct bmp280_data *data = priv;
2205 u16 *dst = val;
2206 int ret, addr;
2207
2208 guard(mutex)(&data->lock);
2209
2210 /* Set sensor in standby mode */
2211 ret = regmap_update_bits(data->regmap, BMP580_REG_ODR_CONFIG,
2212 BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS,
2213 BMP580_ODR_DEEPSLEEP_DIS |
2214 FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP));
2215 if (ret) {
2216 dev_err(data->dev, "failed to change sensor to standby mode\n");
2217 goto exit;
2218 }
2219 /* Wait standby transition time */
2220 fsleep(2500);
2221
2222 while (bytes >= sizeof(*dst)) {
2223 addr = bmp580_nvmem_addrs[offset / sizeof(*dst)];
2224
2225 ret = regmap_write(data->regmap, BMP580_REG_NVM_ADDR,
2226 FIELD_PREP(BMP580_NVM_ROW_ADDR_MASK, addr));
2227 if (ret) {
2228 dev_err(data->dev, "error writing nvm address\n");
2229 goto exit;
2230 }
2231
2232 ret = bmp580_nvm_operation(data, false);
2233 if (ret)
2234 goto exit;
2235
2236 ret = regmap_bulk_read(data->regmap, BMP580_REG_NVM_DATA_LSB,
2237 &data->le16, sizeof(data->le16));
2238 if (ret) {
2239 dev_err(data->dev, "error reading nvm data regs\n");
2240 goto exit;
2241 }
2242
2243 *dst++ = le16_to_cpu(data->le16);
2244 bytes -= sizeof(*dst);
2245 offset += sizeof(*dst);
2246 }
2247 exit:
2248 /* Restore chip config */
2249 data->chip_info->chip_config(data);
2250 return ret;
2251 }
2252
bmp580_nvmem_read(void * priv,unsigned int offset,void * val,size_t bytes)2253 static int bmp580_nvmem_read(void *priv, unsigned int offset, void *val,
2254 size_t bytes)
2255 {
2256 struct bmp280_data *data = priv;
2257 int ret;
2258
2259 pm_runtime_get_sync(data->dev);
2260 ret = bmp580_nvmem_read_impl(priv, offset, val, bytes);
2261 pm_runtime_mark_last_busy(data->dev);
2262 pm_runtime_put_autosuspend(data->dev);
2263
2264 return ret;
2265 }
2266
bmp580_nvmem_write_impl(void * priv,unsigned int offset,void * val,size_t bytes)2267 static int bmp580_nvmem_write_impl(void *priv, unsigned int offset, void *val,
2268 size_t bytes)
2269 {
2270 struct bmp280_data *data = priv;
2271 u16 *buf = val;
2272 int ret, addr;
2273
2274 guard(mutex)(&data->lock);
2275
2276 /* Set sensor in standby mode */
2277 ret = regmap_update_bits(data->regmap, BMP580_REG_ODR_CONFIG,
2278 BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS,
2279 BMP580_ODR_DEEPSLEEP_DIS |
2280 FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP));
2281 if (ret) {
2282 dev_err(data->dev, "failed to change sensor to standby mode\n");
2283 goto exit;
2284 }
2285 /* Wait standby transition time */
2286 fsleep(2500);
2287
2288 while (bytes >= sizeof(*buf)) {
2289 addr = bmp580_nvmem_addrs[offset / sizeof(*buf)];
2290
2291 ret = regmap_write(data->regmap, BMP580_REG_NVM_ADDR,
2292 BMP580_NVM_PROG_EN |
2293 FIELD_PREP(BMP580_NVM_ROW_ADDR_MASK, addr));
2294 if (ret) {
2295 dev_err(data->dev, "error writing nvm address\n");
2296 goto exit;
2297 }
2298 data->le16 = cpu_to_le16(*buf++);
2299
2300 ret = regmap_bulk_write(data->regmap, BMP580_REG_NVM_DATA_LSB,
2301 &data->le16, sizeof(data->le16));
2302 if (ret) {
2303 dev_err(data->dev, "error writing LSB NVM data regs\n");
2304 goto exit;
2305 }
2306
2307 ret = bmp580_nvm_operation(data, true);
2308 if (ret)
2309 goto exit;
2310
2311 /* Disable programming mode bit */
2312 ret = regmap_clear_bits(data->regmap, BMP580_REG_NVM_ADDR,
2313 BMP580_NVM_PROG_EN);
2314 if (ret) {
2315 dev_err(data->dev, "error resetting nvm write\n");
2316 goto exit;
2317 }
2318
2319 bytes -= sizeof(*buf);
2320 offset += sizeof(*buf);
2321 }
2322 exit:
2323 /* Restore chip config */
2324 data->chip_info->chip_config(data);
2325 return ret;
2326 }
2327
bmp580_nvmem_write(void * priv,unsigned int offset,void * val,size_t bytes)2328 static int bmp580_nvmem_write(void *priv, unsigned int offset, void *val,
2329 size_t bytes)
2330 {
2331 struct bmp280_data *data = priv;
2332 int ret;
2333
2334 pm_runtime_get_sync(data->dev);
2335 ret = bmp580_nvmem_write_impl(priv, offset, val, bytes);
2336 pm_runtime_mark_last_busy(data->dev);
2337 pm_runtime_put_autosuspend(data->dev);
2338
2339 return ret;
2340 }
2341
bmp580_preinit(struct bmp280_data * data)2342 static int bmp580_preinit(struct bmp280_data *data)
2343 {
2344 struct nvmem_config config = {
2345 .dev = data->dev,
2346 .priv = data,
2347 .name = "bmp580_nvmem",
2348 .word_size = sizeof(u16),
2349 .stride = sizeof(u16),
2350 .size = 3 * sizeof(u16),
2351 .reg_read = bmp580_nvmem_read,
2352 .reg_write = bmp580_nvmem_write,
2353 };
2354 unsigned int reg;
2355 int ret;
2356
2357 /* Issue soft-reset command */
2358 ret = bmp580_soft_reset(data);
2359 if (ret)
2360 return ret;
2361
2362 /* Post powerup sequence */
2363 ret = regmap_read(data->regmap, BMP580_REG_CHIP_ID, ®);
2364 if (ret) {
2365 dev_err(data->dev, "failed to establish comms with the chip\n");
2366 return ret;
2367 }
2368
2369 /* Print warn message if we don't know the chip id */
2370 if (reg != BMP580_CHIP_ID && reg != BMP580_CHIP_ID_ALT)
2371 dev_warn(data->dev, "unexpected chip_id\n");
2372
2373 ret = regmap_read(data->regmap, BMP580_REG_STATUS, ®);
2374 if (ret) {
2375 dev_err(data->dev, "failed to read nvm status\n");
2376 return ret;
2377 }
2378
2379 /* Check nvm status */
2380 if (!(reg & BMP580_STATUS_NVM_RDY_MASK) || (reg & BMP580_STATUS_NVM_ERR_MASK)) {
2381 dev_err(data->dev, "nvm error on powerup sequence\n");
2382 return -EIO;
2383 }
2384
2385 /* Register nvmem device */
2386 return PTR_ERR_OR_ZERO(devm_nvmem_register(config.dev, &config));
2387 }
2388
2389 static const u8 bmp580_operation_mode[] = {
2390 [BMP280_SLEEP] = BMP580_MODE_SLEEP,
2391 [BMP280_FORCED] = BMP580_MODE_FORCED,
2392 [BMP280_NORMAL] = BMP580_MODE_NORMAL,
2393 };
2394
bmp580_set_mode(struct bmp280_data * data,enum bmp280_op_mode mode)2395 static int bmp580_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
2396 {
2397 struct device *dev = data->dev;
2398 int ret;
2399
2400 if (mode == BMP280_FORCED) {
2401 ret = regmap_set_bits(data->regmap, BMP580_REG_DSP_CONFIG,
2402 BMP580_DSP_IIR_FORCED_FLUSH);
2403 if (ret) {
2404 dev_err(dev, "Could not flush IIR filter constants.\n");
2405 return ret;
2406 }
2407 }
2408
2409 ret = regmap_write_bits(data->regmap, BMP580_REG_ODR_CONFIG,
2410 BMP580_MODE_MASK,
2411 FIELD_PREP(BMP580_MODE_MASK,
2412 bmp580_operation_mode[mode]));
2413 if (ret) {
2414 dev_err(dev, "failed to write power control register.\n");
2415 return ret;
2416 }
2417
2418 data->op_mode = mode;
2419
2420 return 0;
2421 }
2422
bmp580_wait_conv(struct bmp280_data * data)2423 static int bmp580_wait_conv(struct bmp280_data *data)
2424 {
2425 /*
2426 * Taken from datasheet, Section 2 "Specification, Table 3 "Electrical
2427 * characteristics.
2428 */
2429 static const int time_conv_press[] = {
2430 0, 1050, 1785, 3045, 5670, 10920, 21420, 42420,
2431 84420,
2432 };
2433 static const int time_conv_temp[] = {
2434 0, 1050, 1105, 1575, 2205, 3465, 6090, 11340,
2435 21840,
2436 };
2437 int meas_time_us;
2438
2439 meas_time_us = 4 * USEC_PER_MSEC +
2440 time_conv_temp[data->oversampling_temp] +
2441 time_conv_press[data->oversampling_press];
2442
2443 /*
2444 * Measurement time mentioned in Chapter 2, Table 4 of the datasheet.
2445 * The extra 4ms is the required mode change to start of measurement
2446 * time.
2447 */
2448 fsleep(meas_time_us);
2449
2450 return 0;
2451 }
2452
bmp580_chip_config(struct bmp280_data * data)2453 static int bmp580_chip_config(struct bmp280_data *data)
2454 {
2455 bool change = false, aux;
2456 unsigned int tmp;
2457 u8 reg_val;
2458 int ret;
2459
2460 /* Sets sensor in standby mode */
2461 ret = regmap_update_bits(data->regmap, BMP580_REG_ODR_CONFIG,
2462 BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS,
2463 BMP580_ODR_DEEPSLEEP_DIS |
2464 FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP));
2465 if (ret) {
2466 dev_err(data->dev, "failed to change sensor to standby mode\n");
2467 return ret;
2468 }
2469 /* From datasheet's table 4: electrical characteristics */
2470 fsleep(2500);
2471
2472 /* Set default DSP mode settings */
2473 reg_val = FIELD_PREP(BMP580_DSP_COMP_MASK, BMP580_DSP_PRESS_TEMP_COMP_EN) |
2474 BMP580_DSP_SHDW_IIR_TEMP_EN | BMP580_DSP_SHDW_IIR_PRESS_EN;
2475
2476 ret = regmap_update_bits(data->regmap, BMP580_REG_DSP_CONFIG,
2477 BMP580_DSP_COMP_MASK |
2478 BMP580_DSP_SHDW_IIR_TEMP_EN |
2479 BMP580_DSP_SHDW_IIR_PRESS_EN, reg_val);
2480 if (ret) {
2481 dev_err(data->dev, "failed to change DSP mode settings\n");
2482 return ret;
2483 }
2484
2485 /* Configure oversampling */
2486 reg_val = FIELD_PREP(BMP580_OSR_TEMP_MASK, data->oversampling_temp) |
2487 FIELD_PREP(BMP580_OSR_PRESS_MASK, data->oversampling_press) |
2488 BMP580_OSR_PRESS_EN;
2489
2490 ret = regmap_update_bits_check(data->regmap, BMP580_REG_OSR_CONFIG,
2491 BMP580_OSR_TEMP_MASK |
2492 BMP580_OSR_PRESS_MASK |
2493 BMP580_OSR_PRESS_EN,
2494 reg_val, &aux);
2495 if (ret) {
2496 dev_err(data->dev, "failed to write oversampling register\n");
2497 return ret;
2498 }
2499 change = change || aux;
2500
2501 /* Configure output data rate */
2502 ret = regmap_update_bits_check(data->regmap, BMP580_REG_ODR_CONFIG, BMP580_ODR_MASK,
2503 FIELD_PREP(BMP580_ODR_MASK, data->sampling_freq),
2504 &aux);
2505 if (ret) {
2506 dev_err(data->dev, "failed to write ODR configuration register\n");
2507 return ret;
2508 }
2509 change = change || aux;
2510
2511 /* Set filter data */
2512 reg_val = FIELD_PREP(BMP580_DSP_IIR_PRESS_MASK, data->iir_filter_coeff) |
2513 FIELD_PREP(BMP580_DSP_IIR_TEMP_MASK, data->iir_filter_coeff);
2514
2515 ret = regmap_update_bits(data->regmap, BMP580_REG_DSP_IIR,
2516 BMP580_DSP_IIR_PRESS_MASK | BMP580_DSP_IIR_TEMP_MASK,
2517 reg_val);
2518 if (ret) {
2519 dev_err(data->dev, "failed to write config register\n");
2520 return ret;
2521 }
2522
2523 if (change) {
2524 /*
2525 * Check if ODR and OSR settings are valid or we are
2526 * operating in a degraded mode.
2527 */
2528 ret = regmap_read(data->regmap, BMP580_REG_EFF_OSR, &tmp);
2529 if (ret) {
2530 dev_err(data->dev,
2531 "error reading effective OSR register\n");
2532 return ret;
2533 }
2534 if (!(tmp & BMP580_EFF_OSR_VALID_ODR)) {
2535 dev_warn(data->dev, "OSR and ODR incompatible settings detected\n");
2536 /* Set current OSR settings from data on effective OSR */
2537 data->oversampling_temp = FIELD_GET(BMP580_EFF_OSR_TEMP_MASK, tmp);
2538 data->oversampling_press = FIELD_GET(BMP580_EFF_OSR_PRESS_MASK, tmp);
2539 return -EINVAL;
2540 }
2541 }
2542
2543 return 0;
2544 }
2545
bmp580_data_rdy_trigger_set_state(struct iio_trigger * trig,bool state)2546 static int bmp580_data_rdy_trigger_set_state(struct iio_trigger *trig,
2547 bool state)
2548 {
2549 struct bmp280_data *data = iio_trigger_get_drvdata(trig);
2550 int ret;
2551
2552 guard(mutex)(&data->lock);
2553
2554 ret = regmap_update_bits(data->regmap, BMP580_REG_INT_CONFIG,
2555 BMP580_INT_CONFIG_INT_EN,
2556 FIELD_PREP(BMP580_INT_CONFIG_INT_EN, !!state));
2557 if (ret)
2558 dev_err(data->dev,
2559 "Could not %s interrupt.\n", str_enable_disable(state));
2560 return ret;
2561 }
2562
2563 static const struct iio_trigger_ops bmp580_trigger_ops = {
2564 .set_trigger_state = &bmp580_data_rdy_trigger_set_state,
2565 };
2566
bmp580_int_pin_config(struct bmp280_data * data)2567 static int bmp580_int_pin_config(struct bmp280_data *data)
2568 {
2569 int pin_drive_cfg = FIELD_PREP(BMP580_INT_CONFIG_OPEN_DRAIN,
2570 data->trig_open_drain);
2571 int pin_level_cfg = FIELD_PREP(BMP580_INT_CONFIG_LEVEL,
2572 data->trig_active_high);
2573 int ret, int_pin_cfg = pin_drive_cfg | pin_level_cfg;
2574
2575 ret = regmap_update_bits(data->regmap, BMP580_REG_INT_CONFIG,
2576 BMP580_INT_CONFIG_MASK, int_pin_cfg);
2577 if (ret) {
2578 dev_err(data->dev, "Could not set interrupt settings.\n");
2579 return ret;
2580 }
2581
2582 ret = regmap_set_bits(data->regmap, BMP580_REG_INT_SOURCE,
2583 BMP580_INT_SOURCE_DRDY);
2584 if (ret)
2585 dev_err(data->dev, "Could not set interrupt source.\n");
2586
2587 return ret;
2588 }
2589
bmp580_irq_thread_handler(int irq,void * p)2590 static irqreturn_t bmp580_irq_thread_handler(int irq, void *p)
2591 {
2592 struct iio_dev *indio_dev = p;
2593 struct bmp280_data *data = iio_priv(indio_dev);
2594 unsigned int int_ctrl;
2595 int ret;
2596
2597 ret = regmap_read(data->regmap, BMP580_REG_INT_STATUS, &int_ctrl);
2598 if (ret)
2599 return IRQ_NONE;
2600
2601 if (FIELD_GET(BMP580_INT_STATUS_DRDY_MASK, int_ctrl))
2602 iio_trigger_poll_nested(data->trig);
2603
2604 return IRQ_HANDLED;
2605 }
2606
bmp580_trigger_probe(struct iio_dev * indio_dev)2607 static int bmp580_trigger_probe(struct iio_dev *indio_dev)
2608 {
2609 return __bmp280_trigger_probe(indio_dev, &bmp580_trigger_ops,
2610 bmp580_int_pin_config,
2611 bmp580_irq_thread_handler);
2612 }
2613
bmp580_trigger_handler(int irq,void * p)2614 static irqreturn_t bmp580_trigger_handler(int irq, void *p)
2615 {
2616 struct iio_poll_func *pf = p;
2617 struct iio_dev *indio_dev = pf->indio_dev;
2618 struct bmp280_data *data = iio_priv(indio_dev);
2619 struct {
2620 __le32 comp_temp;
2621 __le32 comp_press;
2622 aligned_s64 timestamp;
2623 } buffer;
2624 int ret;
2625
2626 guard(mutex)(&data->lock);
2627
2628 /* Burst read data registers */
2629 ret = regmap_bulk_read(data->regmap, BMP580_REG_TEMP_XLSB,
2630 data->buf, BMP280_BURST_READ_BYTES);
2631 if (ret) {
2632 dev_err(data->dev, "failed to burst read sensor data\n");
2633 goto out;
2634 }
2635
2636 /* Pressure calculations */
2637 memcpy(&buffer.comp_press, &data->buf[3], 3);
2638
2639 /* Temperature calculations */
2640 memcpy(&buffer.comp_temp, &data->buf[0], 3);
2641
2642 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer),
2643 iio_get_time_ns(indio_dev));
2644
2645 out:
2646 iio_trigger_notify_done(indio_dev->trig);
2647
2648 return IRQ_HANDLED;
2649 }
2650
2651 static const int bmp580_oversampling_avail[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
2652 static const u8 bmp580_chip_ids[] = { BMP580_CHIP_ID, BMP580_CHIP_ID_ALT };
2653 /* Instead of { 1000, 16 } we do this, to avoid overflow issues */
2654 static const int bmp580_temp_coeffs[] = { 125, 13 };
2655 static const int bmp580_press_coeffs[] = { 1, 64000};
2656
2657 const struct bmp280_chip_info bmp580_chip_info = {
2658 .id_reg = BMP580_REG_CHIP_ID,
2659 .chip_id = bmp580_chip_ids,
2660 .num_chip_id = ARRAY_SIZE(bmp580_chip_ids),
2661 .regmap_config = &bmp580_regmap_config,
2662 .start_up_time_us = 2000,
2663 .channels = bmp580_channels,
2664 .num_channels = ARRAY_SIZE(bmp580_channels),
2665 .avail_scan_masks = bmp280_avail_scan_masks,
2666
2667 .oversampling_temp_avail = bmp580_oversampling_avail,
2668 .num_oversampling_temp_avail = ARRAY_SIZE(bmp580_oversampling_avail),
2669 .oversampling_temp_default = ilog2(1),
2670
2671 .oversampling_press_avail = bmp580_oversampling_avail,
2672 .num_oversampling_press_avail = ARRAY_SIZE(bmp580_oversampling_avail),
2673 .oversampling_press_default = ilog2(4),
2674
2675 .sampling_freq_avail = bmp580_odr_table,
2676 .num_sampling_freq_avail = ARRAY_SIZE(bmp580_odr_table) * 2,
2677 .sampling_freq_default = BMP580_ODR_50HZ,
2678
2679 .iir_filter_coeffs_avail = bmp380_iir_filter_coeffs_avail,
2680 .num_iir_filter_coeffs_avail = ARRAY_SIZE(bmp380_iir_filter_coeffs_avail),
2681 .iir_filter_coeff_default = 2,
2682
2683 .temp_coeffs = bmp580_temp_coeffs,
2684 .temp_coeffs_type = IIO_VAL_FRACTIONAL_LOG2,
2685 .press_coeffs = bmp580_press_coeffs,
2686 .press_coeffs_type = IIO_VAL_FRACTIONAL,
2687
2688 .chip_config = bmp580_chip_config,
2689 .read_temp = bmp580_read_temp,
2690 .read_press = bmp580_read_press,
2691 .set_mode = bmp580_set_mode,
2692 .wait_conv = bmp580_wait_conv,
2693 .preinit = bmp580_preinit,
2694
2695 .trigger_probe = bmp580_trigger_probe,
2696 .trigger_handler = bmp580_trigger_handler,
2697 };
2698 EXPORT_SYMBOL_NS(bmp580_chip_info, "IIO_BMP280");
2699
bmp180_wait_for_eoc(struct bmp280_data * data,u8 ctrl_meas)2700 static int bmp180_wait_for_eoc(struct bmp280_data *data, u8 ctrl_meas)
2701 {
2702 static const int conversion_time_max[] = { 4500, 7500, 13500, 25500 };
2703 unsigned int delay_us;
2704 unsigned int ctrl;
2705 int ret;
2706
2707 if (data->use_eoc)
2708 reinit_completion(&data->done);
2709
2710 ret = regmap_write(data->regmap, BMP280_REG_CTRL_MEAS, ctrl_meas);
2711 if (ret) {
2712 dev_err(data->dev, "failed to write crtl_meas register\n");
2713 return ret;
2714 }
2715
2716 if (data->use_eoc) {
2717 /*
2718 * If we have a completion interrupt, use it, wait up to
2719 * 100ms. The longest conversion time listed is 76.5 ms for
2720 * advanced resolution mode.
2721 */
2722 ret = wait_for_completion_timeout(&data->done,
2723 1 + msecs_to_jiffies(100));
2724 if (!ret)
2725 dev_err(data->dev, "timeout waiting for completion\n");
2726 } else {
2727 if (FIELD_GET(BMP180_MEAS_CTRL_MASK, ctrl_meas) == BMP180_MEAS_TEMP)
2728 delay_us = 4500;
2729 else
2730 delay_us =
2731 conversion_time_max[data->oversampling_press];
2732
2733 fsleep(delay_us);
2734 }
2735
2736 ret = regmap_read(data->regmap, BMP280_REG_CTRL_MEAS, &ctrl);
2737 if (ret) {
2738 dev_err(data->dev, "failed to read ctrl_meas register\n");
2739 return ret;
2740 }
2741
2742 /* The value of this bit reset to "0" after conversion is complete */
2743 if (ctrl & BMP180_MEAS_SCO) {
2744 dev_err(data->dev, "conversion didn't complete\n");
2745 return -EIO;
2746 }
2747
2748 return 0;
2749 }
2750
bmp180_read_temp_adc(struct bmp280_data * data,u32 * adc_temp)2751 static int bmp180_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
2752 {
2753 int ret;
2754
2755 ret = bmp180_wait_for_eoc(data,
2756 FIELD_PREP(BMP180_MEAS_CTRL_MASK, BMP180_MEAS_TEMP) |
2757 BMP180_MEAS_SCO);
2758 if (ret)
2759 return ret;
2760
2761 ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB,
2762 &data->be16, sizeof(data->be16));
2763 if (ret) {
2764 dev_err(data->dev, "failed to read temperature\n");
2765 return ret;
2766 }
2767
2768 *adc_temp = be16_to_cpu(data->be16);
2769
2770 return 0;
2771 }
2772
bmp180_read_calib(struct bmp280_data * data)2773 static int bmp180_read_calib(struct bmp280_data *data)
2774 {
2775 struct bmp180_calib *calib = &data->calib.bmp180;
2776 int ret;
2777 int i;
2778
2779 ret = regmap_bulk_read(data->regmap, BMP180_REG_CALIB_START,
2780 data->bmp180_cal_buf, sizeof(data->bmp180_cal_buf));
2781 if (ret) {
2782 dev_err(data->dev, "failed to read calibration parameters\n");
2783 return ret;
2784 }
2785
2786 /* None of the words has the value 0 or 0xFFFF */
2787 for (i = 0; i < ARRAY_SIZE(data->bmp180_cal_buf); i++) {
2788 if (data->bmp180_cal_buf[i] == cpu_to_be16(0) ||
2789 data->bmp180_cal_buf[i] == cpu_to_be16(0xffff))
2790 return -EIO;
2791 }
2792
2793 /* Toss the calibration data into the entropy pool */
2794 add_device_randomness(data->bmp180_cal_buf,
2795 sizeof(data->bmp180_cal_buf));
2796
2797 calib->AC1 = be16_to_cpu(data->bmp180_cal_buf[AC1]);
2798 calib->AC2 = be16_to_cpu(data->bmp180_cal_buf[AC2]);
2799 calib->AC3 = be16_to_cpu(data->bmp180_cal_buf[AC3]);
2800 calib->AC4 = be16_to_cpu(data->bmp180_cal_buf[AC4]);
2801 calib->AC5 = be16_to_cpu(data->bmp180_cal_buf[AC5]);
2802 calib->AC6 = be16_to_cpu(data->bmp180_cal_buf[AC6]);
2803 calib->B1 = be16_to_cpu(data->bmp180_cal_buf[B1]);
2804 calib->B2 = be16_to_cpu(data->bmp180_cal_buf[B2]);
2805 calib->MB = be16_to_cpu(data->bmp180_cal_buf[MB]);
2806 calib->MC = be16_to_cpu(data->bmp180_cal_buf[MC]);
2807 calib->MD = be16_to_cpu(data->bmp180_cal_buf[MD]);
2808
2809 return 0;
2810 }
2811
2812 /*
2813 * Returns temperature in DegC, resolution is 0.1 DegC.
2814 * t_fine carries fine temperature as global value.
2815 *
2816 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
2817 */
2818
bmp180_calc_t_fine(struct bmp280_data * data,u32 adc_temp)2819 static s32 bmp180_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
2820 {
2821 struct bmp180_calib *calib = &data->calib.bmp180;
2822 s32 x1, x2;
2823
2824 x1 = ((((s32)adc_temp) - calib->AC6) * calib->AC5) >> 15;
2825 x2 = (calib->MC << 11) / (x1 + calib->MD);
2826 return x1 + x2; /* t_fine = x1 + x2; */
2827 }
2828
bmp180_get_t_fine(struct bmp280_data * data,s32 * t_fine)2829 static int bmp180_get_t_fine(struct bmp280_data *data, s32 *t_fine)
2830 {
2831 s32 adc_temp;
2832 int ret;
2833
2834 ret = bmp180_read_temp_adc(data, &adc_temp);
2835 if (ret)
2836 return ret;
2837
2838 *t_fine = bmp180_calc_t_fine(data, adc_temp);
2839
2840 return 0;
2841 }
2842
bmp180_compensate_temp(struct bmp280_data * data,u32 adc_temp)2843 static s32 bmp180_compensate_temp(struct bmp280_data *data, u32 adc_temp)
2844 {
2845 return (bmp180_calc_t_fine(data, adc_temp) + 8) / 16;
2846 }
2847
bmp180_read_temp(struct bmp280_data * data,s32 * comp_temp)2848 static int bmp180_read_temp(struct bmp280_data *data, s32 *comp_temp)
2849 {
2850 u32 adc_temp;
2851 int ret;
2852
2853 ret = bmp180_read_temp_adc(data, &adc_temp);
2854 if (ret)
2855 return ret;
2856
2857 *comp_temp = bmp180_compensate_temp(data, adc_temp);
2858
2859 return 0;
2860 }
2861
bmp180_read_press_adc(struct bmp280_data * data,u32 * adc_press)2862 static int bmp180_read_press_adc(struct bmp280_data *data, u32 *adc_press)
2863 {
2864 u8 oss = data->oversampling_press;
2865 int ret;
2866
2867 ret = bmp180_wait_for_eoc(data,
2868 FIELD_PREP(BMP180_MEAS_CTRL_MASK, BMP180_MEAS_PRESS) |
2869 FIELD_PREP(BMP180_OSRS_PRESS_MASK, oss) |
2870 BMP180_MEAS_SCO);
2871 if (ret)
2872 return ret;
2873
2874 ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB,
2875 data->buf, BMP280_NUM_PRESS_BYTES);
2876 if (ret) {
2877 dev_err(data->dev, "failed to read pressure\n");
2878 return ret;
2879 }
2880
2881 *adc_press = get_unaligned_be24(data->buf) >> (8 - oss);
2882
2883 return 0;
2884 }
2885
2886 /*
2887 * Returns pressure in Pa, resolution is 1 Pa.
2888 *
2889 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
2890 */
bmp180_compensate_press(struct bmp280_data * data,u32 adc_press,s32 t_fine)2891 static u32 bmp180_compensate_press(struct bmp280_data *data, u32 adc_press,
2892 s32 t_fine)
2893 {
2894 struct bmp180_calib *calib = &data->calib.bmp180;
2895 s32 oss = data->oversampling_press;
2896 s32 x1, x2, x3, p;
2897 s32 b3, b6;
2898 u32 b4, b7;
2899
2900 b6 = t_fine - 4000;
2901 x1 = (calib->B2 * (b6 * b6 >> 12)) >> 11;
2902 x2 = calib->AC2 * b6 >> 11;
2903 x3 = x1 + x2;
2904 b3 = ((((s32)calib->AC1 * 4 + x3) << oss) + 2) / 4;
2905 x1 = calib->AC3 * b6 >> 13;
2906 x2 = (calib->B1 * ((b6 * b6) >> 12)) >> 16;
2907 x3 = (x1 + x2 + 2) >> 2;
2908 b4 = calib->AC4 * (u32)(x3 + 32768) >> 15;
2909 b7 = (adc_press - b3) * (50000 >> oss);
2910 if (b7 < 0x80000000)
2911 p = (b7 * 2) / b4;
2912 else
2913 p = (b7 / b4) * 2;
2914
2915 x1 = (p >> 8) * (p >> 8);
2916 x1 = (x1 * 3038) >> 16;
2917 x2 = (-7357 * p) >> 16;
2918
2919 return p + ((x1 + x2 + 3791) >> 4);
2920 }
2921
bmp180_read_press(struct bmp280_data * data,u32 * comp_press)2922 static int bmp180_read_press(struct bmp280_data *data, u32 *comp_press)
2923 {
2924 u32 adc_press;
2925 s32 t_fine;
2926 int ret;
2927
2928 ret = bmp180_get_t_fine(data, &t_fine);
2929 if (ret)
2930 return ret;
2931
2932 ret = bmp180_read_press_adc(data, &adc_press);
2933 if (ret)
2934 return ret;
2935
2936 *comp_press = bmp180_compensate_press(data, adc_press, t_fine);
2937
2938 return 0;
2939 }
2940
2941 /* Keep compatibility with newer generations of the sensor */
bmp180_set_mode(struct bmp280_data * data,enum bmp280_op_mode mode)2942 static int bmp180_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
2943 {
2944 return 0;
2945 }
2946
2947 /* Keep compatibility with newer generations of the sensor */
bmp180_wait_conv(struct bmp280_data * data)2948 static int bmp180_wait_conv(struct bmp280_data *data)
2949 {
2950 return 0;
2951 }
2952
2953 /* Keep compatibility with newer generations of the sensor */
bmp180_chip_config(struct bmp280_data * data)2954 static int bmp180_chip_config(struct bmp280_data *data)
2955 {
2956 return 0;
2957 }
2958
bmp180_trigger_handler(int irq,void * p)2959 static irqreturn_t bmp180_trigger_handler(int irq, void *p)
2960 {
2961 struct iio_poll_func *pf = p;
2962 struct iio_dev *indio_dev = pf->indio_dev;
2963 struct bmp280_data *data = iio_priv(indio_dev);
2964 struct {
2965 u32 comp_press;
2966 s32 comp_temp;
2967 aligned_s64 timestamp;
2968 } buffer;
2969 int ret;
2970
2971 guard(mutex)(&data->lock);
2972
2973 ret = bmp180_read_temp(data, &buffer.comp_temp);
2974 if (ret)
2975 goto out;
2976
2977
2978 ret = bmp180_read_press(data, &buffer.comp_press);
2979 if (ret)
2980 goto out;
2981
2982 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer),
2983 iio_get_time_ns(indio_dev));
2984
2985 out:
2986 iio_trigger_notify_done(indio_dev->trig);
2987
2988 return IRQ_HANDLED;
2989 }
2990
2991 static const int bmp180_oversampling_temp_avail[] = { 1 };
2992 static const int bmp180_oversampling_press_avail[] = { 1, 2, 4, 8 };
2993 static const u8 bmp180_chip_ids[] = { BMP180_CHIP_ID };
2994 static const int bmp180_temp_coeffs[] = { 100, 1 };
2995 static const int bmp180_press_coeffs[] = { 1, 1000 };
2996
2997 const struct bmp280_chip_info bmp180_chip_info = {
2998 .id_reg = BMP280_REG_ID,
2999 .chip_id = bmp180_chip_ids,
3000 .num_chip_id = ARRAY_SIZE(bmp180_chip_ids),
3001 .regmap_config = &bmp180_regmap_config,
3002 .start_up_time_us = 2000,
3003 .channels = bmp280_channels,
3004 .num_channels = ARRAY_SIZE(bmp280_channels),
3005 .avail_scan_masks = bmp280_avail_scan_masks,
3006
3007 .oversampling_temp_avail = bmp180_oversampling_temp_avail,
3008 .num_oversampling_temp_avail =
3009 ARRAY_SIZE(bmp180_oversampling_temp_avail),
3010 .oversampling_temp_default = 0,
3011
3012 .oversampling_press_avail = bmp180_oversampling_press_avail,
3013 .num_oversampling_press_avail =
3014 ARRAY_SIZE(bmp180_oversampling_press_avail),
3015 .oversampling_press_default = BMP180_MEAS_PRESS_8X,
3016
3017 .temp_coeffs = bmp180_temp_coeffs,
3018 .temp_coeffs_type = IIO_VAL_FRACTIONAL,
3019 .press_coeffs = bmp180_press_coeffs,
3020 .press_coeffs_type = IIO_VAL_FRACTIONAL,
3021
3022 .chip_config = bmp180_chip_config,
3023 .read_temp = bmp180_read_temp,
3024 .read_press = bmp180_read_press,
3025 .read_calib = bmp180_read_calib,
3026 .set_mode = bmp180_set_mode,
3027 .wait_conv = bmp180_wait_conv,
3028
3029 .trigger_handler = bmp180_trigger_handler,
3030 };
3031 EXPORT_SYMBOL_NS(bmp180_chip_info, "IIO_BMP280");
3032
bmp085_eoc_irq(int irq,void * d)3033 static irqreturn_t bmp085_eoc_irq(int irq, void *d)
3034 {
3035 struct bmp280_data *data = d;
3036
3037 complete(&data->done);
3038
3039 return IRQ_HANDLED;
3040 }
3041
bmp085_trigger_probe(struct iio_dev * indio_dev)3042 static int bmp085_trigger_probe(struct iio_dev *indio_dev)
3043 {
3044 struct bmp280_data *data = iio_priv(indio_dev);
3045 struct device *dev = data->dev;
3046 unsigned long irq_trig;
3047 int ret, irq;
3048
3049 irq = fwnode_irq_get(dev_fwnode(dev), 0);
3050 if (irq < 0)
3051 return dev_err_probe(dev, irq, "No interrupt found.\n");
3052
3053 irq_trig = irq_get_trigger_type(irq);
3054 if (irq_trig != IRQF_TRIGGER_RISING) {
3055 dev_err(dev, "non-rising trigger given for EOC interrupt, trying to enforce it\n");
3056 irq_trig = IRQF_TRIGGER_RISING;
3057 }
3058
3059 init_completion(&data->done);
3060
3061 ret = devm_request_irq(dev, irq, bmp085_eoc_irq, irq_trig,
3062 indio_dev->name, data);
3063 if (ret) {
3064 /* Bail out without IRQ but keep the driver in place */
3065 dev_err(dev, "unable to request DRDY IRQ\n");
3066 return 0;
3067 }
3068
3069 data->use_eoc = true;
3070
3071 return 0;
3072 }
3073
3074 /* Identical to bmp180_chip_info + bmp085_trigger_probe */
3075 const struct bmp280_chip_info bmp085_chip_info = {
3076 .id_reg = BMP280_REG_ID,
3077 .chip_id = bmp180_chip_ids,
3078 .num_chip_id = ARRAY_SIZE(bmp180_chip_ids),
3079 .regmap_config = &bmp180_regmap_config,
3080 .start_up_time_us = 2000,
3081 .channels = bmp280_channels,
3082 .num_channels = ARRAY_SIZE(bmp280_channels),
3083 .avail_scan_masks = bmp280_avail_scan_masks,
3084
3085 .oversampling_temp_avail = bmp180_oversampling_temp_avail,
3086 .num_oversampling_temp_avail =
3087 ARRAY_SIZE(bmp180_oversampling_temp_avail),
3088 .oversampling_temp_default = 0,
3089
3090 .oversampling_press_avail = bmp180_oversampling_press_avail,
3091 .num_oversampling_press_avail =
3092 ARRAY_SIZE(bmp180_oversampling_press_avail),
3093 .oversampling_press_default = BMP180_MEAS_PRESS_8X,
3094
3095 .temp_coeffs = bmp180_temp_coeffs,
3096 .temp_coeffs_type = IIO_VAL_FRACTIONAL,
3097 .press_coeffs = bmp180_press_coeffs,
3098 .press_coeffs_type = IIO_VAL_FRACTIONAL,
3099
3100 .chip_config = bmp180_chip_config,
3101 .read_temp = bmp180_read_temp,
3102 .read_press = bmp180_read_press,
3103 .read_calib = bmp180_read_calib,
3104 .set_mode = bmp180_set_mode,
3105 .wait_conv = bmp180_wait_conv,
3106
3107 .trigger_probe = bmp085_trigger_probe,
3108 .trigger_handler = bmp180_trigger_handler,
3109 };
3110 EXPORT_SYMBOL_NS(bmp085_chip_info, "IIO_BMP280");
3111
bmp280_buffer_preenable(struct iio_dev * indio_dev)3112 static int bmp280_buffer_preenable(struct iio_dev *indio_dev)
3113 {
3114 struct bmp280_data *data = iio_priv(indio_dev);
3115
3116 pm_runtime_get_sync(data->dev);
3117 data->chip_info->set_mode(data, BMP280_NORMAL);
3118
3119 return 0;
3120 }
3121
bmp280_buffer_postdisable(struct iio_dev * indio_dev)3122 static int bmp280_buffer_postdisable(struct iio_dev *indio_dev)
3123 {
3124 struct bmp280_data *data = iio_priv(indio_dev);
3125
3126 pm_runtime_mark_last_busy(data->dev);
3127 pm_runtime_put_autosuspend(data->dev);
3128
3129 return 0;
3130 }
3131
3132 static const struct iio_buffer_setup_ops bmp280_buffer_setup_ops = {
3133 .preenable = bmp280_buffer_preenable,
3134 .postdisable = bmp280_buffer_postdisable,
3135 };
3136
bmp280_pm_disable(void * data)3137 static void bmp280_pm_disable(void *data)
3138 {
3139 struct device *dev = data;
3140
3141 pm_runtime_get_sync(dev);
3142 pm_runtime_put_noidle(dev);
3143 pm_runtime_disable(dev);
3144 }
3145
bmp280_regulators_disable(void * data)3146 static void bmp280_regulators_disable(void *data)
3147 {
3148 struct regulator_bulk_data *supplies = data;
3149
3150 regulator_bulk_disable(BMP280_NUM_SUPPLIES, supplies);
3151 }
3152
bmp280_common_probe(struct device * dev,struct regmap * regmap,const struct bmp280_chip_info * chip_info,const char * name,int irq)3153 int bmp280_common_probe(struct device *dev,
3154 struct regmap *regmap,
3155 const struct bmp280_chip_info *chip_info,
3156 const char *name,
3157 int irq)
3158 {
3159 struct iio_dev *indio_dev;
3160 struct bmp280_data *data;
3161 struct gpio_desc *gpiod;
3162 unsigned int chip_id;
3163 unsigned int i;
3164 int ret;
3165
3166 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
3167 if (!indio_dev)
3168 return -ENOMEM;
3169
3170 data = iio_priv(indio_dev);
3171 mutex_init(&data->lock);
3172 data->dev = dev;
3173
3174 indio_dev->name = name;
3175 indio_dev->info = &bmp280_info;
3176 indio_dev->modes = INDIO_DIRECT_MODE;
3177
3178 data->chip_info = chip_info;
3179
3180 /* Apply initial values from chip info structure */
3181 indio_dev->channels = chip_info->channels;
3182 indio_dev->num_channels = chip_info->num_channels;
3183 indio_dev->available_scan_masks = chip_info->avail_scan_masks;
3184 data->oversampling_press = chip_info->oversampling_press_default;
3185 data->oversampling_humid = chip_info->oversampling_humid_default;
3186 data->oversampling_temp = chip_info->oversampling_temp_default;
3187 data->iir_filter_coeff = chip_info->iir_filter_coeff_default;
3188 data->sampling_freq = chip_info->sampling_freq_default;
3189 data->start_up_time_us = chip_info->start_up_time_us;
3190
3191 /* Bring up regulators */
3192 regulator_bulk_set_supply_names(data->supplies,
3193 bmp280_supply_names,
3194 BMP280_NUM_SUPPLIES);
3195
3196 ret = devm_regulator_bulk_get(dev,
3197 BMP280_NUM_SUPPLIES, data->supplies);
3198 if (ret) {
3199 dev_err(dev, "failed to get regulators\n");
3200 return ret;
3201 }
3202
3203 ret = regulator_bulk_enable(BMP280_NUM_SUPPLIES, data->supplies);
3204 if (ret) {
3205 dev_err(dev, "failed to enable regulators\n");
3206 return ret;
3207 }
3208
3209 ret = devm_add_action_or_reset(dev, bmp280_regulators_disable,
3210 data->supplies);
3211 if (ret)
3212 return ret;
3213
3214 /* Wait to make sure we started up properly */
3215 fsleep(data->start_up_time_us);
3216
3217 /* Bring chip out of reset if there is an assigned GPIO line */
3218 gpiod = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
3219 /* Deassert the signal */
3220 if (gpiod) {
3221 dev_info(dev, "release reset\n");
3222 gpiod_set_value(gpiod, 0);
3223 }
3224
3225 data->regmap = regmap;
3226
3227 ret = regmap_read(regmap, data->chip_info->id_reg, &chip_id);
3228 if (ret) {
3229 dev_err(data->dev, "failed to read chip id\n");
3230 return ret;
3231 }
3232
3233 for (i = 0; i < data->chip_info->num_chip_id; i++) {
3234 if (chip_id == data->chip_info->chip_id[i]) {
3235 dev_info(dev, "0x%x is a known chip id for %s\n", chip_id, name);
3236 break;
3237 }
3238 }
3239
3240 if (i == data->chip_info->num_chip_id)
3241 dev_warn(dev, "bad chip id: 0x%x is not a known chip id\n", chip_id);
3242
3243 if (data->chip_info->preinit) {
3244 ret = data->chip_info->preinit(data);
3245 if (ret)
3246 return dev_err_probe(data->dev, ret,
3247 "error running preinit tasks\n");
3248 }
3249
3250 ret = data->chip_info->chip_config(data);
3251 if (ret)
3252 return ret;
3253
3254 dev_set_drvdata(dev, indio_dev);
3255
3256 /*
3257 * Some chips have calibration parameters "programmed into the devices'
3258 * non-volatile memory during production". Let's read them out at probe
3259 * time once. They will not change.
3260 */
3261
3262 if (data->chip_info->read_calib) {
3263 ret = data->chip_info->read_calib(data);
3264 if (ret)
3265 return dev_err_probe(data->dev, ret,
3266 "failed to read calibration coefficients\n");
3267 }
3268
3269 ret = devm_iio_triggered_buffer_setup(data->dev, indio_dev,
3270 iio_pollfunc_store_time,
3271 data->chip_info->trigger_handler,
3272 &bmp280_buffer_setup_ops);
3273 if (ret)
3274 return dev_err_probe(data->dev, ret,
3275 "iio triggered buffer setup failed\n");
3276
3277 /*
3278 * Attempt to grab an optional EOC IRQ - only the BMP085 has this
3279 * however as it happens, the BMP085 shares the chip ID of BMP180
3280 * so we look for an IRQ if we have that.
3281 */
3282 if (irq > 0) {
3283 if (data->chip_info->trigger_probe)
3284 ret = data->chip_info->trigger_probe(indio_dev);
3285 if (ret)
3286 return ret;
3287 }
3288
3289 ret = data->chip_info->set_mode(data, BMP280_SLEEP);
3290 if (ret)
3291 return dev_err_probe(dev, ret, "Failed to set sleep mode\n");
3292
3293 /* Enable runtime PM */
3294 pm_runtime_get_noresume(dev);
3295 pm_runtime_set_active(dev);
3296 pm_runtime_enable(dev);
3297 /*
3298 * Set autosuspend to two orders of magnitude larger than the
3299 * start-up time.
3300 */
3301 pm_runtime_set_autosuspend_delay(dev, data->start_up_time_us / 10);
3302 pm_runtime_use_autosuspend(dev);
3303 pm_runtime_put(dev);
3304
3305 ret = devm_add_action_or_reset(dev, bmp280_pm_disable, dev);
3306 if (ret)
3307 return ret;
3308
3309 return devm_iio_device_register(dev, indio_dev);
3310 }
3311 EXPORT_SYMBOL_NS(bmp280_common_probe, "IIO_BMP280");
3312
bmp280_runtime_suspend(struct device * dev)3313 static int bmp280_runtime_suspend(struct device *dev)
3314 {
3315 struct iio_dev *indio_dev = dev_get_drvdata(dev);
3316 struct bmp280_data *data = iio_priv(indio_dev);
3317
3318 data->chip_info->set_mode(data, BMP280_SLEEP);
3319
3320 fsleep(data->start_up_time_us);
3321 return regulator_bulk_disable(BMP280_NUM_SUPPLIES, data->supplies);
3322 }
3323
bmp280_runtime_resume(struct device * dev)3324 static int bmp280_runtime_resume(struct device *dev)
3325 {
3326 struct iio_dev *indio_dev = dev_get_drvdata(dev);
3327 struct bmp280_data *data = iio_priv(indio_dev);
3328 int ret;
3329
3330 ret = regulator_bulk_enable(BMP280_NUM_SUPPLIES, data->supplies);
3331 if (ret)
3332 return ret;
3333
3334 fsleep(data->start_up_time_us);
3335
3336 ret = data->chip_info->chip_config(data);
3337 if (ret)
3338 return ret;
3339
3340 return data->chip_info->set_mode(data, data->op_mode);
3341 }
3342
3343 EXPORT_RUNTIME_DEV_PM_OPS(bmp280_dev_pm_ops, bmp280_runtime_suspend,
3344 bmp280_runtime_resume, NULL);
3345
3346 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
3347 MODULE_DESCRIPTION("Driver for Bosch Sensortec BMP180/BMP280 pressure and temperature sensor");
3348 MODULE_LICENSE("GPL v2");
3349