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         err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
 207                                      HTS221_ODR_MASK, hts221_odr_table[i].val);
 208         if (err < 0)
 209                 return err;
 210
 211         err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
 212                                      HTS221_ENABLE_MASK, 1);
 213         if (err < 0)
 214                 return err;
 215
 216         hw->odr = odr;
 217
 218         return 0;
 219 }
 220
 221 static int hts221_update_avg(struct hts221_hw *hw,
 222                              enum hts221_sensor_type type,
 223                              u16 val)
 224 {
 225         int i, err;
 226         const struct hts221_avg *avg = &hts221_avg_list[type];
 227
 228         for (i = 0; i < HTS221_AVG_DEPTH; i++)
 229                 if (avg->avg_avl[i] == val)
 230                         break;
 231
 232         if (i == HTS221_AVG_DEPTH)
 233                 return -EINVAL;
 234
 235         err = hts221_write_with_mask(hw, avg->addr, avg->mask, i);
 236         if (err < 0)
 237                 return err;
 238
 239         hw->sensors[type].cur_avg_idx = i;
 240
 241         return 0;
 242 }
 243
 244 static ssize_t hts221_sysfs_sampling_freq(struct device *dev,
 245                                           struct device_attribute *attr,
 246                                           char *buf)
 247 {
 248         int i;
 249         ssize_t len = 0;
 250
 251         for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
 252                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
 253                                  hts221_odr_table[i].hz);
 254         buf[len - 1] = '\n';
 255
 256         return len;
 257 }
 258
 259 static ssize_t
 260 hts221_sysfs_rh_oversampling_avail(struct device *dev,
 261                                    struct device_attribute *attr,
 262                                    char *buf)
 263 {
 264         const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_H];
 265         ssize_t len = 0;
 266         int i;
 267
 268         for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
 269                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
 270                                  avg->avg_avl[i]);
 271         buf[len - 1] = '\n';
 272
 273         return len;
 274 }
 275
 276 static ssize_t
 277 hts221_sysfs_temp_oversampling_avail(struct device *dev,
 278                                      struct device_attribute *attr,
 279                                      char *buf)
 280 {
 281         const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_T];
 282         ssize_t len = 0;
 283         int i;
 284
 285         for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
 286                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
 287                                  avg->avg_avl[i]);
 288         buf[len - 1] = '\n';
 289
 290         return len;
 291 }
 292
 293 int hts221_power_on(struct hts221_hw *hw)
 294 {
 295         int err;
 296
 297         err = hts221_update_odr(hw, hw->odr);
 298         if (err < 0)
 299                 return err;
 300
 301         hw->enabled = true;
 302
 303         return 0;
 304 }
 305
 306 int hts221_power_off(struct hts221_hw *hw)
 307 {
 308         __le16 data = 0;
 309         int err;
 310
 311         err = hw->tf->write(hw->dev, HTS221_REG_CNTRL1_ADDR, sizeof(data),
 312                             (u8 *)&data);
 313         if (err < 0)
 314                 return err;
 315
 316         hw->enabled = false;
 317
 318         return 0;
 319 }
 320
 321 static int hts221_parse_temp_caldata(struct hts221_hw *hw)
 322 {
 323         int err, *slope, *b_gen;
 324         s16 cal_x0, cal_x1, cal_y0, cal_y1;
 325         u8 cal0, cal1;
 326
 327         err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_Y_H,
 328                            sizeof(cal0), &cal0);
 329         if (err < 0)
 330                 return err;
 331
 332         err = hw->tf->read(hw->dev, HTS221_REG_T1_T0_CAL_Y_H,
 333                            sizeof(cal1), &cal1);
 334         if (err < 0)
 335                 return err;
 336         cal_y0 = (le16_to_cpu(cal1 & 0x3) << 8) | cal0;
 337
 338         err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_Y_H,
 339                            sizeof(cal0), &cal0);
 340         if (err < 0)
 341                 return err;
 342         cal_y1 = (((cal1 & 0xc) >> 2) << 8) | cal0;
 343
 344         err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_X_L, sizeof(cal_x0),
 345                            (u8 *)&cal_x0);
 346         if (err < 0)
 347                 return err;
 348         cal_x0 = le16_to_cpu(cal_x0);
 349
 350         err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_X_L, sizeof(cal_x1),
 351                            (u8 *)&cal_x1);
 352         if (err < 0)
 353                 return err;
 354         cal_x1 = le16_to_cpu(cal_x1);
 355
 356         slope = &hw->sensors[HTS221_SENSOR_T].slope;
 357         b_gen = &hw->sensors[HTS221_SENSOR_T].b_gen;
 358
 359         *slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
 360         *b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
 361                  (cal_x1 - cal_x0);
 362         *b_gen *= 8;
 363
 364         return 0;
 365 }
 366
 367 static int hts221_parse_rh_caldata(struct hts221_hw *hw)
 368 {
 369         int err, *slope, *b_gen;
 370         s16 cal_x0, cal_x1, cal_y0, cal_y1;
 371         u8 data;
 372
 373         err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_Y_H, sizeof(data),
 374                            &data);
 375         if (err < 0)
 376                 return err;
 377         cal_y0 = data;
 378
 379         err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_Y_H, sizeof(data),
 380                            &data);
 381         if (err < 0)
 382                 return err;
 383         cal_y1 = data;
 384
 385         err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_X_H, sizeof(cal_x0),
 386                            (u8 *)&cal_x0);
 387         if (err < 0)
 388                 return err;
 389         cal_x0 = le16_to_cpu(cal_x0);
 390
 391         err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_X_H, sizeof(cal_x1),
 392                            (u8 *)&cal_x1);
 393         if (err < 0)
 394                 return err;
 395         cal_x1 = le16_to_cpu(cal_x1);
 396
 397         slope = &hw->sensors[HTS221_SENSOR_H].slope;
 398         b_gen = &hw->sensors[HTS221_SENSOR_H].b_gen;
 399
 400         *slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
 401         *b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
 402                  (cal_x1 - cal_x0);
 403         *b_gen *= 8;
 404
 405         return 0;
 406 }
 407
 408 static int hts221_get_sensor_scale(struct hts221_hw *hw,
 409                                    enum iio_chan_type ch_type,
 410                                    int *val, int *val2)
 411 {
 412         s64 tmp;
 413         s32 rem, div, data;
 414
 415         switch (ch_type) {
 416         case IIO_HUMIDITYRELATIVE:
 417                 data = hw->sensors[HTS221_SENSOR_H].slope;
 418                 div = (1 << 4) * 1000;
 419                 break;
 420         case IIO_TEMP:
 421                 data = hw->sensors[HTS221_SENSOR_T].slope;
 422                 div = (1 << 6) * 1000;
 423                 break;
 424         default:
 425                 return -EINVAL;
 426         }
 427
 428         tmp = div_s64(data * 1000000000LL, div);
 429         tmp = div_s64_rem(tmp, 1000000000LL, &rem);
 430
 431         *val = tmp;
 432         *val2 = rem;
 433
 434         return IIO_VAL_INT_PLUS_NANO;
 435 }
 436
 437 static int hts221_get_sensor_offset(struct hts221_hw *hw,
 438                                     enum iio_chan_type ch_type,
 439                                     int *val, int *val2)
 440 {
 441         s64 tmp;
 442         s32 rem, div, data;
 443
 444         switch (ch_type) {
 445         case IIO_HUMIDITYRELATIVE:
 446                 data = hw->sensors[HTS221_SENSOR_H].b_gen;
 447                 div = hw->sensors[HTS221_SENSOR_H].slope;
 448                 break;
 449         case IIO_TEMP:
 450                 data = hw->sensors[HTS221_SENSOR_T].b_gen;
 451                 div = hw->sensors[HTS221_SENSOR_T].slope;
 452                 break;
 453         default:
 454                 return -EINVAL;
 455         }
 456
 457         tmp = div_s64(data * 1000000000LL, div);
 458         tmp = div_s64_rem(tmp, 1000000000LL, &rem);
 459
 460         *val = tmp;
 461         *val2 = rem;
 462
 463         return IIO_VAL_INT_PLUS_NANO;
 464 }
 465
 466 static int hts221_read_oneshot(struct hts221_hw *hw, u8 addr, int *val)
 467 {
 468         u8 data[HTS221_DATA_SIZE];
 469         int err;
 470
 471         err = hts221_power_on(hw);
 472         if (err < 0)
 473                 return err;
 474
 475         msleep(50);
 476
 477         err = hw->tf->read(hw->dev, addr, sizeof(data), data);
 478         if (err < 0)
 479                 return err;
 480
 481         hts221_power_off(hw);
 482
 483         *val = (s16)get_unaligned_le16(data);
 484
 485         return IIO_VAL_INT;
 486 }
 487
 488 static int hts221_read_raw(struct iio_dev *iio_dev,
 489                            struct iio_chan_spec const *ch,
 490                            int *val, int *val2, long mask)
 491 {
 492         struct hts221_hw *hw = iio_priv(iio_dev);
 493         int ret;
 494
 495         ret = iio_device_claim_direct_mode(iio_dev);
 496         if (ret)
 497                 return ret;
 498
 499         switch (mask) {
 500         case IIO_CHAN_INFO_RAW:
 501                 ret = hts221_read_oneshot(hw, ch->address, val);
 502                 break;
 503         case IIO_CHAN_INFO_SCALE:
 504                 ret = hts221_get_sensor_scale(hw, ch->type, val, val2);
 505                 break;
 506         case IIO_CHAN_INFO_OFFSET:
 507                 ret = hts221_get_sensor_offset(hw, ch->type, val, val2);
 508                 break;
 509         case IIO_CHAN_INFO_SAMP_FREQ:
 510                 *val = hw->odr;
 511                 ret = IIO_VAL_INT;
 512                 break;
 513         case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
 514                 u8 idx;
 515                 const struct hts221_avg *avg;
 516
 517                 switch (ch->type) {
 518                 case IIO_HUMIDITYRELATIVE:
 519                         avg = &hts221_avg_list[HTS221_SENSOR_H];
 520                         idx = hw->sensors[HTS221_SENSOR_H].cur_avg_idx;
 521                         *val = avg->avg_avl[idx];
 522                         ret = IIO_VAL_INT;
 523                         break;
 524                 case IIO_TEMP:
 525                         avg = &hts221_avg_list[HTS221_SENSOR_T];
 526                         idx = hw->sensors[HTS221_SENSOR_T].cur_avg_idx;
 527                         *val = avg->avg_avl[idx];
 528                         ret = IIO_VAL_INT;
 529                         break;
 530                 default:
 531                         ret = -EINVAL;
 532                         break;
 533                 }
 534                 break;
 535         }
 536         default:
 537                 ret = -EINVAL;
 538                 break;
 539         }
 540
 541         iio_device_release_direct_mode(iio_dev);
 542
 543         return ret;
 544 }
 545
 546 static int hts221_write_raw(struct iio_dev *iio_dev,
 547                             struct iio_chan_spec const *chan,
 548                             int val, int val2, long mask)
 549 {
 550         struct hts221_hw *hw = iio_priv(iio_dev);
 551         int ret;
 552
 553         ret = iio_device_claim_direct_mode(iio_dev);
 554         if (ret)
 555                 return ret;
 556
 557         switch (mask) {
 558         case IIO_CHAN_INFO_SAMP_FREQ:
 559                 ret = hts221_update_odr(hw, val);
 560                 break;
 561         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
 562                 switch (chan->type) {
 563                 case IIO_HUMIDITYRELATIVE:
 564                         ret = hts221_update_avg(hw, HTS221_SENSOR_H, val);
 565                         break;
 566                 case IIO_TEMP:
 567                         ret = hts221_update_avg(hw, HTS221_SENSOR_T, val);
 568                         break;
 569                 default:
 570                         ret = -EINVAL;
 571                         break;
 572                 }
 573                 break;
 574         default:
 575                 ret = -EINVAL;
 576                 break;
 577         }
 578
 579         iio_device_release_direct_mode(iio_dev);
 580
 581         return ret;
 582 }
 583
 584 static int hts221_validate_trigger(struct iio_dev *iio_dev,
 585                                    struct iio_trigger *trig)
 586 {
 587         struct hts221_hw *hw = iio_priv(iio_dev);
 588
 589         return hw->trig == trig ? 0 : -EINVAL;
 590 }
 591
 592 static IIO_DEVICE_ATTR(in_humidity_oversampling_ratio_available, S_IRUGO,
 593                        hts221_sysfs_rh_oversampling_avail, NULL, 0);
 594 static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available, S_IRUGO,
 595                        hts221_sysfs_temp_oversampling_avail, NULL, 0);
 596 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hts221_sysfs_sampling_freq);
 597
 598 static struct attribute *hts221_attributes[] = {
 599         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 600         &iio_dev_attr_in_humidity_oversampling_ratio_available.dev_attr.attr,
 601         &iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr,
 602         NULL,
 603 };
 604
 605 static const struct attribute_group hts221_attribute_group = {
 606         .attrs = hts221_attributes,
 607 };
 608
 609 static const struct iio_info hts221_info = {
 610         .driver_module = THIS_MODULE,
 611         .attrs = &hts221_attribute_group,
 612         .read_raw = hts221_read_raw,
 613         .write_raw = hts221_write_raw,
 614         .validate_trigger = hts221_validate_trigger,
 615 };
 616
 617 static const unsigned long hts221_scan_masks[] = {0x3, 0x0};
 618
 619 int hts221_probe(struct iio_dev *iio_dev)
 620 {
 621         struct hts221_hw *hw = iio_priv(iio_dev);
 622         int err;
 623         u8 data;
 624
 625         mutex_init(&hw->lock);
 626
 627         err = hts221_check_whoami(hw);
 628         if (err < 0)
 629                 return err;
 630
 631         hw->odr = hts221_odr_table[0].hz;
 632
 633         iio_dev->modes = INDIO_DIRECT_MODE;
 634         iio_dev->dev.parent = hw->dev;
 635         iio_dev->available_scan_masks = hts221_scan_masks;
 636         iio_dev->channels = hts221_channels;
 637         iio_dev->num_channels = ARRAY_SIZE(hts221_channels);
 638         iio_dev->name = HTS221_DEV_NAME;
 639         iio_dev->info = &hts221_info;
 640
 641         /* enable Block Data Update */
 642         err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
 643                                      HTS221_BDU_MASK, 1);
 644         if (err < 0)
 645                 return err;
 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");