bme680_core.c 24 KB

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