1 // SPDX-License-Identifier: GPL-2.0-only
3 * STMicroelectronics hts221 sensor driver
5 * Copyright 2016 STMicroelectronics Inc.
7 * Lorenzo Bianconi <lorenzo.bianconi@st.com>
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>
16 #include <linux/regmap.h>
17 #include <linux/bitfield.h>
21 #define HTS221_REG_WHOAMI_ADDR 0x0f
22 #define HTS221_REG_WHOAMI_VAL 0xbc
24 #define HTS221_REG_CNTRL1_ADDR 0x20
25 #define HTS221_REG_CNTRL2_ADDR 0x21
27 #define HTS221_REG_AVG_ADDR 0x10
28 #define HTS221_REG_H_OUT_L 0x28
29 #define HTS221_REG_T_OUT_L 0x2a
31 #define HTS221_HUMIDITY_AVG_MASK 0x07
32 #define HTS221_TEMP_AVG_MASK 0x38
34 #define HTS221_ODR_MASK 0x03
35 #define HTS221_BDU_MASK BIT(2)
36 #define HTS221_ENABLE_MASK BIT(7)
38 /* calibration registers */
39 #define HTS221_REG_0RH_CAL_X_H 0x36
40 #define HTS221_REG_1RH_CAL_X_H 0x3a
41 #define HTS221_REG_0RH_CAL_Y_H 0x30
42 #define HTS221_REG_1RH_CAL_Y_H 0x31
43 #define HTS221_REG_0T_CAL_X_L 0x3c
44 #define HTS221_REG_1T_CAL_X_L 0x3e
45 #define HTS221_REG_0T_CAL_Y_H 0x32
46 #define HTS221_REG_1T_CAL_Y_H 0x33
47 #define HTS221_REG_T1_T0_CAL_Y_H 0x35
54 #define HTS221_AVG_DEPTH 8
58 u16 avg_avl[HTS221_AVG_DEPTH];
61 static const struct hts221_odr hts221_odr_table[] = {
62 { 1, 0x01 }, /* 1Hz */
63 { 7, 0x02 }, /* 7Hz */
64 { 13, 0x03 }, /* 12.5Hz */
67 static const struct hts221_avg hts221_avg_list[] = {
69 .addr = HTS221_REG_AVG_ADDR,
70 .mask = HTS221_HUMIDITY_AVG_MASK,
83 .addr = HTS221_REG_AVG_ADDR,
84 .mask = HTS221_TEMP_AVG_MASK,
98 static const struct iio_chan_spec hts221_channels[] = {
100 .type = IIO_HUMIDITYRELATIVE,
101 .address = HTS221_REG_H_OUT_L,
102 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
103 BIT(IIO_CHAN_INFO_OFFSET) |
104 BIT(IIO_CHAN_INFO_SCALE) |
105 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
106 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
112 .endianness = IIO_LE,
117 .address = HTS221_REG_T_OUT_L,
118 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
119 BIT(IIO_CHAN_INFO_OFFSET) |
120 BIT(IIO_CHAN_INFO_SCALE) |
121 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
122 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
128 .endianness = IIO_LE,
131 IIO_CHAN_SOFT_TIMESTAMP(2),
134 static int hts221_check_whoami(struct hts221_hw *hw)
138 err = regmap_read(hw->regmap, HTS221_REG_WHOAMI_ADDR, &data);
140 dev_err(hw->dev, "failed to read whoami register\n");
144 if (data != HTS221_REG_WHOAMI_VAL) {
145 dev_err(hw->dev, "wrong whoami {%02x vs %02x}\n",
146 data, HTS221_REG_WHOAMI_VAL);
153 static int hts221_update_odr(struct hts221_hw *hw, u8 odr)
157 for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
158 if (hts221_odr_table[i].hz == odr)
161 if (i == ARRAY_SIZE(hts221_odr_table))
164 err = regmap_update_bits(hw->regmap, HTS221_REG_CNTRL1_ADDR,
166 FIELD_PREP(HTS221_ODR_MASK,
167 hts221_odr_table[i].val));
176 static int hts221_update_avg(struct hts221_hw *hw,
177 enum hts221_sensor_type type,
180 const struct hts221_avg *avg = &hts221_avg_list[type];
183 for (i = 0; i < HTS221_AVG_DEPTH; i++)
184 if (avg->avg_avl[i] == val)
187 if (i == HTS221_AVG_DEPTH)
190 data = ((i << __ffs(avg->mask)) & avg->mask);
191 err = regmap_update_bits(hw->regmap, avg->addr,
196 hw->sensors[type].cur_avg_idx = i;
201 static ssize_t hts221_sysfs_sampling_freq(struct device *dev,
202 struct device_attribute *attr,
208 for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
209 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
210 hts221_odr_table[i].hz);
217 hts221_sysfs_rh_oversampling_avail(struct device *dev,
218 struct device_attribute *attr,
221 const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_H];
225 for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
226 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
234 hts221_sysfs_temp_oversampling_avail(struct device *dev,
235 struct device_attribute *attr,
238 const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_T];
242 for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
243 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
250 int hts221_set_enable(struct hts221_hw *hw, bool enable)
254 err = regmap_update_bits(hw->regmap, HTS221_REG_CNTRL1_ADDR,
256 FIELD_PREP(HTS221_ENABLE_MASK, enable));
260 hw->enabled = enable;
265 static int hts221_parse_temp_caldata(struct hts221_hw *hw)
267 int err, *slope, *b_gen, cal0, cal1;
268 s16 cal_x0, cal_x1, cal_y0, cal_y1;
271 err = regmap_read(hw->regmap, HTS221_REG_0T_CAL_Y_H, &cal0);
275 err = regmap_read(hw->regmap, HTS221_REG_T1_T0_CAL_Y_H, &cal1);
278 cal_y0 = ((cal1 & 0x3) << 8) | cal0;
280 err = regmap_read(hw->regmap, HTS221_REG_1T_CAL_Y_H, &cal0);
283 cal_y1 = (((cal1 & 0xc) >> 2) << 8) | cal0;
285 err = regmap_bulk_read(hw->regmap, HTS221_REG_0T_CAL_X_L,
289 cal_x0 = le16_to_cpu(val);
291 err = regmap_bulk_read(hw->regmap, HTS221_REG_1T_CAL_X_L,
295 cal_x1 = le16_to_cpu(val);
297 slope = &hw->sensors[HTS221_SENSOR_T].slope;
298 b_gen = &hw->sensors[HTS221_SENSOR_T].b_gen;
300 *slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
301 *b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
308 static int hts221_parse_rh_caldata(struct hts221_hw *hw)
310 int err, *slope, *b_gen, data;
311 s16 cal_x0, cal_x1, cal_y0, cal_y1;
314 err = regmap_read(hw->regmap, HTS221_REG_0RH_CAL_Y_H, &data);
319 err = regmap_read(hw->regmap, HTS221_REG_1RH_CAL_Y_H, &data);
324 err = regmap_bulk_read(hw->regmap, HTS221_REG_0RH_CAL_X_H,
328 cal_x0 = le16_to_cpu(val);
330 err = regmap_bulk_read(hw->regmap, HTS221_REG_1RH_CAL_X_H,
334 cal_x1 = le16_to_cpu(val);
336 slope = &hw->sensors[HTS221_SENSOR_H].slope;
337 b_gen = &hw->sensors[HTS221_SENSOR_H].b_gen;
339 *slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
340 *b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
347 static int hts221_get_sensor_scale(struct hts221_hw *hw,
348 enum iio_chan_type ch_type,
355 case IIO_HUMIDITYRELATIVE:
356 data = hw->sensors[HTS221_SENSOR_H].slope;
357 div = (1 << 4) * 1000;
360 data = hw->sensors[HTS221_SENSOR_T].slope;
361 div = (1 << 6) * 1000;
367 tmp = div_s64(data * 1000000000LL, div);
368 tmp = div_s64_rem(tmp, 1000000000LL, &rem);
373 return IIO_VAL_INT_PLUS_NANO;
376 static int hts221_get_sensor_offset(struct hts221_hw *hw,
377 enum iio_chan_type ch_type,
384 case IIO_HUMIDITYRELATIVE:
385 data = hw->sensors[HTS221_SENSOR_H].b_gen;
386 div = hw->sensors[HTS221_SENSOR_H].slope;
389 data = hw->sensors[HTS221_SENSOR_T].b_gen;
390 div = hw->sensors[HTS221_SENSOR_T].slope;
396 tmp = div_s64(data * 1000000000LL, div);
397 tmp = div_s64_rem(tmp, 1000000000LL, &rem);
402 return IIO_VAL_INT_PLUS_NANO;
405 static int hts221_read_oneshot(struct hts221_hw *hw, u8 addr, int *val)
410 err = hts221_set_enable(hw, true);
416 err = regmap_bulk_read(hw->regmap, addr, &data, sizeof(data));
420 hts221_set_enable(hw, false);
422 *val = (s16)le16_to_cpu(data);
427 static int hts221_read_raw(struct iio_dev *iio_dev,
428 struct iio_chan_spec const *ch,
429 int *val, int *val2, long mask)
431 struct hts221_hw *hw = iio_priv(iio_dev);
434 ret = iio_device_claim_direct_mode(iio_dev);
439 case IIO_CHAN_INFO_RAW:
440 ret = hts221_read_oneshot(hw, ch->address, val);
442 case IIO_CHAN_INFO_SCALE:
443 ret = hts221_get_sensor_scale(hw, ch->type, val, val2);
445 case IIO_CHAN_INFO_OFFSET:
446 ret = hts221_get_sensor_offset(hw, ch->type, val, val2);
448 case IIO_CHAN_INFO_SAMP_FREQ:
452 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
454 const struct hts221_avg *avg;
457 case IIO_HUMIDITYRELATIVE:
458 avg = &hts221_avg_list[HTS221_SENSOR_H];
459 idx = hw->sensors[HTS221_SENSOR_H].cur_avg_idx;
460 *val = avg->avg_avl[idx];
464 avg = &hts221_avg_list[HTS221_SENSOR_T];
465 idx = hw->sensors[HTS221_SENSOR_T].cur_avg_idx;
466 *val = avg->avg_avl[idx];
480 iio_device_release_direct_mode(iio_dev);
485 static int hts221_write_raw(struct iio_dev *iio_dev,
486 struct iio_chan_spec const *chan,
487 int val, int val2, long mask)
489 struct hts221_hw *hw = iio_priv(iio_dev);
492 ret = iio_device_claim_direct_mode(iio_dev);
497 case IIO_CHAN_INFO_SAMP_FREQ:
498 ret = hts221_update_odr(hw, val);
500 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
501 switch (chan->type) {
502 case IIO_HUMIDITYRELATIVE:
503 ret = hts221_update_avg(hw, HTS221_SENSOR_H, val);
506 ret = hts221_update_avg(hw, HTS221_SENSOR_T, val);
518 iio_device_release_direct_mode(iio_dev);
523 static int hts221_validate_trigger(struct iio_dev *iio_dev,
524 struct iio_trigger *trig)
526 struct hts221_hw *hw = iio_priv(iio_dev);
528 return hw->trig == trig ? 0 : -EINVAL;
531 static IIO_DEVICE_ATTR(in_humidity_oversampling_ratio_available, S_IRUGO,
532 hts221_sysfs_rh_oversampling_avail, NULL, 0);
533 static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available, S_IRUGO,
534 hts221_sysfs_temp_oversampling_avail, NULL, 0);
535 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hts221_sysfs_sampling_freq);
537 static struct attribute *hts221_attributes[] = {
538 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
539 &iio_dev_attr_in_humidity_oversampling_ratio_available.dev_attr.attr,
540 &iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr,
544 static const struct attribute_group hts221_attribute_group = {
545 .attrs = hts221_attributes,
548 static const struct iio_info hts221_info = {
549 .attrs = &hts221_attribute_group,
550 .read_raw = hts221_read_raw,
551 .write_raw = hts221_write_raw,
552 .validate_trigger = hts221_validate_trigger,
555 static const unsigned long hts221_scan_masks[] = {0x3, 0x0};
557 int hts221_probe(struct device *dev, int irq, const char *name,
558 struct regmap *regmap)
560 struct iio_dev *iio_dev;
561 struct hts221_hw *hw;
565 iio_dev = devm_iio_device_alloc(dev, sizeof(*hw));
569 dev_set_drvdata(dev, (void *)iio_dev);
571 hw = iio_priv(iio_dev);
577 err = hts221_check_whoami(hw);
581 iio_dev->modes = INDIO_DIRECT_MODE;
582 iio_dev->dev.parent = hw->dev;
583 iio_dev->available_scan_masks = hts221_scan_masks;
584 iio_dev->channels = hts221_channels;
585 iio_dev->num_channels = ARRAY_SIZE(hts221_channels);
586 iio_dev->name = HTS221_DEV_NAME;
587 iio_dev->info = &hts221_info;
589 /* enable Block Data Update */
590 err = regmap_update_bits(hw->regmap, HTS221_REG_CNTRL1_ADDR,
592 FIELD_PREP(HTS221_BDU_MASK, 1));
596 err = hts221_update_odr(hw, hts221_odr_table[0].hz);
600 /* configure humidity sensor */
601 err = hts221_parse_rh_caldata(hw);
603 dev_err(hw->dev, "failed to get rh calibration data\n");
607 data = hts221_avg_list[HTS221_SENSOR_H].avg_avl[3];
608 err = hts221_update_avg(hw, HTS221_SENSOR_H, data);
610 dev_err(hw->dev, "failed to set rh oversampling ratio\n");
614 /* configure temperature sensor */
615 err = hts221_parse_temp_caldata(hw);
618 "failed to get temperature calibration data\n");
622 data = hts221_avg_list[HTS221_SENSOR_T].avg_avl[3];
623 err = hts221_update_avg(hw, HTS221_SENSOR_T, data);
626 "failed to set temperature oversampling ratio\n");
631 err = hts221_allocate_buffers(hw);
635 err = hts221_allocate_trigger(hw);
640 return devm_iio_device_register(hw->dev, iio_dev);
642 EXPORT_SYMBOL(hts221_probe);
644 static int __maybe_unused hts221_suspend(struct device *dev)
646 struct iio_dev *iio_dev = dev_get_drvdata(dev);
647 struct hts221_hw *hw = iio_priv(iio_dev);
649 return regmap_update_bits(hw->regmap, HTS221_REG_CNTRL1_ADDR,
651 FIELD_PREP(HTS221_ENABLE_MASK, false));
654 static int __maybe_unused hts221_resume(struct device *dev)
656 struct iio_dev *iio_dev = dev_get_drvdata(dev);
657 struct hts221_hw *hw = iio_priv(iio_dev);
661 err = regmap_update_bits(hw->regmap, HTS221_REG_CNTRL1_ADDR,
663 FIELD_PREP(HTS221_ENABLE_MASK,
668 const struct dev_pm_ops hts221_pm_ops = {
669 SET_SYSTEM_SLEEP_PM_OPS(hts221_suspend, hts221_resume)
671 EXPORT_SYMBOL(hts221_pm_ops);
673 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
674 MODULE_DESCRIPTION("STMicroelectronics hts221 sensor driver");
675 MODULE_LICENSE("GPL v2");