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