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
hts221_check_whoami(struct hts221_hw * hw)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
hts221_update_odr(struct hts221_hw * hw,u8 odr)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
hts221_update_avg(struct hts221_hw * hw,enum hts221_sensor_type type,u16 val)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
hts221_sysfs_sampling_freq(struct device * dev,struct device_attribute * attr,char * buf)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
hts221_sysfs_rh_oversampling_avail(struct device * dev,struct device_attribute * attr,char * buf)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
hts221_sysfs_temp_oversampling_avail(struct device * dev,struct device_attribute * attr,char * buf)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
hts221_set_enable(struct hts221_hw * hw,bool enable)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
hts221_parse_temp_caldata(struct hts221_hw * hw)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
hts221_parse_rh_caldata(struct hts221_hw * hw)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
hts221_get_sensor_scale(struct hts221_hw * hw,enum iio_chan_type ch_type,int * val,int * val2)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
hts221_get_sensor_offset(struct hts221_hw * hw,enum iio_chan_type ch_type,int * val,int * val2)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
hts221_read_oneshot(struct hts221_hw * hw,u8 addr,int * val)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
hts221_read_raw(struct iio_dev * iio_dev,struct iio_chan_spec const * ch,int * val,int * val2,long mask)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
hts221_write_raw(struct iio_dev * iio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)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
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 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
hts221_chip_uninit(void * data)572 static void hts221_chip_uninit(void *data)
573 {
574 struct hts221_hw *hw = data;
575
576 regulator_disable(hw->vdd);
577 }
578
hts221_probe(struct device * dev,int irq,const char * name,struct regmap * regmap)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
hts221_suspend(struct device * dev)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
hts221_resume(struct device * dev)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");
705