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