drivers/iio/pressure/dps310.c

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