drivers/iio/humidity/hts221_core.c

   1 /*
   2  * STMicroelectronics hts221 sensor driver
   3  *
   4  * Copyright 2016 STMicroelectronics Inc.
   5  *
   6  * Lorenzo Bianconi <lorenzo.bianconi@st.com>
   7  *
   8  * Licensed under the GPL-2.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/device.h>
  14 #include <linux/iio/sysfs.h>
  15 #include <linux/delay.h>
  16 #include <linux/pm.h>
  17 #include <asm/unaligned.h>
  18
  19 #include "hts221.h"
  20
  21 #define HTS221_REG_WHOAMI_ADDR          0x0f
  22 #define HTS221_REG_WHOAMI_VAL           0xbc
  23
  24 #define HTS221_REG_CNTRL1_ADDR          0x20
  25 #define HTS221_REG_CNTRL2_ADDR          0x21
  26 #define HTS221_REG_CNTRL3_ADDR          0x22
  27
  28 #define HTS221_REG_AVG_ADDR             0x10
  29 #define HTS221_REG_H_OUT_L              0x28
  30 #define HTS221_REG_T_OUT_L              0x2a
  31
  32 #define HTS221_HUMIDITY_AVG_MASK        0x07
  33 #define HTS221_TEMP_AVG_MASK            0x38
  34
  35 #define HTS221_ODR_MASK                 0x03
  36 #define HTS221_BDU_MASK                 BIT(2)
  37 #define HTS221_ENABLE_MASK              BIT(7)
  38
  39 #define HTS221_DRDY_MASK                BIT(2)
  40
  41
  42 /* calibration registers */
  43 #define HTS221_REG_0RH_CAL_X_H          0x36
  44 #define HTS221_REG_1RH_CAL_X_H          0x3a
  45 #define HTS221_REG_0RH_CAL_Y_H          0x30
  46 #define HTS221_REG_1RH_CAL_Y_H          0x31
  47 #define HTS221_REG_0T_CAL_X_L           0x3c
  48 #define HTS221_REG_1T_CAL_X_L           0x3e
  49 #define HTS221_REG_0T_CAL_Y_H           0x32
  50 #define HTS221_REG_1T_CAL_Y_H           0x33
  51 #define HTS221_REG_T1_T0_CAL_Y_H        0x35
  52
  53 struct hts221_odr {
  54         u8 hz;
  55         u8 val;
  56 };
  57
  58 #define HTS221_AVG_DEPTH                8
  59 struct hts221_avg {
  60         u8 addr;
  61         u8 mask;
  62         u16 avg_avl[HTS221_AVG_DEPTH];
  63 };
  64
  65 static const struct hts221_odr hts221_odr_table[] = {
  66         {  1, 0x01 },   /* 1Hz */
  67         {  7, 0x02 },   /* 7Hz */
  68         { 13, 0x03 },   /* 12.5Hz */
  69 };
  70
  71 static const struct hts221_avg hts221_avg_list[] = {
  72         {
  73                 .addr = HTS221_REG_AVG_ADDR,
  74                 .mask = HTS221_HUMIDITY_AVG_MASK,
  75                 .avg_avl = {
  76                         4, /* 0.4 %RH */
  77                         8, /* 0.3 %RH */
  78                         16, /* 0.2 %RH */
  79                         32, /* 0.15 %RH */
  80                         64, /* 0.1 %RH */
  81                         128, /* 0.07 %RH */
  82                         256, /* 0.05 %RH */
  83                         512, /* 0.03 %RH */
  84                 },
  85         },
  86         {
  87                 .addr = HTS221_REG_AVG_ADDR,
  88                 .mask = HTS221_TEMP_AVG_MASK,
  89                 .avg_avl = {
  90                         2, /* 0.08 degC */
  91                         4, /* 0.05 degC */
  92                         8, /* 0.04 degC */
  93                         16, /* 0.03 degC */
  94                         32, /* 0.02 degC */
  95                         64, /* 0.015 degC */
  96                         128, /* 0.01 degC */
  97                         256, /* 0.007 degC */
  98                 },
  99         },
 100 };
 101
 102 static const struct iio_chan_spec hts221_channels[] = {
 103         {
 104                 .type = IIO_HUMIDITYRELATIVE,
 105                 .address = HTS221_REG_H_OUT_L,
 106                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 107                                       BIT(IIO_CHAN_INFO_OFFSET) |
 108                                       BIT(IIO_CHAN_INFO_SCALE) |
 109                                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
 110                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 111                 .scan_index = 0,
 112                 .scan_type = {
 113                         .sign = 's',
 114                         .realbits = 16,
 115                         .storagebits = 16,
 116                         .endianness = IIO_LE,
 117                 },
 118         },
 119         {
 120                 .type = IIO_TEMP,
 121                 .address = HTS221_REG_T_OUT_L,
 122                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 123                                       BIT(IIO_CHAN_INFO_OFFSET) |
 124                                       BIT(IIO_CHAN_INFO_SCALE) |
 125                                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
 126                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 127                 .scan_index = 1,
 128                 .scan_type = {
 129                         .sign = 's',
 130                         .realbits = 16,
 131                         .storagebits = 16,
 132                         .endianness = IIO_LE,
 133                 },
 134         },
 135         IIO_CHAN_SOFT_TIMESTAMP(2),
 136 };
 137
 138 static int hts221_write_with_mask(struct hts221_hw *hw, u8 addr, u8 mask,
 139                                   u8 val)
 140 {
 141         u8 data;
 142         int err;
 143
 144         mutex_lock(&hw->lock);
 145
 146         err = hw->tf->read(hw->dev, addr, sizeof(data), &data);
 147         if (err < 0) {
 148                 dev_err(hw->dev, "failed to read %02x register\n", addr);
 149                 goto unlock;
 150         }
 151
 152         data = (data & ~mask) | ((val << __ffs(mask)) & mask);
 153
 154         err = hw->tf->write(hw->dev, addr, sizeof(data), &data);
 155         if (err < 0)
 156                 dev_err(hw->dev, "failed to write %02x register\n", addr);
 157
 158 unlock:
 159         mutex_unlock(&hw->lock);
 160
 161         return err;
 162 }
 163
 164 static int hts221_check_whoami(struct hts221_hw *hw)
 165 {
 166         u8 data;
 167         int err;
 168
 169         err = hw->tf->read(hw->dev, HTS221_REG_WHOAMI_ADDR, sizeof(data),
 170                            &data);
 171         if (err < 0) {
 172                 dev_err(hw->dev, "failed to read whoami register\n");
 173                 return err;
 174         }
 175
 176         if (data != HTS221_REG_WHOAMI_VAL) {
 177                 dev_err(hw->dev, "wrong whoami {%02x vs %02x}\n",
 178                         data, HTS221_REG_WHOAMI_VAL);
 179                 return -ENODEV;
 180         }
 181
 182         return 0;
 183 }
 184
 185 int hts221_config_drdy(struct hts221_hw *hw, bool enable)
 186 {
 187         int err;
 188
 189         err = hts221_write_with_mask(hw, HTS221_REG_CNTRL3_ADDR,
 190                                      HTS221_DRDY_MASK, enable);
 191
 192         return err < 0 ? err : 0;
 193 }
 194
 195 static int hts221_update_odr(struct hts221_hw *hw, u8 odr)
 196 {
 197         int i, err;
 198
 199         for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
 200                 if (hts221_odr_table[i].hz == odr)
 201                         break;
 202
 203         if (i == ARRAY_SIZE(hts221_odr_table))
 204                 return -EINVAL;
 205
 206         /* enable Block Data Update */
 207         err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
 208                                      HTS221_BDU_MASK, 1);
 209         if (err < 0)
 210                 return err;
 211
 212         err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
 213                                      HTS221_ODR_MASK, hts221_odr_table[i].val);
 214         if (err < 0)
 215                 return err;
 216
 217         err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
 218                                      HTS221_ENABLE_MASK, 1);
 219         if (err < 0)
 220                 return err;
 221
 222         hw->odr = odr;
 223
 224         return 0;
 225 }
 226
 227 static int hts221_update_avg(struct hts221_hw *hw,
 228                              enum hts221_sensor_type type,
 229                              u16 val)
 230 {
 231         int i, err;
 232         const struct hts221_avg *avg = &hts221_avg_list[type];
 233
 234         for (i = 0; i < HTS221_AVG_DEPTH; i++)
 235                 if (avg->avg_avl[i] == val)
 236                         break;
 237
 238         if (i == HTS221_AVG_DEPTH)
 239                 return -EINVAL;
 240
 241         err = hts221_write_with_mask(hw, avg->addr, avg->mask, i);
 242         if (err < 0)
 243                 return err;
 244
 245         hw->sensors[type].cur_avg_idx = i;
 246
 247         return 0;
 248 }
 249
 250 static ssize_t hts221_sysfs_sampling_freq(struct device *dev,
 251                                           struct device_attribute *attr,
 252                                           char *buf)
 253 {
 254         int i;
 255         ssize_t len = 0;
 256
 257         for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
 258                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
 259                                  hts221_odr_table[i].hz);
 260         buf[len - 1] = '\n';
 261
 262         return len;
 263 }
 264
 265 static ssize_t
 266 hts221_sysfs_rh_oversampling_avail(struct device *dev,
 267                                    struct device_attribute *attr,
 268                                    char *buf)
 269 {
 270         const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_H];
 271         ssize_t len = 0;
 272         int i;
 273
 274         for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
 275                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
 276                                  avg->avg_avl[i]);
 277         buf[len - 1] = '\n';
 278
 279         return len;
 280 }
 281
 282 static ssize_t
 283 hts221_sysfs_temp_oversampling_avail(struct device *dev,
 284                                      struct device_attribute *attr,
 285                                      char *buf)
 286 {
 287         const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_T];
 288         ssize_t len = 0;
 289         int i;
 290
 291         for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
 292                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
 293                                  avg->avg_avl[i]);
 294         buf[len - 1] = '\n';
 295
 296         return len;
 297 }
 298
 299 int hts221_power_on(struct hts221_hw *hw)
 300 {
 301         int err;
 302
 303         err = hts221_update_odr(hw, hw->odr);
 304         if (err < 0)
 305                 return err;
 306
 307         hw->enabled = true;
 308
 309         return 0;
 310 }
 311
 312 int hts221_power_off(struct hts221_hw *hw)
 313 {
 314         __le16 data = 0;
 315         int err;
 316
 317         err = hw->tf->write(hw->dev, HTS221_REG_CNTRL1_ADDR, sizeof(data),
 318                             (u8 *)&data);
 319         if (err < 0)
 320                 return err;
 321
 322         hw->enabled = false;
 323
 324         return 0;
 325 }
 326
 327 static int hts221_parse_temp_caldata(struct hts221_hw *hw)
 328 {
 329         int err, *slope, *b_gen;
 330         s16 cal_x0, cal_x1, cal_y0, cal_y1;
 331         u8 cal0, cal1;
 332
 333         err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_Y_H,
 334                            sizeof(cal0), &cal0);
 335         if (err < 0)
 336                 return err;
 337
 338         err = hw->tf->read(hw->dev, HTS221_REG_T1_T0_CAL_Y_H,
 339                            sizeof(cal1), &cal1);
 340         if (err < 0)
 341                 return err;
 342         cal_y0 = (le16_to_cpu(cal1 & 0x3) << 8) | cal0;
 343
 344         err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_Y_H,
 345                            sizeof(cal0), &cal0);
 346         if (err < 0)
 347                 return err;
 348         cal_y1 = (((cal1 & 0xc) >> 2) << 8) | cal0;
 349
 350         err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_X_L, sizeof(cal_x0),
 351                            (u8 *)&cal_x0);
 352         if (err < 0)
 353                 return err;
 354         cal_x0 = le16_to_cpu(cal_x0);
 355
 356         err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_X_L, sizeof(cal_x1),
 357                            (u8 *)&cal_x1);
 358         if (err < 0)
 359                 return err;
 360         cal_x1 = le16_to_cpu(cal_x1);
 361
 362         slope = &hw->sensors[HTS221_SENSOR_T].slope;
 363         b_gen = &hw->sensors[HTS221_SENSOR_T].b_gen;
 364
 365         *slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
 366         *b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
 367                  (cal_x1 - cal_x0);
 368         *b_gen *= 8;
 369
 370         return 0;
 371 }
 372
 373 static int hts221_parse_rh_caldata(struct hts221_hw *hw)
 374 {
 375         int err, *slope, *b_gen;
 376         s16 cal_x0, cal_x1, cal_y0, cal_y1;
 377         u8 data;
 378
 379         err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_Y_H, sizeof(data),
 380                            &data);
 381         if (err < 0)
 382                 return err;
 383         cal_y0 = data;
 384
 385         err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_Y_H, sizeof(data),
 386                            &data);
 387         if (err < 0)
 388                 return err;
 389         cal_y1 = data;
 390
 391         err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_X_H, sizeof(cal_x0),
 392                            (u8 *)&cal_x0);
 393         if (err < 0)
 394                 return err;
 395         cal_x0 = le16_to_cpu(cal_x0);
 396
 397         err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_X_H, sizeof(cal_x1),
 398                            (u8 *)&cal_x1);
 399         if (err < 0)
 400                 return err;
 401         cal_x1 = le16_to_cpu(cal_x1);
 402
 403         slope = &hw->sensors[HTS221_SENSOR_H].slope;
 404         b_gen = &hw->sensors[HTS221_SENSOR_H].b_gen;
 405
 406         *slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
 407         *b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
 408                  (cal_x1 - cal_x0);
 409         *b_gen *= 8;
 410
 411         return 0;
 412 }
 413
 414 static int hts221_get_sensor_scale(struct hts221_hw *hw,
 415                                    enum iio_chan_type ch_type,
 416                                    int *val, int *val2)
 417 {
 418         s64 tmp;
 419         s32 rem, div, data;
 420
 421         switch (ch_type) {
 422         case IIO_HUMIDITYRELATIVE:
 423                 data = hw->sensors[HTS221_SENSOR_H].slope;
 424                 div = (1 << 4) * 1000;
 425                 break;
 426         case IIO_TEMP:
 427                 data = hw->sensors[HTS221_SENSOR_T].slope;
 428                 div = (1 << 6) * 1000;
 429                 break;
 430         default:
 431                 return -EINVAL;
 432         }
 433
 434         tmp = div_s64(data * 1000000000LL, div);
 435         tmp = div_s64_rem(tmp, 1000000000LL, &rem);
 436
 437         *val = tmp;
 438         *val2 = rem;
 439
 440         return IIO_VAL_INT_PLUS_NANO;
 441 }
 442
 443 static int hts221_get_sensor_offset(struct hts221_hw *hw,
 444                                     enum iio_chan_type ch_type,
 445                                     int *val, int *val2)
 446 {
 447         s64 tmp;
 448         s32 rem, div, data;
 449
 450         switch (ch_type) {
 451         case IIO_HUMIDITYRELATIVE:
 452                 data = hw->sensors[HTS221_SENSOR_H].b_gen;
 453                 div = hw->sensors[HTS221_SENSOR_H].slope;
 454                 break;
 455         case IIO_TEMP:
 456                 data = hw->sensors[HTS221_SENSOR_T].b_gen;
 457                 div = hw->sensors[HTS221_SENSOR_T].slope;
 458                 break;
 459         default:
 460                 return -EINVAL;
 461         }
 462
 463         tmp = div_s64(data * 1000000000LL, div);
 464         tmp = div_s64_rem(tmp, 1000000000LL, &rem);
 465
 466         *val = tmp;
 467         *val2 = rem;
 468
 469         return IIO_VAL_INT_PLUS_NANO;
 470 }
 471
 472 static int hts221_read_oneshot(struct hts221_hw *hw, u8 addr, int *val)
 473 {
 474         u8 data[HTS221_DATA_SIZE];
 475         int err;
 476
 477         err = hts221_power_on(hw);
 478         if (err < 0)
 479                 return err;
 480
 481         msleep(50);
 482
 483         err = hw->tf->read(hw->dev, addr, sizeof(data), data);
 484         if (err < 0)
 485                 return err;
 486
 487         hts221_power_off(hw);
 488
 489         *val = (s16)get_unaligned_le16(data);
 490
 491         return IIO_VAL_INT;
 492 }
 493
 494 static int hts221_read_raw(struct iio_dev *iio_dev,
 495                            struct iio_chan_spec const *ch,
 496                            int *val, int *val2, long mask)
 497 {
 498         struct hts221_hw *hw = iio_priv(iio_dev);
 499         int ret;
 500
 501         ret = iio_device_claim_direct_mode(iio_dev);
 502         if (ret)
 503                 return ret;
 504
 505         switch (mask) {
 506         case IIO_CHAN_INFO_RAW:
 507                 ret = hts221_read_oneshot(hw, ch->address, val);
 508                 break;
 509         case IIO_CHAN_INFO_SCALE:
 510                 ret = hts221_get_sensor_scale(hw, ch->type, val, val2);
 511                 break;
 512         case IIO_CHAN_INFO_OFFSET:
 513                 ret = hts221_get_sensor_offset(hw, ch->type, val, val2);
 514                 break;
 515         case IIO_CHAN_INFO_SAMP_FREQ:
 516                 *val = hw->odr;
 517                 ret = IIO_VAL_INT;
 518                 break;
 519         case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
 520                 u8 idx;
 521                 const struct hts221_avg *avg;
 522
 523                 switch (ch->type) {
 524                 case IIO_HUMIDITYRELATIVE:
 525                         avg = &hts221_avg_list[HTS221_SENSOR_H];
 526                         idx = hw->sensors[HTS221_SENSOR_H].cur_avg_idx;
 527                         *val = avg->avg_avl[idx];
 528                         ret = IIO_VAL_INT;
 529                         break;
 530                 case IIO_TEMP:
 531                         avg = &hts221_avg_list[HTS221_SENSOR_T];
 532                         idx = hw->sensors[HTS221_SENSOR_T].cur_avg_idx;
 533                         *val = avg->avg_avl[idx];
 534                         ret = IIO_VAL_INT;
 535                         break;
 536                 default:
 537                         ret = -EINVAL;
 538                         break;
 539                 }
 540                 break;
 541         }
 542         default:
 543                 ret = -EINVAL;
 544                 break;
 545         }
 546
 547         iio_device_release_direct_mode(iio_dev);
 548
 549         return ret;
 550 }
 551
 552 static int hts221_write_raw(struct iio_dev *iio_dev,
 553                             struct iio_chan_spec const *chan,
 554                             int val, int val2, long mask)
 555 {
 556         struct hts221_hw *hw = iio_priv(iio_dev);
 557         int ret;
 558
 559         ret = iio_device_claim_direct_mode(iio_dev);
 560         if (ret)
 561                 return ret;
 562
 563         switch (mask) {
 564         case IIO_CHAN_INFO_SAMP_FREQ:
 565                 ret = hts221_update_odr(hw, val);
 566                 break;
 567         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
 568                 switch (chan->type) {
 569                 case IIO_HUMIDITYRELATIVE:
 570                         ret = hts221_update_avg(hw, HTS221_SENSOR_H, val);
 571                         break;
 572                 case IIO_TEMP:
 573                         ret = hts221_update_avg(hw, HTS221_SENSOR_T, val);
 574                         break;
 575                 default:
 576                         ret = -EINVAL;
 577                         break;
 578                 }
 579                 break;
 580         default:
 581                 ret = -EINVAL;
 582                 break;
 583         }
 584
 585         iio_device_release_direct_mode(iio_dev);
 586
 587         return ret;
 588 }
 589
 590 static int hts221_validate_trigger(struct iio_dev *iio_dev,
 591                                    struct iio_trigger *trig)
 592 {
 593         struct hts221_hw *hw = iio_priv(iio_dev);
 594
 595         return hw->trig == trig ? 0 : -EINVAL;
 596 }
 597
 598 static IIO_DEVICE_ATTR(in_humidity_oversampling_ratio_available, S_IRUGO,
 599                        hts221_sysfs_rh_oversampling_avail, NULL, 0);
 600 static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available, S_IRUGO,
 601                        hts221_sysfs_temp_oversampling_avail, NULL, 0);
 602 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hts221_sysfs_sampling_freq);
 603
 604 static struct attribute *hts221_attributes[] = {
 605         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 606         &iio_dev_attr_in_humidity_oversampling_ratio_available.dev_attr.attr,
 607         &iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr,
 608         NULL,
 609 };
 610
 611 static const struct attribute_group hts221_attribute_group = {
 612         .attrs = hts221_attributes,
 613 };
 614
 615 static const struct iio_info hts221_info = {
 616         .driver_module = THIS_MODULE,
 617         .attrs = &hts221_attribute_group,
 618         .read_raw = hts221_read_raw,
 619         .write_raw = hts221_write_raw,
 620         .validate_trigger = hts221_validate_trigger,
 621 };
 622
 623 static const unsigned long hts221_scan_masks[] = {0x3, 0x0};
 624
 625 int hts221_probe(struct iio_dev *iio_dev)
 626 {
 627         struct hts221_hw *hw = iio_priv(iio_dev);
 628         int err;
 629         u8 data;
 630
 631         mutex_init(&hw->lock);
 632
 633         err = hts221_check_whoami(hw);
 634         if (err < 0)
 635                 return err;
 636
 637         hw->odr = hts221_odr_table[0].hz;
 638
 639         iio_dev->modes = INDIO_DIRECT_MODE;
 640         iio_dev->dev.parent = hw->dev;
 641         iio_dev->available_scan_masks = hts221_scan_masks;
 642         iio_dev->channels = hts221_channels;
 643         iio_dev->num_channels = ARRAY_SIZE(hts221_channels);
 644         iio_dev->name = HTS221_DEV_NAME;
 645         iio_dev->info = &hts221_info;
 646
 647         /* configure humidity sensor */
 648         err = hts221_parse_rh_caldata(hw);
 649         if (err < 0) {
 650                 dev_err(hw->dev, "failed to get rh calibration data\n");
 651                 return err;
 652         }
 653
 654         data = hts221_avg_list[HTS221_SENSOR_H].avg_avl[3];
 655         err = hts221_update_avg(hw, HTS221_SENSOR_H, data);
 656         if (err < 0) {
 657                 dev_err(hw->dev, "failed to set rh oversampling ratio\n");
 658                 return err;
 659         }
 660
 661         /* configure temperature sensor */
 662         err = hts221_parse_temp_caldata(hw);
 663         if (err < 0) {
 664                 dev_err(hw->dev,
 665                         "failed to get temperature calibration data\n");
 666                 return err;
 667         }
 668
 669         data = hts221_avg_list[HTS221_SENSOR_T].avg_avl[3];
 670         err = hts221_update_avg(hw, HTS221_SENSOR_T, data);
 671         if (err < 0) {
 672                 dev_err(hw->dev,
 673                         "failed to set temperature oversampling ratio\n");
 674                 return err;
 675         }
 676
 677         if (hw->irq > 0) {
 678                 err = hts221_allocate_buffers(hw);
 679                 if (err < 0)
 680                         return err;
 681
 682                 err = hts221_allocate_trigger(hw);
 683                 if (err)
 684                         return err;
 685         }
 686
 687         return devm_iio_device_register(hw->dev, iio_dev);
 688 }
 689 EXPORT_SYMBOL(hts221_probe);
 690
 691 static int __maybe_unused hts221_suspend(struct device *dev)
 692 {
 693         struct iio_dev *iio_dev = dev_get_drvdata(dev);
 694         struct hts221_hw *hw = iio_priv(iio_dev);
 695         __le16 data = 0;
 696         int err;
 697
 698         err = hw->tf->write(hw->dev, HTS221_REG_CNTRL1_ADDR, sizeof(data),
 699                             (u8 *)&data);
 700
 701         return err < 0 ? err : 0;
 702 }
 703
 704 static int __maybe_unused hts221_resume(struct device *dev)
 705 {
 706         struct iio_dev *iio_dev = dev_get_drvdata(dev);
 707         struct hts221_hw *hw = iio_priv(iio_dev);
 708         int err = 0;
 709
 710         if (hw->enabled)
 711                 err = hts221_update_odr(hw, hw->odr);
 712
 713         return err;
 714 }
 715
 716 const struct dev_pm_ops hts221_pm_ops = {
 717         SET_SYSTEM_SLEEP_PM_OPS(hts221_suspend, hts221_resume)
 718 };
 719 EXPORT_SYMBOL(hts221_pm_ops);
 720
 721 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
 722 MODULE_DESCRIPTION("STMicroelectronics hts221 sensor driver");
 723 MODULE_LICENSE("GPL v2");