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 = { }; /* Don't leak uninitialized stack to userspace. */
1238 int ret;
1239
1240 guard(mutex)(&data->lock);
1241
1242 /* Burst read data registers */
1243 ret = regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB,
1244 data->buf, BME280_BURST_READ_BYTES);
1245 if (ret) {
1246 dev_err(data->dev, "failed to burst read sensor data\n");
1247 goto out;
1248 }
1249
1250 /* Temperature calculations */
1251 adc_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[3]));
1252 if (adc_temp == BMP280_TEMP_SKIPPED) {
1253 dev_err(data->dev, "reading temperature skipped\n");
1254 goto out;
1255 }
1256
1257 buffer.comp_temp = bmp280_compensate_temp(data, adc_temp);
1258
1259 /* Pressure calculations */
1260 adc_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[0]));
1261 if (adc_press == BMP280_PRESS_SKIPPED) {
1262 dev_err(data->dev, "reading pressure skipped\n");
1263 goto out;
1264 }
1265
1266 t_fine = bmp280_calc_t_fine(data, adc_temp);
1267 buffer.comp_press = bmp280_compensate_press(data, adc_press, t_fine);
1268
1269 /* Humidity calculations */
1270 adc_humidity = get_unaligned_be16(&data->buf[6]);
1271
1272 if (adc_humidity == BMP280_HUMIDITY_SKIPPED) {
1273 dev_err(data->dev, "reading humidity skipped\n");
1274 goto out;
1275 }
1276
1277 buffer.comp_humidity = bme280_compensate_humidity(data, adc_humidity,
1278 t_fine);
1279
1280 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer),
1281 iio_get_time_ns(indio_dev));
1282
1283 out:
1284 iio_trigger_notify_done(indio_dev->trig);
1285
1286 return IRQ_HANDLED;
1287 }
1288
__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)1289 static int __bmp280_trigger_probe(struct iio_dev *indio_dev,
1290 const struct iio_trigger_ops *trigger_ops,
1291 int (*int_pin_config)(struct bmp280_data *data),
1292 irq_handler_t irq_thread_handler)
1293 {
1294 struct bmp280_data *data = iio_priv(indio_dev);
1295 struct device *dev = data->dev;
1296 u32 irq_type;
1297 int ret, irq;
1298
1299 irq = fwnode_irq_get(dev_fwnode(dev), 0);
1300 if (irq < 0)
1301 return dev_err_probe(dev, irq, "No interrupt found.\n");
1302
1303 irq_type = irq_get_trigger_type(irq);
1304 switch (irq_type) {
1305 case IRQF_TRIGGER_RISING:
1306 data->trig_active_high = true;
1307 break;
1308 case IRQF_TRIGGER_FALLING:
1309 data->trig_active_high = false;
1310 break;
1311 default:
1312 return dev_err_probe(dev, -EINVAL, "Invalid interrupt type specified.\n");
1313 }
1314
1315 data->trig_open_drain =
1316 fwnode_property_read_bool(dev_fwnode(dev), "int-open-drain");
1317
1318 ret = int_pin_config(data);
1319 if (ret)
1320 return ret;
1321
1322 data->trig = devm_iio_trigger_alloc(data->dev, "%s-dev%d",
1323 indio_dev->name,
1324 iio_device_id(indio_dev));
1325 if (!data->trig)
1326 return -ENOMEM;
1327
1328 data->trig->ops = trigger_ops;
1329 iio_trigger_set_drvdata(data->trig, data);
1330
1331 ret = devm_request_threaded_irq(data->dev, irq, NULL,
1332 irq_thread_handler, IRQF_ONESHOT,
1333 indio_dev->name, indio_dev);
1334 if (ret)
1335 return dev_err_probe(dev, ret, "request IRQ failed.\n");
1336
1337 ret = devm_iio_trigger_register(data->dev, data->trig);
1338 if (ret)
1339 return dev_err_probe(dev, ret, "iio trigger register failed.\n");
1340
1341 indio_dev->trig = iio_trigger_get(data->trig);
1342
1343 return 0;
1344 }
1345
1346 static const u8 bme280_chip_ids[] = { BME280_CHIP_ID };
1347 static const int bme280_humid_coeffs[] = { 1000, 1024 };
1348
1349 const struct bmp280_chip_info bme280_chip_info = {
1350 .id_reg = BMP280_REG_ID,
1351 .chip_id = bme280_chip_ids,
1352 .num_chip_id = ARRAY_SIZE(bme280_chip_ids),
1353 .regmap_config = &bme280_regmap_config,
1354 .start_up_time_us = 2000,
1355 .channels = bme280_channels,
1356 .num_channels = ARRAY_SIZE(bme280_channels),
1357 .avail_scan_masks = bme280_avail_scan_masks,
1358
1359 .oversampling_temp_avail = bmp280_oversampling_avail,
1360 .num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1361 .oversampling_temp_default = BMP280_OSRS_TEMP_2X - 1,
1362
1363 .oversampling_press_avail = bmp280_oversampling_avail,
1364 .num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1365 .oversampling_press_default = BMP280_OSRS_PRESS_16X - 1,
1366
1367 .oversampling_humid_avail = bmp280_oversampling_avail,
1368 .num_oversampling_humid_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1369 .oversampling_humid_default = BME280_OSRS_HUMIDITY_16X - 1,
1370
1371 .temp_coeffs = bmp280_temp_coeffs,
1372 .temp_coeffs_type = IIO_VAL_FRACTIONAL,
1373 .press_coeffs = bmp280_press_coeffs,
1374 .press_coeffs_type = IIO_VAL_FRACTIONAL,
1375 .humid_coeffs = bme280_humid_coeffs,
1376 .humid_coeffs_type = IIO_VAL_FRACTIONAL,
1377
1378 .chip_config = bme280_chip_config,
1379 .read_temp = bmp280_read_temp,
1380 .read_press = bmp280_read_press,
1381 .read_humid = bme280_read_humid,
1382 .read_calib = bme280_read_calib,
1383 .set_mode = bmp280_set_mode,
1384 .wait_conv = bmp280_wait_conv,
1385 .preinit = bmp280_preinit,
1386
1387 .trigger_handler = bme280_trigger_handler,
1388 };
1389 EXPORT_SYMBOL_NS(bme280_chip_info, "IIO_BMP280");
1390
1391 /*
1392 * Helper function to send a command to BMP3XX sensors.
1393 *
1394 * Sensor processes commands written to the CMD register and signals
1395 * execution result through "cmd_rdy" and "cmd_error" flags available on
1396 * STATUS and ERROR registers.
1397 */
bmp380_cmd(struct bmp280_data * data,u8 cmd)1398 static int bmp380_cmd(struct bmp280_data *data, u8 cmd)
1399 {
1400 unsigned int reg;
1401 int ret;
1402
1403 /* Check if device is ready to process a command */
1404 ret = regmap_read(data->regmap, BMP380_REG_STATUS, ®);
1405 if (ret) {
1406 dev_err(data->dev, "failed to read error register\n");
1407 return ret;
1408 }
1409 if (!(reg & BMP380_STATUS_CMD_RDY_MASK)) {
1410 dev_err(data->dev, "device is not ready to accept commands\n");
1411 return -EBUSY;
1412 }
1413
1414 /* Send command to process */
1415 ret = regmap_write(data->regmap, BMP380_REG_CMD, cmd);
1416 if (ret) {
1417 dev_err(data->dev, "failed to send command to device\n");
1418 return ret;
1419 }
1420 /* Wait for 2ms for command to be processed */
1421 fsleep(data->start_up_time_us);
1422 /* Check for command processing error */
1423 ret = regmap_read(data->regmap, BMP380_REG_ERROR, ®);
1424 if (ret) {
1425 dev_err(data->dev, "error reading ERROR reg\n");
1426 return ret;
1427 }
1428 if (reg & BMP380_ERR_CMD_MASK) {
1429 dev_err(data->dev, "error processing command 0x%X\n", cmd);
1430 return -EINVAL;
1431 }
1432
1433 return 0;
1434 }
1435
bmp380_read_temp_adc(struct bmp280_data * data,u32 * adc_temp)1436 static int bmp380_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
1437 {
1438 u32 value_temp;
1439 int ret;
1440
1441 ret = regmap_bulk_read(data->regmap, BMP380_REG_TEMP_XLSB,
1442 data->buf, BMP280_NUM_TEMP_BYTES);
1443 if (ret) {
1444 dev_err(data->dev, "failed to read temperature\n");
1445 return ret;
1446 }
1447
1448 value_temp = get_unaligned_le24(data->buf);
1449 if (value_temp == BMP380_TEMP_SKIPPED) {
1450 dev_err(data->dev, "reading temperature skipped\n");
1451 return -EIO;
1452 }
1453 *adc_temp = value_temp;
1454
1455 return 0;
1456 }
1457
1458 /*
1459 * Returns temperature in Celsius degrees, resolution is 0.01º C. Output value
1460 * of "5123" equals 51.2º C. t_fine carries fine temperature as global value.
1461 *
1462 * Taken from datasheet, Section Appendix 9, "Compensation formula" and repo
1463 * https://github.com/BoschSensortec/BMP3-Sensor-API.
1464 */
bmp380_calc_t_fine(struct bmp280_data * data,u32 adc_temp)1465 static s32 bmp380_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
1466 {
1467 s64 var1, var2, var3, var4, var5, var6;
1468 struct bmp380_calib *calib = &data->calib.bmp380;
1469
1470 var1 = ((s64) adc_temp) - (((s64) calib->T1) << 8);
1471 var2 = var1 * ((s64) calib->T2);
1472 var3 = var1 * var1;
1473 var4 = var3 * ((s64) calib->T3);
1474 var5 = (var2 << 18) + var4;
1475 var6 = var5 >> 32;
1476 return (s32)var6; /* t_fine = var6 */
1477 }
1478
bmp380_get_t_fine(struct bmp280_data * data,s32 * t_fine)1479 static int bmp380_get_t_fine(struct bmp280_data *data, s32 *t_fine)
1480 {
1481 s32 adc_temp;
1482 int ret;
1483
1484 ret = bmp380_read_temp_adc(data, &adc_temp);
1485 if (ret)
1486 return ret;
1487
1488 *t_fine = bmp380_calc_t_fine(data, adc_temp);
1489
1490 return 0;
1491 }
1492
bmp380_compensate_temp(struct bmp280_data * data,u32 adc_temp)1493 static int bmp380_compensate_temp(struct bmp280_data *data, u32 adc_temp)
1494 {
1495 s64 comp_temp;
1496 s32 var6;
1497
1498 var6 = bmp380_calc_t_fine(data, adc_temp);
1499 comp_temp = (var6 * 25) >> 14;
1500
1501 comp_temp = clamp_val(comp_temp, BMP380_MIN_TEMP, BMP380_MAX_TEMP);
1502 return (s32) comp_temp;
1503 }
1504
bmp380_read_press_adc(struct bmp280_data * data,u32 * adc_press)1505 static int bmp380_read_press_adc(struct bmp280_data *data, u32 *adc_press)
1506 {
1507 u32 value_press;
1508 int ret;
1509
1510 ret = regmap_bulk_read(data->regmap, BMP380_REG_PRESS_XLSB,
1511 data->buf, BMP280_NUM_PRESS_BYTES);
1512 if (ret) {
1513 dev_err(data->dev, "failed to read pressure\n");
1514 return ret;
1515 }
1516
1517 value_press = get_unaligned_le24(data->buf);
1518 if (value_press == BMP380_PRESS_SKIPPED) {
1519 dev_err(data->dev, "reading pressure skipped\n");
1520 return -EIO;
1521 }
1522 *adc_press = value_press;
1523
1524 return 0;
1525 }
1526
1527 /*
1528 * Returns pressure in Pa as an unsigned 32 bit integer in fractional Pascal.
1529 * Output value of "9528709" represents 9528709/100 = 95287.09 Pa = 952.8709 hPa.
1530 *
1531 * Taken from datasheet, Section 9.3. "Pressure compensation" and repository
1532 * https://github.com/BoschSensortec/BMP3-Sensor-API.
1533 */
bmp380_compensate_press(struct bmp280_data * data,u32 adc_press,s32 t_fine)1534 static u32 bmp380_compensate_press(struct bmp280_data *data,
1535 u32 adc_press, s32 t_fine)
1536 {
1537 s64 var1, var2, var3, var4, var5, var6, offset, sensitivity;
1538 struct bmp380_calib *calib = &data->calib.bmp380;
1539 u32 comp_press;
1540
1541 var1 = (s64)t_fine * (s64)t_fine;
1542 var2 = var1 >> 6;
1543 var3 = (var2 * ((s64)t_fine)) >> 8;
1544 var4 = ((s64)calib->P8 * var3) >> 5;
1545 var5 = ((s64)calib->P7 * var1) << 4;
1546 var6 = ((s64)calib->P6 * (s64)t_fine) << 22;
1547 offset = ((s64)calib->P5 << 47) + var4 + var5 + var6;
1548 var2 = ((s64)calib->P4 * var3) >> 5;
1549 var4 = ((s64)calib->P3 * var1) << 2;
1550 var5 = ((s64)calib->P2 - ((s64)1 << 14)) *
1551 ((s64)t_fine << 21);
1552 sensitivity = (((s64) calib->P1 - ((s64) 1 << 14)) << 46) +
1553 var2 + var4 + var5;
1554 var1 = (sensitivity >> 24) * (s64)adc_press;
1555 var2 = (s64)calib->P10 * (s64)t_fine;
1556 var3 = var2 + ((s64)calib->P9 << 16);
1557 var4 = (var3 * (s64)adc_press) >> 13;
1558
1559 /*
1560 * Dividing by 10 followed by multiplying by 10 to avoid
1561 * possible overflow caused by (uncomp_data->pressure * partial_data4).
1562 */
1563 var5 = ((s64)adc_press * div_s64(var4, 10)) >> 9;
1564 var5 *= 10;
1565 var6 = (s64)adc_press * (s64)adc_press;
1566 var2 = ((s64)calib->P11 * var6) >> 16;
1567 var3 = (var2 * (s64)adc_press) >> 7;
1568 var4 = (offset >> 2) + var1 + var5 + var3;
1569 comp_press = ((u64)var4 * 25) >> 40;
1570
1571 comp_press = clamp_val(comp_press, BMP380_MIN_PRES, BMP380_MAX_PRES);
1572 return comp_press;
1573 }
1574
bmp380_read_temp(struct bmp280_data * data,s32 * comp_temp)1575 static int bmp380_read_temp(struct bmp280_data *data, s32 *comp_temp)
1576 {
1577 u32 adc_temp;
1578 int ret;
1579
1580 ret = bmp380_read_temp_adc(data, &adc_temp);
1581 if (ret)
1582 return ret;
1583
1584 *comp_temp = bmp380_compensate_temp(data, adc_temp);
1585
1586 return 0;
1587 }
1588
bmp380_read_press(struct bmp280_data * data,u32 * comp_press)1589 static int bmp380_read_press(struct bmp280_data *data, u32 *comp_press)
1590 {
1591 u32 adc_press, t_fine;
1592 int ret;
1593
1594 ret = bmp380_get_t_fine(data, &t_fine);
1595 if (ret)
1596 return ret;
1597
1598 ret = bmp380_read_press_adc(data, &adc_press);
1599 if (ret)
1600 return ret;
1601
1602 *comp_press = bmp380_compensate_press(data, adc_press, t_fine);
1603
1604 return 0;
1605 }
1606
bmp380_read_calib(struct bmp280_data * data)1607 static int bmp380_read_calib(struct bmp280_data *data)
1608 {
1609 struct bmp380_calib *calib = &data->calib.bmp380;
1610 int ret;
1611
1612 /* Read temperature and pressure calibration data */
1613 ret = regmap_bulk_read(data->regmap, BMP380_REG_CALIB_TEMP_START,
1614 data->bmp380_cal_buf,
1615 sizeof(data->bmp380_cal_buf));
1616 if (ret) {
1617 dev_err(data->dev,
1618 "failed to read calibration parameters\n");
1619 return ret;
1620 }
1621
1622 /* Toss the temperature calibration data into the entropy pool */
1623 add_device_randomness(data->bmp380_cal_buf,
1624 sizeof(data->bmp380_cal_buf));
1625
1626 /* Parse calibration values */
1627 calib->T1 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_T1]);
1628 calib->T2 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_T2]);
1629 calib->T3 = data->bmp380_cal_buf[BMP380_T3];
1630 calib->P1 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P1]);
1631 calib->P2 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P2]);
1632 calib->P3 = data->bmp380_cal_buf[BMP380_P3];
1633 calib->P4 = data->bmp380_cal_buf[BMP380_P4];
1634 calib->P5 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P5]);
1635 calib->P6 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P6]);
1636 calib->P7 = data->bmp380_cal_buf[BMP380_P7];
1637 calib->P8 = data->bmp380_cal_buf[BMP380_P8];
1638 calib->P9 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P9]);
1639 calib->P10 = data->bmp380_cal_buf[BMP380_P10];
1640 calib->P11 = data->bmp380_cal_buf[BMP380_P11];
1641
1642 return 0;
1643 }
1644
1645 static const int bmp380_odr_table[][2] = {
1646 [BMP380_ODR_200HZ] = {200, 0},
1647 [BMP380_ODR_100HZ] = {100, 0},
1648 [BMP380_ODR_50HZ] = {50, 0},
1649 [BMP380_ODR_25HZ] = {25, 0},
1650 [BMP380_ODR_12_5HZ] = {12, 500000},
1651 [BMP380_ODR_6_25HZ] = {6, 250000},
1652 [BMP380_ODR_3_125HZ] = {3, 125000},
1653 [BMP380_ODR_1_5625HZ] = {1, 562500},
1654 [BMP380_ODR_0_78HZ] = {0, 781250},
1655 [BMP380_ODR_0_39HZ] = {0, 390625},
1656 [BMP380_ODR_0_2HZ] = {0, 195313},
1657 [BMP380_ODR_0_1HZ] = {0, 97656},
1658 [BMP380_ODR_0_05HZ] = {0, 48828},
1659 [BMP380_ODR_0_02HZ] = {0, 24414},
1660 [BMP380_ODR_0_01HZ] = {0, 12207},
1661 [BMP380_ODR_0_006HZ] = {0, 6104},
1662 [BMP380_ODR_0_003HZ] = {0, 3052},
1663 [BMP380_ODR_0_0015HZ] = {0, 1526},
1664 };
1665
bmp380_preinit(struct bmp280_data * data)1666 static int bmp380_preinit(struct bmp280_data *data)
1667 {
1668 /* BMP3xx requires soft-reset as part of initialization */
1669 return bmp380_cmd(data, BMP380_CMD_SOFT_RESET);
1670 }
1671
1672 static const u8 bmp380_operation_mode[] = {
1673 [BMP280_SLEEP] = BMP380_MODE_SLEEP,
1674 [BMP280_FORCED] = BMP380_MODE_FORCED,
1675 [BMP280_NORMAL] = BMP380_MODE_NORMAL,
1676 };
1677
bmp380_set_mode(struct bmp280_data * data,enum bmp280_op_mode mode)1678 static int bmp380_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
1679 {
1680 int ret;
1681
1682 ret = regmap_write_bits(data->regmap, BMP380_REG_POWER_CONTROL,
1683 BMP380_MODE_MASK,
1684 FIELD_PREP(BMP380_MODE_MASK,
1685 bmp380_operation_mode[mode]));
1686 if (ret) {
1687 dev_err(data->dev, "failed to write power control register.\n");
1688 return ret;
1689 }
1690
1691 data->op_mode = mode;
1692
1693 return 0;
1694 }
1695
bmp380_wait_conv(struct bmp280_data * data)1696 static int bmp380_wait_conv(struct bmp280_data *data)
1697 {
1698 unsigned int reg;
1699 int ret, meas_time_us;
1700
1701 /* Offset measurement time */
1702 meas_time_us = BMP380_MEAS_OFFSET;
1703
1704 /* Pressure measurement time */
1705 meas_time_us += BMP380_PRESS_MEAS_OFFSET +
1706 BIT(data->oversampling_press) * BMP380_MEAS_DUR;
1707
1708 /* Temperature measurement time */
1709 meas_time_us += BMP380_TEMP_MEAS_OFFSET +
1710 BIT(data->oversampling_temp) * BMP380_MEAS_DUR;
1711
1712 /* Measurement time defined in Datasheet Section 3.9.2 */
1713 fsleep(meas_time_us);
1714
1715 ret = regmap_read(data->regmap, BMP380_REG_STATUS, ®);
1716 if (ret) {
1717 dev_err(data->dev, "failed to read status register.\n");
1718 return ret;
1719 }
1720
1721 if (!((reg & BMP380_STATUS_DRDY_PRESS_MASK) &&
1722 (reg & BMP380_STATUS_DRDY_TEMP_MASK))) {
1723 dev_err(data->dev, "Measurement cycle didn't complete.\n");
1724 return -EBUSY;
1725 }
1726
1727 return 0;
1728 }
1729
bmp380_chip_config(struct bmp280_data * data)1730 static int bmp380_chip_config(struct bmp280_data *data)
1731 {
1732 bool change = false, aux;
1733 unsigned int tmp;
1734 u8 osrs;
1735 int ret;
1736
1737 /* Configure power control register */
1738 ret = regmap_update_bits(data->regmap, BMP380_REG_POWER_CONTROL,
1739 BMP380_CTRL_SENSORS_MASK,
1740 BMP380_CTRL_SENSORS_PRESS_EN |
1741 BMP380_CTRL_SENSORS_TEMP_EN);
1742 if (ret) {
1743 dev_err(data->dev,
1744 "failed to write operation control register\n");
1745 return ret;
1746 }
1747
1748 /* Configure oversampling */
1749 osrs = FIELD_PREP(BMP380_OSRS_TEMP_MASK, data->oversampling_temp) |
1750 FIELD_PREP(BMP380_OSRS_PRESS_MASK, data->oversampling_press);
1751
1752 ret = regmap_update_bits_check(data->regmap, BMP380_REG_OSR,
1753 BMP380_OSRS_TEMP_MASK |
1754 BMP380_OSRS_PRESS_MASK,
1755 osrs, &aux);
1756 if (ret) {
1757 dev_err(data->dev, "failed to write oversampling register\n");
1758 return ret;
1759 }
1760 change = change || aux;
1761
1762 /* Configure output data rate */
1763 ret = regmap_update_bits_check(data->regmap, BMP380_REG_ODR,
1764 BMP380_ODRS_MASK, data->sampling_freq,
1765 &aux);
1766 if (ret) {
1767 dev_err(data->dev, "failed to write ODR selection register\n");
1768 return ret;
1769 }
1770 change = change || aux;
1771
1772 /* Set filter data */
1773 ret = regmap_update_bits(data->regmap, BMP380_REG_CONFIG, BMP380_FILTER_MASK,
1774 FIELD_PREP(BMP380_FILTER_MASK, data->iir_filter_coeff));
1775 if (ret) {
1776 dev_err(data->dev, "failed to write config register\n");
1777 return ret;
1778 }
1779
1780 if (change) {
1781 /*
1782 * The configurations errors are detected on the fly during a
1783 * measurement cycle. If the sampling frequency is too low, it's
1784 * faster to reset the measurement loop than wait until the next
1785 * measurement is due.
1786 *
1787 * Resets sensor measurement loop toggling between sleep and
1788 * normal operating modes.
1789 */
1790 ret = bmp380_set_mode(data, BMP280_SLEEP);
1791 if (ret) {
1792 dev_err(data->dev, "failed to set sleep mode\n");
1793 return ret;
1794 }
1795
1796 /*
1797 * According to the BMP3 Sensor API, the sensor needs 5ms
1798 * in order to go to the sleep mode.
1799 */
1800 fsleep(5 * USEC_PER_MSEC);
1801
1802 ret = bmp380_set_mode(data, BMP280_NORMAL);
1803 if (ret) {
1804 dev_err(data->dev, "failed to set normal mode\n");
1805 return ret;
1806 }
1807 /*
1808 * Waits for measurement before checking configuration error
1809 * flag. Selected longest measurement time, calculated from
1810 * formula in datasheet section 3.9.2 with an offset of ~+15%
1811 * as it seen as well in table 3.9.1.
1812 */
1813 fsleep(150 * USEC_PER_MSEC);
1814
1815 /* Check config error flag */
1816 ret = regmap_read(data->regmap, BMP380_REG_ERROR, &tmp);
1817 if (ret) {
1818 dev_err(data->dev, "failed to read error register\n");
1819 return ret;
1820 }
1821 if (tmp & BMP380_ERR_CONF_MASK) {
1822 dev_warn(data->dev,
1823 "sensor flagged configuration as incompatible\n");
1824 return -EINVAL;
1825 }
1826 }
1827
1828 /* Dummy read to empty data registers. */
1829 ret = bmp380_read_press(data, &tmp);
1830 if (ret)
1831 return ret;
1832
1833 ret = bmp380_set_mode(data, BMP280_SLEEP);
1834 if (ret)
1835 dev_err(data->dev, "failed to set sleep mode.\n");
1836
1837 return ret;
1838 }
1839
bmp380_data_rdy_trigger_set_state(struct iio_trigger * trig,bool state)1840 static int bmp380_data_rdy_trigger_set_state(struct iio_trigger *trig,
1841 bool state)
1842 {
1843 struct bmp280_data *data = iio_trigger_get_drvdata(trig);
1844 int ret;
1845
1846 guard(mutex)(&data->lock);
1847
1848 ret = regmap_update_bits(data->regmap, BMP380_REG_INT_CONTROL,
1849 BMP380_INT_CTRL_DRDY_EN,
1850 FIELD_PREP(BMP380_INT_CTRL_DRDY_EN, !!state));
1851 if (ret)
1852 dev_err(data->dev,
1853 "Could not %s interrupt.\n", str_enable_disable(state));
1854 return ret;
1855 }
1856
1857 static const struct iio_trigger_ops bmp380_trigger_ops = {
1858 .set_trigger_state = &bmp380_data_rdy_trigger_set_state,
1859 };
1860
bmp380_int_pin_config(struct bmp280_data * data)1861 static int bmp380_int_pin_config(struct bmp280_data *data)
1862 {
1863 int pin_drive_cfg = FIELD_PREP(BMP380_INT_CTRL_OPEN_DRAIN,
1864 data->trig_open_drain);
1865 int pin_level_cfg = FIELD_PREP(BMP380_INT_CTRL_LEVEL,
1866 data->trig_active_high);
1867 int ret, int_pin_cfg = pin_drive_cfg | pin_level_cfg;
1868
1869 ret = regmap_update_bits(data->regmap, BMP380_REG_INT_CONTROL,
1870 BMP380_INT_CTRL_SETTINGS_MASK, int_pin_cfg);
1871 if (ret)
1872 dev_err(data->dev, "Could not set interrupt settings.\n");
1873
1874 return ret;
1875 }
1876
bmp380_irq_thread_handler(int irq,void * p)1877 static irqreturn_t bmp380_irq_thread_handler(int irq, void *p)
1878 {
1879 struct iio_dev *indio_dev = p;
1880 struct bmp280_data *data = iio_priv(indio_dev);
1881 unsigned int int_ctrl;
1882 int ret;
1883
1884 ret = regmap_read(data->regmap, BMP380_REG_INT_STATUS, &int_ctrl);
1885 if (ret)
1886 return IRQ_NONE;
1887
1888 if (FIELD_GET(BMP380_INT_STATUS_DRDY, int_ctrl))
1889 iio_trigger_poll_nested(data->trig);
1890
1891 return IRQ_HANDLED;
1892 }
1893
bmp380_trigger_probe(struct iio_dev * indio_dev)1894 static int bmp380_trigger_probe(struct iio_dev *indio_dev)
1895 {
1896 return __bmp280_trigger_probe(indio_dev, &bmp380_trigger_ops,
1897 bmp380_int_pin_config,
1898 bmp380_irq_thread_handler);
1899 }
1900
bmp380_trigger_handler(int irq,void * p)1901 static irqreturn_t bmp380_trigger_handler(int irq, void *p)
1902 {
1903 struct iio_poll_func *pf = p;
1904 struct iio_dev *indio_dev = pf->indio_dev;
1905 struct bmp280_data *data = iio_priv(indio_dev);
1906 u32 adc_temp, adc_press;
1907 s32 t_fine;
1908 struct {
1909 u32 comp_press;
1910 s32 comp_temp;
1911 aligned_s64 timestamp;
1912 } buffer;
1913 int ret;
1914
1915 guard(mutex)(&data->lock);
1916
1917 /* Burst read data registers */
1918 ret = regmap_bulk_read(data->regmap, BMP380_REG_PRESS_XLSB,
1919 data->buf, BMP280_BURST_READ_BYTES);
1920 if (ret) {
1921 dev_err(data->dev, "failed to burst read sensor data\n");
1922 goto out;
1923 }
1924
1925 /* Temperature calculations */
1926 adc_temp = get_unaligned_le24(&data->buf[3]);
1927 if (adc_temp == BMP380_TEMP_SKIPPED) {
1928 dev_err(data->dev, "reading temperature skipped\n");
1929 goto out;
1930 }
1931
1932 buffer.comp_temp = bmp380_compensate_temp(data, adc_temp);
1933
1934 /* Pressure calculations */
1935 adc_press = get_unaligned_le24(&data->buf[0]);
1936 if (adc_press == BMP380_PRESS_SKIPPED) {
1937 dev_err(data->dev, "reading pressure skipped\n");
1938 goto out;
1939 }
1940
1941 t_fine = bmp380_calc_t_fine(data, adc_temp);
1942 buffer.comp_press = bmp380_compensate_press(data, adc_press, t_fine);
1943
1944 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer),
1945 iio_get_time_ns(indio_dev));
1946
1947 out:
1948 iio_trigger_notify_done(indio_dev->trig);
1949
1950 return IRQ_HANDLED;
1951 }
1952
1953 static const int bmp380_oversampling_avail[] = { 1, 2, 4, 8, 16, 32 };
1954 static const int bmp380_iir_filter_coeffs_avail[] = { 1, 2, 4, 8, 16, 32, 64, 128};
1955 static const u8 bmp380_chip_ids[] = { BMP380_CHIP_ID, BMP390_CHIP_ID };
1956 static const int bmp380_temp_coeffs[] = { 10, 1 };
1957 static const int bmp380_press_coeffs[] = { 1, 100000 };
1958
1959 const struct bmp280_chip_info bmp380_chip_info = {
1960 .id_reg = BMP380_REG_ID,
1961 .chip_id = bmp380_chip_ids,
1962 .num_chip_id = ARRAY_SIZE(bmp380_chip_ids),
1963 .regmap_config = &bmp380_regmap_config,
1964 .spi_read_extra_byte = true,
1965 .start_up_time_us = 2000,
1966 .channels = bmp380_channels,
1967 .num_channels = ARRAY_SIZE(bmp380_channels),
1968 .avail_scan_masks = bmp280_avail_scan_masks,
1969
1970 .oversampling_temp_avail = bmp380_oversampling_avail,
1971 .num_oversampling_temp_avail = ARRAY_SIZE(bmp380_oversampling_avail),
1972 .oversampling_temp_default = ilog2(1),
1973
1974 .oversampling_press_avail = bmp380_oversampling_avail,
1975 .num_oversampling_press_avail = ARRAY_SIZE(bmp380_oversampling_avail),
1976 .oversampling_press_default = ilog2(4),
1977
1978 .sampling_freq_avail = bmp380_odr_table,
1979 .num_sampling_freq_avail = ARRAY_SIZE(bmp380_odr_table) * 2,
1980 .sampling_freq_default = BMP380_ODR_50HZ,
1981
1982 .iir_filter_coeffs_avail = bmp380_iir_filter_coeffs_avail,
1983 .num_iir_filter_coeffs_avail = ARRAY_SIZE(bmp380_iir_filter_coeffs_avail),
1984 .iir_filter_coeff_default = 2,
1985
1986 .temp_coeffs = bmp380_temp_coeffs,
1987 .temp_coeffs_type = IIO_VAL_FRACTIONAL,
1988 .press_coeffs = bmp380_press_coeffs,
1989 .press_coeffs_type = IIO_VAL_FRACTIONAL,
1990
1991 .chip_config = bmp380_chip_config,
1992 .read_temp = bmp380_read_temp,
1993 .read_press = bmp380_read_press,
1994 .read_calib = bmp380_read_calib,
1995 .set_mode = bmp380_set_mode,
1996 .wait_conv = bmp380_wait_conv,
1997 .preinit = bmp380_preinit,
1998
1999 .trigger_probe = bmp380_trigger_probe,
2000 .trigger_handler = bmp380_trigger_handler,
2001 };
2002 EXPORT_SYMBOL_NS(bmp380_chip_info, "IIO_BMP280");
2003
bmp580_soft_reset(struct bmp280_data * data)2004 static int bmp580_soft_reset(struct bmp280_data *data)
2005 {
2006 unsigned int reg;
2007 int ret;
2008
2009 ret = regmap_write(data->regmap, BMP580_REG_CMD, BMP580_CMD_SOFT_RESET);
2010 if (ret) {
2011 dev_err(data->dev, "failed to send reset command to device\n");
2012 return ret;
2013 }
2014 /* From datasheet's table 4: electrical characteristics */
2015 fsleep(2000);
2016
2017 /* Dummy read of chip_id */
2018 ret = regmap_read(data->regmap, BMP580_REG_CHIP_ID, ®);
2019 if (ret) {
2020 dev_err(data->dev, "failed to reestablish comms after reset\n");
2021 return ret;
2022 }
2023
2024 ret = regmap_read(data->regmap, BMP580_REG_INT_STATUS, ®);
2025 if (ret) {
2026 dev_err(data->dev, "error reading interrupt status register\n");
2027 return ret;
2028 }
2029 if (!(reg & BMP580_INT_STATUS_POR_MASK)) {
2030 dev_err(data->dev, "error resetting sensor\n");
2031 return -EINVAL;
2032 }
2033
2034 return 0;
2035 }
2036
2037 /**
2038 * bmp580_nvm_operation() - Helper function to commit NVM memory operations
2039 * @data: sensor data struct
2040 * @is_write: flag to signal write operation
2041 */
bmp580_nvm_operation(struct bmp280_data * data,bool is_write)2042 static int bmp580_nvm_operation(struct bmp280_data *data, bool is_write)
2043 {
2044 unsigned long timeout, poll;
2045 unsigned int reg;
2046 int ret;
2047
2048 /* Check NVM ready flag */
2049 ret = regmap_read(data->regmap, BMP580_REG_STATUS, ®);
2050 if (ret) {
2051 dev_err(data->dev, "failed to check nvm status\n");
2052 return ret;
2053 }
2054 if (!(reg & BMP580_STATUS_NVM_RDY_MASK)) {
2055 dev_err(data->dev, "sensor's nvm is not ready\n");
2056 return -EIO;
2057 }
2058
2059 /* Start NVM operation sequence */
2060 ret = regmap_write(data->regmap, BMP580_REG_CMD,
2061 BMP580_CMD_NVM_OP_SEQ_0);
2062 if (ret) {
2063 dev_err(data->dev,
2064 "failed to send nvm operation's first sequence\n");
2065 return ret;
2066 }
2067 if (is_write) {
2068 /* Send NVM write sequence */
2069 ret = regmap_write(data->regmap, BMP580_REG_CMD,
2070 BMP580_CMD_NVM_WRITE_SEQ_1);
2071 if (ret) {
2072 dev_err(data->dev,
2073 "failed to send nvm write sequence\n");
2074 return ret;
2075 }
2076 /* Datasheet says on 4.8.1.2 it takes approximately 10ms */
2077 poll = 2000;
2078 timeout = 12000;
2079 } else {
2080 /* Send NVM read sequence */
2081 ret = regmap_write(data->regmap, BMP580_REG_CMD,
2082 BMP580_CMD_NVM_READ_SEQ_1);
2083 if (ret) {
2084 dev_err(data->dev,
2085 "failed to send nvm read sequence\n");
2086 return ret;
2087 }
2088 /* Datasheet says on 4.8.1.1 it takes approximately 200us */
2089 poll = 50;
2090 timeout = 400;
2091 }
2092
2093 /* Wait until NVM is ready again */
2094 ret = regmap_read_poll_timeout(data->regmap, BMP580_REG_STATUS, reg,
2095 (reg & BMP580_STATUS_NVM_RDY_MASK),
2096 poll, timeout);
2097 if (ret) {
2098 dev_err(data->dev, "error checking nvm operation status\n");
2099 return ret;
2100 }
2101
2102 /* Check NVM error flags */
2103 if ((reg & BMP580_STATUS_NVM_ERR_MASK) || (reg & BMP580_STATUS_NVM_CMD_ERR_MASK)) {
2104 dev_err(data->dev, "error processing nvm operation\n");
2105 return -EIO;
2106 }
2107
2108 return 0;
2109 }
2110
2111 /*
2112 * Contrary to previous sensors families, compensation algorithm is builtin.
2113 * We are only required to read the register raw data and adapt the ranges
2114 * for what is expected on IIO ABI.
2115 */
2116
bmp580_read_temp(struct bmp280_data * data,s32 * raw_temp)2117 static int bmp580_read_temp(struct bmp280_data *data, s32 *raw_temp)
2118 {
2119 s32 value_temp;
2120 int ret;
2121
2122 ret = regmap_bulk_read(data->regmap, BMP580_REG_TEMP_XLSB,
2123 data->buf, BMP280_NUM_TEMP_BYTES);
2124 if (ret) {
2125 dev_err(data->dev, "failed to read temperature\n");
2126 return ret;
2127 }
2128
2129 value_temp = get_unaligned_le24(data->buf);
2130 if (value_temp == BMP580_TEMP_SKIPPED) {
2131 dev_err(data->dev, "reading temperature skipped\n");
2132 return -EIO;
2133 }
2134 *raw_temp = sign_extend32(value_temp, 23);
2135
2136 return 0;
2137 }
2138
bmp580_read_press(struct bmp280_data * data,u32 * raw_press)2139 static int bmp580_read_press(struct bmp280_data *data, u32 *raw_press)
2140 {
2141 u32 value_press;
2142 int ret;
2143
2144 ret = regmap_bulk_read(data->regmap, BMP580_REG_PRESS_XLSB,
2145 data->buf, BMP280_NUM_PRESS_BYTES);
2146 if (ret) {
2147 dev_err(data->dev, "failed to read pressure\n");
2148 return ret;
2149 }
2150
2151 value_press = get_unaligned_le24(data->buf);
2152 if (value_press == BMP580_PRESS_SKIPPED) {
2153 dev_err(data->dev, "reading pressure skipped\n");
2154 return -EIO;
2155 }
2156 *raw_press = value_press;
2157
2158 return 0;
2159 }
2160
2161 static const int bmp580_odr_table[][2] = {
2162 [BMP580_ODR_240HZ] = {240, 0},
2163 [BMP580_ODR_218HZ] = {218, 0},
2164 [BMP580_ODR_199HZ] = {199, 0},
2165 [BMP580_ODR_179HZ] = {179, 0},
2166 [BMP580_ODR_160HZ] = {160, 0},
2167 [BMP580_ODR_149HZ] = {149, 0},
2168 [BMP580_ODR_140HZ] = {140, 0},
2169 [BMP580_ODR_129HZ] = {129, 0},
2170 [BMP580_ODR_120HZ] = {120, 0},
2171 [BMP580_ODR_110HZ] = {110, 0},
2172 [BMP580_ODR_100HZ] = {100, 0},
2173 [BMP580_ODR_89HZ] = {89, 0},
2174 [BMP580_ODR_80HZ] = {80, 0},
2175 [BMP580_ODR_70HZ] = {70, 0},
2176 [BMP580_ODR_60HZ] = {60, 0},
2177 [BMP580_ODR_50HZ] = {50, 0},
2178 [BMP580_ODR_45HZ] = {45, 0},
2179 [BMP580_ODR_40HZ] = {40, 0},
2180 [BMP580_ODR_35HZ] = {35, 0},
2181 [BMP580_ODR_30HZ] = {30, 0},
2182 [BMP580_ODR_25HZ] = {25, 0},
2183 [BMP580_ODR_20HZ] = {20, 0},
2184 [BMP580_ODR_15HZ] = {15, 0},
2185 [BMP580_ODR_10HZ] = {10, 0},
2186 [BMP580_ODR_5HZ] = {5, 0},
2187 [BMP580_ODR_4HZ] = {4, 0},
2188 [BMP580_ODR_3HZ] = {3, 0},
2189 [BMP580_ODR_2HZ] = {2, 0},
2190 [BMP580_ODR_1HZ] = {1, 0},
2191 [BMP580_ODR_0_5HZ] = {0, 500000},
2192 [BMP580_ODR_0_25HZ] = {0, 250000},
2193 [BMP580_ODR_0_125HZ] = {0, 125000},
2194 };
2195
2196 static const int bmp580_nvmem_addrs[] = { 0x20, 0x21, 0x22 };
2197
bmp580_nvmem_read_impl(void * priv,unsigned int offset,void * val,size_t bytes)2198 static int bmp580_nvmem_read_impl(void *priv, unsigned int offset, void *val,
2199 size_t bytes)
2200 {
2201 struct bmp280_data *data = priv;
2202 u16 *dst = val;
2203 int ret, addr;
2204
2205 guard(mutex)(&data->lock);
2206
2207 /* Set sensor in standby mode */
2208 ret = regmap_update_bits(data->regmap, BMP580_REG_ODR_CONFIG,
2209 BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS,
2210 BMP580_ODR_DEEPSLEEP_DIS |
2211 FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP));
2212 if (ret) {
2213 dev_err(data->dev, "failed to change sensor to standby mode\n");
2214 goto exit;
2215 }
2216 /* Wait standby transition time */
2217 fsleep(2500);
2218
2219 while (bytes >= sizeof(*dst)) {
2220 addr = bmp580_nvmem_addrs[offset / sizeof(*dst)];
2221
2222 ret = regmap_write(data->regmap, BMP580_REG_NVM_ADDR,
2223 FIELD_PREP(BMP580_NVM_ROW_ADDR_MASK, addr));
2224 if (ret) {
2225 dev_err(data->dev, "error writing nvm address\n");
2226 goto exit;
2227 }
2228
2229 ret = bmp580_nvm_operation(data, false);
2230 if (ret)
2231 goto exit;
2232
2233 ret = regmap_bulk_read(data->regmap, BMP580_REG_NVM_DATA_LSB,
2234 &data->le16, sizeof(data->le16));
2235 if (ret) {
2236 dev_err(data->dev, "error reading nvm data regs\n");
2237 goto exit;
2238 }
2239
2240 *dst++ = le16_to_cpu(data->le16);
2241 bytes -= sizeof(*dst);
2242 offset += sizeof(*dst);
2243 }
2244 exit:
2245 /* Restore chip config */
2246 data->chip_info->chip_config(data);
2247 return ret;
2248 }
2249
bmp580_nvmem_read(void * priv,unsigned int offset,void * val,size_t bytes)2250 static int bmp580_nvmem_read(void *priv, unsigned int offset, void *val,
2251 size_t bytes)
2252 {
2253 struct bmp280_data *data = priv;
2254 int ret;
2255
2256 pm_runtime_get_sync(data->dev);
2257 ret = bmp580_nvmem_read_impl(priv, offset, val, bytes);
2258 pm_runtime_mark_last_busy(data->dev);
2259 pm_runtime_put_autosuspend(data->dev);
2260
2261 return ret;
2262 }
2263
bmp580_nvmem_write_impl(void * priv,unsigned int offset,void * val,size_t bytes)2264 static int bmp580_nvmem_write_impl(void *priv, unsigned int offset, void *val,
2265 size_t bytes)
2266 {
2267 struct bmp280_data *data = priv;
2268 u16 *buf = val;
2269 int ret, addr;
2270
2271 guard(mutex)(&data->lock);
2272
2273 /* Set sensor in standby mode */
2274 ret = regmap_update_bits(data->regmap, BMP580_REG_ODR_CONFIG,
2275 BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS,
2276 BMP580_ODR_DEEPSLEEP_DIS |
2277 FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP));
2278 if (ret) {
2279 dev_err(data->dev, "failed to change sensor to standby mode\n");
2280 goto exit;
2281 }
2282 /* Wait standby transition time */
2283 fsleep(2500);
2284
2285 while (bytes >= sizeof(*buf)) {
2286 addr = bmp580_nvmem_addrs[offset / sizeof(*buf)];
2287
2288 ret = regmap_write(data->regmap, BMP580_REG_NVM_ADDR,
2289 BMP580_NVM_PROG_EN |
2290 FIELD_PREP(BMP580_NVM_ROW_ADDR_MASK, addr));
2291 if (ret) {
2292 dev_err(data->dev, "error writing nvm address\n");
2293 goto exit;
2294 }
2295 data->le16 = cpu_to_le16(*buf++);
2296
2297 ret = regmap_bulk_write(data->regmap, BMP580_REG_NVM_DATA_LSB,
2298 &data->le16, sizeof(data->le16));
2299 if (ret) {
2300 dev_err(data->dev, "error writing LSB NVM data regs\n");
2301 goto exit;
2302 }
2303
2304 ret = bmp580_nvm_operation(data, true);
2305 if (ret)
2306 goto exit;
2307
2308 /* Disable programming mode bit */
2309 ret = regmap_clear_bits(data->regmap, BMP580_REG_NVM_ADDR,
2310 BMP580_NVM_PROG_EN);
2311 if (ret) {
2312 dev_err(data->dev, "error resetting nvm write\n");
2313 goto exit;
2314 }
2315
2316 bytes -= sizeof(*buf);
2317 offset += sizeof(*buf);
2318 }
2319 exit:
2320 /* Restore chip config */
2321 data->chip_info->chip_config(data);
2322 return ret;
2323 }
2324
bmp580_nvmem_write(void * priv,unsigned int offset,void * val,size_t bytes)2325 static int bmp580_nvmem_write(void *priv, unsigned int offset, void *val,
2326 size_t bytes)
2327 {
2328 struct bmp280_data *data = priv;
2329 int ret;
2330
2331 pm_runtime_get_sync(data->dev);
2332 ret = bmp580_nvmem_write_impl(priv, offset, val, bytes);
2333 pm_runtime_mark_last_busy(data->dev);
2334 pm_runtime_put_autosuspend(data->dev);
2335
2336 return ret;
2337 }
2338
bmp580_preinit(struct bmp280_data * data)2339 static int bmp580_preinit(struct bmp280_data *data)
2340 {
2341 struct nvmem_config config = {
2342 .dev = data->dev,
2343 .priv = data,
2344 .name = "bmp580_nvmem",
2345 .word_size = sizeof(u16),
2346 .stride = sizeof(u16),
2347 .size = 3 * sizeof(u16),
2348 .reg_read = bmp580_nvmem_read,
2349 .reg_write = bmp580_nvmem_write,
2350 };
2351 unsigned int reg;
2352 int ret;
2353
2354 /* Issue soft-reset command */
2355 ret = bmp580_soft_reset(data);
2356 if (ret)
2357 return ret;
2358
2359 /* Post powerup sequence */
2360 ret = regmap_read(data->regmap, BMP580_REG_CHIP_ID, ®);
2361 if (ret) {
2362 dev_err(data->dev, "failed to establish comms with the chip\n");
2363 return ret;
2364 }
2365
2366 /* Print warn message if we don't know the chip id */
2367 if (reg != BMP580_CHIP_ID && reg != BMP580_CHIP_ID_ALT)
2368 dev_warn(data->dev, "unexpected chip_id\n");
2369
2370 ret = regmap_read(data->regmap, BMP580_REG_STATUS, ®);
2371 if (ret) {
2372 dev_err(data->dev, "failed to read nvm status\n");
2373 return ret;
2374 }
2375
2376 /* Check nvm status */
2377 if (!(reg & BMP580_STATUS_NVM_RDY_MASK) || (reg & BMP580_STATUS_NVM_ERR_MASK)) {
2378 dev_err(data->dev, "nvm error on powerup sequence\n");
2379 return -EIO;
2380 }
2381
2382 /* Register nvmem device */
2383 return PTR_ERR_OR_ZERO(devm_nvmem_register(config.dev, &config));
2384 }
2385
2386 static const u8 bmp580_operation_mode[] = {
2387 [BMP280_SLEEP] = BMP580_MODE_SLEEP,
2388 [BMP280_FORCED] = BMP580_MODE_FORCED,
2389 [BMP280_NORMAL] = BMP580_MODE_NORMAL,
2390 };
2391
bmp580_set_mode(struct bmp280_data * data,enum bmp280_op_mode mode)2392 static int bmp580_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
2393 {
2394 struct device *dev = data->dev;
2395 int ret;
2396
2397 if (mode == BMP280_FORCED) {
2398 ret = regmap_set_bits(data->regmap, BMP580_REG_DSP_CONFIG,
2399 BMP580_DSP_IIR_FORCED_FLUSH);
2400 if (ret) {
2401 dev_err(dev, "Could not flush IIR filter constants.\n");
2402 return ret;
2403 }
2404 }
2405
2406 ret = regmap_write_bits(data->regmap, BMP580_REG_ODR_CONFIG,
2407 BMP580_MODE_MASK,
2408 FIELD_PREP(BMP580_MODE_MASK,
2409 bmp580_operation_mode[mode]));
2410 if (ret) {
2411 dev_err(dev, "failed to write power control register.\n");
2412 return ret;
2413 }
2414
2415 data->op_mode = mode;
2416
2417 return 0;
2418 }
2419
bmp580_wait_conv(struct bmp280_data * data)2420 static int bmp580_wait_conv(struct bmp280_data *data)
2421 {
2422 /*
2423 * Taken from datasheet, Section 2 "Specification, Table 3 "Electrical
2424 * characteristics.
2425 */
2426 static const int time_conv_press[] = {
2427 0, 1050, 1785, 3045, 5670, 10920, 21420, 42420,
2428 84420,
2429 };
2430 static const int time_conv_temp[] = {
2431 0, 1050, 1105, 1575, 2205, 3465, 6090, 11340,
2432 21840,
2433 };
2434 int meas_time_us;
2435
2436 meas_time_us = 4 * USEC_PER_MSEC +
2437 time_conv_temp[data->oversampling_temp] +
2438 time_conv_press[data->oversampling_press];
2439
2440 /*
2441 * Measurement time mentioned in Chapter 2, Table 4 of the datasheet.
2442 * The extra 4ms is the required mode change to start of measurement
2443 * time.
2444 */
2445 fsleep(meas_time_us);
2446
2447 return 0;
2448 }
2449
bmp580_chip_config(struct bmp280_data * data)2450 static int bmp580_chip_config(struct bmp280_data *data)
2451 {
2452 bool change = false, aux;
2453 unsigned int tmp;
2454 u8 reg_val;
2455 int ret;
2456
2457 /* Sets sensor in standby mode */
2458 ret = regmap_update_bits(data->regmap, BMP580_REG_ODR_CONFIG,
2459 BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS,
2460 BMP580_ODR_DEEPSLEEP_DIS |
2461 FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP));
2462 if (ret) {
2463 dev_err(data->dev, "failed to change sensor to standby mode\n");
2464 return ret;
2465 }
2466 /* From datasheet's table 4: electrical characteristics */
2467 fsleep(2500);
2468
2469 /* Set default DSP mode settings */
2470 reg_val = FIELD_PREP(BMP580_DSP_COMP_MASK, BMP580_DSP_PRESS_TEMP_COMP_EN) |
2471 BMP580_DSP_SHDW_IIR_TEMP_EN | BMP580_DSP_SHDW_IIR_PRESS_EN;
2472
2473 ret = regmap_update_bits(data->regmap, BMP580_REG_DSP_CONFIG,
2474 BMP580_DSP_COMP_MASK |
2475 BMP580_DSP_SHDW_IIR_TEMP_EN |
2476 BMP580_DSP_SHDW_IIR_PRESS_EN, reg_val);
2477 if (ret) {
2478 dev_err(data->dev, "failed to change DSP mode settings\n");
2479 return ret;
2480 }
2481
2482 /* Configure oversampling */
2483 reg_val = FIELD_PREP(BMP580_OSR_TEMP_MASK, data->oversampling_temp) |
2484 FIELD_PREP(BMP580_OSR_PRESS_MASK, data->oversampling_press) |
2485 BMP580_OSR_PRESS_EN;
2486
2487 ret = regmap_update_bits_check(data->regmap, BMP580_REG_OSR_CONFIG,
2488 BMP580_OSR_TEMP_MASK |
2489 BMP580_OSR_PRESS_MASK |
2490 BMP580_OSR_PRESS_EN,
2491 reg_val, &aux);
2492 if (ret) {
2493 dev_err(data->dev, "failed to write oversampling register\n");
2494 return ret;
2495 }
2496 change = change || aux;
2497
2498 /* Configure output data rate */
2499 ret = regmap_update_bits_check(data->regmap, BMP580_REG_ODR_CONFIG, BMP580_ODR_MASK,
2500 FIELD_PREP(BMP580_ODR_MASK, data->sampling_freq),
2501 &aux);
2502 if (ret) {
2503 dev_err(data->dev, "failed to write ODR configuration register\n");
2504 return ret;
2505 }
2506 change = change || aux;
2507
2508 /* Set filter data */
2509 reg_val = FIELD_PREP(BMP580_DSP_IIR_PRESS_MASK, data->iir_filter_coeff) |
2510 FIELD_PREP(BMP580_DSP_IIR_TEMP_MASK, data->iir_filter_coeff);
2511
2512 ret = regmap_update_bits(data->regmap, BMP580_REG_DSP_IIR,
2513 BMP580_DSP_IIR_PRESS_MASK | BMP580_DSP_IIR_TEMP_MASK,
2514 reg_val);
2515 if (ret) {
2516 dev_err(data->dev, "failed to write config register\n");
2517 return ret;
2518 }
2519
2520 if (change) {
2521 /*
2522 * Check if ODR and OSR settings are valid or we are
2523 * operating in a degraded mode.
2524 */
2525 ret = regmap_read(data->regmap, BMP580_REG_EFF_OSR, &tmp);
2526 if (ret) {
2527 dev_err(data->dev,
2528 "error reading effective OSR register\n");
2529 return ret;
2530 }
2531 if (!(tmp & BMP580_EFF_OSR_VALID_ODR)) {
2532 dev_warn(data->dev, "OSR and ODR incompatible settings detected\n");
2533 /* Set current OSR settings from data on effective OSR */
2534 data->oversampling_temp = FIELD_GET(BMP580_EFF_OSR_TEMP_MASK, tmp);
2535 data->oversampling_press = FIELD_GET(BMP580_EFF_OSR_PRESS_MASK, tmp);
2536 return -EINVAL;
2537 }
2538 }
2539
2540 return 0;
2541 }
2542
bmp580_data_rdy_trigger_set_state(struct iio_trigger * trig,bool state)2543 static int bmp580_data_rdy_trigger_set_state(struct iio_trigger *trig,
2544 bool state)
2545 {
2546 struct bmp280_data *data = iio_trigger_get_drvdata(trig);
2547 int ret;
2548
2549 guard(mutex)(&data->lock);
2550
2551 ret = regmap_update_bits(data->regmap, BMP580_REG_INT_CONFIG,
2552 BMP580_INT_CONFIG_INT_EN,
2553 FIELD_PREP(BMP580_INT_CONFIG_INT_EN, !!state));
2554 if (ret)
2555 dev_err(data->dev,
2556 "Could not %s interrupt.\n", str_enable_disable(state));
2557 return ret;
2558 }
2559
2560 static const struct iio_trigger_ops bmp580_trigger_ops = {
2561 .set_trigger_state = &bmp580_data_rdy_trigger_set_state,
2562 };
2563
bmp580_int_pin_config(struct bmp280_data * data)2564 static int bmp580_int_pin_config(struct bmp280_data *data)
2565 {
2566 int pin_drive_cfg = FIELD_PREP(BMP580_INT_CONFIG_OPEN_DRAIN,
2567 data->trig_open_drain);
2568 int pin_level_cfg = FIELD_PREP(BMP580_INT_CONFIG_LEVEL,
2569 data->trig_active_high);
2570 int ret, int_pin_cfg = pin_drive_cfg | pin_level_cfg;
2571
2572 ret = regmap_update_bits(data->regmap, BMP580_REG_INT_CONFIG,
2573 BMP580_INT_CONFIG_MASK, int_pin_cfg);
2574 if (ret) {
2575 dev_err(data->dev, "Could not set interrupt settings.\n");
2576 return ret;
2577 }
2578
2579 ret = regmap_set_bits(data->regmap, BMP580_REG_INT_SOURCE,
2580 BMP580_INT_SOURCE_DRDY);
2581 if (ret)
2582 dev_err(data->dev, "Could not set interrupt source.\n");
2583
2584 return ret;
2585 }
2586
bmp580_irq_thread_handler(int irq,void * p)2587 static irqreturn_t bmp580_irq_thread_handler(int irq, void *p)
2588 {
2589 struct iio_dev *indio_dev = p;
2590 struct bmp280_data *data = iio_priv(indio_dev);
2591 unsigned int int_ctrl;
2592 int ret;
2593
2594 ret = regmap_read(data->regmap, BMP580_REG_INT_STATUS, &int_ctrl);
2595 if (ret)
2596 return IRQ_NONE;
2597
2598 if (FIELD_GET(BMP580_INT_STATUS_DRDY_MASK, int_ctrl))
2599 iio_trigger_poll_nested(data->trig);
2600
2601 return IRQ_HANDLED;
2602 }
2603
bmp580_trigger_probe(struct iio_dev * indio_dev)2604 static int bmp580_trigger_probe(struct iio_dev *indio_dev)
2605 {
2606 return __bmp280_trigger_probe(indio_dev, &bmp580_trigger_ops,
2607 bmp580_int_pin_config,
2608 bmp580_irq_thread_handler);
2609 }
2610
bmp580_trigger_handler(int irq,void * p)2611 static irqreturn_t bmp580_trigger_handler(int irq, void *p)
2612 {
2613 struct iio_poll_func *pf = p;
2614 struct iio_dev *indio_dev = pf->indio_dev;
2615 struct bmp280_data *data = iio_priv(indio_dev);
2616 struct {
2617 __le32 comp_temp;
2618 __le32 comp_press;
2619 aligned_s64 timestamp;
2620 } buffer;
2621 int ret;
2622
2623 guard(mutex)(&data->lock);
2624
2625 /* Burst read data registers */
2626 ret = regmap_bulk_read(data->regmap, BMP580_REG_TEMP_XLSB,
2627 data->buf, BMP280_BURST_READ_BYTES);
2628 if (ret) {
2629 dev_err(data->dev, "failed to burst read sensor data\n");
2630 goto out;
2631 }
2632
2633 /* Pressure calculations */
2634 memcpy(&buffer.comp_press, &data->buf[3], 3);
2635
2636 /* Temperature calculations */
2637 memcpy(&buffer.comp_temp, &data->buf[0], 3);
2638
2639 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer),
2640 iio_get_time_ns(indio_dev));
2641
2642 out:
2643 iio_trigger_notify_done(indio_dev->trig);
2644
2645 return IRQ_HANDLED;
2646 }
2647
2648 static const int bmp580_oversampling_avail[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
2649 static const u8 bmp580_chip_ids[] = { BMP580_CHIP_ID, BMP580_CHIP_ID_ALT };
2650 /* Instead of { 1000, 16 } we do this, to avoid overflow issues */
2651 static const int bmp580_temp_coeffs[] = { 125, 13 };
2652 static const int bmp580_press_coeffs[] = { 1, 64000};
2653
2654 const struct bmp280_chip_info bmp580_chip_info = {
2655 .id_reg = BMP580_REG_CHIP_ID,
2656 .chip_id = bmp580_chip_ids,
2657 .num_chip_id = ARRAY_SIZE(bmp580_chip_ids),
2658 .regmap_config = &bmp580_regmap_config,
2659 .start_up_time_us = 2000,
2660 .channels = bmp580_channels,
2661 .num_channels = ARRAY_SIZE(bmp580_channels),
2662 .avail_scan_masks = bmp280_avail_scan_masks,
2663
2664 .oversampling_temp_avail = bmp580_oversampling_avail,
2665 .num_oversampling_temp_avail = ARRAY_SIZE(bmp580_oversampling_avail),
2666 .oversampling_temp_default = ilog2(1),
2667
2668 .oversampling_press_avail = bmp580_oversampling_avail,
2669 .num_oversampling_press_avail = ARRAY_SIZE(bmp580_oversampling_avail),
2670 .oversampling_press_default = ilog2(4),
2671
2672 .sampling_freq_avail = bmp580_odr_table,
2673 .num_sampling_freq_avail = ARRAY_SIZE(bmp580_odr_table) * 2,
2674 .sampling_freq_default = BMP580_ODR_50HZ,
2675
2676 .iir_filter_coeffs_avail = bmp380_iir_filter_coeffs_avail,
2677 .num_iir_filter_coeffs_avail = ARRAY_SIZE(bmp380_iir_filter_coeffs_avail),
2678 .iir_filter_coeff_default = 2,
2679
2680 .temp_coeffs = bmp580_temp_coeffs,
2681 .temp_coeffs_type = IIO_VAL_FRACTIONAL_LOG2,
2682 .press_coeffs = bmp580_press_coeffs,
2683 .press_coeffs_type = IIO_VAL_FRACTIONAL,
2684
2685 .chip_config = bmp580_chip_config,
2686 .read_temp = bmp580_read_temp,
2687 .read_press = bmp580_read_press,
2688 .set_mode = bmp580_set_mode,
2689 .wait_conv = bmp580_wait_conv,
2690 .preinit = bmp580_preinit,
2691
2692 .trigger_probe = bmp580_trigger_probe,
2693 .trigger_handler = bmp580_trigger_handler,
2694 };
2695 EXPORT_SYMBOL_NS(bmp580_chip_info, "IIO_BMP280");
2696
bmp180_wait_for_eoc(struct bmp280_data * data,u8 ctrl_meas)2697 static int bmp180_wait_for_eoc(struct bmp280_data *data, u8 ctrl_meas)
2698 {
2699 static const int conversion_time_max[] = { 4500, 7500, 13500, 25500 };
2700 unsigned int delay_us;
2701 unsigned int ctrl;
2702 int ret;
2703
2704 if (data->use_eoc)
2705 reinit_completion(&data->done);
2706
2707 ret = regmap_write(data->regmap, BMP280_REG_CTRL_MEAS, ctrl_meas);
2708 if (ret) {
2709 dev_err(data->dev, "failed to write crtl_meas register\n");
2710 return ret;
2711 }
2712
2713 if (data->use_eoc) {
2714 /*
2715 * If we have a completion interrupt, use it, wait up to
2716 * 100ms. The longest conversion time listed is 76.5 ms for
2717 * advanced resolution mode.
2718 */
2719 ret = wait_for_completion_timeout(&data->done,
2720 1 + msecs_to_jiffies(100));
2721 if (!ret)
2722 dev_err(data->dev, "timeout waiting for completion\n");
2723 } else {
2724 if (FIELD_GET(BMP180_MEAS_CTRL_MASK, ctrl_meas) == BMP180_MEAS_TEMP)
2725 delay_us = 4500;
2726 else
2727 delay_us =
2728 conversion_time_max[data->oversampling_press];
2729
2730 fsleep(delay_us);
2731 }
2732
2733 ret = regmap_read(data->regmap, BMP280_REG_CTRL_MEAS, &ctrl);
2734 if (ret) {
2735 dev_err(data->dev, "failed to read ctrl_meas register\n");
2736 return ret;
2737 }
2738
2739 /* The value of this bit reset to "0" after conversion is complete */
2740 if (ctrl & BMP180_MEAS_SCO) {
2741 dev_err(data->dev, "conversion didn't complete\n");
2742 return -EIO;
2743 }
2744
2745 return 0;
2746 }
2747
bmp180_read_temp_adc(struct bmp280_data * data,u32 * adc_temp)2748 static int bmp180_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
2749 {
2750 int ret;
2751
2752 ret = bmp180_wait_for_eoc(data,
2753 FIELD_PREP(BMP180_MEAS_CTRL_MASK, BMP180_MEAS_TEMP) |
2754 BMP180_MEAS_SCO);
2755 if (ret)
2756 return ret;
2757
2758 ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB,
2759 &data->be16, sizeof(data->be16));
2760 if (ret) {
2761 dev_err(data->dev, "failed to read temperature\n");
2762 return ret;
2763 }
2764
2765 *adc_temp = be16_to_cpu(data->be16);
2766
2767 return 0;
2768 }
2769
bmp180_read_calib(struct bmp280_data * data)2770 static int bmp180_read_calib(struct bmp280_data *data)
2771 {
2772 struct bmp180_calib *calib = &data->calib.bmp180;
2773 int ret;
2774 int i;
2775
2776 ret = regmap_bulk_read(data->regmap, BMP180_REG_CALIB_START,
2777 data->bmp180_cal_buf, sizeof(data->bmp180_cal_buf));
2778 if (ret) {
2779 dev_err(data->dev, "failed to read calibration parameters\n");
2780 return ret;
2781 }
2782
2783 /* None of the words has the value 0 or 0xFFFF */
2784 for (i = 0; i < ARRAY_SIZE(data->bmp180_cal_buf); i++) {
2785 if (data->bmp180_cal_buf[i] == cpu_to_be16(0) ||
2786 data->bmp180_cal_buf[i] == cpu_to_be16(0xffff))
2787 return -EIO;
2788 }
2789
2790 /* Toss the calibration data into the entropy pool */
2791 add_device_randomness(data->bmp180_cal_buf,
2792 sizeof(data->bmp180_cal_buf));
2793
2794 calib->AC1 = be16_to_cpu(data->bmp180_cal_buf[AC1]);
2795 calib->AC2 = be16_to_cpu(data->bmp180_cal_buf[AC2]);
2796 calib->AC3 = be16_to_cpu(data->bmp180_cal_buf[AC3]);
2797 calib->AC4 = be16_to_cpu(data->bmp180_cal_buf[AC4]);
2798 calib->AC5 = be16_to_cpu(data->bmp180_cal_buf[AC5]);
2799 calib->AC6 = be16_to_cpu(data->bmp180_cal_buf[AC6]);
2800 calib->B1 = be16_to_cpu(data->bmp180_cal_buf[B1]);
2801 calib->B2 = be16_to_cpu(data->bmp180_cal_buf[B2]);
2802 calib->MB = be16_to_cpu(data->bmp180_cal_buf[MB]);
2803 calib->MC = be16_to_cpu(data->bmp180_cal_buf[MC]);
2804 calib->MD = be16_to_cpu(data->bmp180_cal_buf[MD]);
2805
2806 return 0;
2807 }
2808
2809 /*
2810 * Returns temperature in DegC, resolution is 0.1 DegC.
2811 * t_fine carries fine temperature as global value.
2812 *
2813 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
2814 */
2815
bmp180_calc_t_fine(struct bmp280_data * data,u32 adc_temp)2816 static s32 bmp180_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
2817 {
2818 struct bmp180_calib *calib = &data->calib.bmp180;
2819 s32 x1, x2;
2820
2821 x1 = ((((s32)adc_temp) - calib->AC6) * calib->AC5) >> 15;
2822 x2 = (calib->MC << 11) / (x1 + calib->MD);
2823 return x1 + x2; /* t_fine = x1 + x2; */
2824 }
2825
bmp180_get_t_fine(struct bmp280_data * data,s32 * t_fine)2826 static int bmp180_get_t_fine(struct bmp280_data *data, s32 *t_fine)
2827 {
2828 s32 adc_temp;
2829 int ret;
2830
2831 ret = bmp180_read_temp_adc(data, &adc_temp);
2832 if (ret)
2833 return ret;
2834
2835 *t_fine = bmp180_calc_t_fine(data, adc_temp);
2836
2837 return 0;
2838 }
2839
bmp180_compensate_temp(struct bmp280_data * data,u32 adc_temp)2840 static s32 bmp180_compensate_temp(struct bmp280_data *data, u32 adc_temp)
2841 {
2842 return (bmp180_calc_t_fine(data, adc_temp) + 8) / 16;
2843 }
2844
bmp180_read_temp(struct bmp280_data * data,s32 * comp_temp)2845 static int bmp180_read_temp(struct bmp280_data *data, s32 *comp_temp)
2846 {
2847 u32 adc_temp;
2848 int ret;
2849
2850 ret = bmp180_read_temp_adc(data, &adc_temp);
2851 if (ret)
2852 return ret;
2853
2854 *comp_temp = bmp180_compensate_temp(data, adc_temp);
2855
2856 return 0;
2857 }
2858
bmp180_read_press_adc(struct bmp280_data * data,u32 * adc_press)2859 static int bmp180_read_press_adc(struct bmp280_data *data, u32 *adc_press)
2860 {
2861 u8 oss = data->oversampling_press;
2862 int ret;
2863
2864 ret = bmp180_wait_for_eoc(data,
2865 FIELD_PREP(BMP180_MEAS_CTRL_MASK, BMP180_MEAS_PRESS) |
2866 FIELD_PREP(BMP180_OSRS_PRESS_MASK, oss) |
2867 BMP180_MEAS_SCO);
2868 if (ret)
2869 return ret;
2870
2871 ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB,
2872 data->buf, BMP280_NUM_PRESS_BYTES);
2873 if (ret) {
2874 dev_err(data->dev, "failed to read pressure\n");
2875 return ret;
2876 }
2877
2878 *adc_press = get_unaligned_be24(data->buf) >> (8 - oss);
2879
2880 return 0;
2881 }
2882
2883 /*
2884 * Returns pressure in Pa, resolution is 1 Pa.
2885 *
2886 * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
2887 */
bmp180_compensate_press(struct bmp280_data * data,u32 adc_press,s32 t_fine)2888 static u32 bmp180_compensate_press(struct bmp280_data *data, u32 adc_press,
2889 s32 t_fine)
2890 {
2891 struct bmp180_calib *calib = &data->calib.bmp180;
2892 s32 oss = data->oversampling_press;
2893 s32 x1, x2, x3, p;
2894 s32 b3, b6;
2895 u32 b4, b7;
2896
2897 b6 = t_fine - 4000;
2898 x1 = (calib->B2 * (b6 * b6 >> 12)) >> 11;
2899 x2 = calib->AC2 * b6 >> 11;
2900 x3 = x1 + x2;
2901 b3 = ((((s32)calib->AC1 * 4 + x3) << oss) + 2) / 4;
2902 x1 = calib->AC3 * b6 >> 13;
2903 x2 = (calib->B1 * ((b6 * b6) >> 12)) >> 16;
2904 x3 = (x1 + x2 + 2) >> 2;
2905 b4 = calib->AC4 * (u32)(x3 + 32768) >> 15;
2906 b7 = (adc_press - b3) * (50000 >> oss);
2907 if (b7 < 0x80000000)
2908 p = (b7 * 2) / b4;
2909 else
2910 p = (b7 / b4) * 2;
2911
2912 x1 = (p >> 8) * (p >> 8);
2913 x1 = (x1 * 3038) >> 16;
2914 x2 = (-7357 * p) >> 16;
2915
2916 return p + ((x1 + x2 + 3791) >> 4);
2917 }
2918
bmp180_read_press(struct bmp280_data * data,u32 * comp_press)2919 static int bmp180_read_press(struct bmp280_data *data, u32 *comp_press)
2920 {
2921 u32 adc_press;
2922 s32 t_fine;
2923 int ret;
2924
2925 ret = bmp180_get_t_fine(data, &t_fine);
2926 if (ret)
2927 return ret;
2928
2929 ret = bmp180_read_press_adc(data, &adc_press);
2930 if (ret)
2931 return ret;
2932
2933 *comp_press = bmp180_compensate_press(data, adc_press, t_fine);
2934
2935 return 0;
2936 }
2937
2938 /* Keep compatibility with newer generations of the sensor */
bmp180_set_mode(struct bmp280_data * data,enum bmp280_op_mode mode)2939 static int bmp180_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
2940 {
2941 return 0;
2942 }
2943
2944 /* Keep compatibility with newer generations of the sensor */
bmp180_wait_conv(struct bmp280_data * data)2945 static int bmp180_wait_conv(struct bmp280_data *data)
2946 {
2947 return 0;
2948 }
2949
2950 /* Keep compatibility with newer generations of the sensor */
bmp180_chip_config(struct bmp280_data * data)2951 static int bmp180_chip_config(struct bmp280_data *data)
2952 {
2953 return 0;
2954 }
2955
bmp180_trigger_handler(int irq,void * p)2956 static irqreturn_t bmp180_trigger_handler(int irq, void *p)
2957 {
2958 struct iio_poll_func *pf = p;
2959 struct iio_dev *indio_dev = pf->indio_dev;
2960 struct bmp280_data *data = iio_priv(indio_dev);
2961 struct {
2962 u32 comp_press;
2963 s32 comp_temp;
2964 aligned_s64 timestamp;
2965 } buffer;
2966 int ret;
2967
2968 guard(mutex)(&data->lock);
2969
2970 ret = bmp180_read_temp(data, &buffer.comp_temp);
2971 if (ret)
2972 goto out;
2973
2974
2975 ret = bmp180_read_press(data, &buffer.comp_press);
2976 if (ret)
2977 goto out;
2978
2979 iio_push_to_buffers_with_ts(indio_dev, &buffer, sizeof(buffer),
2980 iio_get_time_ns(indio_dev));
2981
2982 out:
2983 iio_trigger_notify_done(indio_dev->trig);
2984
2985 return IRQ_HANDLED;
2986 }
2987
2988 static const int bmp180_oversampling_temp_avail[] = { 1 };
2989 static const int bmp180_oversampling_press_avail[] = { 1, 2, 4, 8 };
2990 static const u8 bmp180_chip_ids[] = { BMP180_CHIP_ID };
2991 static const int bmp180_temp_coeffs[] = { 100, 1 };
2992 static const int bmp180_press_coeffs[] = { 1, 1000 };
2993
2994 const struct bmp280_chip_info bmp180_chip_info = {
2995 .id_reg = BMP280_REG_ID,
2996 .chip_id = bmp180_chip_ids,
2997 .num_chip_id = ARRAY_SIZE(bmp180_chip_ids),
2998 .regmap_config = &bmp180_regmap_config,
2999 .start_up_time_us = 2000,
3000 .channels = bmp280_channels,
3001 .num_channels = ARRAY_SIZE(bmp280_channels),
3002 .avail_scan_masks = bmp280_avail_scan_masks,
3003
3004 .oversampling_temp_avail = bmp180_oversampling_temp_avail,
3005 .num_oversampling_temp_avail =
3006 ARRAY_SIZE(bmp180_oversampling_temp_avail),
3007 .oversampling_temp_default = 0,
3008
3009 .oversampling_press_avail = bmp180_oversampling_press_avail,
3010 .num_oversampling_press_avail =
3011 ARRAY_SIZE(bmp180_oversampling_press_avail),
3012 .oversampling_press_default = BMP180_MEAS_PRESS_8X,
3013
3014 .temp_coeffs = bmp180_temp_coeffs,
3015 .temp_coeffs_type = IIO_VAL_FRACTIONAL,
3016 .press_coeffs = bmp180_press_coeffs,
3017 .press_coeffs_type = IIO_VAL_FRACTIONAL,
3018
3019 .chip_config = bmp180_chip_config,
3020 .read_temp = bmp180_read_temp,
3021 .read_press = bmp180_read_press,
3022 .read_calib = bmp180_read_calib,
3023 .set_mode = bmp180_set_mode,
3024 .wait_conv = bmp180_wait_conv,
3025
3026 .trigger_handler = bmp180_trigger_handler,
3027 };
3028 EXPORT_SYMBOL_NS(bmp180_chip_info, "IIO_BMP280");
3029
bmp085_eoc_irq(int irq,void * d)3030 static irqreturn_t bmp085_eoc_irq(int irq, void *d)
3031 {
3032 struct bmp280_data *data = d;
3033
3034 complete(&data->done);
3035
3036 return IRQ_HANDLED;
3037 }
3038
bmp085_trigger_probe(struct iio_dev * indio_dev)3039 static int bmp085_trigger_probe(struct iio_dev *indio_dev)
3040 {
3041 struct bmp280_data *data = iio_priv(indio_dev);
3042 struct device *dev = data->dev;
3043 unsigned long irq_trig;
3044 int ret, irq;
3045
3046 irq = fwnode_irq_get(dev_fwnode(dev), 0);
3047 if (irq < 0)
3048 return dev_err_probe(dev, irq, "No interrupt found.\n");
3049
3050 irq_trig = irq_get_trigger_type(irq);
3051 if (irq_trig != IRQF_TRIGGER_RISING) {
3052 dev_err(dev, "non-rising trigger given for EOC interrupt, trying to enforce it\n");
3053 irq_trig = IRQF_TRIGGER_RISING;
3054 }
3055
3056 init_completion(&data->done);
3057
3058 ret = devm_request_irq(dev, irq, bmp085_eoc_irq, irq_trig,
3059 indio_dev->name, data);
3060 if (ret) {
3061 /* Bail out without IRQ but keep the driver in place */
3062 dev_err(dev, "unable to request DRDY IRQ\n");
3063 return 0;
3064 }
3065
3066 data->use_eoc = true;
3067
3068 return 0;
3069 }
3070
3071 /* Identical to bmp180_chip_info + bmp085_trigger_probe */
3072 const struct bmp280_chip_info bmp085_chip_info = {
3073 .id_reg = BMP280_REG_ID,
3074 .chip_id = bmp180_chip_ids,
3075 .num_chip_id = ARRAY_SIZE(bmp180_chip_ids),
3076 .regmap_config = &bmp180_regmap_config,
3077 .start_up_time_us = 2000,
3078 .channels = bmp280_channels,
3079 .num_channels = ARRAY_SIZE(bmp280_channels),
3080 .avail_scan_masks = bmp280_avail_scan_masks,
3081
3082 .oversampling_temp_avail = bmp180_oversampling_temp_avail,
3083 .num_oversampling_temp_avail =
3084 ARRAY_SIZE(bmp180_oversampling_temp_avail),
3085 .oversampling_temp_default = 0,
3086
3087 .oversampling_press_avail = bmp180_oversampling_press_avail,
3088 .num_oversampling_press_avail =
3089 ARRAY_SIZE(bmp180_oversampling_press_avail),
3090 .oversampling_press_default = BMP180_MEAS_PRESS_8X,
3091
3092 .temp_coeffs = bmp180_temp_coeffs,
3093 .temp_coeffs_type = IIO_VAL_FRACTIONAL,
3094 .press_coeffs = bmp180_press_coeffs,
3095 .press_coeffs_type = IIO_VAL_FRACTIONAL,
3096
3097 .chip_config = bmp180_chip_config,
3098 .read_temp = bmp180_read_temp,
3099 .read_press = bmp180_read_press,
3100 .read_calib = bmp180_read_calib,
3101 .set_mode = bmp180_set_mode,
3102 .wait_conv = bmp180_wait_conv,
3103
3104 .trigger_probe = bmp085_trigger_probe,
3105 .trigger_handler = bmp180_trigger_handler,
3106 };
3107 EXPORT_SYMBOL_NS(bmp085_chip_info, "IIO_BMP280");
3108
bmp280_buffer_preenable(struct iio_dev * indio_dev)3109 static int bmp280_buffer_preenable(struct iio_dev *indio_dev)
3110 {
3111 struct bmp280_data *data = iio_priv(indio_dev);
3112
3113 pm_runtime_get_sync(data->dev);
3114 data->chip_info->set_mode(data, BMP280_NORMAL);
3115
3116 return 0;
3117 }
3118
bmp280_buffer_postdisable(struct iio_dev * indio_dev)3119 static int bmp280_buffer_postdisable(struct iio_dev *indio_dev)
3120 {
3121 struct bmp280_data *data = iio_priv(indio_dev);
3122
3123 pm_runtime_mark_last_busy(data->dev);
3124 pm_runtime_put_autosuspend(data->dev);
3125
3126 return 0;
3127 }
3128
3129 static const struct iio_buffer_setup_ops bmp280_buffer_setup_ops = {
3130 .preenable = bmp280_buffer_preenable,
3131 .postdisable = bmp280_buffer_postdisable,
3132 };
3133
bmp280_pm_disable(void * data)3134 static void bmp280_pm_disable(void *data)
3135 {
3136 struct device *dev = data;
3137
3138 pm_runtime_get_sync(dev);
3139 pm_runtime_put_noidle(dev);
3140 pm_runtime_disable(dev);
3141 }
3142
bmp280_regulators_disable(void * data)3143 static void bmp280_regulators_disable(void *data)
3144 {
3145 struct regulator_bulk_data *supplies = data;
3146
3147 regulator_bulk_disable(BMP280_NUM_SUPPLIES, supplies);
3148 }
3149
bmp280_common_probe(struct device * dev,struct regmap * regmap,const struct bmp280_chip_info * chip_info,const char * name,int irq)3150 int bmp280_common_probe(struct device *dev,
3151 struct regmap *regmap,
3152 const struct bmp280_chip_info *chip_info,
3153 const char *name,
3154 int irq)
3155 {
3156 struct iio_dev *indio_dev;
3157 struct bmp280_data *data;
3158 struct gpio_desc *gpiod;
3159 unsigned int chip_id;
3160 unsigned int i;
3161 int ret;
3162
3163 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
3164 if (!indio_dev)
3165 return -ENOMEM;
3166
3167 data = iio_priv(indio_dev);
3168 mutex_init(&data->lock);
3169 data->dev = dev;
3170
3171 indio_dev->name = name;
3172 indio_dev->info = &bmp280_info;
3173 indio_dev->modes = INDIO_DIRECT_MODE;
3174
3175 data->chip_info = chip_info;
3176
3177 /* Apply initial values from chip info structure */
3178 indio_dev->channels = chip_info->channels;
3179 indio_dev->num_channels = chip_info->num_channels;
3180 indio_dev->available_scan_masks = chip_info->avail_scan_masks;
3181 data->oversampling_press = chip_info->oversampling_press_default;
3182 data->oversampling_humid = chip_info->oversampling_humid_default;
3183 data->oversampling_temp = chip_info->oversampling_temp_default;
3184 data->iir_filter_coeff = chip_info->iir_filter_coeff_default;
3185 data->sampling_freq = chip_info->sampling_freq_default;
3186 data->start_up_time_us = chip_info->start_up_time_us;
3187
3188 /* Bring up regulators */
3189 regulator_bulk_set_supply_names(data->supplies,
3190 bmp280_supply_names,
3191 BMP280_NUM_SUPPLIES);
3192
3193 ret = devm_regulator_bulk_get(dev,
3194 BMP280_NUM_SUPPLIES, data->supplies);
3195 if (ret) {
3196 dev_err(dev, "failed to get regulators\n");
3197 return ret;
3198 }
3199
3200 ret = regulator_bulk_enable(BMP280_NUM_SUPPLIES, data->supplies);
3201 if (ret) {
3202 dev_err(dev, "failed to enable regulators\n");
3203 return ret;
3204 }
3205
3206 ret = devm_add_action_or_reset(dev, bmp280_regulators_disable,
3207 data->supplies);
3208 if (ret)
3209 return ret;
3210
3211 /* Wait to make sure we started up properly */
3212 fsleep(data->start_up_time_us);
3213
3214 /* Bring chip out of reset if there is an assigned GPIO line */
3215 gpiod = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
3216 /* Deassert the signal */
3217 if (gpiod) {
3218 dev_info(dev, "release reset\n");
3219 gpiod_set_value(gpiod, 0);
3220 }
3221
3222 data->regmap = regmap;
3223
3224 ret = regmap_read(regmap, data->chip_info->id_reg, &chip_id);
3225 if (ret) {
3226 dev_err(data->dev, "failed to read chip id\n");
3227 return ret;
3228 }
3229
3230 for (i = 0; i < data->chip_info->num_chip_id; i++) {
3231 if (chip_id == data->chip_info->chip_id[i]) {
3232 dev_info(dev, "0x%x is a known chip id for %s\n", chip_id, name);
3233 break;
3234 }
3235 }
3236
3237 if (i == data->chip_info->num_chip_id)
3238 dev_warn(dev, "bad chip id: 0x%x is not a known chip id\n", chip_id);
3239
3240 if (data->chip_info->preinit) {
3241 ret = data->chip_info->preinit(data);
3242 if (ret)
3243 return dev_err_probe(data->dev, ret,
3244 "error running preinit tasks\n");
3245 }
3246
3247 ret = data->chip_info->chip_config(data);
3248 if (ret)
3249 return ret;
3250
3251 dev_set_drvdata(dev, indio_dev);
3252
3253 /*
3254 * Some chips have calibration parameters "programmed into the devices'
3255 * non-volatile memory during production". Let's read them out at probe
3256 * time once. They will not change.
3257 */
3258
3259 if (data->chip_info->read_calib) {
3260 ret = data->chip_info->read_calib(data);
3261 if (ret)
3262 return dev_err_probe(data->dev, ret,
3263 "failed to read calibration coefficients\n");
3264 }
3265
3266 ret = devm_iio_triggered_buffer_setup(data->dev, indio_dev,
3267 iio_pollfunc_store_time,
3268 data->chip_info->trigger_handler,
3269 &bmp280_buffer_setup_ops);
3270 if (ret)
3271 return dev_err_probe(data->dev, ret,
3272 "iio triggered buffer setup failed\n");
3273
3274 /*
3275 * Attempt to grab an optional EOC IRQ - only the BMP085 has this
3276 * however as it happens, the BMP085 shares the chip ID of BMP180
3277 * so we look for an IRQ if we have that.
3278 */
3279 if (irq > 0) {
3280 if (data->chip_info->trigger_probe)
3281 ret = data->chip_info->trigger_probe(indio_dev);
3282 if (ret)
3283 return ret;
3284 }
3285
3286 ret = data->chip_info->set_mode(data, BMP280_SLEEP);
3287 if (ret)
3288 return dev_err_probe(dev, ret, "Failed to set sleep mode\n");
3289
3290 /* Enable runtime PM */
3291 pm_runtime_get_noresume(dev);
3292 pm_runtime_set_active(dev);
3293 pm_runtime_enable(dev);
3294 /*
3295 * Set autosuspend to two orders of magnitude larger than the
3296 * start-up time.
3297 */
3298 pm_runtime_set_autosuspend_delay(dev, data->start_up_time_us / 10);
3299 pm_runtime_use_autosuspend(dev);
3300 pm_runtime_put(dev);
3301
3302 ret = devm_add_action_or_reset(dev, bmp280_pm_disable, dev);
3303 if (ret)
3304 return ret;
3305
3306 return devm_iio_device_register(dev, indio_dev);
3307 }
3308 EXPORT_SYMBOL_NS(bmp280_common_probe, "IIO_BMP280");
3309
bmp280_runtime_suspend(struct device * dev)3310 static int bmp280_runtime_suspend(struct device *dev)
3311 {
3312 struct iio_dev *indio_dev = dev_get_drvdata(dev);
3313 struct bmp280_data *data = iio_priv(indio_dev);
3314
3315 data->chip_info->set_mode(data, BMP280_SLEEP);
3316
3317 fsleep(data->start_up_time_us);
3318 return regulator_bulk_disable(BMP280_NUM_SUPPLIES, data->supplies);
3319 }
3320
bmp280_runtime_resume(struct device * dev)3321 static int bmp280_runtime_resume(struct device *dev)
3322 {
3323 struct iio_dev *indio_dev = dev_get_drvdata(dev);
3324 struct bmp280_data *data = iio_priv(indio_dev);
3325 int ret;
3326
3327 ret = regulator_bulk_enable(BMP280_NUM_SUPPLIES, data->supplies);
3328 if (ret)
3329 return ret;
3330
3331 fsleep(data->start_up_time_us);
3332
3333 ret = data->chip_info->chip_config(data);
3334 if (ret)
3335 return ret;
3336
3337 return data->chip_info->set_mode(data, data->op_mode);
3338 }
3339
3340 EXPORT_RUNTIME_DEV_PM_OPS(bmp280_dev_pm_ops, bmp280_runtime_suspend,
3341 bmp280_runtime_resume, NULL);
3342
3343 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
3344 MODULE_DESCRIPTION("Driver for Bosch Sensortec BMP180/BMP280 pressure and temperature sensor");
3345 MODULE_LICENSE("GPL v2");
3346