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 <asm/unaligned.h> 17 18 #include "hts221.h" 19 20 #define HTS221_REG_WHOAMI_ADDR 0x0f 21 #define HTS221_REG_WHOAMI_VAL 0xbc 22 23 #define HTS221_REG_CNTRL1_ADDR 0x20 24 #define HTS221_REG_CNTRL2_ADDR 0x21 25 #define HTS221_REG_CNTRL3_ADDR 0x22 26 27 #define HTS221_REG_AVG_ADDR 0x10 28 #define HTS221_REG_H_OUT_L 0x28 29 #define HTS221_REG_T_OUT_L 0x2a 30 31 #define HTS221_HUMIDITY_AVG_MASK 0x07 32 #define HTS221_TEMP_AVG_MASK 0x38 33 34 #define HTS221_ODR_MASK 0x87 35 #define HTS221_BDU_MASK BIT(2) 36 37 #define HTS221_DRDY_MASK BIT(2) 38 39 #define HTS221_ENABLE_SENSOR BIT(7) 40 41 #define HTS221_HUMIDITY_AVG_4 0x00 /* 0.4 %RH */ 42 #define HTS221_HUMIDITY_AVG_8 0x01 /* 0.3 %RH */ 43 #define HTS221_HUMIDITY_AVG_16 0x02 /* 0.2 %RH */ 44 #define HTS221_HUMIDITY_AVG_32 0x03 /* 0.15 %RH */ 45 #define HTS221_HUMIDITY_AVG_64 0x04 /* 0.1 %RH */ 46 #define HTS221_HUMIDITY_AVG_128 0x05 /* 0.07 %RH */ 47 #define HTS221_HUMIDITY_AVG_256 0x06 /* 0.05 %RH */ 48 #define HTS221_HUMIDITY_AVG_512 0x07 /* 0.03 %RH */ 49 50 #define HTS221_TEMP_AVG_2 0x00 /* 0.08 degC */ 51 #define HTS221_TEMP_AVG_4 0x08 /* 0.05 degC */ 52 #define HTS221_TEMP_AVG_8 0x10 /* 0.04 degC */ 53 #define HTS221_TEMP_AVG_16 0x18 /* 0.03 degC */ 54 #define HTS221_TEMP_AVG_32 0x20 /* 0.02 degC */ 55 #define HTS221_TEMP_AVG_64 0x28 /* 0.015 degC */ 56 #define HTS221_TEMP_AVG_128 0x30 /* 0.01 degC */ 57 #define HTS221_TEMP_AVG_256 0x38 /* 0.007 degC */ 58 59 /* calibration registers */ 60 #define HTS221_REG_0RH_CAL_X_H 0x36 61 #define HTS221_REG_1RH_CAL_X_H 0x3a 62 #define HTS221_REG_0RH_CAL_Y_H 0x30 63 #define HTS221_REG_1RH_CAL_Y_H 0x31 64 #define HTS221_REG_0T_CAL_X_L 0x3c 65 #define HTS221_REG_1T_CAL_X_L 0x3e 66 #define HTS221_REG_0T_CAL_Y_H 0x32 67 #define HTS221_REG_1T_CAL_Y_H 0x33 68 #define HTS221_REG_T1_T0_CAL_Y_H 0x35 69 70 struct hts221_odr { 71 u8 hz; 72 u8 val; 73 }; 74 75 struct hts221_avg { 76 u8 addr; 77 u8 mask; 78 struct hts221_avg_avl avg_avl[HTS221_AVG_DEPTH]; 79 }; 80 81 static const struct hts221_odr hts221_odr_table[] = { 82 { 1, 0x01 }, /* 1Hz */ 83 { 7, 0x02 }, /* 7Hz */ 84 { 13, 0x03 }, /* 12.5Hz */ 85 }; 86 87 static const struct hts221_avg hts221_avg_list[] = { 88 { 89 .addr = HTS221_REG_AVG_ADDR, 90 .mask = HTS221_HUMIDITY_AVG_MASK, 91 .avg_avl = { 92 { 4, HTS221_HUMIDITY_AVG_4 }, 93 { 8, HTS221_HUMIDITY_AVG_8 }, 94 { 16, HTS221_HUMIDITY_AVG_16 }, 95 { 32, HTS221_HUMIDITY_AVG_32 }, 96 { 64, HTS221_HUMIDITY_AVG_64 }, 97 { 128, HTS221_HUMIDITY_AVG_128 }, 98 { 256, HTS221_HUMIDITY_AVG_256 }, 99 { 512, HTS221_HUMIDITY_AVG_512 }, 100 }, 101 }, 102 { 103 .addr = HTS221_REG_AVG_ADDR, 104 .mask = HTS221_TEMP_AVG_MASK, 105 .avg_avl = { 106 { 2, HTS221_TEMP_AVG_2 }, 107 { 4, HTS221_TEMP_AVG_4 }, 108 { 8, HTS221_TEMP_AVG_8 }, 109 { 16, HTS221_TEMP_AVG_16 }, 110 { 32, HTS221_TEMP_AVG_32 }, 111 { 64, HTS221_TEMP_AVG_64 }, 112 { 128, HTS221_TEMP_AVG_128 }, 113 { 256, HTS221_TEMP_AVG_256 }, 114 }, 115 }, 116 }; 117 118 static const struct iio_chan_spec hts221_channels[] = { 119 { 120 .type = IIO_HUMIDITYRELATIVE, 121 .address = HTS221_REG_H_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 = 0, 128 .scan_type = { 129 .sign = 's', 130 .realbits = 16, 131 .storagebits = 16, 132 .endianness = IIO_LE, 133 }, 134 }, 135 { 136 .type = IIO_TEMP, 137 .address = HTS221_REG_T_OUT_L, 138 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 139 BIT(IIO_CHAN_INFO_OFFSET) | 140 BIT(IIO_CHAN_INFO_SCALE) | 141 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 142 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), 143 .scan_index = 1, 144 .scan_type = { 145 .sign = 's', 146 .realbits = 16, 147 .storagebits = 16, 148 .endianness = IIO_LE, 149 }, 150 }, 151 IIO_CHAN_SOFT_TIMESTAMP(2), 152 }; 153 154 static int hts221_write_with_mask(struct hts221_hw *hw, u8 addr, u8 mask, 155 u8 val) 156 { 157 u8 data; 158 int err; 159 160 mutex_lock(&hw->lock); 161 162 err = hw->tf->read(hw->dev, addr, sizeof(data), &data); 163 if (err < 0) { 164 dev_err(hw->dev, "failed to read %02x register\n", addr); 165 goto unlock; 166 } 167 168 data = (data & ~mask) | (val & mask); 169 170 err = hw->tf->write(hw->dev, addr, sizeof(data), &data); 171 if (err < 0) 172 dev_err(hw->dev, "failed to write %02x register\n", addr); 173 174 unlock: 175 mutex_unlock(&hw->lock); 176 177 return err; 178 } 179 180 static int hts221_check_whoami(struct hts221_hw *hw) 181 { 182 u8 data; 183 int err; 184 185 err = hw->tf->read(hw->dev, HTS221_REG_WHOAMI_ADDR, sizeof(data), 186 &data); 187 if (err < 0) { 188 dev_err(hw->dev, "failed to read whoami register\n"); 189 return err; 190 } 191 192 if (data != HTS221_REG_WHOAMI_VAL) { 193 dev_err(hw->dev, "wrong whoami {%02x vs %02x}\n", 194 data, HTS221_REG_WHOAMI_VAL); 195 return -ENODEV; 196 } 197 198 return 0; 199 } 200 201 int hts221_config_drdy(struct hts221_hw *hw, bool enable) 202 { 203 u8 val = enable ? BIT(2) : 0; 204 int err; 205 206 err = hts221_write_with_mask(hw, HTS221_REG_CNTRL3_ADDR, 207 HTS221_DRDY_MASK, val); 208 209 return err < 0 ? err : 0; 210 } 211 212 static int hts221_update_odr(struct hts221_hw *hw, u8 odr) 213 { 214 int i, err; 215 u8 val; 216 217 for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++) 218 if (hts221_odr_table[i].hz == odr) 219 break; 220 221 if (i == ARRAY_SIZE(hts221_odr_table)) 222 return -EINVAL; 223 224 val = HTS221_ENABLE_SENSOR | HTS221_BDU_MASK | hts221_odr_table[i].val; 225 err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR, 226 HTS221_ODR_MASK, val); 227 if (err < 0) 228 return err; 229 230 hw->odr = odr; 231 232 return 0; 233 } 234 235 static int hts221_update_avg(struct hts221_hw *hw, 236 enum hts221_sensor_type type, 237 u16 val) 238 { 239 int i, err; 240 const struct hts221_avg *avg = &hts221_avg_list[type]; 241 242 for (i = 0; i < HTS221_AVG_DEPTH; i++) 243 if (avg->avg_avl[i].avg == val) 244 break; 245 246 if (i == HTS221_AVG_DEPTH) 247 return -EINVAL; 248 249 err = hts221_write_with_mask(hw, avg->addr, avg->mask, 250 avg->avg_avl[i].val); 251 if (err < 0) 252 return err; 253 254 hw->sensors[type].cur_avg_idx = i; 255 256 return 0; 257 } 258 259 static ssize_t hts221_sysfs_sampling_freq(struct device *dev, 260 struct device_attribute *attr, 261 char *buf) 262 { 263 int i; 264 ssize_t len = 0; 265 266 for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++) 267 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ", 268 hts221_odr_table[i].hz); 269 buf[len - 1] = '\n'; 270 271 return len; 272 } 273 274 static ssize_t 275 hts221_sysfs_rh_oversampling_avail(struct device *dev, 276 struct device_attribute *attr, 277 char *buf) 278 { 279 const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_H]; 280 ssize_t len = 0; 281 int i; 282 283 for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++) 284 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ", 285 avg->avg_avl[i].avg); 286 buf[len - 1] = '\n'; 287 288 return len; 289 } 290 291 static ssize_t 292 hts221_sysfs_temp_oversampling_avail(struct device *dev, 293 struct device_attribute *attr, 294 char *buf) 295 { 296 const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_T]; 297 ssize_t len = 0; 298 int i; 299 300 for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++) 301 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ", 302 avg->avg_avl[i].avg); 303 buf[len - 1] = '\n'; 304 305 return len; 306 } 307 308 int hts221_power_on(struct hts221_hw *hw) 309 { 310 return hts221_update_odr(hw, hw->odr); 311 } 312 313 int hts221_power_off(struct hts221_hw *hw) 314 { 315 u8 data[] = {0x00, 0x00}; 316 317 return hw->tf->write(hw->dev, HTS221_REG_CNTRL1_ADDR, sizeof(data), 318 data); 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].avg; 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].avg; 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 /* configure humidity sensor */ 642 err = hts221_parse_rh_caldata(hw); 643 if (err < 0) { 644 dev_err(hw->dev, "failed to get rh calibration data\n"); 645 return err; 646 } 647 648 data = hts221_avg_list[HTS221_SENSOR_H].avg_avl[3].avg; 649 err = hts221_update_avg(hw, HTS221_SENSOR_H, data); 650 if (err < 0) { 651 dev_err(hw->dev, "failed to set rh oversampling ratio\n"); 652 return err; 653 } 654 655 /* configure temperature sensor */ 656 err = hts221_parse_temp_caldata(hw); 657 if (err < 0) { 658 dev_err(hw->dev, 659 "failed to get temperature calibration data\n"); 660 return err; 661 } 662 663 data = hts221_avg_list[HTS221_SENSOR_T].avg_avl[3].avg; 664 err = hts221_update_avg(hw, HTS221_SENSOR_T, data); 665 if (err < 0) { 666 dev_err(hw->dev, 667 "failed to set temperature oversampling ratio\n"); 668 return err; 669 } 670 671 if (hw->irq > 0) { 672 err = hts221_allocate_buffers(hw); 673 if (err < 0) 674 return err; 675 676 err = hts221_allocate_trigger(hw); 677 if (err) 678 return err; 679 } 680 681 return devm_iio_device_register(hw->dev, iio_dev); 682 } 683 EXPORT_SYMBOL(hts221_probe); 684 685 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>"); 686 MODULE_DESCRIPTION("STMicroelectronics hts221 sensor driver"); 687 MODULE_LICENSE("GPL v2"); 688