1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Bosch BME680 - Temperature, Pressure, Humidity & Gas Sensor
4 *
5 * Copyright (C) 2017 - 2018 Bosch Sensortec GmbH
6 * Copyright (C) 2018 Himanshu Jha <himanshujha199640@gmail.com>
7 *
8 * Datasheet:
9 * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BME680-DS001-00.pdf
10 */
11 #include <linux/acpi.h>
12 #include <linux/bitfield.h>
13 #include <linux/device.h>
14 #include <linux/module.h>
15 #include <linux/log2.h>
16 #include <linux/regmap.h>
17 #include <linux/iio/iio.h>
18 #include <linux/iio/sysfs.h>
19
20 #include "bme680.h"
21
22 struct bme680_calib {
23 u16 par_t1;
24 s16 par_t2;
25 s8 par_t3;
26 u16 par_p1;
27 s16 par_p2;
28 s8 par_p3;
29 s16 par_p4;
30 s16 par_p5;
31 s8 par_p6;
32 s8 par_p7;
33 s16 par_p8;
34 s16 par_p9;
35 u8 par_p10;
36 u16 par_h1;
37 u16 par_h2;
38 s8 par_h3;
39 s8 par_h4;
40 s8 par_h5;
41 s8 par_h6;
42 s8 par_h7;
43 s8 par_gh1;
44 s16 par_gh2;
45 s8 par_gh3;
46 u8 res_heat_range;
47 s8 res_heat_val;
48 s8 range_sw_err;
49 };
50
51 struct bme680_data {
52 struct regmap *regmap;
53 struct bme680_calib bme680;
54 u8 oversampling_temp;
55 u8 oversampling_press;
56 u8 oversampling_humid;
57 u16 heater_dur;
58 u16 heater_temp;
59 /*
60 * Carryover value from temperature conversion, used in pressure
61 * and humidity compensation calculations.
62 */
63 s32 t_fine;
64 };
65
66 static const struct regmap_range bme680_volatile_ranges[] = {
67 regmap_reg_range(BME680_REG_MEAS_STAT_0, BME680_REG_GAS_R_LSB),
68 regmap_reg_range(BME680_REG_STATUS, BME680_REG_STATUS),
69 regmap_reg_range(BME680_T2_LSB_REG, BME680_GH3_REG),
70 };
71
72 static const struct regmap_access_table bme680_volatile_table = {
73 .yes_ranges = bme680_volatile_ranges,
74 .n_yes_ranges = ARRAY_SIZE(bme680_volatile_ranges),
75 };
76
77 const struct regmap_config bme680_regmap_config = {
78 .reg_bits = 8,
79 .val_bits = 8,
80 .max_register = 0xef,
81 .volatile_table = &bme680_volatile_table,
82 .cache_type = REGCACHE_RBTREE,
83 };
84 EXPORT_SYMBOL(bme680_regmap_config);
85
86 static const struct iio_chan_spec bme680_channels[] = {
87 {
88 .type = IIO_TEMP,
89 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
90 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
91 },
92 {
93 .type = IIO_PRESSURE,
94 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
95 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
96 },
97 {
98 .type = IIO_HUMIDITYRELATIVE,
99 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
100 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
101 },
102 {
103 .type = IIO_RESISTANCE,
104 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
105 },
106 };
107
108 static const int bme680_oversampling_avail[] = { 1, 2, 4, 8, 16 };
109
bme680_read_calib(struct bme680_data * data,struct bme680_calib * calib)110 static int bme680_read_calib(struct bme680_data *data,
111 struct bme680_calib *calib)
112 {
113 struct device *dev = regmap_get_device(data->regmap);
114 unsigned int tmp, tmp_msb, tmp_lsb;
115 int ret;
116 __le16 buf;
117
118 /* Temperature related coefficients */
119 ret = regmap_bulk_read(data->regmap, BME680_T1_LSB_REG,
120 (u8 *) &buf, 2);
121 if (ret < 0) {
122 dev_err(dev, "failed to read BME680_T1_LSB_REG\n");
123 return ret;
124 }
125 calib->par_t1 = le16_to_cpu(buf);
126
127 ret = regmap_bulk_read(data->regmap, BME680_T2_LSB_REG,
128 (u8 *) &buf, 2);
129 if (ret < 0) {
130 dev_err(dev, "failed to read BME680_T2_LSB_REG\n");
131 return ret;
132 }
133 calib->par_t2 = le16_to_cpu(buf);
134
135 ret = regmap_read(data->regmap, BME680_T3_REG, &tmp);
136 if (ret < 0) {
137 dev_err(dev, "failed to read BME680_T3_REG\n");
138 return ret;
139 }
140 calib->par_t3 = tmp;
141
142 /* Pressure related coefficients */
143 ret = regmap_bulk_read(data->regmap, BME680_P1_LSB_REG,
144 (u8 *) &buf, 2);
145 if (ret < 0) {
146 dev_err(dev, "failed to read BME680_P1_LSB_REG\n");
147 return ret;
148 }
149 calib->par_p1 = le16_to_cpu(buf);
150
151 ret = regmap_bulk_read(data->regmap, BME680_P2_LSB_REG,
152 (u8 *) &buf, 2);
153 if (ret < 0) {
154 dev_err(dev, "failed to read BME680_P2_LSB_REG\n");
155 return ret;
156 }
157 calib->par_p2 = le16_to_cpu(buf);
158
159 ret = regmap_read(data->regmap, BME680_P3_REG, &tmp);
160 if (ret < 0) {
161 dev_err(dev, "failed to read BME680_P3_REG\n");
162 return ret;
163 }
164 calib->par_p3 = tmp;
165
166 ret = regmap_bulk_read(data->regmap, BME680_P4_LSB_REG,
167 (u8 *) &buf, 2);
168 if (ret < 0) {
169 dev_err(dev, "failed to read BME680_P4_LSB_REG\n");
170 return ret;
171 }
172 calib->par_p4 = le16_to_cpu(buf);
173
174 ret = regmap_bulk_read(data->regmap, BME680_P5_LSB_REG,
175 (u8 *) &buf, 2);
176 if (ret < 0) {
177 dev_err(dev, "failed to read BME680_P5_LSB_REG\n");
178 return ret;
179 }
180 calib->par_p5 = le16_to_cpu(buf);
181
182 ret = regmap_read(data->regmap, BME680_P6_REG, &tmp);
183 if (ret < 0) {
184 dev_err(dev, "failed to read BME680_P6_REG\n");
185 return ret;
186 }
187 calib->par_p6 = tmp;
188
189 ret = regmap_read(data->regmap, BME680_P7_REG, &tmp);
190 if (ret < 0) {
191 dev_err(dev, "failed to read BME680_P7_REG\n");
192 return ret;
193 }
194 calib->par_p7 = tmp;
195
196 ret = regmap_bulk_read(data->regmap, BME680_P8_LSB_REG,
197 (u8 *) &buf, 2);
198 if (ret < 0) {
199 dev_err(dev, "failed to read BME680_P8_LSB_REG\n");
200 return ret;
201 }
202 calib->par_p8 = le16_to_cpu(buf);
203
204 ret = regmap_bulk_read(data->regmap, BME680_P9_LSB_REG,
205 (u8 *) &buf, 2);
206 if (ret < 0) {
207 dev_err(dev, "failed to read BME680_P9_LSB_REG\n");
208 return ret;
209 }
210 calib->par_p9 = le16_to_cpu(buf);
211
212 ret = regmap_read(data->regmap, BME680_P10_REG, &tmp);
213 if (ret < 0) {
214 dev_err(dev, "failed to read BME680_P10_REG\n");
215 return ret;
216 }
217 calib->par_p10 = tmp;
218
219 /* Humidity related coefficients */
220 ret = regmap_read(data->regmap, BME680_H1_MSB_REG, &tmp_msb);
221 if (ret < 0) {
222 dev_err(dev, "failed to read BME680_H1_MSB_REG\n");
223 return ret;
224 }
225
226 ret = regmap_read(data->regmap, BME680_H1_LSB_REG, &tmp_lsb);
227 if (ret < 0) {
228 dev_err(dev, "failed to read BME680_H1_LSB_REG\n");
229 return ret;
230 }
231
232 calib->par_h1 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) |
233 (tmp_lsb & BME680_BIT_H1_DATA_MSK);
234
235 ret = regmap_read(data->regmap, BME680_H2_MSB_REG, &tmp_msb);
236 if (ret < 0) {
237 dev_err(dev, "failed to read BME680_H2_MSB_REG\n");
238 return ret;
239 }
240
241 ret = regmap_read(data->regmap, BME680_H2_LSB_REG, &tmp_lsb);
242 if (ret < 0) {
243 dev_err(dev, "failed to read BME680_H2_LSB_REG\n");
244 return ret;
245 }
246
247 calib->par_h2 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) |
248 (tmp_lsb >> BME680_HUM_REG_SHIFT_VAL);
249
250 ret = regmap_read(data->regmap, BME680_H3_REG, &tmp);
251 if (ret < 0) {
252 dev_err(dev, "failed to read BME680_H3_REG\n");
253 return ret;
254 }
255 calib->par_h3 = tmp;
256
257 ret = regmap_read(data->regmap, BME680_H4_REG, &tmp);
258 if (ret < 0) {
259 dev_err(dev, "failed to read BME680_H4_REG\n");
260 return ret;
261 }
262 calib->par_h4 = tmp;
263
264 ret = regmap_read(data->regmap, BME680_H5_REG, &tmp);
265 if (ret < 0) {
266 dev_err(dev, "failed to read BME680_H5_REG\n");
267 return ret;
268 }
269 calib->par_h5 = tmp;
270
271 ret = regmap_read(data->regmap, BME680_H6_REG, &tmp);
272 if (ret < 0) {
273 dev_err(dev, "failed to read BME680_H6_REG\n");
274 return ret;
275 }
276 calib->par_h6 = tmp;
277
278 ret = regmap_read(data->regmap, BME680_H7_REG, &tmp);
279 if (ret < 0) {
280 dev_err(dev, "failed to read BME680_H7_REG\n");
281 return ret;
282 }
283 calib->par_h7 = tmp;
284
285 /* Gas heater related coefficients */
286 ret = regmap_read(data->regmap, BME680_GH1_REG, &tmp);
287 if (ret < 0) {
288 dev_err(dev, "failed to read BME680_GH1_REG\n");
289 return ret;
290 }
291 calib->par_gh1 = tmp;
292
293 ret = regmap_bulk_read(data->regmap, BME680_GH2_LSB_REG,
294 (u8 *) &buf, 2);
295 if (ret < 0) {
296 dev_err(dev, "failed to read BME680_GH2_LSB_REG\n");
297 return ret;
298 }
299 calib->par_gh2 = le16_to_cpu(buf);
300
301 ret = regmap_read(data->regmap, BME680_GH3_REG, &tmp);
302 if (ret < 0) {
303 dev_err(dev, "failed to read BME680_GH3_REG\n");
304 return ret;
305 }
306 calib->par_gh3 = tmp;
307
308 /* Other coefficients */
309 ret = regmap_read(data->regmap, BME680_REG_RES_HEAT_RANGE, &tmp);
310 if (ret < 0) {
311 dev_err(dev, "failed to read resistance heat range\n");
312 return ret;
313 }
314 calib->res_heat_range = (tmp & BME680_RHRANGE_MSK) / 16;
315
316 ret = regmap_read(data->regmap, BME680_REG_RES_HEAT_VAL, &tmp);
317 if (ret < 0) {
318 dev_err(dev, "failed to read resistance heat value\n");
319 return ret;
320 }
321 calib->res_heat_val = tmp;
322
323 ret = regmap_read(data->regmap, BME680_REG_RANGE_SW_ERR, &tmp);
324 if (ret < 0) {
325 dev_err(dev, "failed to read range software error\n");
326 return ret;
327 }
328 calib->range_sw_err = (tmp & BME680_RSERROR_MSK) / 16;
329
330 return 0;
331 }
332
333 /*
334 * Taken from Bosch BME680 API:
335 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L876
336 *
337 * Returns temperature measurement in DegC, resolutions is 0.01 DegC. Therefore,
338 * output value of "3233" represents 32.33 DegC.
339 */
bme680_compensate_temp(struct bme680_data * data,s32 adc_temp)340 static s16 bme680_compensate_temp(struct bme680_data *data,
341 s32 adc_temp)
342 {
343 struct bme680_calib *calib = &data->bme680;
344 s64 var1, var2, var3;
345 s16 calc_temp;
346
347 /* If the calibration is invalid, attempt to reload it */
348 if (!calib->par_t2)
349 bme680_read_calib(data, calib);
350
351 var1 = (adc_temp >> 3) - (calib->par_t1 << 1);
352 var2 = (var1 * calib->par_t2) >> 11;
353 var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
354 var3 = (var3 * (calib->par_t3 << 4)) >> 14;
355 data->t_fine = var2 + var3;
356 calc_temp = (data->t_fine * 5 + 128) >> 8;
357
358 return calc_temp;
359 }
360
361 /*
362 * Taken from Bosch BME680 API:
363 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L896
364 *
365 * Returns pressure measurement in Pa. Output value of "97356" represents
366 * 97356 Pa = 973.56 hPa.
367 */
bme680_compensate_press(struct bme680_data * data,u32 adc_press)368 static u32 bme680_compensate_press(struct bme680_data *data,
369 u32 adc_press)
370 {
371 struct bme680_calib *calib = &data->bme680;
372 s32 var1, var2, var3, press_comp;
373
374 var1 = (data->t_fine >> 1) - 64000;
375 var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) * calib->par_p6) >> 2;
376 var2 = var2 + (var1 * calib->par_p5 << 1);
377 var2 = (var2 >> 2) + (calib->par_p4 << 16);
378 var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
379 (calib->par_p3 << 5)) >> 3) +
380 ((calib->par_p2 * var1) >> 1);
381 var1 = var1 >> 18;
382 var1 = ((32768 + var1) * calib->par_p1) >> 15;
383 press_comp = 1048576 - adc_press;
384 press_comp = ((press_comp - (var2 >> 12)) * 3125);
385
386 if (press_comp >= BME680_MAX_OVERFLOW_VAL)
387 press_comp = ((press_comp / (u32)var1) << 1);
388 else
389 press_comp = ((press_comp << 1) / (u32)var1);
390
391 var1 = (calib->par_p9 * (((press_comp >> 3) *
392 (press_comp >> 3)) >> 13)) >> 12;
393 var2 = ((press_comp >> 2) * calib->par_p8) >> 13;
394 var3 = ((press_comp >> 8) * (press_comp >> 8) *
395 (press_comp >> 8) * calib->par_p10) >> 17;
396
397 press_comp += (var1 + var2 + var3 + (calib->par_p7 << 7)) >> 4;
398
399 return press_comp;
400 }
401
402 /*
403 * Taken from Bosch BME680 API:
404 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L937
405 *
406 * Returns humidity measurement in percent, resolution is 0.001 percent. Output
407 * value of "43215" represents 43.215 %rH.
408 */
bme680_compensate_humid(struct bme680_data * data,u16 adc_humid)409 static u32 bme680_compensate_humid(struct bme680_data *data,
410 u16 adc_humid)
411 {
412 struct bme680_calib *calib = &data->bme680;
413 s32 var1, var2, var3, var4, var5, var6, temp_scaled, calc_hum;
414
415 temp_scaled = (data->t_fine * 5 + 128) >> 8;
416 var1 = (adc_humid - ((s32) ((s32) calib->par_h1 * 16))) -
417 (((temp_scaled * (s32) calib->par_h3) / 100) >> 1);
418 var2 = ((s32) calib->par_h2 *
419 (((temp_scaled * calib->par_h4) / 100) +
420 (((temp_scaled * ((temp_scaled * calib->par_h5) / 100))
421 >> 6) / 100) + (1 << 14))) >> 10;
422 var3 = var1 * var2;
423 var4 = calib->par_h6 << 7;
424 var4 = (var4 + ((temp_scaled * calib->par_h7) / 100)) >> 4;
425 var5 = ((var3 >> 14) * (var3 >> 14)) >> 10;
426 var6 = (var4 * var5) >> 1;
427 calc_hum = (((var3 + var6) >> 10) * 1000) >> 12;
428
429 if (calc_hum > 100000) /* Cap at 100%rH */
430 calc_hum = 100000;
431 else if (calc_hum < 0)
432 calc_hum = 0;
433
434 return calc_hum;
435 }
436
437 /*
438 * Taken from Bosch BME680 API:
439 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L973
440 *
441 * Returns gas measurement in Ohm. Output value of "82986" represent 82986 ohms.
442 */
bme680_compensate_gas(struct bme680_data * data,u16 gas_res_adc,u8 gas_range)443 static u32 bme680_compensate_gas(struct bme680_data *data, u16 gas_res_adc,
444 u8 gas_range)
445 {
446 struct bme680_calib *calib = &data->bme680;
447 s64 var1;
448 u64 var2;
449 s64 var3;
450 u32 calc_gas_res;
451
452 /* Look up table for the possible gas range values */
453 const u32 lookupTable[16] = {2147483647u, 2147483647u,
454 2147483647u, 2147483647u, 2147483647u,
455 2126008810u, 2147483647u, 2130303777u,
456 2147483647u, 2147483647u, 2143188679u,
457 2136746228u, 2147483647u, 2126008810u,
458 2147483647u, 2147483647u};
459
460 var1 = ((1340 + (5 * (s64) calib->range_sw_err)) *
461 ((s64) lookupTable[gas_range])) >> 16;
462 var2 = ((gas_res_adc << 15) - 16777216) + var1;
463 var3 = ((125000 << (15 - gas_range)) * var1) >> 9;
464 var3 += (var2 >> 1);
465 calc_gas_res = div64_s64(var3, (s64) var2);
466
467 return calc_gas_res;
468 }
469
470 /*
471 * Taken from Bosch BME680 API:
472 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1002
473 */
bme680_calc_heater_res(struct bme680_data * data,u16 temp)474 static u8 bme680_calc_heater_res(struct bme680_data *data, u16 temp)
475 {
476 struct bme680_calib *calib = &data->bme680;
477 s32 var1, var2, var3, var4, var5, heatr_res_x100;
478 u8 heatr_res;
479
480 if (temp > 400) /* Cap temperature */
481 temp = 400;
482
483 var1 = (((s32) BME680_AMB_TEMP * calib->par_gh3) / 1000) * 256;
484 var2 = (calib->par_gh1 + 784) * (((((calib->par_gh2 + 154009) *
485 temp * 5) / 100)
486 + 3276800) / 10);
487 var3 = var1 + (var2 / 2);
488 var4 = (var3 / (calib->res_heat_range + 4));
489 var5 = 131 * calib->res_heat_val + 65536;
490 heatr_res_x100 = ((var4 / var5) - 250) * 34;
491 heatr_res = (heatr_res_x100 + 50) / 100;
492
493 return heatr_res;
494 }
495
496 /*
497 * Taken from Bosch BME680 API:
498 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1188
499 */
bme680_calc_heater_dur(u16 dur)500 static u8 bme680_calc_heater_dur(u16 dur)
501 {
502 u8 durval, factor = 0;
503
504 if (dur >= 0xfc0) {
505 durval = 0xff; /* Max duration */
506 } else {
507 while (dur > 0x3F) {
508 dur = dur / 4;
509 factor += 1;
510 }
511 durval = dur + (factor * 64);
512 }
513
514 return durval;
515 }
516
bme680_set_mode(struct bme680_data * data,bool mode)517 static int bme680_set_mode(struct bme680_data *data, bool mode)
518 {
519 struct device *dev = regmap_get_device(data->regmap);
520 int ret;
521
522 if (mode) {
523 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
524 BME680_MODE_MASK, BME680_MODE_FORCED);
525 if (ret < 0)
526 dev_err(dev, "failed to set forced mode\n");
527
528 } else {
529 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
530 BME680_MODE_MASK, BME680_MODE_SLEEP);
531 if (ret < 0)
532 dev_err(dev, "failed to set sleep mode\n");
533
534 }
535
536 return ret;
537 }
538
bme680_chip_config(struct bme680_data * data)539 static int bme680_chip_config(struct bme680_data *data)
540 {
541 struct device *dev = regmap_get_device(data->regmap);
542 int ret;
543 u8 osrs = FIELD_PREP(BME680_OSRS_HUMIDITY_MASK,
544 data->oversampling_humid + 1);
545 /*
546 * Highly recommended to set oversampling of humidity before
547 * temperature/pressure oversampling.
548 */
549 ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_HUMIDITY,
550 BME680_OSRS_HUMIDITY_MASK, osrs);
551 if (ret < 0) {
552 dev_err(dev, "failed to write ctrl_hum register\n");
553 return ret;
554 }
555
556 /* IIR filter settings */
557 ret = regmap_update_bits(data->regmap, BME680_REG_CONFIG,
558 BME680_FILTER_MASK,
559 BME680_FILTER_COEFF_VAL);
560 if (ret < 0) {
561 dev_err(dev, "failed to write config register\n");
562 return ret;
563 }
564
565 osrs = FIELD_PREP(BME680_OSRS_TEMP_MASK, data->oversampling_temp + 1) |
566 FIELD_PREP(BME680_OSRS_PRESS_MASK, data->oversampling_press + 1);
567
568 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
569 BME680_OSRS_TEMP_MASK |
570 BME680_OSRS_PRESS_MASK,
571 osrs);
572 if (ret < 0)
573 dev_err(dev, "failed to write ctrl_meas register\n");
574
575 return ret;
576 }
577
bme680_gas_config(struct bme680_data * data)578 static int bme680_gas_config(struct bme680_data *data)
579 {
580 struct device *dev = regmap_get_device(data->regmap);
581 int ret;
582 u8 heatr_res, heatr_dur;
583
584 heatr_res = bme680_calc_heater_res(data, data->heater_temp);
585
586 /* set target heater temperature */
587 ret = regmap_write(data->regmap, BME680_REG_RES_HEAT_0, heatr_res);
588 if (ret < 0) {
589 dev_err(dev, "failed to write res_heat_0 register\n");
590 return ret;
591 }
592
593 heatr_dur = bme680_calc_heater_dur(data->heater_dur);
594
595 /* set target heating duration */
596 ret = regmap_write(data->regmap, BME680_REG_GAS_WAIT_0, heatr_dur);
597 if (ret < 0) {
598 dev_err(dev, "failted to write gas_wait_0 register\n");
599 return ret;
600 }
601
602 /* Selecting the runGas and NB conversion settings for the sensor */
603 ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_GAS_1,
604 BME680_RUN_GAS_MASK | BME680_NB_CONV_MASK,
605 BME680_RUN_GAS_EN_BIT | BME680_NB_CONV_0_VAL);
606 if (ret < 0)
607 dev_err(dev, "failed to write ctrl_gas_1 register\n");
608
609 return ret;
610 }
611
bme680_read_temp(struct bme680_data * data,int * val)612 static int bme680_read_temp(struct bme680_data *data, int *val)
613 {
614 struct device *dev = regmap_get_device(data->regmap);
615 int ret;
616 __be32 tmp = 0;
617 s32 adc_temp;
618 s16 comp_temp;
619
620 /* set forced mode to trigger measurement */
621 ret = bme680_set_mode(data, true);
622 if (ret < 0)
623 return ret;
624
625 ret = regmap_bulk_read(data->regmap, BME680_REG_TEMP_MSB,
626 (u8 *) &tmp, 3);
627 if (ret < 0) {
628 dev_err(dev, "failed to read temperature\n");
629 return ret;
630 }
631
632 adc_temp = be32_to_cpu(tmp) >> 12;
633 if (adc_temp == BME680_MEAS_SKIPPED) {
634 /* reading was skipped */
635 dev_err(dev, "reading temperature skipped\n");
636 return -EINVAL;
637 }
638 comp_temp = bme680_compensate_temp(data, adc_temp);
639 /*
640 * val might be NULL if we're called by the read_press/read_humid
641 * routine which is callled to get t_fine value used in
642 * compensate_press/compensate_humid to get compensated
643 * pressure/humidity readings.
644 */
645 if (val) {
646 *val = comp_temp * 10; /* Centidegrees to millidegrees */
647 return IIO_VAL_INT;
648 }
649
650 return ret;
651 }
652
bme680_read_press(struct bme680_data * data,int * val,int * val2)653 static int bme680_read_press(struct bme680_data *data,
654 int *val, int *val2)
655 {
656 struct device *dev = regmap_get_device(data->regmap);
657 int ret;
658 __be32 tmp = 0;
659 s32 adc_press;
660
661 /* Read and compensate temperature to get a reading of t_fine */
662 ret = bme680_read_temp(data, NULL);
663 if (ret < 0)
664 return ret;
665
666 ret = regmap_bulk_read(data->regmap, BME680_REG_PRESS_MSB,
667 (u8 *) &tmp, 3);
668 if (ret < 0) {
669 dev_err(dev, "failed to read pressure\n");
670 return ret;
671 }
672
673 adc_press = be32_to_cpu(tmp) >> 12;
674 if (adc_press == BME680_MEAS_SKIPPED) {
675 /* reading was skipped */
676 dev_err(dev, "reading pressure skipped\n");
677 return -EINVAL;
678 }
679
680 *val = bme680_compensate_press(data, adc_press);
681 *val2 = 100;
682 return IIO_VAL_FRACTIONAL;
683 }
684
bme680_read_humid(struct bme680_data * data,int * val,int * val2)685 static int bme680_read_humid(struct bme680_data *data,
686 int *val, int *val2)
687 {
688 struct device *dev = regmap_get_device(data->regmap);
689 int ret;
690 __be16 tmp = 0;
691 s32 adc_humidity;
692 u32 comp_humidity;
693
694 /* Read and compensate temperature to get a reading of t_fine */
695 ret = bme680_read_temp(data, NULL);
696 if (ret < 0)
697 return ret;
698
699 ret = regmap_bulk_read(data->regmap, BM6880_REG_HUMIDITY_MSB,
700 (u8 *) &tmp, 2);
701 if (ret < 0) {
702 dev_err(dev, "failed to read humidity\n");
703 return ret;
704 }
705
706 adc_humidity = be16_to_cpu(tmp);
707 if (adc_humidity == BME680_MEAS_SKIPPED) {
708 /* reading was skipped */
709 dev_err(dev, "reading humidity skipped\n");
710 return -EINVAL;
711 }
712 comp_humidity = bme680_compensate_humid(data, adc_humidity);
713
714 *val = comp_humidity;
715 *val2 = 1000;
716 return IIO_VAL_FRACTIONAL;
717 }
718
bme680_read_gas(struct bme680_data * data,int * val)719 static int bme680_read_gas(struct bme680_data *data,
720 int *val)
721 {
722 struct device *dev = regmap_get_device(data->regmap);
723 int ret;
724 __be16 tmp = 0;
725 unsigned int check;
726 u16 adc_gas_res;
727 u8 gas_range;
728
729 /* Set heater settings */
730 ret = bme680_gas_config(data);
731 if (ret < 0) {
732 dev_err(dev, "failed to set gas config\n");
733 return ret;
734 }
735
736 /* set forced mode to trigger measurement */
737 ret = bme680_set_mode(data, true);
738 if (ret < 0)
739 return ret;
740
741 ret = regmap_read(data->regmap, BME680_REG_MEAS_STAT_0, &check);
742 if (check & BME680_GAS_MEAS_BIT) {
743 dev_err(dev, "gas measurement incomplete\n");
744 return -EBUSY;
745 }
746
747 ret = regmap_read(data->regmap, BME680_REG_GAS_R_LSB, &check);
748 if (ret < 0) {
749 dev_err(dev, "failed to read gas_r_lsb register\n");
750 return ret;
751 }
752
753 /*
754 * occurs if either the gas heating duration was insuffient
755 * to reach the target heater temperature or the target
756 * heater temperature was too high for the heater sink to
757 * reach.
758 */
759 if ((check & BME680_GAS_STAB_BIT) == 0) {
760 dev_err(dev, "heater failed to reach the target temperature\n");
761 return -EINVAL;
762 }
763
764 ret = regmap_bulk_read(data->regmap, BME680_REG_GAS_MSB,
765 (u8 *) &tmp, 2);
766 if (ret < 0) {
767 dev_err(dev, "failed to read gas resistance\n");
768 return ret;
769 }
770
771 gas_range = check & BME680_GAS_RANGE_MASK;
772 adc_gas_res = be16_to_cpu(tmp) >> BME680_ADC_GAS_RES_SHIFT;
773
774 *val = bme680_compensate_gas(data, adc_gas_res, gas_range);
775 return IIO_VAL_INT;
776 }
777
bme680_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)778 static int bme680_read_raw(struct iio_dev *indio_dev,
779 struct iio_chan_spec const *chan,
780 int *val, int *val2, long mask)
781 {
782 struct bme680_data *data = iio_priv(indio_dev);
783
784 switch (mask) {
785 case IIO_CHAN_INFO_PROCESSED:
786 switch (chan->type) {
787 case IIO_TEMP:
788 return bme680_read_temp(data, val);
789 case IIO_PRESSURE:
790 return bme680_read_press(data, val, val2);
791 case IIO_HUMIDITYRELATIVE:
792 return bme680_read_humid(data, val, val2);
793 case IIO_RESISTANCE:
794 return bme680_read_gas(data, val);
795 default:
796 return -EINVAL;
797 }
798 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
799 switch (chan->type) {
800 case IIO_TEMP:
801 *val = 1 << data->oversampling_temp;
802 return IIO_VAL_INT;
803 case IIO_PRESSURE:
804 *val = 1 << data->oversampling_press;
805 return IIO_VAL_INT;
806 case IIO_HUMIDITYRELATIVE:
807 *val = 1 << data->oversampling_humid;
808 return IIO_VAL_INT;
809 default:
810 return -EINVAL;
811 }
812 default:
813 return -EINVAL;
814 }
815 }
816
bme680_write_oversampling_ratio_temp(struct bme680_data * data,int val)817 static int bme680_write_oversampling_ratio_temp(struct bme680_data *data,
818 int val)
819 {
820 int i;
821
822 for (i = 0; i < ARRAY_SIZE(bme680_oversampling_avail); i++) {
823 if (bme680_oversampling_avail[i] == val) {
824 data->oversampling_temp = ilog2(val);
825
826 return bme680_chip_config(data);
827 }
828 }
829
830 return -EINVAL;
831 }
832
bme680_write_oversampling_ratio_press(struct bme680_data * data,int val)833 static int bme680_write_oversampling_ratio_press(struct bme680_data *data,
834 int val)
835 {
836 int i;
837
838 for (i = 0; i < ARRAY_SIZE(bme680_oversampling_avail); i++) {
839 if (bme680_oversampling_avail[i] == val) {
840 data->oversampling_press = ilog2(val);
841
842 return bme680_chip_config(data);
843 }
844 }
845
846 return -EINVAL;
847 }
848
bme680_write_oversampling_ratio_humid(struct bme680_data * data,int val)849 static int bme680_write_oversampling_ratio_humid(struct bme680_data *data,
850 int val)
851 {
852 int i;
853
854 for (i = 0; i < ARRAY_SIZE(bme680_oversampling_avail); i++) {
855 if (bme680_oversampling_avail[i] == val) {
856 data->oversampling_humid = ilog2(val);
857
858 return bme680_chip_config(data);
859 }
860 }
861
862 return -EINVAL;
863 }
864
bme680_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)865 static int bme680_write_raw(struct iio_dev *indio_dev,
866 struct iio_chan_spec const *chan,
867 int val, int val2, long mask)
868 {
869 struct bme680_data *data = iio_priv(indio_dev);
870
871 switch (mask) {
872 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
873 switch (chan->type) {
874 case IIO_TEMP:
875 return bme680_write_oversampling_ratio_temp(data, val);
876 case IIO_PRESSURE:
877 return bme680_write_oversampling_ratio_press(data, val);
878 case IIO_HUMIDITYRELATIVE:
879 return bme680_write_oversampling_ratio_humid(data, val);
880 default:
881 return -EINVAL;
882 }
883 default:
884 return -EINVAL;
885 }
886 }
887
888 static const char bme680_oversampling_ratio_show[] = "1 2 4 8 16";
889
890 static IIO_CONST_ATTR(oversampling_ratio_available,
891 bme680_oversampling_ratio_show);
892
893 static struct attribute *bme680_attributes[] = {
894 &iio_const_attr_oversampling_ratio_available.dev_attr.attr,
895 NULL,
896 };
897
898 static const struct attribute_group bme680_attribute_group = {
899 .attrs = bme680_attributes,
900 };
901
902 static const struct iio_info bme680_info = {
903 .read_raw = &bme680_read_raw,
904 .write_raw = &bme680_write_raw,
905 .attrs = &bme680_attribute_group,
906 };
907
bme680_match_acpi_device(struct device * dev)908 static const char *bme680_match_acpi_device(struct device *dev)
909 {
910 const struct acpi_device_id *id;
911
912 id = acpi_match_device(dev->driver->acpi_match_table, dev);
913 if (!id)
914 return NULL;
915
916 return dev_name(dev);
917 }
918
bme680_core_probe(struct device * dev,struct regmap * regmap,const char * name)919 int bme680_core_probe(struct device *dev, struct regmap *regmap,
920 const char *name)
921 {
922 struct iio_dev *indio_dev;
923 struct bme680_data *data;
924 unsigned int val;
925 int ret;
926
927 ret = regmap_write(regmap, BME680_REG_SOFT_RESET,
928 BME680_CMD_SOFTRESET);
929 if (ret < 0) {
930 dev_err(dev, "Failed to reset chip\n");
931 return ret;
932 }
933
934 ret = regmap_read(regmap, BME680_REG_CHIP_ID, &val);
935 if (ret < 0) {
936 dev_err(dev, "Error reading chip ID\n");
937 return ret;
938 }
939
940 if (val != BME680_CHIP_ID_VAL) {
941 dev_err(dev, "Wrong chip ID, got %x expected %x\n",
942 val, BME680_CHIP_ID_VAL);
943 return -ENODEV;
944 }
945
946 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
947 if (!indio_dev)
948 return -ENOMEM;
949
950 if (!name && ACPI_HANDLE(dev))
951 name = bme680_match_acpi_device(dev);
952
953 data = iio_priv(indio_dev);
954 dev_set_drvdata(dev, indio_dev);
955 data->regmap = regmap;
956 indio_dev->dev.parent = dev;
957 indio_dev->name = name;
958 indio_dev->channels = bme680_channels;
959 indio_dev->num_channels = ARRAY_SIZE(bme680_channels);
960 indio_dev->info = &bme680_info;
961 indio_dev->modes = INDIO_DIRECT_MODE;
962
963 /* default values for the sensor */
964 data->oversampling_humid = ilog2(2); /* 2X oversampling rate */
965 data->oversampling_press = ilog2(4); /* 4X oversampling rate */
966 data->oversampling_temp = ilog2(8); /* 8X oversampling rate */
967 data->heater_temp = 320; /* degree Celsius */
968 data->heater_dur = 150; /* milliseconds */
969
970 ret = bme680_chip_config(data);
971 if (ret < 0) {
972 dev_err(dev, "failed to set chip_config data\n");
973 return ret;
974 }
975
976 ret = bme680_gas_config(data);
977 if (ret < 0) {
978 dev_err(dev, "failed to set gas config data\n");
979 return ret;
980 }
981
982 ret = bme680_read_calib(data, &data->bme680);
983 if (ret < 0) {
984 dev_err(dev,
985 "failed to read calibration coefficients at probe\n");
986 return ret;
987 }
988
989 return devm_iio_device_register(dev, indio_dev);
990 }
991 EXPORT_SYMBOL_GPL(bme680_core_probe);
992
993 MODULE_AUTHOR("Himanshu Jha <himanshujha199640@gmail.com>");
994 MODULE_DESCRIPTION("Bosch BME680 Driver");
995 MODULE_LICENSE("GPL v2");
996