drivers/iio/humidity/hdc3020.c

   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
  75 struct 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
  88 static const int hdc3020_heater_vals[] = {0, 1, 0x3FFF};
  89
  90 static 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
 105 static 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
 135 DECLARE_CRC8_TABLE(hdc3020_crc8_table);
 136
 137 static 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(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
 164 static
 165 int 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 again
 189          */
 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
 202 static 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
 218 static 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
 226 static 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         else
 251                 return -EINVAL;
 252
 253         return 0;
 254 }
 255
 256 static 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                 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)(&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
 321 static 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
 335 static 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
 356 static 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
 374 static 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
 390 static 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
 406 static 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(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
 425 static 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(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
 443 static
 444 int 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(s_clr, 65535);
 460 }
 461
 462 static 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
 473 static 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 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_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 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_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
 603 static 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
 672 static 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
 724 static 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
 732 static 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
 742 static 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
 776 static void hdc3020_exit(void *data)
 777 {
 778         hdc3020_power_off(data);
 779 }
 780
 781 static 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
 844 static 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
 852 static 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
 860 static DEFINE_SIMPLE_DEV_PM_OPS(hdc3020_pm_ops, hdc3020_suspend, hdc3020_resume);
 861
 862 static const struct i2c_device_id hdc3020_id[] = {
 863         { "hdc3020" },
 864         { "hdc3021" },
 865         { "hdc3022" },
 866         { }
 867 };
 868 MODULE_DEVICE_TABLE(i2c, hdc3020_id);
 869
 870 static const struct of_device_id hdc3020_dt_ids[] = {
 871         { .compatible = "ti,hdc3020" },
 872         { .compatible = "ti,hdc3021" },
 873         { .compatible = "ti,hdc3022" },
 874         { }
 875 };
 876 MODULE_DEVICE_TABLE(of, hdc3020_dt_ids);
 877
 878 static 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 };
 887 module_i2c_driver(hdc3020_driver);
 888
 889 MODULE_AUTHOR("Javier Carrasco <javier.carrasco.cruz@gmail.com>");
 890 MODULE_AUTHOR("Li peiyu <579lpy@gmail.com>");
 891 MODULE_DESCRIPTION("TI HDC3020 humidity and temperature sensor driver");
 892 MODULE_LICENSE("GPL");