893 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/*3 * hdc3020.c - Support for the TI HDC3020,HDC3021 and HDC30224 * temperature + relative humidity sensors5 *6 * Copyright (C) 20237 *8 * Copyright (C) 2024 Liebherr-Electronics and Drives GmbH9 *10 * Datasheet: https://www.ti.com/lit/ds/symlink/hdc3020.pdf11 */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 0x273735#define HDC3020_S_STATUS 0x304136#define HDC3020_HEATER_DISABLE 0x306637#define HDC3020_HEATER_ENABLE 0x306D38#define HDC3020_HEATER_CONFIG 0x306E39#define HDC3020_EXIT_AUTO 0x309340#define HDC3020_S_T_RH_THRESH_LOW 0x610041#define HDC3020_S_T_RH_THRESH_LOW_CLR 0x610B42#define HDC3020_S_T_RH_THRESH_HIGH_CLR 0x611643#define HDC3020_S_T_RH_THRESH_HIGH 0x611D44#define HDC3020_R_T_RH_AUTO 0xE00045#define HDC3020_R_T_LOW_AUTO 0xE00246#define HDC3020_R_T_HIGH_AUTO 0xE00347#define HDC3020_R_RH_LOW_AUTO 0xE00448#define HDC3020_R_RH_HIGH_AUTO 0xE00549#define HDC3020_R_T_RH_THRESH_LOW 0xE10250#define HDC3020_R_T_RH_THRESH_LOW_CLR 0xE10951#define HDC3020_R_T_RH_THRESH_HIGH_CLR 0xE11452#define HDC3020_R_T_RH_THRESH_HIGH 0xE11F53#define HDC3020_R_STATUS 0xF32D54 55#define HDC3020_THRESH_TEMP_MASK GENMASK(8, 0)56#define HDC3020_THRESH_TEMP_TRUNC_SHIFT 757#define HDC3020_THRESH_HUM_MASK GENMASK(15, 9)58#define HDC3020_THRESH_HUM_TRUNC_SHIFT 959 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 1066#define HDC3020_BUSY_DELAY_MS 1067 68#define HDC3020_CRC8_POLYNOMIAL 0x3169 70#define HDC3020_MIN_TEMP_MICRO -3987296871#define HDC3020_MAX_TEMP_MICRO 12487563972#define HDC3020_MAX_TEMP_HYST_MICRO 16474860773#define HDC3020_MAX_HUM_MICRO 9922026474 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 is81 * supported) will not be changed during the process of reading82 * sensor data (this driver will try HDC3020_READ_RETRY_TIMES times83 * 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 to125 * prevent or remove any condensation that may develop when the126 * 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 again151 */152 for (cnt = 0; cnt < HDC3020_READ_RETRY_TIMES; cnt++) {153 ret = i2c_transfer(client->adapter, &msg, 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 164static165int 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(reg, reg_buf);186 /*187 * During the measurement process, HDC3020 will not return data.188 * So wait for a while and try again189 */190 for (cnt = 0; cnt < HDC3020_READ_RETRY_TIMES; cnt++) {191 ret = i2c_transfer(client->adapter, msg, 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, 3);208 if (ret < 0)209 return ret;210 211 crc = crc8(hdc3020_crc8_table, buf, 2, CRC8_INIT_VALUE);212 if (crc != buf[2])213 return -EINVAL;214 215 return get_unaligned_be16(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(reg, reg_buf);223 return hdc3020_write_bytes(data, reg_buf, 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, 6);233 if (ret < 0)234 return ret;235 236 /* CRC check of the temperature measurement */237 crc = crc8(hdc3020_crc8_table, buf, 2, CRC8_INIT_VALUE);238 if (crc != buf[2])239 return -EINVAL;240 241 /* CRC check of the relative humidity measurement */242 crc = crc8(hdc3020_crc8_table, buf + 3, 2, CRC8_INIT_VALUE);243 if (crc != buf[5])244 return -EINVAL;245 246 if (type == IIO_TEMP)247 *val = get_unaligned_be16(buf);248 else if (type == IIO_HUMIDITYRELATIVE)249 *val = get_unaligned_be16(&buf[3]);250 else251 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)(&data->lock);269 ret = hdc3020_read_measurement(data, 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)(&data->lock);277 if (chan->type == IIO_TEMP)278 ret = hdc3020_read_be16(data, HDC3020_R_T_HIGH_AUTO);279 else280 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)(&data->lock);290 if (chan->type == IIO_TEMP)291 ret = hdc3020_read_be16(data, HDC3020_R_T_LOW_AUTO);292 else293 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 else306 *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, buf);347 put_unaligned_be16(val & GENMASK(13, 0), &buf[2]);348 buf[4] = crc8(hdc3020_crc8_table, buf + 2, 2, CRC8_INIT_VALUE);349 ret = hdc3020_write_bytes(data, buf, 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)(&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 get380 * the truncated temperature threshold representation and381 * calculate the threshold according to the formula in the382 * 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 the396 * truncated humidity threshold representation and calculate the397 * threshold according to the formula in the datasheet. Result is398 * 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 the413 * truncated threshold representation in the 9LSBs while keeping414 * the current humidity threshold in the 7 MSBs.415 */416 temp = (u64)(s_temp + 45000000) * 65535ULL;417 temp = div_u64(temp, 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 the432 * truncated threshold representation in the 7MSBs while keeping433 * the current temperature threshold in the 9 LSBs.434 */435 hum = (u64)(s_hum) * 65535ULL;436 hum = div_u64(hum, 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 443static444int 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 the451 * 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 else456 s_clr = s_thresh + s_hyst;457 458 /* Divide by 65535 to get units of micro */459 return div_s64(s_clr, 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(reg, buf);467 put_unaligned_be16(val, buf + 2);468 buf[4] = crc8(hdc3020_crc8_table, buf + 2, 2, CRC8_INIT_VALUE);469 470 return hdc3020_write_bytes(data, buf, 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)(&data->lock);499 ret = hdc3020_read_be16(data, reg_thresh_rd);500 if (ret < 0)501 return ret;502 503 thresh = ret;504 ret = hdc3020_read_be16(data, 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_val, thresh);519 ret = _hdc3020_write_thresh(data, reg, 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(clr) * 1000000;526 s_hyst = div_s64(abs(s_thresh - s_clr), 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 temperature535 * in degree celsius scaled by 65535. Scale by 1000000536 * 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 by541 * 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_clr, 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_val, thresh);561 ret = _hdc3020_write_thresh(data, reg, 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(clr) * 1000000;568 s_hyst = div_s64(abs(s_thresh - s_clr), 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 relative577 * humidity in percent scaled by 65535. Scale by 1000000578 * 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 65535583 * 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_clr, 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, 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)(&data->lock);624 ret = hdc3020_read_be16(data, reg_thresh);625 if (ret < 0)626 return ret;627 628 switch (chan->type) {629 case IIO_TEMP:630 thresh = hdc3020_thresh_get_temp(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_clr);637 if (ret < 0)638 return ret;639 640 clr = hdc3020_thresh_get_temp(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(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_clr);656 if (ret < 0)657 return ret;658 659 clr = hdc3020_thresh_get_hum(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 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 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 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 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(data->reset_gpio, 1);738 739 return regulator_disable(data->vdd_supply);740}741 742static int hdc3020_power_on(struct hdc3020_data *data)743{744 int ret;745 746 ret = regulator_enable(data->vdd_supply);747 if (ret)748 return ret;749 750 fsleep(5000);751 752 if (data->reset_gpio) {753 gpiod_set_value_cansleep(data->reset_gpio, 0);754 fsleep(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(client->adapter, I2C_FUNC_I2C))788 return -EOPNOTSUPP;789 790 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));791 if (!indio_dev)792 return -ENOMEM;793 794 dev_set_drvdata(&client->dev, indio_dev);795 796 data = iio_priv(indio_dev);797 data->client = client;798 mutex_init(&data->lock);799 800 crc8_populate_msb(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(&client->dev, "vdd");809 if (IS_ERR(data->vdd_supply))810 return dev_err_probe(&client->dev, PTR_ERR(data->vdd_supply),811 "Unable to get VDD regulator\n");812 813 data->reset_gpio = devm_gpiod_get_optional(&client->dev, "reset",814 GPIOD_OUT_HIGH);815 if (IS_ERR(data->reset_gpio))816 return dev_err_probe(&client->dev, PTR_ERR(data->reset_gpio),817 "Cannot get reset GPIO\n");818 819 ret = hdc3020_power_on(data);820 if (ret)821 return dev_err_probe(&client->dev, ret, "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(&client->dev, client->irq,829 NULL, hdc3020_interrupt_handler,830 IRQF_ONESHOT, "hdc3020",831 indio_dev);832 if (ret)833 return dev_err_probe(&client->dev, ret,834 "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(&client->dev, ret, "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(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(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