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