drivers/iio/humidity/hts221_core.c

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