drivers/iio/pressure/dps310.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
dps310_get_coefs
dps310_get_pres_precision
dps310_get_temp_precision
dps310_set_pres_precision
dps310_set_temp_precision
dps310_set_pres_samp_freq
dps310_set_temp_samp_freq
dps310_get_pres_samp_freq
dps310_get_temp_samp_freq
dps310_get_pres_k
dps310_get_temp_k
dps310_read_pres_raw
dps310_read_temp_ready
dps310_read_temp_raw
dps310_is_writeable_reg
dps310_is_volatile_reg
dps310_write_raw
dps310_calculate_pressure
dps310_read_pressure
dps310_calculate_temp
dps310_read_temp
dps310_read_raw
dps310_reset
dps310_temp_workaround
dps310_probe
   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->dev.parent = &client->dev;
 736         iio->name = id->name;
 737         iio->channels = dps310_channels;
 738         iio->num_channels = ARRAY_SIZE(dps310_channels);
 739         iio->info = &dps310_info;
 740         iio->modes = INDIO_DIRECT_MODE;
 741 
 742         data->regmap = devm_regmap_init_i2c(client, &dps310_regmap_config);
 743         if (IS_ERR(data->regmap))
 744                 return PTR_ERR(data->regmap);
 745 
 746         /* Register to run the device reset when the device is removed */
 747         rc = devm_add_action_or_reset(&client->dev, dps310_reset, data);
 748         if (rc)
 749                 return rc;
 750 
 751         /*
 752          * Set up pressure sensor in single sample, one measurement per second
 753          * mode
 754          */
 755         rc = regmap_write(data->regmap, DPS310_PRS_CFG, 0);
 756 
 757         /*
 758          * Set up external (MEMS) temperature sensor in single sample, one
 759          * measurement per second mode
 760          */
 761         rc = regmap_write(data->regmap, DPS310_TMP_CFG, DPS310_TMP_EXT);
 762         if (rc < 0)
 763                 return rc;
 764 
 765         /* Temp and pressure shifts are disabled when PRC <= 8 */
 766         rc = regmap_write_bits(data->regmap, DPS310_CFG_REG,
 767                                DPS310_PRS_SHIFT_EN | DPS310_TMP_SHIFT_EN, 0);
 768         if (rc < 0)
 769                 return rc;
 770 
 771         /* MEAS_CFG doesn't update correctly unless first written with 0 */
 772         rc = regmap_write_bits(data->regmap, DPS310_MEAS_CFG,
 773                                DPS310_MEAS_CTRL_BITS, 0);
 774         if (rc < 0)
 775                 return rc;
 776 
 777         /* Turn on temperature and pressure measurement in the background */
 778         rc = regmap_write_bits(data->regmap, DPS310_MEAS_CFG,
 779                                DPS310_MEAS_CTRL_BITS, DPS310_PRS_EN |
 780                                DPS310_TEMP_EN | DPS310_BACKGROUND);
 781         if (rc < 0)
 782                 return rc;
 783 
 784         /*
 785          * Calibration coefficients required for reporting temperature.
 786          * They are available 40ms after the device has started
 787          */
 788         rc = regmap_read_poll_timeout(data->regmap, DPS310_MEAS_CFG, ready,
 789                                       ready & DPS310_COEF_RDY, 10000, 40000);
 790         if (rc < 0)
 791                 return rc;
 792 
 793         rc = dps310_get_coefs(data);
 794         if (rc < 0)
 795                 return rc;
 796 
 797         rc = dps310_temp_workaround(data);
 798         if (rc < 0)
 799                 return rc;
 800 
 801         rc = devm_iio_device_register(&client->dev, iio);
 802         if (rc)
 803                 return rc;
 804 
 805         i2c_set_clientdata(client, iio);
 806 
 807         return 0;
 808 }
 809 
 810 static const struct i2c_device_id dps310_id[] = {
 811         { DPS310_DEV_NAME, 0 },
 812         {}
 813 };
 814 MODULE_DEVICE_TABLE(i2c, dps310_id);
 815 
 816 static struct i2c_driver dps310_driver = {
 817         .driver = {
 818                 .name = DPS310_DEV_NAME,
 819         },
 820         .probe = dps310_probe,
 821         .id_table = dps310_id,
 822 };
 823 module_i2c_driver(dps310_driver);
 824 
 825 MODULE_AUTHOR("Joel Stanley <joel@jms.id.au>");
 826 MODULE_DESCRIPTION("Infineon DPS310 pressure and temperature sensor");
 827 MODULE_LICENSE("GPL v2");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/iio/pressure/dps310.c

DEFINITIONS
