1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * hdc3020.c - Support for the TI HDC3020,HDC3021 and HDC3022
4 * temperature + relative humidity sensors
5 *
6 * Copyright (C) 2023
7 *
8 * Copyright (C) 2024 Liebherr-Electronics and Drives GmbH
9 *
10 * Datasheet: https://www.ti.com/lit/ds/symlink/hdc3020.pdf
11 */
12
13#include <linux/bitfield.h>
14#include <linux/bitops.h>
15#include <linux/cleanup.h>
16#include <linux/crc8.h>
17#include <linux/delay.h>
18#include <linux/gpio/consumer.h>
19#include <linux/i2c.h>
20#include <linux/init.h>
21#include <linux/interrupt.h>
22#include <linux/math64.h>
23#include <linux/module.h>
24#include <linux/mutex.h>
25#include <linux/pm.h>
26#include <linux/regulator/consumer.h>
27#include <linux/units.h>
28
29#include <linux/unaligned.h>
30
31#include <linux/iio/events.h>
32#include <linux/iio/iio.h>
33
34#define HDC3020_S_AUTO_10HZ_MOD0 0x2737
35#define HDC3020_S_STATUS 0x3041
36#define HDC3020_HEATER_DISABLE 0x3066
37#define HDC3020_HEATER_ENABLE 0x306D
38#define HDC3020_HEATER_CONFIG 0x306E
39#define HDC3020_EXIT_AUTO 0x3093
40#define HDC3020_S_T_RH_THRESH_LOW 0x6100
41#define HDC3020_S_T_RH_THRESH_LOW_CLR 0x610B
42#define HDC3020_S_T_RH_THRESH_HIGH_CLR 0x6116
43#define HDC3020_S_T_RH_THRESH_HIGH 0x611D
44#define HDC3020_R_T_RH_AUTO 0xE000
45#define HDC3020_R_T_LOW_AUTO 0xE002
46#define HDC3020_R_T_HIGH_AUTO 0xE003
47#define HDC3020_R_RH_LOW_AUTO 0xE004
48#define HDC3020_R_RH_HIGH_AUTO 0xE005
49#define HDC3020_R_T_RH_THRESH_LOW 0xE102
50#define HDC3020_R_T_RH_THRESH_LOW_CLR 0xE109
51#define HDC3020_R_T_RH_THRESH_HIGH_CLR 0xE114
52#define HDC3020_R_T_RH_THRESH_HIGH 0xE11F
53#define HDC3020_R_STATUS 0xF32D
54
55#define HDC3020_THRESH_TEMP_MASK GENMASK(8, 0)
56#define HDC3020_THRESH_TEMP_TRUNC_SHIFT 7
57#define HDC3020_THRESH_HUM_MASK GENMASK(15, 9)
58#define HDC3020_THRESH_HUM_TRUNC_SHIFT 9
59
60#define HDC3020_STATUS_T_LOW_ALERT BIT(6)
61#define HDC3020_STATUS_T_HIGH_ALERT BIT(7)
62#define HDC3020_STATUS_RH_LOW_ALERT BIT(8)
63#define HDC3020_STATUS_RH_HIGH_ALERT BIT(9)
64
65#define HDC3020_READ_RETRY_TIMES 10
66#define HDC3020_BUSY_DELAY_MS 10
67
68#define HDC3020_CRC8_POLYNOMIAL 0x31
69
70#define HDC3020_MIN_TEMP_MICRO -39872968
71#define HDC3020_MAX_TEMP_MICRO 124875639
72#define HDC3020_MAX_TEMP_HYST_MICRO 164748607
73#define HDC3020_MAX_HUM_MICRO 99220264
74
75struct hdc3020_data {
76 struct i2c_client *client;
77 struct gpio_desc *reset_gpio;
78 struct regulator *vdd_supply;
79 /*
80 * Ensure that the sensor configuration (currently only heater is
81 * supported) will not be changed during the process of reading
82 * sensor data (this driver will try HDC3020_READ_RETRY_TIMES times
83 * if the device does not respond).
84 */
85 struct mutex lock;
86};
87
88static const int hdc3020_heater_vals[] = {0, 1, 0x3FFF};
89
90static const struct iio_event_spec hdc3020_t_rh_event[] = {
91 {
92 .type = IIO_EV_TYPE_THRESH,
93 .dir = IIO_EV_DIR_RISING,
94 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
95 BIT(IIO_EV_INFO_HYSTERESIS),
96 },
97 {
98 .type = IIO_EV_TYPE_THRESH,
99 .dir = IIO_EV_DIR_FALLING,
100 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
101 BIT(IIO_EV_INFO_HYSTERESIS),
102 },
103};
104
105static const struct iio_chan_spec hdc3020_channels[] = {
106 {
107 .type = IIO_TEMP,
108 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
109 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_PEAK) |
110 BIT(IIO_CHAN_INFO_TROUGH) | BIT(IIO_CHAN_INFO_OFFSET),
111 .event_spec = hdc3020_t_rh_event,
112 .num_event_specs = ARRAY_SIZE(hdc3020_t_rh_event),
113 },
114 {
115 .type = IIO_HUMIDITYRELATIVE,
116 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
117 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_PEAK) |
118 BIT(IIO_CHAN_INFO_TROUGH),
119 .event_spec = hdc3020_t_rh_event,
120 .num_event_specs = ARRAY_SIZE(hdc3020_t_rh_event),
121 },
122 {
123 /*
124 * For setting the internal heater, which can be switched on to
125 * prevent or remove any condensation that may develop when the
126 * ambient environment approaches its dew point temperature.
127 */
128 .type = IIO_CURRENT,
129 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
130 .info_mask_separate_available = BIT(IIO_CHAN_INFO_RAW),
131 .output = 1,
132 },
133};
134
135DECLARE_CRC8_TABLE(hdc3020_crc8_table);
136
137static int hdc3020_write_bytes(struct hdc3020_data *data, u8 *buf, u8 len)
138{
139 struct i2c_client *client = data->client;
140 struct i2c_msg msg;
141 int ret, cnt;
142
143 msg.addr = client->addr;
144 msg.flags = 0;
145 msg.buf = buf;
146 msg.len = len;
147
148 /*
149 * During the measurement process, HDC3020 will not return data.
150 * So wait for a while and try again
151 */
152 for (cnt = 0; cnt < HDC3020_READ_RETRY_TIMES; cnt++) {
153 ret = i2c_transfer(adap: client->adapter, msgs: &msg, num: 1);
154 if (ret == 1)
155 return 0;
156
157 mdelay(HDC3020_BUSY_DELAY_MS);
158 }
159 dev_err(&client->dev, "Could not write sensor command\n");
160
161 return -ETIMEDOUT;
162}
163
164static
165int hdc3020_read_bytes(struct hdc3020_data *data, u16 reg, u8 *buf, int len)
166{
167 u8 reg_buf[2];
168 int ret, cnt;
169 struct i2c_client *client = data->client;
170 struct i2c_msg msg[2] = {
171 [0] = {
172 .addr = client->addr,
173 .flags = 0,
174 .buf = reg_buf,
175 .len = 2,
176 },
177 [1] = {
178 .addr = client->addr,
179 .flags = I2C_M_RD,
180 .buf = buf,
181 .len = len,
182 },
183 };
184
185 put_unaligned_be16(val: reg, p: reg_buf);
186 /*
187 * During the measurement process, HDC3020 will not return data.
188 * So wait for a while and try again
189 */
190 for (cnt = 0; cnt < HDC3020_READ_RETRY_TIMES; cnt++) {
191 ret = i2c_transfer(adap: client->adapter, msgs: msg, num: 2);
192 if (ret == 2)
193 return 0;
194
195 mdelay(HDC3020_BUSY_DELAY_MS);
196 }
197 dev_err(&client->dev, "Could not read sensor data\n");
198
199 return -ETIMEDOUT;
200}
201
202static int hdc3020_read_be16(struct hdc3020_data *data, u16 reg)
203{
204 u8 crc, buf[3];
205 int ret;
206
207 ret = hdc3020_read_bytes(data, reg, buf, len: 3);
208 if (ret < 0)
209 return ret;
210
211 crc = crc8(table: hdc3020_crc8_table, pdata: buf, nbytes: 2, CRC8_INIT_VALUE);
212 if (crc != buf[2])
213 return -EINVAL;
214
215 return get_unaligned_be16(p: buf);
216}
217
218static int hdc3020_exec_cmd(struct hdc3020_data *data, u16 reg)
219{
220 u8 reg_buf[2];
221
222 put_unaligned_be16(val: reg, p: reg_buf);
223 return hdc3020_write_bytes(data, buf: reg_buf, len: 2);
224}
225
226static int hdc3020_read_measurement(struct hdc3020_data *data,
227 enum iio_chan_type type, int *val)
228{
229 u8 crc, buf[6];
230 int ret;
231
232 ret = hdc3020_read_bytes(data, HDC3020_R_T_RH_AUTO, buf, len: 6);
233 if (ret < 0)
234 return ret;
235
236 /* CRC check of the temperature measurement */
237 crc = crc8(table: hdc3020_crc8_table, pdata: buf, nbytes: 2, CRC8_INIT_VALUE);
238 if (crc != buf[2])
239 return -EINVAL;
240
241 /* CRC check of the relative humidity measurement */
242 crc = crc8(table: hdc3020_crc8_table, pdata: buf + 3, nbytes: 2, CRC8_INIT_VALUE);
243 if (crc != buf[5])
244 return -EINVAL;
245
246 if (type == IIO_TEMP)
247 *val = get_unaligned_be16(p: buf);
248 else if (type == IIO_HUMIDITYRELATIVE)
249 *val = get_unaligned_be16(p: &buf[3]);
250 else
251 return -EINVAL;
252
253 return 0;
254}
255
256static int hdc3020_read_raw(struct iio_dev *indio_dev,
257 struct iio_chan_spec const *chan, int *val,
258 int *val2, long mask)
259{
260 struct hdc3020_data *data = iio_priv(indio_dev);
261 int ret;
262
263 if (chan->type != IIO_TEMP && chan->type != IIO_HUMIDITYRELATIVE)
264 return -EINVAL;
265
266 switch (mask) {
267 case IIO_CHAN_INFO_RAW: {
268 guard(mutex)(T: &data->lock);
269 ret = hdc3020_read_measurement(data, type: chan->type, val);
270 if (ret < 0)
271 return ret;
272
273 return IIO_VAL_INT;
274 }
275 case IIO_CHAN_INFO_PEAK: {
276 guard(mutex)(T: &data->lock);
277 if (chan->type == IIO_TEMP)
278 ret = hdc3020_read_be16(data, HDC3020_R_T_HIGH_AUTO);
279 else
280 ret = hdc3020_read_be16(data, HDC3020_R_RH_HIGH_AUTO);
281
282 if (ret < 0)
283 return ret;
284
285 *val = ret;
286 return IIO_VAL_INT;
287 }
288 case IIO_CHAN_INFO_TROUGH: {
289 guard(mutex)(T: &data->lock);
290 if (chan->type == IIO_TEMP)
291 ret = hdc3020_read_be16(data, HDC3020_R_T_LOW_AUTO);
292 else
293 ret = hdc3020_read_be16(data, HDC3020_R_RH_LOW_AUTO);
294
295 if (ret < 0)
296 return ret;
297
298 *val = ret;
299 return IIO_VAL_INT;
300 }
301 case IIO_CHAN_INFO_SCALE:
302 *val2 = 65536;
303 if (chan->type == IIO_TEMP)
304 *val = 175;
305 else
306 *val = 100;
307 return IIO_VAL_FRACTIONAL;
308
309 case IIO_CHAN_INFO_OFFSET:
310 if (chan->type != IIO_TEMP)
311 return -EINVAL;
312
313 *val = -16852;
314 return IIO_VAL_INT;
315
316 default:
317 return -EINVAL;
318 }
319}
320
321static int hdc3020_read_available(struct iio_dev *indio_dev,
322 struct iio_chan_spec const *chan,
323 const int **vals,
324 int *type, int *length, long mask)
325{
326 if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_CURRENT)
327 return -EINVAL;
328
329 *vals = hdc3020_heater_vals;
330 *type = IIO_VAL_INT;
331
332 return IIO_AVAIL_RANGE;
333}
334
335static int hdc3020_update_heater(struct hdc3020_data *data, int val)
336{
337 u8 buf[5];
338 int ret;
339
340 if (val < hdc3020_heater_vals[0] || val > hdc3020_heater_vals[2])
341 return -EINVAL;
342
343 if (!val)
344 hdc3020_exec_cmd(data, HDC3020_HEATER_DISABLE);
345
346 put_unaligned_be16(HDC3020_HEATER_CONFIG, p: buf);
347 put_unaligned_be16(val: val & GENMASK(13, 0), p: &buf[2]);
348 buf[4] = crc8(table: hdc3020_crc8_table, pdata: buf + 2, nbytes: 2, CRC8_INIT_VALUE);
349 ret = hdc3020_write_bytes(data, buf, len: 5);
350 if (ret < 0)
351 return ret;
352
353 return hdc3020_exec_cmd(data, HDC3020_HEATER_ENABLE);
354}
355
356static int hdc3020_write_raw(struct iio_dev *indio_dev,
357 struct iio_chan_spec const *chan,
358 int val, int val2, long mask)
359{
360 struct hdc3020_data *data = iio_priv(indio_dev);
361
362 switch (mask) {
363 case IIO_CHAN_INFO_RAW:
364 if (chan->type != IIO_CURRENT)
365 return -EINVAL;
366
367 guard(mutex)(T: &data->lock);
368 return hdc3020_update_heater(data, val);
369 }
370
371 return -EINVAL;
372}
373
374static int hdc3020_thresh_get_temp(u16 thresh)
375{
376 int temp;
377
378 /*
379 * Get the temperature threshold from 9 LSBs, shift them to get
380 * the truncated temperature threshold representation and
381 * calculate the threshold according to the formula in the
382 * datasheet. Result is degree celsius scaled by 65535.
383 */
384 temp = FIELD_GET(HDC3020_THRESH_TEMP_MASK, thresh) <<
385 HDC3020_THRESH_TEMP_TRUNC_SHIFT;
386
387 return -2949075 + (175 * temp);
388}
389
390static int hdc3020_thresh_get_hum(u16 thresh)
391{
392 int hum;
393
394 /*
395 * Get the humidity threshold from 7 MSBs, shift them to get the
396 * truncated humidity threshold representation and calculate the
397 * threshold according to the formula in the datasheet. Result is
398 * percent scaled by 65535.
399 */
400 hum = FIELD_GET(HDC3020_THRESH_HUM_MASK, thresh) <<
401 HDC3020_THRESH_HUM_TRUNC_SHIFT;
402
403 return hum * 100;
404}
405
406static u16 hdc3020_thresh_set_temp(int s_temp, u16 curr_thresh)
407{
408 u64 temp;
409 u16 thresh;
410
411 /*
412 * Calculate temperature threshold, shift it down to get the
413 * truncated threshold representation in the 9LSBs while keeping
414 * the current humidity threshold in the 7 MSBs.
415 */
416 temp = (u64)(s_temp + 45000000) * 65535ULL;
417 temp = div_u64(dividend: temp, divisor: 1000000 * 175) >> HDC3020_THRESH_TEMP_TRUNC_SHIFT;
418 thresh = FIELD_PREP(HDC3020_THRESH_TEMP_MASK, temp);
419 thresh |= (FIELD_GET(HDC3020_THRESH_HUM_MASK, curr_thresh) <<
420 HDC3020_THRESH_HUM_TRUNC_SHIFT);
421
422 return thresh;
423}
424
425static u16 hdc3020_thresh_set_hum(int s_hum, u16 curr_thresh)
426{
427 u64 hum;
428 u16 thresh;
429
430 /*
431 * Calculate humidity threshold, shift it down and up to get the
432 * truncated threshold representation in the 7MSBs while keeping
433 * the current temperature threshold in the 9 LSBs.
434 */
435 hum = (u64)(s_hum) * 65535ULL;
436 hum = div_u64(dividend: hum, divisor: 1000000 * 100) >> HDC3020_THRESH_HUM_TRUNC_SHIFT;
437 thresh = FIELD_PREP(HDC3020_THRESH_HUM_MASK, hum);
438 thresh |= FIELD_GET(HDC3020_THRESH_TEMP_MASK, curr_thresh);
439
440 return thresh;
441}
442
443static
444int hdc3020_thresh_clr(s64 s_thresh, s64 s_hyst, enum iio_event_direction dir)
445{
446 s64 s_clr;
447
448 /*
449 * Include directions when calculation the clear value,
450 * since hysteresis is unsigned by definition and the
451 * clear value is an absolute value which is signed.
452 */
453 if (dir == IIO_EV_DIR_RISING)
454 s_clr = s_thresh - s_hyst;
455 else
456 s_clr = s_thresh + s_hyst;
457
458 /* Divide by 65535 to get units of micro */
459 return div_s64(dividend: s_clr, divisor: 65535);
460}
461
462static int _hdc3020_write_thresh(struct hdc3020_data *data, u16 reg, u16 val)
463{
464 u8 buf[5];
465
466 put_unaligned_be16(val: reg, p: buf);
467 put_unaligned_be16(val, p: buf + 2);
468 buf[4] = crc8(table: hdc3020_crc8_table, pdata: buf + 2, nbytes: 2, CRC8_INIT_VALUE);
469
470 return hdc3020_write_bytes(data, buf, len: 5);
471}
472
473static int hdc3020_write_thresh(struct iio_dev *indio_dev,
474 const struct iio_chan_spec *chan,
475 enum iio_event_type type,
476 enum iio_event_direction dir,
477 enum iio_event_info info,
478 int val, int val2)
479{
480 struct hdc3020_data *data = iio_priv(indio_dev);
481 u16 reg, reg_val, reg_thresh_rd, reg_clr_rd, reg_thresh_wr, reg_clr_wr;
482 s64 s_thresh, s_hyst, s_clr;
483 int s_val, thresh, clr, ret;
484
485 /* Select threshold registers */
486 if (dir == IIO_EV_DIR_RISING) {
487 reg_thresh_rd = HDC3020_R_T_RH_THRESH_HIGH;
488 reg_thresh_wr = HDC3020_S_T_RH_THRESH_HIGH;
489 reg_clr_rd = HDC3020_R_T_RH_THRESH_HIGH_CLR;
490 reg_clr_wr = HDC3020_S_T_RH_THRESH_HIGH_CLR;
491 } else {
492 reg_thresh_rd = HDC3020_R_T_RH_THRESH_LOW;
493 reg_thresh_wr = HDC3020_S_T_RH_THRESH_LOW;
494 reg_clr_rd = HDC3020_R_T_RH_THRESH_LOW_CLR;
495 reg_clr_wr = HDC3020_S_T_RH_THRESH_LOW_CLR;
496 }
497
498 guard(mutex)(T: &data->lock);
499 ret = hdc3020_read_be16(data, reg: reg_thresh_rd);
500 if (ret < 0)
501 return ret;
502
503 thresh = ret;
504 ret = hdc3020_read_be16(data, reg: reg_clr_rd);
505 if (ret < 0)
506 return ret;
507
508 clr = ret;
509 /* Scale value to include decimal part into calculations */
510 s_val = (val < 0) ? (val * 1000000 - val2) : (val * 1000000 + val2);
511 switch (chan->type) {
512 case IIO_TEMP:
513 switch (info) {
514 case IIO_EV_INFO_VALUE:
515 s_val = max(s_val, HDC3020_MIN_TEMP_MICRO);
516 s_val = min(s_val, HDC3020_MAX_TEMP_MICRO);
517 reg = reg_thresh_wr;
518 reg_val = hdc3020_thresh_set_temp(s_temp: s_val, curr_thresh: thresh);
519 ret = _hdc3020_write_thresh(data, reg, val: reg_val);
520 if (ret < 0)
521 return ret;
522
523 /* Calculate old hysteresis */
524 s_thresh = (s64)hdc3020_thresh_get_temp(thresh) * 1000000;
525 s_clr = (s64)hdc3020_thresh_get_temp(thresh: clr) * 1000000;
526 s_hyst = div_s64(abs(s_thresh - s_clr), divisor: 65535);
527 /* Set new threshold */
528 thresh = reg_val;
529 /* Set old hysteresis */
530 s_val = s_hyst;
531 fallthrough;
532 case IIO_EV_INFO_HYSTERESIS:
533 /*
534 * Function hdc3020_thresh_get_temp returns temperature
535 * in degree celsius scaled by 65535. Scale by 1000000
536 * to be able to subtract scaled hysteresis value.
537 */
538 s_thresh = (s64)hdc3020_thresh_get_temp(thresh) * 1000000;
539 /*
540 * Units of s_val are in micro degree celsius, scale by
541 * 65535 to get same units as s_thresh.
542 */
543 s_val = min(abs(s_val), HDC3020_MAX_TEMP_HYST_MICRO);
544 s_hyst = (s64)s_val * 65535;
545 s_clr = hdc3020_thresh_clr(s_thresh, s_hyst, dir);
546 s_clr = max(s_clr, HDC3020_MIN_TEMP_MICRO);
547 s_clr = min(s_clr, HDC3020_MAX_TEMP_MICRO);
548 reg = reg_clr_wr;
549 reg_val = hdc3020_thresh_set_temp(s_temp: s_clr, curr_thresh: clr);
550 break;
551 default:
552 return -EOPNOTSUPP;
553 }
554 break;
555 case IIO_HUMIDITYRELATIVE:
556 s_val = (s_val < 0) ? 0 : min(s_val, HDC3020_MAX_HUM_MICRO);
557 switch (info) {
558 case IIO_EV_INFO_VALUE:
559 reg = reg_thresh_wr;
560 reg_val = hdc3020_thresh_set_hum(s_hum: s_val, curr_thresh: thresh);
561 ret = _hdc3020_write_thresh(data, reg, val: reg_val);
562 if (ret < 0)
563 return ret;
564
565 /* Calculate old hysteresis */
566 s_thresh = (s64)hdc3020_thresh_get_hum(thresh) * 1000000;
567 s_clr = (s64)hdc3020_thresh_get_hum(thresh: clr) * 1000000;
568 s_hyst = div_s64(abs(s_thresh - s_clr), divisor: 65535);
569 /* Set new threshold */
570 thresh = reg_val;
571 /* Try to set old hysteresis */
572 s_val = min(abs(s_hyst), HDC3020_MAX_HUM_MICRO);
573 fallthrough;
574 case IIO_EV_INFO_HYSTERESIS:
575 /*
576 * Function hdc3020_thresh_get_hum returns relative
577 * humidity in percent scaled by 65535. Scale by 1000000
578 * to be able to subtract scaled hysteresis value.
579 */
580 s_thresh = (s64)hdc3020_thresh_get_hum(thresh) * 1000000;
581 /*
582 * Units of s_val are in micro percent, scale by 65535
583 * to get same units as s_thresh.
584 */
585 s_hyst = (s64)s_val * 65535;
586 s_clr = hdc3020_thresh_clr(s_thresh, s_hyst, dir);
587 s_clr = max(s_clr, 0);
588 s_clr = min(s_clr, HDC3020_MAX_HUM_MICRO);
589 reg = reg_clr_wr;
590 reg_val = hdc3020_thresh_set_hum(s_hum: s_clr, curr_thresh: clr);
591 break;
592 default:
593 return -EOPNOTSUPP;
594 }
595 break;
596 default:
597 return -EOPNOTSUPP;
598 }
599
600 return _hdc3020_write_thresh(data, reg, val: reg_val);
601}
602
603static int hdc3020_read_thresh(struct iio_dev *indio_dev,
604 const struct iio_chan_spec *chan,
605 enum iio_event_type type,
606 enum iio_event_direction dir,
607 enum iio_event_info info,
608 int *val, int *val2)
609{
610 struct hdc3020_data *data = iio_priv(indio_dev);
611 u16 reg_thresh, reg_clr;
612 int thresh, clr, ret;
613
614 /* Select threshold registers */
615 if (dir == IIO_EV_DIR_RISING) {
616 reg_thresh = HDC3020_R_T_RH_THRESH_HIGH;
617 reg_clr = HDC3020_R_T_RH_THRESH_HIGH_CLR;
618 } else {
619 reg_thresh = HDC3020_R_T_RH_THRESH_LOW;
620 reg_clr = HDC3020_R_T_RH_THRESH_LOW_CLR;
621 }
622
623 guard(mutex)(T: &data->lock);
624 ret = hdc3020_read_be16(data, reg: reg_thresh);
625 if (ret < 0)
626 return ret;
627
628 switch (chan->type) {
629 case IIO_TEMP:
630 thresh = hdc3020_thresh_get_temp(thresh: ret);
631 switch (info) {
632 case IIO_EV_INFO_VALUE:
633 *val = thresh;
634 break;
635 case IIO_EV_INFO_HYSTERESIS:
636 ret = hdc3020_read_be16(data, reg: reg_clr);
637 if (ret < 0)
638 return ret;
639
640 clr = hdc3020_thresh_get_temp(thresh: ret);
641 *val = abs(thresh - clr);
642 break;
643 default:
644 return -EOPNOTSUPP;
645 }
646 *val2 = 65535;
647 return IIO_VAL_FRACTIONAL;
648 case IIO_HUMIDITYRELATIVE:
649 thresh = hdc3020_thresh_get_hum(thresh: ret);
650 switch (info) {
651 case IIO_EV_INFO_VALUE:
652 *val = thresh;
653 break;
654 case IIO_EV_INFO_HYSTERESIS:
655 ret = hdc3020_read_be16(data, reg: reg_clr);
656 if (ret < 0)
657 return ret;
658
659 clr = hdc3020_thresh_get_hum(thresh: ret);
660 *val = abs(thresh - clr);
661 break;
662 default:
663 return -EOPNOTSUPP;
664 }
665 *val2 = 65535;
666 return IIO_VAL_FRACTIONAL;
667 default:
668 return -EOPNOTSUPP;
669 }
670}
671
672static irqreturn_t hdc3020_interrupt_handler(int irq, void *private)
673{
674 struct iio_dev *indio_dev = private;
675 struct hdc3020_data *data;
676 s64 time;
677 int ret;
678
679 data = iio_priv(indio_dev);
680 ret = hdc3020_read_be16(data, HDC3020_R_STATUS);
681 if (ret < 0)
682 return IRQ_HANDLED;
683
684 if (!(ret & (HDC3020_STATUS_T_HIGH_ALERT | HDC3020_STATUS_T_LOW_ALERT |
685 HDC3020_STATUS_RH_HIGH_ALERT | HDC3020_STATUS_RH_LOW_ALERT)))
686 return IRQ_NONE;
687
688 time = iio_get_time_ns(indio_dev);
689 if (ret & HDC3020_STATUS_T_HIGH_ALERT)
690 iio_push_event(indio_dev,
691 IIO_MOD_EVENT_CODE(IIO_TEMP, 0,
692 IIO_NO_MOD,
693 IIO_EV_TYPE_THRESH,
694 IIO_EV_DIR_RISING),
695 timestamp: time);
696
697 if (ret & HDC3020_STATUS_T_LOW_ALERT)
698 iio_push_event(indio_dev,
699 IIO_MOD_EVENT_CODE(IIO_TEMP, 0,
700 IIO_NO_MOD,
701 IIO_EV_TYPE_THRESH,
702 IIO_EV_DIR_FALLING),
703 timestamp: time);
704
705 if (ret & HDC3020_STATUS_RH_HIGH_ALERT)
706 iio_push_event(indio_dev,
707 IIO_MOD_EVENT_CODE(IIO_HUMIDITYRELATIVE, 0,
708 IIO_NO_MOD,
709 IIO_EV_TYPE_THRESH,
710 IIO_EV_DIR_RISING),
711 timestamp: time);
712
713 if (ret & HDC3020_STATUS_RH_LOW_ALERT)
714 iio_push_event(indio_dev,
715 IIO_MOD_EVENT_CODE(IIO_HUMIDITYRELATIVE, 0,
716 IIO_NO_MOD,
717 IIO_EV_TYPE_THRESH,
718 IIO_EV_DIR_FALLING),
719 timestamp: time);
720
721 return IRQ_HANDLED;
722}
723
724static const struct iio_info hdc3020_info = {
725 .read_raw = hdc3020_read_raw,
726 .write_raw = hdc3020_write_raw,
727 .read_avail = hdc3020_read_available,
728 .read_event_value = hdc3020_read_thresh,
729 .write_event_value = hdc3020_write_thresh,
730};
731
732static int hdc3020_power_off(struct hdc3020_data *data)
733{
734 hdc3020_exec_cmd(data, HDC3020_EXIT_AUTO);
735
736 if (data->reset_gpio)
737 gpiod_set_value_cansleep(desc: data->reset_gpio, value: 1);
738
739 return regulator_disable(regulator: data->vdd_supply);
740}
741
742static int hdc3020_power_on(struct hdc3020_data *data)
743{
744 int ret;
745
746 ret = regulator_enable(regulator: data->vdd_supply);
747 if (ret)
748 return ret;
749
750 fsleep(usecs: 5000);
751
752 if (data->reset_gpio) {
753 gpiod_set_value_cansleep(desc: data->reset_gpio, value: 0);
754 fsleep(usecs: 3000);
755 }
756
757 if (data->client->irq) {
758 /*
759 * The alert output is activated by default upon power up,
760 * hardware reset, and soft reset. Clear the status register.
761 */
762 ret = hdc3020_exec_cmd(data, HDC3020_S_STATUS);
763 if (ret) {
764 hdc3020_power_off(data);
765 return ret;
766 }
767 }
768
769 ret = hdc3020_exec_cmd(data, HDC3020_S_AUTO_10HZ_MOD0);
770 if (ret)
771 hdc3020_power_off(data);
772
773 return ret;
774}
775
776static void hdc3020_exit(void *data)
777{
778 hdc3020_power_off(data);
779}
780
781static int hdc3020_probe(struct i2c_client *client)
782{
783 struct iio_dev *indio_dev;
784 struct hdc3020_data *data;
785 int ret;
786
787 if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C))
788 return -EOPNOTSUPP;
789
790 indio_dev = devm_iio_device_alloc(parent: &client->dev, sizeof_priv: sizeof(*data));
791 if (!indio_dev)
792 return -ENOMEM;
793
794 dev_set_drvdata(dev: &client->dev, data: indio_dev);
795
796 data = iio_priv(indio_dev);
797 data->client = client;
798 mutex_init(&data->lock);
799
800 crc8_populate_msb(table: hdc3020_crc8_table, HDC3020_CRC8_POLYNOMIAL);
801
802 indio_dev->name = "hdc3020";
803 indio_dev->modes = INDIO_DIRECT_MODE;
804 indio_dev->info = &hdc3020_info;
805 indio_dev->channels = hdc3020_channels;
806 indio_dev->num_channels = ARRAY_SIZE(hdc3020_channels);
807
808 data->vdd_supply = devm_regulator_get(dev: &client->dev, id: "vdd");
809 if (IS_ERR(ptr: data->vdd_supply))
810 return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: data->vdd_supply),
811 fmt: "Unable to get VDD regulator\n");
812
813 data->reset_gpio = devm_gpiod_get_optional(dev: &client->dev, con_id: "reset",
814 flags: GPIOD_OUT_HIGH);
815 if (IS_ERR(ptr: data->reset_gpio))
816 return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: data->reset_gpio),
817 fmt: "Cannot get reset GPIO\n");
818
819 ret = hdc3020_power_on(data);
820 if (ret)
821 return dev_err_probe(dev: &client->dev, err: ret, fmt: "Power on failed\n");
822
823 ret = devm_add_action_or_reset(&data->client->dev, hdc3020_exit, data);
824 if (ret)
825 return ret;
826
827 if (client->irq) {
828 ret = devm_request_threaded_irq(dev: &client->dev, irq: client->irq,
829 NULL, thread_fn: hdc3020_interrupt_handler,
830 IRQF_ONESHOT, devname: "hdc3020",
831 dev_id: indio_dev);
832 if (ret)
833 return dev_err_probe(dev: &client->dev, err: ret,
834 fmt: "Failed to request IRQ\n");
835 }
836
837 ret = devm_iio_device_register(&data->client->dev, indio_dev);
838 if (ret)
839 return dev_err_probe(dev: &client->dev, err: ret, fmt: "Failed to add device");
840
841 return 0;
842}
843
844static int hdc3020_suspend(struct device *dev)
845{
846 struct iio_dev *iio_dev = dev_get_drvdata(dev);
847 struct hdc3020_data *data = iio_priv(indio_dev: iio_dev);
848
849 return hdc3020_power_off(data);
850}
851
852static int hdc3020_resume(struct device *dev)
853{
854 struct iio_dev *iio_dev = dev_get_drvdata(dev);
855 struct hdc3020_data *data = iio_priv(indio_dev: iio_dev);
856
857 return hdc3020_power_on(data);
858}
859
860static DEFINE_SIMPLE_DEV_PM_OPS(hdc3020_pm_ops, hdc3020_suspend, hdc3020_resume);
861
862static const struct i2c_device_id hdc3020_id[] = {
863 { "hdc3020" },
864 { "hdc3021" },
865 { "hdc3022" },
866 { }
867};
868MODULE_DEVICE_TABLE(i2c, hdc3020_id);
869
870static const struct of_device_id hdc3020_dt_ids[] = {
871 { .compatible = "ti,hdc3020" },
872 { .compatible = "ti,hdc3021" },
873 { .compatible = "ti,hdc3022" },
874 { }
875};
876MODULE_DEVICE_TABLE(of, hdc3020_dt_ids);
877
878static struct i2c_driver hdc3020_driver = {
879 .driver = {
880 .name = "hdc3020",
881 .pm = pm_sleep_ptr(&hdc3020_pm_ops),
882 .of_match_table = hdc3020_dt_ids,
883 },
884 .probe = hdc3020_probe,
885 .id_table = hdc3020_id,
886};
887module_i2c_driver(hdc3020_driver);
888
889MODULE_AUTHOR("Javier Carrasco <javier.carrasco.cruz@gmail.com>");
890MODULE_AUTHOR("Li peiyu <579lpy@gmail.com>");
891MODULE_DESCRIPTION("TI HDC3020 humidity and temperature sensor driver");
892MODULE_LICENSE("GPL");
893

source code of linux/drivers/iio/humidity/hdc3020.c