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