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/bitfield.h>
12 #include <linux/cleanup.h>
13 #include <linux/delay.h>
14 #include <linux/device.h>
15 #include <linux/log2.h>
16 #include <linux/module.h>
17 #include <linux/pm.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/regmap.h>
20 #include <linux/regulator/consumer.h>
21
22 #include <linux/iio/buffer.h>
23 #include <linux/iio/iio.h>
24 #include <linux/iio/sysfs.h>
25 #include <linux/iio/trigger_consumer.h>
26 #include <linux/iio/triggered_buffer.h>
27
28 #include <linux/unaligned.h>
29
30 #include "bme680.h"
31
32 /* 1st set of calibration data */
33 enum {
34 /* Temperature calib indexes */
35 T2_LSB = 0,
36 T3 = 2,
37 /* Pressure calib indexes */
38 P1_LSB = 4,
39 P2_LSB = 6,
40 P3 = 8,
41 P4_LSB = 10,
42 P5_LSB = 12,
43 P7 = 14,
44 P6 = 15,
45 P8_LSB = 18,
46 P9_LSB = 20,
47 P10 = 22,
48 };
49
50 /* 2nd set of calibration data */
51 enum {
52 /* Humidity calib indexes */
53 H2_MSB = 0,
54 H1_LSB = 1,
55 H3 = 3,
56 H4 = 4,
57 H5 = 5,
58 H6 = 6,
59 H7 = 7,
60 /* Stray T1 calib index */
61 T1_LSB = 8,
62 /* Gas heater calib indexes */
63 GH2_LSB = 10,
64 GH1 = 12,
65 GH3 = 13,
66 };
67
68 /* 3rd set of calibration data */
69 enum {
70 RES_HEAT_VAL = 0,
71 RES_HEAT_RANGE = 2,
72 RANGE_SW_ERR = 4,
73 };
74
75 struct bme680_calib {
76 u16 par_t1;
77 s16 par_t2;
78 s8 par_t3;
79 u16 par_p1;
80 s16 par_p2;
81 s8 par_p3;
82 s16 par_p4;
83 s16 par_p5;
84 s8 par_p6;
85 s8 par_p7;
86 s16 par_p8;
87 s16 par_p9;
88 u8 par_p10;
89 u16 par_h1;
90 u16 par_h2;
91 s8 par_h3;
92 s8 par_h4;
93 s8 par_h5;
94 u8 par_h6;
95 s8 par_h7;
96 s8 par_gh1;
97 s16 par_gh2;
98 s8 par_gh3;
99 u8 res_heat_range;
100 s8 res_heat_val;
101 s8 range_sw_err;
102 };
103
104 /* values of CTRL_MEAS register */
105 enum bme680_op_mode {
106 BME680_MODE_SLEEP = 0,
107 BME680_MODE_FORCED = 1,
108 };
109
110 enum bme680_scan {
111 BME680_TEMP,
112 BME680_PRESS,
113 BME680_HUMID,
114 BME680_GAS,
115 };
116
117 static const char *const bme680_supply_names[] = { "vdd", "vddio" };
118
119 struct bme680_data {
120 struct regmap *regmap;
121 struct bme680_calib bme680;
122 struct mutex lock; /* Protect multiple serial R/W ops to device. */
123 u8 oversampling_temp;
124 u8 oversampling_press;
125 u8 oversampling_humid;
126 u8 preheat_curr_mA;
127 u16 heater_dur;
128 u16 heater_temp;
129
130 struct {
131 s32 chan[4];
132 aligned_s64 ts;
133 } scan;
134
135 union {
136 u8 buf[BME680_NUM_BULK_READ_REGS];
137 unsigned int check;
138 __be16 be16;
139 u8 bme680_cal_buf_1[BME680_CALIB_RANGE_1_LEN];
140 u8 bme680_cal_buf_2[BME680_CALIB_RANGE_2_LEN];
141 u8 bme680_cal_buf_3[BME680_CALIB_RANGE_3_LEN];
142 };
143 };
144
145 static const struct regmap_range bme680_volatile_ranges[] = {
146 regmap_reg_range(BME680_REG_MEAS_STAT_0, BME680_REG_GAS_R_LSB),
147 regmap_reg_range(BME680_REG_STATUS, BME680_REG_STATUS),
148 regmap_reg_range(BME680_T2_LSB_REG, BME680_GH3_REG),
149 };
150
151 static const struct regmap_access_table bme680_volatile_table = {
152 .yes_ranges = bme680_volatile_ranges,
153 .n_yes_ranges = ARRAY_SIZE(bme680_volatile_ranges),
154 };
155
156 const struct regmap_config bme680_regmap_config = {
157 .reg_bits = 8,
158 .val_bits = 8,
159 .max_register = 0xef,
160 .volatile_table = &bme680_volatile_table,
161 .cache_type = REGCACHE_RBTREE,
162 };
163 EXPORT_SYMBOL_NS(bme680_regmap_config, "IIO_BME680");
164
165 static const struct iio_chan_spec bme680_channels[] = {
166 {
167 .type = IIO_TEMP,
168 /* PROCESSED maintained for ABI backwards compatibility */
169 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
170 BIT(IIO_CHAN_INFO_RAW) |
171 BIT(IIO_CHAN_INFO_SCALE) |
172 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
173 .scan_index = 0,
174 .scan_type = {
175 .sign = 's',
176 .realbits = 16,
177 .storagebits = 16,
178 .endianness = IIO_CPU,
179 },
180 },
181 {
182 .type = IIO_PRESSURE,
183 /* PROCESSED maintained for ABI backwards compatibility */
184 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
185 BIT(IIO_CHAN_INFO_RAW) |
186 BIT(IIO_CHAN_INFO_SCALE) |
187 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
188 .scan_index = 1,
189 .scan_type = {
190 .sign = 'u',
191 .realbits = 32,
192 .storagebits = 32,
193 .endianness = IIO_CPU,
194 },
195 },
196 {
197 .type = IIO_HUMIDITYRELATIVE,
198 /* PROCESSED maintained for ABI backwards compatibility */
199 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
200 BIT(IIO_CHAN_INFO_RAW) |
201 BIT(IIO_CHAN_INFO_SCALE) |
202 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
203 .scan_index = 2,
204 .scan_type = {
205 .sign = 'u',
206 .realbits = 32,
207 .storagebits = 32,
208 .endianness = IIO_CPU,
209 },
210 },
211 {
212 .type = IIO_RESISTANCE,
213 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
214 .scan_index = 3,
215 .scan_type = {
216 .sign = 'u',
217 .realbits = 32,
218 .storagebits = 32,
219 .endianness = IIO_CPU,
220 },
221 },
222 IIO_CHAN_SOFT_TIMESTAMP(4),
223 {
224 .type = IIO_CURRENT,
225 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
226 .output = 1,
227 .scan_index = -1,
228 },
229 };
230
bme680_read_calib(struct bme680_data * data,struct bme680_calib * calib)231 static int bme680_read_calib(struct bme680_data *data,
232 struct bme680_calib *calib)
233 {
234 struct device *dev = regmap_get_device(data->regmap);
235 unsigned int tmp_msb, tmp_lsb;
236 int ret;
237
238 ret = regmap_bulk_read(data->regmap, BME680_T2_LSB_REG,
239 data->bme680_cal_buf_1,
240 sizeof(data->bme680_cal_buf_1));
241 if (ret < 0) {
242 dev_err(dev, "failed to read 1st set of calib data;\n");
243 return ret;
244 }
245
246 calib->par_t2 = get_unaligned_le16(&data->bme680_cal_buf_1[T2_LSB]);
247 calib->par_t3 = data->bme680_cal_buf_1[T3];
248 calib->par_p1 = get_unaligned_le16(&data->bme680_cal_buf_1[P1_LSB]);
249 calib->par_p2 = get_unaligned_le16(&data->bme680_cal_buf_1[P2_LSB]);
250 calib->par_p3 = data->bme680_cal_buf_1[P3];
251 calib->par_p4 = get_unaligned_le16(&data->bme680_cal_buf_1[P4_LSB]);
252 calib->par_p5 = get_unaligned_le16(&data->bme680_cal_buf_1[P5_LSB]);
253 calib->par_p7 = data->bme680_cal_buf_1[P7];
254 calib->par_p6 = data->bme680_cal_buf_1[P6];
255 calib->par_p8 = get_unaligned_le16(&data->bme680_cal_buf_1[P8_LSB]);
256 calib->par_p9 = get_unaligned_le16(&data->bme680_cal_buf_1[P9_LSB]);
257 calib->par_p10 = data->bme680_cal_buf_1[P10];
258
259 ret = regmap_bulk_read(data->regmap, BME680_H2_MSB_REG,
260 data->bme680_cal_buf_2,
261 sizeof(data->bme680_cal_buf_2));
262 if (ret < 0) {
263 dev_err(dev, "failed to read 2nd set of calib data;\n");
264 return ret;
265 }
266
267 tmp_lsb = data->bme680_cal_buf_2[H1_LSB];
268 tmp_msb = data->bme680_cal_buf_2[H1_LSB + 1];
269 calib->par_h1 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) |
270 (tmp_lsb & BME680_BIT_H1_DATA_MASK);
271
272 tmp_msb = data->bme680_cal_buf_2[H2_MSB];
273 tmp_lsb = data->bme680_cal_buf_2[H2_MSB + 1];
274 calib->par_h2 = (tmp_msb << BME680_HUM_REG_SHIFT_VAL) |
275 (tmp_lsb >> BME680_HUM_REG_SHIFT_VAL);
276
277 calib->par_h3 = data->bme680_cal_buf_2[H3];
278 calib->par_h4 = data->bme680_cal_buf_2[H4];
279 calib->par_h5 = data->bme680_cal_buf_2[H5];
280 calib->par_h6 = data->bme680_cal_buf_2[H6];
281 calib->par_h7 = data->bme680_cal_buf_2[H7];
282 calib->par_t1 = get_unaligned_le16(&data->bme680_cal_buf_2[T1_LSB]);
283 calib->par_gh2 = get_unaligned_le16(&data->bme680_cal_buf_2[GH2_LSB]);
284 calib->par_gh1 = data->bme680_cal_buf_2[GH1];
285 calib->par_gh3 = data->bme680_cal_buf_2[GH3];
286
287 ret = regmap_bulk_read(data->regmap, BME680_REG_RES_HEAT_VAL,
288 data->bme680_cal_buf_3,
289 sizeof(data->bme680_cal_buf_3));
290 if (ret < 0) {
291 dev_err(dev, "failed to read 3rd set of calib data;\n");
292 return ret;
293 }
294
295 calib->res_heat_val = data->bme680_cal_buf_3[RES_HEAT_VAL];
296
297 calib->res_heat_range = FIELD_GET(BME680_RHRANGE_MASK,
298 data->bme680_cal_buf_3[RES_HEAT_RANGE]);
299
300 calib->range_sw_err = FIELD_GET(BME680_RSERROR_MASK,
301 data->bme680_cal_buf_3[RANGE_SW_ERR]);
302
303 return 0;
304 }
305
bme680_read_temp_adc(struct bme680_data * data,u32 * adc_temp)306 static int bme680_read_temp_adc(struct bme680_data *data, u32 *adc_temp)
307 {
308 struct device *dev = regmap_get_device(data->regmap);
309 u32 value_temp;
310 int ret;
311
312 ret = regmap_bulk_read(data->regmap, BME680_REG_TEMP_MSB,
313 data->buf, BME680_TEMP_NUM_BYTES);
314 if (ret < 0) {
315 dev_err(dev, "failed to read temperature\n");
316 return ret;
317 }
318
319 value_temp = FIELD_GET(BME680_MEAS_TRIM_MASK,
320 get_unaligned_be24(data->buf));
321 if (value_temp == BME680_MEAS_SKIPPED) {
322 /* reading was skipped */
323 dev_err(dev, "reading temperature skipped\n");
324 return -EINVAL;
325 }
326 *adc_temp = value_temp;
327
328 return 0;
329 }
330
331 /*
332 * Taken from Bosch BME680 API:
333 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L876
334 *
335 * Returns temperature measurement in DegC, resolutions is 0.01 DegC. Therefore,
336 * output value of "3233" represents 32.33 DegC.
337 */
bme680_calc_t_fine(struct bme680_data * data,u32 adc_temp)338 static s32 bme680_calc_t_fine(struct bme680_data *data, u32 adc_temp)
339 {
340 struct bme680_calib *calib = &data->bme680;
341 s64 var1, var2, var3;
342
343 /* If the calibration is invalid, attempt to reload it */
344 if (!calib->par_t2)
345 bme680_read_calib(data, calib);
346
347 var1 = ((s32)adc_temp >> 3) - ((s32)calib->par_t1 << 1);
348 var2 = (var1 * calib->par_t2) >> 11;
349 var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
350 var3 = (var3 * ((s32)calib->par_t3 << 4)) >> 14;
351 return var2 + var3; /* t_fine = var2 + var3 */
352 }
353
bme680_get_t_fine(struct bme680_data * data,s32 * t_fine)354 static int bme680_get_t_fine(struct bme680_data *data, s32 *t_fine)
355 {
356 u32 adc_temp;
357 int ret;
358
359 ret = bme680_read_temp_adc(data, &adc_temp);
360 if (ret)
361 return ret;
362
363 *t_fine = bme680_calc_t_fine(data, adc_temp);
364
365 return 0;
366 }
367
bme680_compensate_temp(struct bme680_data * data,u32 adc_temp)368 static s16 bme680_compensate_temp(struct bme680_data *data,
369 u32 adc_temp)
370 {
371 return (bme680_calc_t_fine(data, adc_temp) * 5 + 128) / 256;
372 }
373
bme680_read_press_adc(struct bme680_data * data,u32 * adc_press)374 static int bme680_read_press_adc(struct bme680_data *data, u32 *adc_press)
375 {
376 struct device *dev = regmap_get_device(data->regmap);
377 u32 value_press;
378 int ret;
379
380 ret = regmap_bulk_read(data->regmap, BME680_REG_PRESS_MSB,
381 data->buf, BME680_PRESS_NUM_BYTES);
382 if (ret < 0) {
383 dev_err(dev, "failed to read pressure\n");
384 return ret;
385 }
386
387 value_press = FIELD_GET(BME680_MEAS_TRIM_MASK,
388 get_unaligned_be24(data->buf));
389 if (value_press == BME680_MEAS_SKIPPED) {
390 /* reading was skipped */
391 dev_err(dev, "reading pressure skipped\n");
392 return -EINVAL;
393 }
394 *adc_press = value_press;
395
396 return 0;
397 }
398
399 /*
400 * Taken from Bosch BME680 API:
401 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L896
402 *
403 * Returns pressure measurement in Pa. Output value of "97356" represents
404 * 97356 Pa = 973.56 hPa.
405 */
bme680_compensate_press(struct bme680_data * data,u32 adc_press,s32 t_fine)406 static u32 bme680_compensate_press(struct bme680_data *data,
407 u32 adc_press, s32 t_fine)
408 {
409 struct bme680_calib *calib = &data->bme680;
410 s32 var1, var2, var3, press_comp;
411
412 var1 = (t_fine >> 1) - 64000;
413 var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) * calib->par_p6) >> 2;
414 var2 = var2 + (var1 * calib->par_p5 << 1);
415 var2 = (var2 >> 2) + ((s32)calib->par_p4 << 16);
416 var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
417 ((s32)calib->par_p3 << 5)) >> 3) +
418 ((calib->par_p2 * var1) >> 1);
419 var1 = var1 >> 18;
420 var1 = ((32768 + var1) * calib->par_p1) >> 15;
421 press_comp = 1048576 - adc_press;
422 press_comp = ((press_comp - (var2 >> 12)) * 3125);
423
424 if (press_comp >= BME680_MAX_OVERFLOW_VAL)
425 press_comp = ((press_comp / (u32)var1) << 1);
426 else
427 press_comp = ((press_comp << 1) / (u32)var1);
428
429 var1 = (calib->par_p9 * (((press_comp >> 3) *
430 (press_comp >> 3)) >> 13)) >> 12;
431 var2 = ((press_comp >> 2) * calib->par_p8) >> 13;
432 var3 = ((press_comp >> 8) * (press_comp >> 8) *
433 (press_comp >> 8) * calib->par_p10) >> 17;
434
435 press_comp += (var1 + var2 + var3 + ((s32)calib->par_p7 << 7)) >> 4;
436
437 return press_comp;
438 }
439
bme680_read_humid_adc(struct bme680_data * data,u32 * adc_humidity)440 static int bme680_read_humid_adc(struct bme680_data *data, u32 *adc_humidity)
441 {
442 struct device *dev = regmap_get_device(data->regmap);
443 u32 value_humidity;
444 int ret;
445
446 ret = regmap_bulk_read(data->regmap, BME680_REG_HUMIDITY_MSB,
447 &data->be16, BME680_HUMID_NUM_BYTES);
448 if (ret < 0) {
449 dev_err(dev, "failed to read humidity\n");
450 return ret;
451 }
452
453 value_humidity = be16_to_cpu(data->be16);
454 if (value_humidity == BME680_MEAS_SKIPPED) {
455 /* reading was skipped */
456 dev_err(dev, "reading humidity skipped\n");
457 return -EINVAL;
458 }
459 *adc_humidity = value_humidity;
460
461 return 0;
462 }
463
464 /*
465 * Taken from Bosch BME680 API:
466 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L937
467 *
468 * Returns humidity measurement in percent, resolution is 0.001 percent. Output
469 * value of "43215" represents 43.215 %rH.
470 */
bme680_compensate_humid(struct bme680_data * data,u16 adc_humid,s32 t_fine)471 static u32 bme680_compensate_humid(struct bme680_data *data,
472 u16 adc_humid, s32 t_fine)
473 {
474 struct bme680_calib *calib = &data->bme680;
475 s32 var1, var2, var3, var4, var5, var6, temp_scaled, calc_hum;
476
477 temp_scaled = (t_fine * 5 + 128) >> 8;
478 var1 = (adc_humid - (((s32)calib->par_h1 * 16))) -
479 (((temp_scaled * calib->par_h3) / 100) >> 1);
480 var2 = (calib->par_h2 *
481 (((temp_scaled * calib->par_h4) / 100) +
482 (((temp_scaled * ((temp_scaled * calib->par_h5) / 100))
483 >> 6) / 100) + (1 << 14))) >> 10;
484 var3 = var1 * var2;
485 var4 = (s32)calib->par_h6 << 7;
486 var4 = (var4 + ((temp_scaled * calib->par_h7) / 100)) >> 4;
487 var5 = ((var3 >> 14) * (var3 >> 14)) >> 10;
488 var6 = (var4 * var5) >> 1;
489 calc_hum = (((var3 + var6) >> 10) * 1000) >> 12;
490
491 calc_hum = clamp(calc_hum, 0, 100000); /* clamp between 0-100 %rH */
492
493 return calc_hum;
494 }
495
496 /*
497 * Taken from Bosch BME680 API:
498 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L973
499 *
500 * Returns gas measurement in Ohm. Output value of "82986" represent 82986 ohms.
501 */
bme680_compensate_gas(struct bme680_data * data,u16 gas_res_adc,u8 gas_range)502 static u32 bme680_compensate_gas(struct bme680_data *data, u16 gas_res_adc,
503 u8 gas_range)
504 {
505 struct bme680_calib *calib = &data->bme680;
506 s64 var1;
507 u64 var2;
508 s64 var3;
509 u32 calc_gas_res;
510
511 /* Look up table for the possible gas range values */
512 static const u32 lookup_table[16] = {
513 2147483647u, 2147483647u, 2147483647u, 2147483647u,
514 2147483647u, 2126008810u, 2147483647u, 2130303777u,
515 2147483647u, 2147483647u, 2143188679u, 2136746228u,
516 2147483647u, 2126008810u, 2147483647u, 2147483647u
517 };
518
519 var1 = ((1340LL + (5 * calib->range_sw_err)) *
520 (lookup_table[gas_range])) >> 16;
521 var2 = ((gas_res_adc << 15) - 16777216) + var1;
522 var3 = ((125000 << (15 - gas_range)) * var1) >> 9;
523 var3 += (var2 >> 1);
524 calc_gas_res = div64_s64(var3, (s64)var2);
525
526 return calc_gas_res;
527 }
528
529 /*
530 * Taken from Bosch BME680 API:
531 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1002
532 */
bme680_calc_heater_res(struct bme680_data * data,u16 temp)533 static u8 bme680_calc_heater_res(struct bme680_data *data, u16 temp)
534 {
535 struct bme680_calib *calib = &data->bme680;
536 s32 var1, var2, var3, var4, var5, heatr_res_x100;
537 u8 heatr_res;
538
539 if (temp > 400) /* Cap temperature */
540 temp = 400;
541
542 var1 = (((s32)BME680_AMB_TEMP * calib->par_gh3) / 1000) * 256;
543 var2 = (calib->par_gh1 + 784) * (((((calib->par_gh2 + 154009) *
544 temp * 5) / 100)
545 + 3276800) / 10);
546 var3 = var1 + (var2 / 2);
547 var4 = (var3 / (calib->res_heat_range + 4));
548 var5 = 131 * calib->res_heat_val + 65536;
549 heatr_res_x100 = ((var4 / var5) - 250) * 34;
550 heatr_res = DIV_ROUND_CLOSEST(heatr_res_x100, 100);
551
552 return heatr_res;
553 }
554
555 /*
556 * Taken from Bosch BME680 API:
557 * https://github.com/BoschSensortec/BME680_driver/blob/63bb5336/bme680.c#L1188
558 */
bme680_calc_heater_dur(u16 dur)559 static u8 bme680_calc_heater_dur(u16 dur)
560 {
561 u8 durval, factor = 0;
562
563 if (dur >= 0xfc0) {
564 durval = 0xff; /* Max duration */
565 } else {
566 while (dur > 0x3F) {
567 dur = dur / 4;
568 factor += 1;
569 }
570 durval = dur + (factor * 64);
571 }
572
573 return durval;
574 }
575
576 /* Taken from datasheet, section 5.3.3 */
bme680_calc_heater_preheat_current(u8 curr)577 static u8 bme680_calc_heater_preheat_current(u8 curr)
578 {
579 return 8 * curr - 1;
580 }
581
bme680_set_mode(struct bme680_data * data,enum bme680_op_mode mode)582 static int bme680_set_mode(struct bme680_data *data, enum bme680_op_mode mode)
583 {
584 struct device *dev = regmap_get_device(data->regmap);
585 int ret;
586
587 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
588 BME680_MODE_MASK, mode);
589 if (ret < 0) {
590 dev_err(dev, "failed to set ctrl_meas register\n");
591 return ret;
592 }
593
594 return ret;
595 }
596
bme680_oversampling_to_reg(u8 val)597 static u8 bme680_oversampling_to_reg(u8 val)
598 {
599 return ilog2(val) + 1;
600 }
601
602 /*
603 * Taken from Bosch BME680 API:
604 * https://github.com/boschsensortec/BME68x_SensorAPI/blob/v4.4.8/bme68x.c#L490
605 */
bme680_wait_for_eoc(struct bme680_data * data)606 static int bme680_wait_for_eoc(struct bme680_data *data)
607 {
608 struct device *dev = regmap_get_device(data->regmap);
609 int ret;
610 /*
611 * (Sum of oversampling ratios * time per oversampling) +
612 * TPH measurement + gas measurement + wait transition from forced mode
613 * + heater duration
614 */
615 int wait_eoc_us = ((data->oversampling_temp + data->oversampling_press +
616 data->oversampling_humid) * 1936) + (477 * 4) +
617 (477 * 5) + 1000 + (data->heater_dur * 1000);
618
619 fsleep(wait_eoc_us);
620
621 ret = regmap_read(data->regmap, BME680_REG_MEAS_STAT_0, &data->check);
622 if (ret) {
623 dev_err(dev, "failed to read measurement status register.\n");
624 return ret;
625 }
626 if (data->check & BME680_MEAS_BIT) {
627 dev_err(dev, "Device measurement cycle incomplete.\n");
628 return -EBUSY;
629 }
630 if (!(data->check & BME680_NEW_DATA_BIT)) {
631 dev_err(dev, "No new data available from the device.\n");
632 return -ENODATA;
633 }
634
635 return 0;
636 }
637
bme680_chip_config(struct bme680_data * data)638 static int bme680_chip_config(struct bme680_data *data)
639 {
640 struct device *dev = regmap_get_device(data->regmap);
641 int ret;
642 u8 osrs;
643
644 osrs = FIELD_PREP(BME680_OSRS_HUMIDITY_MASK,
645 bme680_oversampling_to_reg(data->oversampling_humid));
646 /*
647 * Highly recommended to set oversampling of humidity before
648 * temperature/pressure oversampling.
649 */
650 ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_HUMIDITY,
651 BME680_OSRS_HUMIDITY_MASK, osrs);
652 if (ret < 0) {
653 dev_err(dev, "failed to write ctrl_hum register\n");
654 return ret;
655 }
656
657 /* IIR filter settings */
658 ret = regmap_update_bits(data->regmap, BME680_REG_CONFIG,
659 BME680_FILTER_MASK, BME680_FILTER_COEFF_VAL);
660 if (ret < 0) {
661 dev_err(dev, "failed to write config register\n");
662 return ret;
663 }
664
665 osrs = FIELD_PREP(BME680_OSRS_TEMP_MASK,
666 bme680_oversampling_to_reg(data->oversampling_temp)) |
667 FIELD_PREP(BME680_OSRS_PRESS_MASK,
668 bme680_oversampling_to_reg(data->oversampling_press));
669 ret = regmap_write_bits(data->regmap, BME680_REG_CTRL_MEAS,
670 BME680_OSRS_TEMP_MASK | BME680_OSRS_PRESS_MASK,
671 osrs);
672 if (ret < 0) {
673 dev_err(dev, "failed to write ctrl_meas register\n");
674 return ret;
675 }
676
677 return 0;
678 }
679
bme680_preheat_curr_config(struct bme680_data * data,u8 val)680 static int bme680_preheat_curr_config(struct bme680_data *data, u8 val)
681 {
682 struct device *dev = regmap_get_device(data->regmap);
683 u8 heatr_curr;
684 int ret;
685
686 heatr_curr = bme680_calc_heater_preheat_current(val);
687 ret = regmap_write(data->regmap, BME680_REG_IDAC_HEAT_0, heatr_curr);
688 if (ret < 0)
689 dev_err(dev, "failed to write idac_heat_0 register\n");
690
691 return ret;
692 }
693
bme680_gas_config(struct bme680_data * data)694 static int bme680_gas_config(struct bme680_data *data)
695 {
696 struct device *dev = regmap_get_device(data->regmap);
697 int ret;
698 u8 heatr_res, heatr_dur;
699
700 ret = bme680_set_mode(data, BME680_MODE_SLEEP);
701 if (ret < 0)
702 return ret;
703
704 heatr_res = bme680_calc_heater_res(data, data->heater_temp);
705
706 /* set target heater temperature */
707 ret = regmap_write(data->regmap, BME680_REG_RES_HEAT_0, heatr_res);
708 if (ret < 0) {
709 dev_err(dev, "failed to write res_heat_0 register\n");
710 return ret;
711 }
712
713 heatr_dur = bme680_calc_heater_dur(data->heater_dur);
714
715 /* set target heating duration */
716 ret = regmap_write(data->regmap, BME680_REG_GAS_WAIT_0, heatr_dur);
717 if (ret < 0) {
718 dev_err(dev, "failed to write gas_wait_0 register\n");
719 return ret;
720 }
721
722 ret = bme680_preheat_curr_config(data, data->preheat_curr_mA);
723 if (ret)
724 return ret;
725
726 /* Enable the gas sensor and select heater profile set-point 0 */
727 ret = regmap_update_bits(data->regmap, BME680_REG_CTRL_GAS_1,
728 BME680_RUN_GAS_MASK | BME680_NB_CONV_MASK,
729 FIELD_PREP(BME680_RUN_GAS_MASK, 1) |
730 FIELD_PREP(BME680_NB_CONV_MASK, 0));
731 if (ret < 0)
732 dev_err(dev, "failed to write ctrl_gas_1 register\n");
733
734 return ret;
735 }
736
bme680_read_temp(struct bme680_data * data,s16 * comp_temp)737 static int bme680_read_temp(struct bme680_data *data, s16 *comp_temp)
738 {
739 int ret;
740 u32 adc_temp;
741
742 ret = bme680_read_temp_adc(data, &adc_temp);
743 if (ret)
744 return ret;
745
746 *comp_temp = bme680_compensate_temp(data, adc_temp);
747 return 0;
748 }
749
bme680_read_press(struct bme680_data * data,u32 * comp_press)750 static int bme680_read_press(struct bme680_data *data, u32 *comp_press)
751 {
752 int ret;
753 u32 adc_press;
754 s32 t_fine;
755
756 ret = bme680_get_t_fine(data, &t_fine);
757 if (ret)
758 return ret;
759
760 ret = bme680_read_press_adc(data, &adc_press);
761 if (ret)
762 return ret;
763
764 *comp_press = bme680_compensate_press(data, adc_press, t_fine);
765 return 0;
766 }
767
bme680_read_humid(struct bme680_data * data,u32 * comp_humidity)768 static int bme680_read_humid(struct bme680_data *data, u32 *comp_humidity)
769 {
770 int ret;
771 u32 adc_humidity;
772 s32 t_fine;
773
774 ret = bme680_get_t_fine(data, &t_fine);
775 if (ret)
776 return ret;
777
778 ret = bme680_read_humid_adc(data, &adc_humidity);
779 if (ret)
780 return ret;
781
782 *comp_humidity = bme680_compensate_humid(data, adc_humidity, t_fine);
783 return 0;
784 }
785
bme680_read_gas(struct bme680_data * data,int * comp_gas_res)786 static int bme680_read_gas(struct bme680_data *data, int *comp_gas_res)
787 {
788 struct device *dev = regmap_get_device(data->regmap);
789 int ret;
790 u16 adc_gas_res, gas_regs_val;
791 u8 gas_range;
792
793 ret = regmap_read(data->regmap, BME680_REG_MEAS_STAT_0, &data->check);
794 if (data->check & BME680_GAS_MEAS_BIT) {
795 dev_err(dev, "gas measurement incomplete\n");
796 return -EBUSY;
797 }
798
799 ret = regmap_bulk_read(data->regmap, BME680_REG_GAS_MSB,
800 &data->be16, BME680_GAS_NUM_BYTES);
801 if (ret < 0) {
802 dev_err(dev, "failed to read gas resistance\n");
803 return ret;
804 }
805
806 gas_regs_val = be16_to_cpu(data->be16);
807 adc_gas_res = FIELD_GET(BME680_ADC_GAS_RES, gas_regs_val);
808
809 /*
810 * occurs if either the gas heating duration was insuffient
811 * to reach the target heater temperature or the target
812 * heater temperature was too high for the heater sink to
813 * reach.
814 */
815 if ((gas_regs_val & BME680_GAS_STAB_BIT) == 0) {
816 dev_err(dev, "heater failed to reach the target temperature\n");
817 return -EINVAL;
818 }
819
820 gas_range = FIELD_GET(BME680_GAS_RANGE_MASK, gas_regs_val);
821 *comp_gas_res = bme680_compensate_gas(data, adc_gas_res, gas_range);
822 return 0;
823 }
824
__bme680_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)825 static int __bme680_read_raw(struct iio_dev *indio_dev,
826 struct iio_chan_spec const *chan,
827 int *val, int *val2, long mask)
828 {
829 struct bme680_data *data = iio_priv(indio_dev);
830 int chan_val, ret;
831 s16 temp_chan_val;
832
833 guard(mutex)(&data->lock);
834
835 ret = bme680_set_mode(data, BME680_MODE_FORCED);
836 if (ret < 0)
837 return ret;
838
839 ret = bme680_wait_for_eoc(data);
840 if (ret)
841 return ret;
842
843 switch (mask) {
844 case IIO_CHAN_INFO_PROCESSED:
845 switch (chan->type) {
846 case IIO_TEMP:
847 ret = bme680_read_temp(data, &temp_chan_val);
848 if (ret)
849 return ret;
850
851 *val = temp_chan_val * 10;
852 return IIO_VAL_INT;
853 case IIO_PRESSURE:
854 ret = bme680_read_press(data, &chan_val);
855 if (ret)
856 return ret;
857
858 *val = chan_val;
859 *val2 = 1000;
860 return IIO_VAL_FRACTIONAL;
861 case IIO_HUMIDITYRELATIVE:
862 ret = bme680_read_humid(data, &chan_val);
863 if (ret)
864 return ret;
865
866 *val = chan_val;
867 *val2 = 1000;
868 return IIO_VAL_FRACTIONAL;
869 case IIO_RESISTANCE:
870 ret = bme680_read_gas(data, &chan_val);
871 if (ret)
872 return ret;
873
874 *val = chan_val;
875 return IIO_VAL_INT;
876 default:
877 return -EINVAL;
878 }
879 case IIO_CHAN_INFO_RAW:
880 switch (chan->type) {
881 case IIO_TEMP:
882 ret = bme680_read_temp(data, &temp_chan_val);
883 if (ret)
884 return ret;
885
886 *val = temp_chan_val;
887 return IIO_VAL_INT;
888 case IIO_PRESSURE:
889 ret = bme680_read_press(data, &chan_val);
890 if (ret)
891 return ret;
892
893 *val = chan_val;
894 return IIO_VAL_INT;
895 case IIO_HUMIDITYRELATIVE:
896 ret = bme680_read_humid(data, &chan_val);
897 if (ret)
898 return ret;
899
900 *val = chan_val;
901 return IIO_VAL_INT;
902 default:
903 return -EINVAL;
904 }
905 case IIO_CHAN_INFO_SCALE:
906 switch (chan->type) {
907 case IIO_TEMP:
908 *val = 10;
909 return IIO_VAL_INT;
910 case IIO_PRESSURE:
911 *val = 1;
912 *val2 = 1000;
913 return IIO_VAL_FRACTIONAL;
914 case IIO_HUMIDITYRELATIVE:
915 *val = 1;
916 *val2 = 1000;
917 return IIO_VAL_FRACTIONAL;
918 default:
919 return -EINVAL;
920 }
921 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
922 switch (chan->type) {
923 case IIO_TEMP:
924 *val = data->oversampling_temp;
925 return IIO_VAL_INT;
926 case IIO_PRESSURE:
927 *val = data->oversampling_press;
928 return IIO_VAL_INT;
929 case IIO_HUMIDITYRELATIVE:
930 *val = data->oversampling_humid;
931 return IIO_VAL_INT;
932 default:
933 return -EINVAL;
934 }
935 default:
936 return -EINVAL;
937 }
938 }
939
bme680_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)940 static int bme680_read_raw(struct iio_dev *indio_dev,
941 struct iio_chan_spec const *chan,
942 int *val, int *val2, long mask)
943 {
944 struct bme680_data *data = iio_priv(indio_dev);
945 struct device *dev = regmap_get_device(data->regmap);
946 int ret;
947
948 ret = pm_runtime_resume_and_get(dev);
949 if (ret)
950 return ret;
951
952 ret = __bme680_read_raw(indio_dev, chan, val, val2, mask);
953 pm_runtime_mark_last_busy(dev);
954 pm_runtime_put_autosuspend(dev);
955
956 return ret;
957 }
958
bme680_is_valid_oversampling(int rate)959 static bool bme680_is_valid_oversampling(int rate)
960 {
961 return (rate > 0 && rate <= 16 && is_power_of_2(rate));
962 }
963
__bme680_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)964 static int __bme680_write_raw(struct iio_dev *indio_dev,
965 struct iio_chan_spec const *chan,
966 int val, int val2, long mask)
967 {
968 struct bme680_data *data = iio_priv(indio_dev);
969
970 guard(mutex)(&data->lock);
971
972 if (val2 != 0)
973 return -EINVAL;
974
975 switch (mask) {
976 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
977 {
978 if (!bme680_is_valid_oversampling(val))
979 return -EINVAL;
980
981 switch (chan->type) {
982 case IIO_TEMP:
983 data->oversampling_temp = val;
984 break;
985 case IIO_PRESSURE:
986 data->oversampling_press = val;
987 break;
988 case IIO_HUMIDITYRELATIVE:
989 data->oversampling_humid = val;
990 break;
991 default:
992 return -EINVAL;
993 }
994
995 return bme680_chip_config(data);
996 }
997 case IIO_CHAN_INFO_PROCESSED:
998 {
999 switch (chan->type) {
1000 case IIO_CURRENT:
1001 return bme680_preheat_curr_config(data, (u8)val);
1002 default:
1003 return -EINVAL;
1004 }
1005 }
1006 default:
1007 return -EINVAL;
1008 }
1009 }
1010
bme680_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)1011 static int bme680_write_raw(struct iio_dev *indio_dev,
1012 struct iio_chan_spec const *chan,
1013 int val, int val2, long mask)
1014 {
1015 struct bme680_data *data = iio_priv(indio_dev);
1016 struct device *dev = regmap_get_device(data->regmap);
1017 int ret;
1018
1019 ret = pm_runtime_resume_and_get(dev);
1020 if (ret)
1021 return ret;
1022
1023 ret = __bme680_write_raw(indio_dev, chan, val, val2, mask);
1024 pm_runtime_mark_last_busy(dev);
1025 pm_runtime_put_autosuspend(dev);
1026
1027 return ret;
1028 }
1029
1030 static const char bme680_oversampling_ratio_show[] = "1 2 4 8 16";
1031
1032 static IIO_CONST_ATTR(oversampling_ratio_available,
1033 bme680_oversampling_ratio_show);
1034
1035 static struct attribute *bme680_attributes[] = {
1036 &iio_const_attr_oversampling_ratio_available.dev_attr.attr,
1037 NULL,
1038 };
1039
1040 static const struct attribute_group bme680_attribute_group = {
1041 .attrs = bme680_attributes,
1042 };
1043
1044 static const struct iio_info bme680_info = {
1045 .read_raw = &bme680_read_raw,
1046 .write_raw = &bme680_write_raw,
1047 .attrs = &bme680_attribute_group,
1048 };
1049
1050 static const unsigned long bme680_avail_scan_masks[] = {
1051 BIT(BME680_GAS) | BIT(BME680_HUMID) | BIT(BME680_PRESS) | BIT(BME680_TEMP),
1052 0
1053 };
1054
bme680_trigger_handler(int irq,void * p)1055 static irqreturn_t bme680_trigger_handler(int irq, void *p)
1056 {
1057 struct iio_poll_func *pf = p;
1058 struct iio_dev *indio_dev = pf->indio_dev;
1059 struct bme680_data *data = iio_priv(indio_dev);
1060 struct device *dev = regmap_get_device(data->regmap);
1061 u32 adc_temp, adc_press, adc_humid;
1062 u16 adc_gas_res, gas_regs_val;
1063 u8 gas_range;
1064 s32 t_fine;
1065 int ret;
1066
1067 guard(mutex)(&data->lock);
1068
1069 ret = bme680_set_mode(data, BME680_MODE_FORCED);
1070 if (ret < 0)
1071 goto out;
1072
1073 ret = bme680_wait_for_eoc(data);
1074 if (ret)
1075 goto out;
1076
1077 ret = regmap_bulk_read(data->regmap, BME680_REG_MEAS_STAT_0,
1078 data->buf, sizeof(data->buf));
1079 if (ret) {
1080 dev_err(dev, "failed to burst read sensor data\n");
1081 goto out;
1082 }
1083 if (data->buf[0] & BME680_GAS_MEAS_BIT) {
1084 dev_err(dev, "gas measurement incomplete\n");
1085 goto out;
1086 }
1087
1088 /* Temperature calculations */
1089 adc_temp = FIELD_GET(BME680_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[5]));
1090 if (adc_temp == BME680_MEAS_SKIPPED) {
1091 dev_err(dev, "reading temperature skipped\n");
1092 goto out;
1093 }
1094 data->scan.chan[0] = bme680_compensate_temp(data, adc_temp);
1095 t_fine = bme680_calc_t_fine(data, adc_temp);
1096
1097 /* Pressure calculations */
1098 adc_press = FIELD_GET(BME680_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[2]));
1099 if (adc_press == BME680_MEAS_SKIPPED) {
1100 dev_err(dev, "reading pressure skipped\n");
1101 goto out;
1102 }
1103 data->scan.chan[1] = bme680_compensate_press(data, adc_press, t_fine);
1104
1105 /* Humidity calculations */
1106 adc_humid = get_unaligned_be16(&data->buf[8]);
1107 if (adc_humid == BME680_MEAS_SKIPPED) {
1108 dev_err(dev, "reading humidity skipped\n");
1109 goto out;
1110 }
1111 data->scan.chan[2] = bme680_compensate_humid(data, adc_humid, t_fine);
1112
1113 /* Gas calculations */
1114 gas_regs_val = get_unaligned_be16(&data->buf[13]);
1115 adc_gas_res = FIELD_GET(BME680_ADC_GAS_RES, gas_regs_val);
1116 if ((gas_regs_val & BME680_GAS_STAB_BIT) == 0) {
1117 dev_err(dev, "heater failed to reach the target temperature\n");
1118 goto out;
1119 }
1120 gas_range = FIELD_GET(BME680_GAS_RANGE_MASK, gas_regs_val);
1121 data->scan.chan[3] = bme680_compensate_gas(data, adc_gas_res, gas_range);
1122
1123 iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
1124 iio_get_time_ns(indio_dev));
1125 out:
1126 iio_trigger_notify_done(indio_dev->trig);
1127 return IRQ_HANDLED;
1128 }
1129
bme680_buffer_preenable(struct iio_dev * indio_dev)1130 static int bme680_buffer_preenable(struct iio_dev *indio_dev)
1131 {
1132 struct bme680_data *data = iio_priv(indio_dev);
1133 struct device *dev = regmap_get_device(data->regmap);
1134
1135 return pm_runtime_resume_and_get(dev);
1136 }
1137
bme680_buffer_postdisable(struct iio_dev * indio_dev)1138 static int bme680_buffer_postdisable(struct iio_dev *indio_dev)
1139 {
1140 struct bme680_data *data = iio_priv(indio_dev);
1141 struct device *dev = regmap_get_device(data->regmap);
1142
1143 pm_runtime_mark_last_busy(dev);
1144 pm_runtime_put_autosuspend(dev);
1145 return 0;
1146 }
1147
1148 static const struct iio_buffer_setup_ops bme680_buffer_setup_ops = {
1149 .preenable = bme680_buffer_preenable,
1150 .postdisable = bme680_buffer_postdisable,
1151 };
1152
bme680_core_probe(struct device * dev,struct regmap * regmap,const char * name)1153 int bme680_core_probe(struct device *dev, struct regmap *regmap,
1154 const char *name)
1155 {
1156 struct iio_dev *indio_dev;
1157 struct bme680_data *data;
1158 int ret;
1159
1160 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
1161 if (!indio_dev)
1162 return -ENOMEM;
1163
1164 data = iio_priv(indio_dev);
1165 mutex_init(&data->lock);
1166 dev_set_drvdata(dev, indio_dev);
1167 data->regmap = regmap;
1168 indio_dev->name = name;
1169 indio_dev->channels = bme680_channels;
1170 indio_dev->num_channels = ARRAY_SIZE(bme680_channels);
1171 indio_dev->available_scan_masks = bme680_avail_scan_masks;
1172 indio_dev->info = &bme680_info;
1173 indio_dev->modes = INDIO_DIRECT_MODE;
1174
1175 /* default values for the sensor */
1176 data->oversampling_humid = 2; /* 2X oversampling rate */
1177 data->oversampling_press = 4; /* 4X oversampling rate */
1178 data->oversampling_temp = 8; /* 8X oversampling rate */
1179 data->heater_temp = 320; /* degree Celsius */
1180 data->heater_dur = 150; /* milliseconds */
1181 data->preheat_curr_mA = 0;
1182
1183 ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(bme680_supply_names),
1184 bme680_supply_names);
1185 if (ret)
1186 return dev_err_probe(dev, ret,
1187 "failed to get and enable supplies.\n");
1188
1189 fsleep(BME680_STARTUP_TIME_US);
1190
1191 ret = regmap_write(regmap, BME680_REG_SOFT_RESET, BME680_CMD_SOFTRESET);
1192 if (ret < 0)
1193 return dev_err_probe(dev, ret, "Failed to reset chip\n");
1194
1195 fsleep(BME680_STARTUP_TIME_US);
1196
1197 ret = regmap_read(regmap, BME680_REG_CHIP_ID, &data->check);
1198 if (ret < 0)
1199 return dev_err_probe(dev, ret, "Error reading chip ID\n");
1200
1201 if (data->check != BME680_CHIP_ID_VAL) {
1202 dev_err(dev, "Wrong chip ID, got %x expected %x\n",
1203 data->check, BME680_CHIP_ID_VAL);
1204 return -ENODEV;
1205 }
1206
1207 ret = bme680_read_calib(data, &data->bme680);
1208 if (ret < 0) {
1209 return dev_err_probe(dev, ret,
1210 "failed to read calibration coefficients at probe\n");
1211 }
1212
1213 ret = bme680_chip_config(data);
1214 if (ret < 0)
1215 return dev_err_probe(dev, ret,
1216 "failed to set chip_config data\n");
1217
1218 ret = bme680_gas_config(data);
1219 if (ret < 0)
1220 return dev_err_probe(dev, ret,
1221 "failed to set gas config data\n");
1222
1223 ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
1224 iio_pollfunc_store_time,
1225 bme680_trigger_handler,
1226 &bme680_buffer_setup_ops);
1227 if (ret)
1228 return dev_err_probe(dev, ret,
1229 "iio triggered buffer setup failed\n");
1230
1231 /* Enable runtime PM */
1232 pm_runtime_set_autosuspend_delay(dev, BME680_STARTUP_TIME_US);
1233 pm_runtime_use_autosuspend(dev);
1234 pm_runtime_set_active(dev);
1235 ret = devm_pm_runtime_enable(dev);
1236 if (ret)
1237 return ret;
1238
1239 return devm_iio_device_register(dev, indio_dev);
1240 }
1241 EXPORT_SYMBOL_NS_GPL(bme680_core_probe, "IIO_BME680");
1242
bme680_runtime_suspend(struct device * dev)1243 static int bme680_runtime_suspend(struct device *dev)
1244 {
1245 struct iio_dev *indio_dev = dev_get_drvdata(dev);
1246 struct bme680_data *data = iio_priv(indio_dev);
1247
1248 return bme680_set_mode(data, BME680_MODE_SLEEP);
1249 }
1250
bme680_runtime_resume(struct device * dev)1251 static int bme680_runtime_resume(struct device *dev)
1252 {
1253 struct iio_dev *indio_dev = dev_get_drvdata(dev);
1254 struct bme680_data *data = iio_priv(indio_dev);
1255 int ret;
1256
1257 ret = bme680_chip_config(data);
1258 if (ret)
1259 return ret;
1260
1261 return bme680_gas_config(data);
1262 }
1263
1264 EXPORT_RUNTIME_DEV_PM_OPS(bme680_dev_pm_ops, bme680_runtime_suspend,
1265 bme680_runtime_resume, NULL);
1266
1267 MODULE_AUTHOR("Himanshu Jha <himanshujha199640@gmail.com>");
1268 MODULE_DESCRIPTION("Bosch BME680 Driver");
1269 MODULE_LICENSE("GPL v2");
1270