dps310.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897
  1. // SPDX-License-Identifier: GPL-2.0+
  2. // Copyright IBM Corp 2019
  3. /*
  4. * The DPS310 is a barometric pressure and temperature sensor.
  5. * Currently only reading a single temperature is supported by
  6. * this driver.
  7. *
  8. * https://www.infineon.com/dgdl/?fileId=5546d462576f34750157750826c42242
  9. *
  10. * Temperature calculation:
  11. * c0 * 0.5 + c1 * T_raw / kT °C
  12. *
  13. * TODO:
  14. * - Optionally support the FIFO
  15. */
  16. #include <linux/i2c.h>
  17. #include <linux/limits.h>
  18. #include <linux/math64.h>
  19. #include <linux/module.h>
  20. #include <linux/regmap.h>
  21. #include <linux/iio/iio.h>
  22. #include <linux/iio/sysfs.h>
  23. #define DPS310_DEV_NAME "dps310"
  24. #define DPS310_PRS_B0 0x00
  25. #define DPS310_PRS_B1 0x01
  26. #define DPS310_PRS_B2 0x02
  27. #define DPS310_TMP_B0 0x03
  28. #define DPS310_TMP_B1 0x04
  29. #define DPS310_TMP_B2 0x05
  30. #define DPS310_PRS_CFG 0x06
  31. #define DPS310_PRS_RATE_BITS GENMASK(6, 4)
  32. #define DPS310_PRS_PRC_BITS GENMASK(3, 0)
  33. #define DPS310_TMP_CFG 0x07
  34. #define DPS310_TMP_RATE_BITS GENMASK(6, 4)
  35. #define DPS310_TMP_PRC_BITS GENMASK(3, 0)
  36. #define DPS310_TMP_EXT BIT(7)
  37. #define DPS310_MEAS_CFG 0x08
  38. #define DPS310_MEAS_CTRL_BITS GENMASK(2, 0)
  39. #define DPS310_PRS_EN BIT(0)
  40. #define DPS310_TEMP_EN BIT(1)
  41. #define DPS310_BACKGROUND BIT(2)
  42. #define DPS310_PRS_RDY BIT(4)
  43. #define DPS310_TMP_RDY BIT(5)
  44. #define DPS310_SENSOR_RDY BIT(6)
  45. #define DPS310_COEF_RDY BIT(7)
  46. #define DPS310_CFG_REG 0x09
  47. #define DPS310_INT_HL BIT(7)
  48. #define DPS310_TMP_SHIFT_EN BIT(3)
  49. #define DPS310_PRS_SHIFT_EN BIT(4)
  50. #define DPS310_FIFO_EN BIT(5)
  51. #define DPS310_SPI_EN BIT(6)
  52. #define DPS310_RESET 0x0c
  53. #define DPS310_RESET_MAGIC 0x09
  54. #define DPS310_COEF_BASE 0x10
  55. /* Make sure sleep time is <= 30ms for usleep_range */
  56. #define DPS310_POLL_SLEEP_US(t) min(30000, (t) / 8)
  57. /* Silently handle error in rate value here */
  58. #define DPS310_POLL_TIMEOUT_US(rc) ((rc) <= 0 ? 1000000 : 1000000 / (rc))
  59. #define DPS310_PRS_BASE DPS310_PRS_B0
  60. #define DPS310_TMP_BASE DPS310_TMP_B0
  61. /*
  62. * These values (defined in the spec) indicate how to scale the raw register
  63. * values for each level of precision available.
  64. */
  65. static const int scale_factors[] = {
  66. 524288,
  67. 1572864,
  68. 3670016,
  69. 7864320,
  70. 253952,
  71. 516096,
  72. 1040384,
  73. 2088960,
  74. };
  75. struct dps310_data {
  76. struct i2c_client *client;
  77. struct regmap *regmap;
  78. struct mutex lock; /* Lock for sequential HW access functions */
  79. s32 c0, c1;
  80. s32 c00, c10, c20, c30, c01, c11, c21;
  81. s32 pressure_raw;
  82. s32 temp_raw;
  83. bool timeout_recovery_failed;
  84. };
  85. static const struct iio_chan_spec dps310_channels[] = {
  86. {
  87. .type = IIO_TEMP,
  88. .info_mask_separate = BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) |
  89. BIT(IIO_CHAN_INFO_SAMP_FREQ) |
  90. BIT(IIO_CHAN_INFO_PROCESSED),
  91. },
  92. {
  93. .type = IIO_PRESSURE,
  94. .info_mask_separate = BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) |
  95. BIT(IIO_CHAN_INFO_SAMP_FREQ) |
  96. BIT(IIO_CHAN_INFO_PROCESSED),
  97. },
  98. };
  99. /* To be called after checking the COEF_RDY bit in MEAS_CFG */
  100. static int dps310_get_coefs(struct dps310_data *data)
  101. {
  102. int rc;
  103. u8 coef[18];
  104. u32 c0, c1;
  105. u32 c00, c10, c20, c30, c01, c11, c21;
  106. /* Read all sensor calibration coefficients from the COEF registers. */
  107. rc = regmap_bulk_read(data->regmap, DPS310_COEF_BASE, coef,
  108. sizeof(coef));
  109. if (rc < 0)
  110. return rc;
  111. /*
  112. * Calculate temperature calibration coefficients c0 and c1. The
  113. * numbers are 12-bit 2's complement numbers.
  114. */
  115. c0 = (coef[0] << 4) | (coef[1] >> 4);
  116. data->c0 = sign_extend32(c0, 11);
  117. c1 = ((coef[1] & GENMASK(3, 0)) << 8) | coef[2];
  118. data->c1 = sign_extend32(c1, 11);
  119. /*
  120. * Calculate pressure calibration coefficients. c00 and c10 are 20 bit
  121. * 2's complement numbers, while the rest are 16 bit 2's complement
  122. * numbers.
  123. */
  124. c00 = (coef[3] << 12) | (coef[4] << 4) | (coef[5] >> 4);
  125. data->c00 = sign_extend32(c00, 19);
  126. c10 = ((coef[5] & GENMASK(3, 0)) << 16) | (coef[6] << 8) | coef[7];
  127. data->c10 = sign_extend32(c10, 19);
  128. c01 = (coef[8] << 8) | coef[9];
  129. data->c01 = sign_extend32(c01, 15);
  130. c11 = (coef[10] << 8) | coef[11];
  131. data->c11 = sign_extend32(c11, 15);
  132. c20 = (coef[12] << 8) | coef[13];
  133. data->c20 = sign_extend32(c20, 15);
  134. c21 = (coef[14] << 8) | coef[15];
  135. data->c21 = sign_extend32(c21, 15);
  136. c30 = (coef[16] << 8) | coef[17];
  137. data->c30 = sign_extend32(c30, 15);
  138. return 0;
  139. }
  140. /*
  141. * Some versions of the chip will read temperatures in the ~60C range when
  142. * it's actually ~20C. This is the manufacturer recommended workaround
  143. * to correct the issue. The registers used below are undocumented.
  144. */
  145. static int dps310_temp_workaround(struct dps310_data *data)
  146. {
  147. int rc;
  148. int reg;
  149. rc = regmap_read(data->regmap, 0x32, &reg);
  150. if (rc)
  151. return rc;
  152. /*
  153. * If bit 1 is set then the device is okay, and the workaround does not
  154. * need to be applied
  155. */
  156. if (reg & BIT(1))
  157. return 0;
  158. rc = regmap_write(data->regmap, 0x0e, 0xA5);
  159. if (rc)
  160. return rc;
  161. rc = regmap_write(data->regmap, 0x0f, 0x96);
  162. if (rc)
  163. return rc;
  164. rc = regmap_write(data->regmap, 0x62, 0x02);
  165. if (rc)
  166. return rc;
  167. rc = regmap_write(data->regmap, 0x0e, 0x00);
  168. if (rc)
  169. return rc;
  170. return regmap_write(data->regmap, 0x0f, 0x00);
  171. }
  172. static int dps310_startup(struct dps310_data *data)
  173. {
  174. int rc;
  175. int ready;
  176. /*
  177. * Set up pressure sensor in single sample, one measurement per second
  178. * mode
  179. */
  180. rc = regmap_write(data->regmap, DPS310_PRS_CFG, 0);
  181. if (rc)
  182. return rc;
  183. /*
  184. * Set up external (MEMS) temperature sensor in single sample, one
  185. * measurement per second mode
  186. */
  187. rc = regmap_write(data->regmap, DPS310_TMP_CFG, DPS310_TMP_EXT);
  188. if (rc)
  189. return rc;
  190. /* Temp and pressure shifts are disabled when PRC <= 8 */
  191. rc = regmap_write_bits(data->regmap, DPS310_CFG_REG,
  192. DPS310_PRS_SHIFT_EN | DPS310_TMP_SHIFT_EN, 0);
  193. if (rc)
  194. return rc;
  195. /* MEAS_CFG doesn't update correctly unless first written with 0 */
  196. rc = regmap_write_bits(data->regmap, DPS310_MEAS_CFG,
  197. DPS310_MEAS_CTRL_BITS, 0);
  198. if (rc)
  199. return rc;
  200. /* Turn on temperature and pressure measurement in the background */
  201. rc = regmap_write_bits(data->regmap, DPS310_MEAS_CFG,
  202. DPS310_MEAS_CTRL_BITS, DPS310_PRS_EN |
  203. DPS310_TEMP_EN | DPS310_BACKGROUND);
  204. if (rc)
  205. return rc;
  206. /*
  207. * Calibration coefficients required for reporting temperature.
  208. * They are available 40ms after the device has started
  209. */
  210. rc = regmap_read_poll_timeout(data->regmap, DPS310_MEAS_CFG, ready,
  211. ready & DPS310_COEF_RDY, 10000, 40000);
  212. if (rc)
  213. return rc;
  214. rc = dps310_get_coefs(data);
  215. if (rc)
  216. return rc;
  217. return dps310_temp_workaround(data);
  218. }
  219. static int dps310_get_pres_precision(struct dps310_data *data)
  220. {
  221. int rc;
  222. int val;
  223. rc = regmap_read(data->regmap, DPS310_PRS_CFG, &val);
  224. if (rc < 0)
  225. return rc;
  226. return BIT(val & GENMASK(2, 0));
  227. }
  228. static int dps310_get_temp_precision(struct dps310_data *data)
  229. {
  230. int rc;
  231. int val;
  232. rc = regmap_read(data->regmap, DPS310_TMP_CFG, &val);
  233. if (rc < 0)
  234. return rc;
  235. /*
  236. * Scale factor is bottom 4 bits of the register, but 1111 is
  237. * reserved so just grab bottom three
  238. */
  239. return BIT(val & GENMASK(2, 0));
  240. }
  241. /* Called with lock held */
  242. static int dps310_set_pres_precision(struct dps310_data *data, int val)
  243. {
  244. int rc;
  245. u8 shift_en;
  246. if (val < 0 || val > 128)
  247. return -EINVAL;
  248. shift_en = val >= 16 ? DPS310_PRS_SHIFT_EN : 0;
  249. rc = regmap_write_bits(data->regmap, DPS310_CFG_REG,
  250. DPS310_PRS_SHIFT_EN, shift_en);
  251. if (rc)
  252. return rc;
  253. return regmap_update_bits(data->regmap, DPS310_PRS_CFG,
  254. DPS310_PRS_PRC_BITS, ilog2(val));
  255. }
  256. /* Called with lock held */
  257. static int dps310_set_temp_precision(struct dps310_data *data, int val)
  258. {
  259. int rc;
  260. u8 shift_en;
  261. if (val < 0 || val > 128)
  262. return -EINVAL;
  263. shift_en = val >= 16 ? DPS310_TMP_SHIFT_EN : 0;
  264. rc = regmap_write_bits(data->regmap, DPS310_CFG_REG,
  265. DPS310_TMP_SHIFT_EN, shift_en);
  266. if (rc)
  267. return rc;
  268. return regmap_update_bits(data->regmap, DPS310_TMP_CFG,
  269. DPS310_TMP_PRC_BITS, ilog2(val));
  270. }
  271. /* Called with lock held */
  272. static int dps310_set_pres_samp_freq(struct dps310_data *data, int freq)
  273. {
  274. u8 val;
  275. if (freq < 0 || freq > 128)
  276. return -EINVAL;
  277. val = ilog2(freq) << 4;
  278. return regmap_update_bits(data->regmap, DPS310_PRS_CFG,
  279. DPS310_PRS_RATE_BITS, val);
  280. }
  281. /* Called with lock held */
  282. static int dps310_set_temp_samp_freq(struct dps310_data *data, int freq)
  283. {
  284. u8 val;
  285. if (freq < 0 || freq > 128)
  286. return -EINVAL;
  287. val = ilog2(freq) << 4;
  288. return regmap_update_bits(data->regmap, DPS310_TMP_CFG,
  289. DPS310_TMP_RATE_BITS, val);
  290. }
  291. static int dps310_get_pres_samp_freq(struct dps310_data *data)
  292. {
  293. int rc;
  294. int val;
  295. rc = regmap_read(data->regmap, DPS310_PRS_CFG, &val);
  296. if (rc < 0)
  297. return rc;
  298. return BIT((val & DPS310_PRS_RATE_BITS) >> 4);
  299. }
  300. static int dps310_get_temp_samp_freq(struct dps310_data *data)
  301. {
  302. int rc;
  303. int val;
  304. rc = regmap_read(data->regmap, DPS310_TMP_CFG, &val);
  305. if (rc < 0)
  306. return rc;
  307. return BIT((val & DPS310_TMP_RATE_BITS) >> 4);
  308. }
  309. static int dps310_get_pres_k(struct dps310_data *data)
  310. {
  311. int rc = dps310_get_pres_precision(data);
  312. if (rc < 0)
  313. return rc;
  314. return scale_factors[ilog2(rc)];
  315. }
  316. static int dps310_get_temp_k(struct dps310_data *data)
  317. {
  318. int rc = dps310_get_temp_precision(data);
  319. if (rc < 0)
  320. return rc;
  321. return scale_factors[ilog2(rc)];
  322. }
  323. static int dps310_reset_wait(struct dps310_data *data)
  324. {
  325. int rc;
  326. rc = regmap_write(data->regmap, DPS310_RESET, DPS310_RESET_MAGIC);
  327. if (rc)
  328. return rc;
  329. /* Wait for device chip access: 15ms in specification */
  330. usleep_range(15000, 55000);
  331. return 0;
  332. }
  333. static int dps310_reset_reinit(struct dps310_data *data)
  334. {
  335. int rc;
  336. rc = dps310_reset_wait(data);
  337. if (rc)
  338. return rc;
  339. return dps310_startup(data);
  340. }
  341. static int dps310_ready_status(struct dps310_data *data, int ready_bit, int timeout)
  342. {
  343. int sleep = DPS310_POLL_SLEEP_US(timeout);
  344. int ready;
  345. return regmap_read_poll_timeout(data->regmap, DPS310_MEAS_CFG, ready, ready & ready_bit,
  346. sleep, timeout);
  347. }
  348. static int dps310_ready(struct dps310_data *data, int ready_bit, int timeout)
  349. {
  350. int rc;
  351. rc = dps310_ready_status(data, ready_bit, timeout);
  352. if (rc) {
  353. if (rc == -ETIMEDOUT && !data->timeout_recovery_failed) {
  354. /* Reset and reinitialize the chip. */
  355. if (dps310_reset_reinit(data)) {
  356. data->timeout_recovery_failed = true;
  357. } else {
  358. /* Try again to get sensor ready status. */
  359. if (dps310_ready_status(data, ready_bit, timeout))
  360. data->timeout_recovery_failed = true;
  361. else
  362. return 0;
  363. }
  364. }
  365. return rc;
  366. }
  367. data->timeout_recovery_failed = false;
  368. return 0;
  369. }
  370. static int dps310_read_pres_raw(struct dps310_data *data)
  371. {
  372. int rc;
  373. int rate;
  374. int timeout;
  375. s32 raw;
  376. u8 val[3];
  377. if (mutex_lock_interruptible(&data->lock))
  378. return -EINTR;
  379. rate = dps310_get_pres_samp_freq(data);
  380. timeout = DPS310_POLL_TIMEOUT_US(rate);
  381. /* Poll for sensor readiness; base the timeout upon the sample rate. */
  382. rc = dps310_ready(data, DPS310_PRS_RDY, timeout);
  383. if (rc)
  384. goto done;
  385. rc = regmap_bulk_read(data->regmap, DPS310_PRS_BASE, val, sizeof(val));
  386. if (rc < 0)
  387. goto done;
  388. raw = (val[0] << 16) | (val[1] << 8) | val[2];
  389. data->pressure_raw = sign_extend32(raw, 23);
  390. done:
  391. mutex_unlock(&data->lock);
  392. return rc;
  393. }
  394. /* Called with lock held */
  395. static int dps310_read_temp_ready(struct dps310_data *data)
  396. {
  397. int rc;
  398. u8 val[3];
  399. s32 raw;
  400. rc = regmap_bulk_read(data->regmap, DPS310_TMP_BASE, val, sizeof(val));
  401. if (rc < 0)
  402. return rc;
  403. raw = (val[0] << 16) | (val[1] << 8) | val[2];
  404. data->temp_raw = sign_extend32(raw, 23);
  405. return 0;
  406. }
  407. static int dps310_read_temp_raw(struct dps310_data *data)
  408. {
  409. int rc;
  410. int rate;
  411. int timeout;
  412. if (mutex_lock_interruptible(&data->lock))
  413. return -EINTR;
  414. rate = dps310_get_temp_samp_freq(data);
  415. timeout = DPS310_POLL_TIMEOUT_US(rate);
  416. /* Poll for sensor readiness; base the timeout upon the sample rate. */
  417. rc = dps310_ready(data, DPS310_TMP_RDY, timeout);
  418. if (rc)
  419. goto done;
  420. rc = dps310_read_temp_ready(data);
  421. done:
  422. mutex_unlock(&data->lock);
  423. return rc;
  424. }
  425. static bool dps310_is_writeable_reg(struct device *dev, unsigned int reg)
  426. {
  427. switch (reg) {
  428. case DPS310_PRS_CFG:
  429. case DPS310_TMP_CFG:
  430. case DPS310_MEAS_CFG:
  431. case DPS310_CFG_REG:
  432. case DPS310_RESET:
  433. /* No documentation available on the registers below */
  434. case 0x0e:
  435. case 0x0f:
  436. case 0x62:
  437. return true;
  438. default:
  439. return false;
  440. }
  441. }
  442. static bool dps310_is_volatile_reg(struct device *dev, unsigned int reg)
  443. {
  444. switch (reg) {
  445. case DPS310_PRS_B0:
  446. case DPS310_PRS_B1:
  447. case DPS310_PRS_B2:
  448. case DPS310_TMP_B0:
  449. case DPS310_TMP_B1:
  450. case DPS310_TMP_B2:
  451. case DPS310_MEAS_CFG:
  452. case 0x32: /* No documentation available on this register */
  453. return true;
  454. default:
  455. return false;
  456. }
  457. }
  458. static int dps310_write_raw(struct iio_dev *iio,
  459. struct iio_chan_spec const *chan, int val,
  460. int val2, long mask)
  461. {
  462. int rc;
  463. struct dps310_data *data = iio_priv(iio);
  464. if (mutex_lock_interruptible(&data->lock))
  465. return -EINTR;
  466. switch (mask) {
  467. case IIO_CHAN_INFO_SAMP_FREQ:
  468. switch (chan->type) {
  469. case IIO_PRESSURE:
  470. rc = dps310_set_pres_samp_freq(data, val);
  471. break;
  472. case IIO_TEMP:
  473. rc = dps310_set_temp_samp_freq(data, val);
  474. break;
  475. default:
  476. rc = -EINVAL;
  477. break;
  478. }
  479. break;
  480. case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
  481. switch (chan->type) {
  482. case IIO_PRESSURE:
  483. rc = dps310_set_pres_precision(data, val);
  484. break;
  485. case IIO_TEMP:
  486. rc = dps310_set_temp_precision(data, val);
  487. break;
  488. default:
  489. rc = -EINVAL;
  490. break;
  491. }
  492. break;
  493. default:
  494. rc = -EINVAL;
  495. break;
  496. }
  497. mutex_unlock(&data->lock);
  498. return rc;
  499. }
  500. static int dps310_calculate_pressure(struct dps310_data *data)
  501. {
  502. int i;
  503. int rc;
  504. int t_ready;
  505. int kpi = dps310_get_pres_k(data);
  506. int kti = dps310_get_temp_k(data);
  507. s64 rem = 0ULL;
  508. s64 pressure = 0ULL;
  509. s64 p;
  510. s64 t;
  511. s64 denoms[7];
  512. s64 nums[7];
  513. s64 rems[7];
  514. s64 kp;
  515. s64 kt;
  516. if (kpi < 0)
  517. return kpi;
  518. if (kti < 0)
  519. return kti;
  520. kp = (s64)kpi;
  521. kt = (s64)kti;
  522. /* Refresh temp if it's ready, otherwise just use the latest value */
  523. if (mutex_trylock(&data->lock)) {
  524. rc = regmap_read(data->regmap, DPS310_MEAS_CFG, &t_ready);
  525. if (rc >= 0 && t_ready & DPS310_TMP_RDY)
  526. dps310_read_temp_ready(data);
  527. mutex_unlock(&data->lock);
  528. }
  529. p = (s64)data->pressure_raw;
  530. t = (s64)data->temp_raw;
  531. /* Section 4.9.1 of the DPS310 spec; algebra'd to avoid underflow */
  532. nums[0] = (s64)data->c00;
  533. denoms[0] = 1LL;
  534. nums[1] = p * (s64)data->c10;
  535. denoms[1] = kp;
  536. nums[2] = p * p * (s64)data->c20;
  537. denoms[2] = kp * kp;
  538. nums[3] = p * p * p * (s64)data->c30;
  539. denoms[3] = kp * kp * kp;
  540. nums[4] = t * (s64)data->c01;
  541. denoms[4] = kt;
  542. nums[5] = t * p * (s64)data->c11;
  543. denoms[5] = kp * kt;
  544. nums[6] = t * p * p * (s64)data->c21;
  545. denoms[6] = kp * kp * kt;
  546. /* Kernel lacks a div64_s64_rem function; denoms are all positive */
  547. for (i = 0; i < 7; ++i) {
  548. u64 irem;
  549. if (nums[i] < 0LL) {
  550. pressure -= div64_u64_rem(-nums[i], denoms[i], &irem);
  551. rems[i] = -irem;
  552. } else {
  553. pressure += div64_u64_rem(nums[i], denoms[i], &irem);
  554. rems[i] = (s64)irem;
  555. }
  556. }
  557. /* Increase precision and calculate the remainder sum */
  558. for (i = 0; i < 7; ++i)
  559. rem += div64_s64((s64)rems[i] * 1000000000LL, denoms[i]);
  560. pressure += div_s64(rem, 1000000000LL);
  561. if (pressure < 0LL)
  562. return -ERANGE;
  563. return (int)min_t(s64, pressure, INT_MAX);
  564. }
  565. static int dps310_read_pressure(struct dps310_data *data, int *val, int *val2,
  566. long mask)
  567. {
  568. int rc;
  569. switch (mask) {
  570. case IIO_CHAN_INFO_SAMP_FREQ:
  571. rc = dps310_get_pres_samp_freq(data);
  572. if (rc < 0)
  573. return rc;
  574. *val = rc;
  575. return IIO_VAL_INT;
  576. case IIO_CHAN_INFO_PROCESSED:
  577. rc = dps310_read_pres_raw(data);
  578. if (rc)
  579. return rc;
  580. rc = dps310_calculate_pressure(data);
  581. if (rc < 0)
  582. return rc;
  583. *val = rc;
  584. *val2 = 1000; /* Convert Pa to KPa per IIO ABI */
  585. return IIO_VAL_FRACTIONAL;
  586. case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
  587. rc = dps310_get_pres_precision(data);
  588. if (rc < 0)
  589. return rc;
  590. *val = rc;
  591. return IIO_VAL_INT;
  592. default:
  593. return -EINVAL;
  594. }
  595. }
  596. static int dps310_calculate_temp(struct dps310_data *data)
  597. {
  598. s64 c0;
  599. s64 t;
  600. int kt = dps310_get_temp_k(data);
  601. if (kt < 0)
  602. return kt;
  603. /* Obtain inverse-scaled offset */
  604. c0 = div_s64((s64)kt * (s64)data->c0, 2);
  605. /* Add the offset to the unscaled temperature */
  606. t = c0 + ((s64)data->temp_raw * (s64)data->c1);
  607. /* Convert to milliCelsius and scale the temperature */
  608. return (int)div_s64(t * 1000LL, kt);
  609. }
  610. static int dps310_read_temp(struct dps310_data *data, int *val, int *val2,
  611. long mask)
  612. {
  613. int rc;
  614. switch (mask) {
  615. case IIO_CHAN_INFO_SAMP_FREQ:
  616. rc = dps310_get_temp_samp_freq(data);
  617. if (rc < 0)
  618. return rc;
  619. *val = rc;
  620. return IIO_VAL_INT;
  621. case IIO_CHAN_INFO_PROCESSED:
  622. rc = dps310_read_temp_raw(data);
  623. if (rc)
  624. return rc;
  625. rc = dps310_calculate_temp(data);
  626. if (rc < 0)
  627. return rc;
  628. *val = rc;
  629. return IIO_VAL_INT;
  630. case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
  631. rc = dps310_get_temp_precision(data);
  632. if (rc < 0)
  633. return rc;
  634. *val = rc;
  635. return IIO_VAL_INT;
  636. default:
  637. return -EINVAL;
  638. }
  639. }
  640. static int dps310_read_raw(struct iio_dev *iio,
  641. struct iio_chan_spec const *chan,
  642. int *val, int *val2, long mask)
  643. {
  644. struct dps310_data *data = iio_priv(iio);
  645. switch (chan->type) {
  646. case IIO_PRESSURE:
  647. return dps310_read_pressure(data, val, val2, mask);
  648. case IIO_TEMP:
  649. return dps310_read_temp(data, val, val2, mask);
  650. default:
  651. return -EINVAL;
  652. }
  653. }
  654. static void dps310_reset(void *action_data)
  655. {
  656. struct dps310_data *data = action_data;
  657. dps310_reset_wait(data);
  658. }
  659. static const struct regmap_config dps310_regmap_config = {
  660. .reg_bits = 8,
  661. .val_bits = 8,
  662. .writeable_reg = dps310_is_writeable_reg,
  663. .volatile_reg = dps310_is_volatile_reg,
  664. .cache_type = REGCACHE_RBTREE,
  665. .max_register = 0x62, /* No documentation available on this register */
  666. };
  667. static const struct iio_info dps310_info = {
  668. .read_raw = dps310_read_raw,
  669. .write_raw = dps310_write_raw,
  670. };
  671. static int dps310_probe(struct i2c_client *client,
  672. const struct i2c_device_id *id)
  673. {
  674. struct dps310_data *data;
  675. struct iio_dev *iio;
  676. int rc;
  677. iio = devm_iio_device_alloc(&client->dev, sizeof(*data));
  678. if (!iio)
  679. return -ENOMEM;
  680. data = iio_priv(iio);
  681. data->client = client;
  682. mutex_init(&data->lock);
  683. iio->name = id->name;
  684. iio->channels = dps310_channels;
  685. iio->num_channels = ARRAY_SIZE(dps310_channels);
  686. iio->info = &dps310_info;
  687. iio->modes = INDIO_DIRECT_MODE;
  688. data->regmap = devm_regmap_init_i2c(client, &dps310_regmap_config);
  689. if (IS_ERR(data->regmap))
  690. return PTR_ERR(data->regmap);
  691. /* Register to run the device reset when the device is removed */
  692. rc = devm_add_action_or_reset(&client->dev, dps310_reset, data);
  693. if (rc)
  694. return rc;
  695. rc = dps310_startup(data);
  696. if (rc)
  697. return rc;
  698. rc = devm_iio_device_register(&client->dev, iio);
  699. if (rc)
  700. return rc;
  701. i2c_set_clientdata(client, iio);
  702. return 0;
  703. }
  704. static const struct i2c_device_id dps310_id[] = {
  705. { DPS310_DEV_NAME, 0 },
  706. {}
  707. };
  708. MODULE_DEVICE_TABLE(i2c, dps310_id);
  709. static const struct acpi_device_id dps310_acpi_match[] = {
  710. { "IFX3100" },
  711. {}
  712. };
  713. MODULE_DEVICE_TABLE(acpi, dps310_acpi_match);
  714. static struct i2c_driver dps310_driver = {
  715. .driver = {
  716. .name = DPS310_DEV_NAME,
  717. .acpi_match_table = dps310_acpi_match,
  718. },
  719. .probe = dps310_probe,
  720. .id_table = dps310_id,
  721. };
  722. module_i2c_driver(dps310_driver);
  723. MODULE_AUTHOR("Joel Stanley <[email protected]>");
  724. MODULE_DESCRIPTION("Infineon DPS310 pressure and temperature sensor");
  725. MODULE_LICENSE("GPL v2");