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  * Datasheet: https://www.ti.com/lit/ds/symlink/hdc3020.pdf
   9  */
  10
  11 #include <linux/bitops.h>
  12 #include <linux/cleanup.h>
  13 #include <linux/crc8.h>
  14 #include <linux/delay.h>
  15 #include <linux/i2c.h>
  16 #include <linux/init.h>
  17 #include <linux/module.h>
  18 #include <linux/mutex.h>
  19
  20 #include <asm/unaligned.h>
  21
  22 #include <linux/iio/iio.h>
  23
  24 #define HDC3020_HEATER_CMD_MSB          0x30 /* shared by all heater commands */
  25 #define HDC3020_HEATER_ENABLE           0x6D
  26 #define HDC3020_HEATER_DISABLE          0x66
  27 #define HDC3020_HEATER_CONFIG           0x6E
  28
  29 #define HDC3020_READ_RETRY_TIMES        10
  30 #define HDC3020_BUSY_DELAY_MS           10
  31
  32 #define HDC3020_CRC8_POLYNOMIAL         0x31
  33
  34 static const u8 HDC3020_S_AUTO_10HZ_MOD0[2] = { 0x27, 0x37 };
  35
  36 static const u8 HDC3020_EXIT_AUTO[2] = { 0x30, 0x93 };
  37
  38 static const u8 HDC3020_R_T_RH_AUTO[2] = { 0xE0, 0x00 };
  39 static const u8 HDC3020_R_T_LOW_AUTO[2] = { 0xE0, 0x02 };
  40 static const u8 HDC3020_R_T_HIGH_AUTO[2] = { 0xE0, 0x03 };
  41 static const u8 HDC3020_R_RH_LOW_AUTO[2] = { 0xE0, 0x04 };
  42 static const u8 HDC3020_R_RH_HIGH_AUTO[2] = { 0xE0, 0x05 };
  43
  44 struct hdc3020_data {
  45         struct i2c_client *client;
  46         /*
  47          * Ensure that the sensor configuration (currently only heater is
  48          * supported) will not be changed during the process of reading
  49          * sensor data (this driver will try HDC3020_READ_RETRY_TIMES times
  50          * if the device does not respond).
  51          */
  52         struct mutex lock;
  53 };
  54
  55 static const int hdc3020_heater_vals[] = {0, 1, 0x3FFF};
  56
  57 static const struct iio_chan_spec hdc3020_channels[] = {
  58         {
  59                 .type = IIO_TEMP,
  60                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  61                 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_PEAK) |
  62                 BIT(IIO_CHAN_INFO_TROUGH) | BIT(IIO_CHAN_INFO_OFFSET),
  63         },
  64         {
  65                 .type = IIO_HUMIDITYRELATIVE,
  66                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  67                 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_PEAK) |
  68                 BIT(IIO_CHAN_INFO_TROUGH),
  69         },
  70         {
  71                 /*
  72                  * For setting the internal heater, which can be switched on to
  73                  * prevent or remove any condensation that may develop when the
  74                  * ambient environment approaches its dew point temperature.
  75                  */
  76                 .type = IIO_CURRENT,
  77                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  78                 .info_mask_separate_available = BIT(IIO_CHAN_INFO_RAW),
  79                 .output = 1,
  80         },
  81 };
  82
  83 DECLARE_CRC8_TABLE(hdc3020_crc8_table);
  84
  85 static int hdc3020_write_bytes(struct hdc3020_data *data, const u8 *buf, u8 len)
  86 {
  87         struct i2c_client *client = data->client;
  88         struct i2c_msg msg;
  89         int ret, cnt;
  90
  91         msg.addr = client->addr;
  92         msg.flags = 0;
  93         msg.buf = (char *)buf;
  94         msg.len = len;
  95
  96         /*
  97          * During the measurement process, HDC3020 will not return data.
  98          * So wait for a while and try again
  99          */
 100         for (cnt = 0; cnt < HDC3020_READ_RETRY_TIMES; cnt++) {
 101                 ret = i2c_transfer(client->adapter, &msg, 1);
 102                 if (ret == 1)
 103                         return 0;
 104
 105                 mdelay(HDC3020_BUSY_DELAY_MS);
 106         }
 107         dev_err(&client->dev, "Could not write sensor command\n");
 108
 109         return -ETIMEDOUT;
 110 }
 111
 112 static int hdc3020_read_bytes(struct hdc3020_data *data, const u8 *buf,
 113                               void *val, int len)
 114 {
 115         int ret, cnt;
 116         struct i2c_client *client = data->client;
 117         struct i2c_msg msg[2] = {
 118                 [0] = {
 119                         .addr = client->addr,
 120                         .flags = 0,
 121                         .buf = (char *)buf,
 122                         .len = 2,
 123                 },
 124                 [1] = {
 125                         .addr = client->addr,
 126                         .flags = I2C_M_RD,
 127                         .buf = val,
 128                         .len = len,
 129                 },
 130         };
 131
 132         /*
 133          * During the measurement process, HDC3020 will not return data.
 134          * So wait for a while and try again
 135          */
 136         for (cnt = 0; cnt < HDC3020_READ_RETRY_TIMES; cnt++) {
 137                 ret = i2c_transfer(client->adapter, msg, 2);
 138                 if (ret == 2)
 139                         return 0;
 140
 141                 mdelay(HDC3020_BUSY_DELAY_MS);
 142         }
 143         dev_err(&client->dev, "Could not read sensor data\n");
 144
 145         return -ETIMEDOUT;
 146 }
 147
 148 static int hdc3020_read_measurement(struct hdc3020_data *data,
 149                                     enum iio_chan_type type, int *val)
 150 {
 151         u8 crc, buf[6];
 152         int ret;
 153
 154         ret = hdc3020_read_bytes(data, HDC3020_R_T_RH_AUTO, buf, 6);
 155         if (ret < 0)
 156                 return ret;
 157
 158         /* CRC check of the temperature measurement */
 159         crc = crc8(hdc3020_crc8_table, buf, 2, CRC8_INIT_VALUE);
 160         if (crc != buf[2])
 161                 return -EINVAL;
 162
 163         /* CRC check of the relative humidity measurement */
 164         crc = crc8(hdc3020_crc8_table, buf + 3, 2, CRC8_INIT_VALUE);
 165         if (crc != buf[5])
 166                 return -EINVAL;
 167
 168         if (type == IIO_TEMP)
 169                 *val = get_unaligned_be16(buf);
 170         else if (type == IIO_HUMIDITYRELATIVE)
 171                 *val = get_unaligned_be16(&buf[3]);
 172         else
 173                 return -EINVAL;
 174
 175         return 0;
 176 }
 177
 178 /*
 179  * After exiting the automatic measurement mode or resetting, the peak
 180  * value will be reset to the default value
 181  * This method is used to get the highest temp measured during automatic
 182  * measurement
 183  */
 184 static int hdc3020_read_high_peak_t(struct hdc3020_data *data, int *val)
 185 {
 186         u8 crc, buf[3];
 187         int ret;
 188
 189         ret = hdc3020_read_bytes(data, HDC3020_R_T_HIGH_AUTO, buf, 3);
 190         if (ret < 0)
 191                 return ret;
 192
 193         crc = crc8(hdc3020_crc8_table, buf, 2, CRC8_INIT_VALUE);
 194         if (crc != buf[2])
 195                 return -EINVAL;
 196
 197         *val = get_unaligned_be16(buf);
 198
 199         return 0;
 200 }
 201
 202 /*
 203  * This method is used to get the lowest temp measured during automatic
 204  * measurement
 205  */
 206 static int hdc3020_read_low_peak_t(struct hdc3020_data *data, int *val)
 207 {
 208         u8 crc, buf[3];
 209         int ret;
 210
 211         ret = hdc3020_read_bytes(data, HDC3020_R_T_LOW_AUTO, buf, 3);
 212         if (ret < 0)
 213                 return ret;
 214
 215         crc = crc8(hdc3020_crc8_table, buf, 2, CRC8_INIT_VALUE);
 216         if (crc != buf[2])
 217                 return -EINVAL;
 218
 219         *val = get_unaligned_be16(buf);
 220
 221         return 0;
 222 }
 223
 224 /*
 225  * This method is used to get the highest humidity measured during automatic
 226  * measurement
 227  */
 228 static int hdc3020_read_high_peak_rh(struct hdc3020_data *data, int *val)
 229 {
 230         u8 crc, buf[3];
 231         int ret;
 232
 233         ret = hdc3020_read_bytes(data, HDC3020_R_RH_HIGH_AUTO, buf, 3);
 234         if (ret < 0)
 235                 return ret;
 236
 237         crc = crc8(hdc3020_crc8_table, buf, 2, CRC8_INIT_VALUE);
 238         if (crc != buf[2])
 239                 return -EINVAL;
 240
 241         *val = get_unaligned_be16(buf);
 242
 243         return 0;
 244 }
 245
 246 /*
 247  * This method is used to get the lowest humidity measured during automatic
 248  * measurement
 249  */
 250 static int hdc3020_read_low_peak_rh(struct hdc3020_data *data, int *val)
 251 {
 252         u8 crc, buf[3];
 253         int ret;
 254
 255         ret = hdc3020_read_bytes(data, HDC3020_R_RH_LOW_AUTO, buf, 3);
 256         if (ret < 0)
 257                 return ret;
 258
 259         crc = crc8(hdc3020_crc8_table, buf, 2, CRC8_INIT_VALUE);
 260         if (crc != buf[2])
 261                 return -EINVAL;
 262
 263         *val = get_unaligned_be16(buf);
 264
 265         return 0;
 266 }
 267
 268 static int hdc3020_read_raw(struct iio_dev *indio_dev,
 269                             struct iio_chan_spec const *chan, int *val,
 270                             int *val2, long mask)
 271 {
 272         struct hdc3020_data *data = iio_priv(indio_dev);
 273         int ret;
 274
 275         if (chan->type != IIO_TEMP && chan->type != IIO_HUMIDITYRELATIVE)
 276                 return -EINVAL;
 277
 278         switch (mask) {
 279         case IIO_CHAN_INFO_RAW: {
 280                 guard(mutex)(&data->lock);
 281                 ret = hdc3020_read_measurement(data, chan->type, val);
 282                 if (ret < 0)
 283                         return ret;
 284
 285                 return IIO_VAL_INT;
 286         }
 287         case IIO_CHAN_INFO_PEAK: {
 288                 guard(mutex)(&data->lock);
 289                 if (chan->type == IIO_TEMP) {
 290                         ret = hdc3020_read_high_peak_t(data, val);
 291                         if (ret < 0)
 292                                 return ret;
 293                 } else {
 294                         ret = hdc3020_read_high_peak_rh(data, val);
 295                         if (ret < 0)
 296                                 return ret;
 297                 }
 298                 return IIO_VAL_INT;
 299         }
 300         case IIO_CHAN_INFO_TROUGH: {
 301                 guard(mutex)(&data->lock);
 302                 if (chan->type == IIO_TEMP) {
 303                         ret = hdc3020_read_low_peak_t(data, val);
 304                         if (ret < 0)
 305                                 return ret;
 306                 } else {
 307                         ret = hdc3020_read_low_peak_rh(data, val);
 308                         if (ret < 0)
 309                                 return ret;
 310                 }
 311                 return IIO_VAL_INT;
 312         }
 313         case IIO_CHAN_INFO_SCALE:
 314                 *val2 = 65536;
 315                 if (chan->type == IIO_TEMP)
 316                         *val = 175;
 317                 else
 318                         *val = 100;
 319                 return IIO_VAL_FRACTIONAL;
 320
 321         case IIO_CHAN_INFO_OFFSET:
 322                 if (chan->type != IIO_TEMP)
 323                         return -EINVAL;
 324
 325                 *val = 16852;
 326                 return IIO_VAL_INT;
 327
 328         default:
 329                 return -EINVAL;
 330         }
 331 }
 332
 333 static int hdc3020_read_available(struct iio_dev *indio_dev,
 334                                   struct iio_chan_spec const *chan,
 335                                   const int **vals,
 336                                   int *type, int *length, long mask)
 337 {
 338         if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_CURRENT)
 339                 return -EINVAL;
 340
 341         *vals = hdc3020_heater_vals;
 342         *type = IIO_VAL_INT;
 343
 344         return IIO_AVAIL_RANGE;
 345 }
 346
 347 static int hdc3020_update_heater(struct hdc3020_data *data, int val)
 348 {
 349         u8 buf[5];
 350         int ret;
 351
 352         if (val < hdc3020_heater_vals[0] || val > hdc3020_heater_vals[2])
 353                 return -EINVAL;
 354
 355         buf[0] = HDC3020_HEATER_CMD_MSB;
 356
 357         if (!val) {
 358                 buf[1] = HDC3020_HEATER_DISABLE;
 359                 return hdc3020_write_bytes(data, buf, 2);
 360         }
 361
 362         buf[1] = HDC3020_HEATER_CONFIG;
 363         put_unaligned_be16(val & GENMASK(13, 0), &buf[2]);
 364         buf[4] = crc8(hdc3020_crc8_table, buf + 2, 2, CRC8_INIT_VALUE);
 365         ret = hdc3020_write_bytes(data, buf, 5);
 366         if (ret < 0)
 367                 return ret;
 368
 369         buf[1] = HDC3020_HEATER_ENABLE;
 370
 371         return hdc3020_write_bytes(data, buf, 2);
 372 }
 373
 374 static int hdc3020_write_raw(struct iio_dev *indio_dev,
 375                              struct iio_chan_spec const *chan,
 376                              int val, int val2, long mask)
 377 {
 378         struct hdc3020_data *data = iio_priv(indio_dev);
 379
 380         switch (mask) {
 381         case IIO_CHAN_INFO_RAW:
 382                 if (chan->type != IIO_CURRENT)
 383                         return -EINVAL;
 384
 385                 guard(mutex)(&data->lock);
 386                 return hdc3020_update_heater(data, val);
 387         }
 388
 389         return -EINVAL;
 390 }
 391
 392 static const struct iio_info hdc3020_info = {
 393         .read_raw = hdc3020_read_raw,
 394         .write_raw = hdc3020_write_raw,
 395         .read_avail = hdc3020_read_available,
 396 };
 397
 398 static void hdc3020_stop(void *data)
 399 {
 400         hdc3020_write_bytes((struct hdc3020_data *)data, HDC3020_EXIT_AUTO, 2);
 401 }
 402
 403 static int hdc3020_probe(struct i2c_client *client)
 404 {
 405         struct iio_dev *indio_dev;
 406         struct hdc3020_data *data;
 407         int ret;
 408
 409         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 410                 return -EOPNOTSUPP;
 411
 412         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 413         if (!indio_dev)
 414                 return -ENOMEM;
 415
 416         data = iio_priv(indio_dev);
 417         data->client = client;
 418         mutex_init(&data->lock);
 419
 420         crc8_populate_msb(hdc3020_crc8_table, HDC3020_CRC8_POLYNOMIAL);
 421
 422         indio_dev->name = "hdc3020";
 423         indio_dev->modes = INDIO_DIRECT_MODE;
 424         indio_dev->info = &hdc3020_info;
 425         indio_dev->channels = hdc3020_channels;
 426         indio_dev->num_channels = ARRAY_SIZE(hdc3020_channels);
 427
 428         ret = hdc3020_write_bytes(data, HDC3020_S_AUTO_10HZ_MOD0, 2);
 429         if (ret)
 430                 return dev_err_probe(&client->dev, ret,
 431                                      "Unable to set up measurement\n");
 432
 433         ret = devm_add_action_or_reset(&data->client->dev, hdc3020_stop, data);
 434         if (ret)
 435                 return ret;
 436
 437         ret = devm_iio_device_register(&data->client->dev, indio_dev);
 438         if (ret)
 439                 return dev_err_probe(&client->dev, ret, "Failed to add device");
 440
 441         return 0;
 442 }
 443
 444 static const struct i2c_device_id hdc3020_id[] = {
 445         { "hdc3020" },
 446         { "hdc3021" },
 447         { "hdc3022" },
 448         { }
 449 };
 450 MODULE_DEVICE_TABLE(i2c, hdc3020_id);
 451
 452 static const struct of_device_id hdc3020_dt_ids[] = {
 453         { .compatible = "ti,hdc3020" },
 454         { .compatible = "ti,hdc3021" },
 455         { .compatible = "ti,hdc3022" },
 456         { }
 457 };
 458 MODULE_DEVICE_TABLE(of, hdc3020_dt_ids);
 459
 460 static struct i2c_driver hdc3020_driver = {
 461         .driver = {
 462                 .name = "hdc3020",
 463                 .of_match_table = hdc3020_dt_ids,
 464         },
 465         .probe = hdc3020_probe,
 466         .id_table = hdc3020_id,
 467 };
 468 module_i2c_driver(hdc3020_driver);
 469
 470 MODULE_AUTHOR("Javier Carrasco <javier.carrasco.cruz@gmail.com>");
 471 MODULE_AUTHOR("Li peiyu <579lpy@gmail.com>");
 472 MODULE_DESCRIPTION("TI HDC3020 humidity and temperature sensor driver");
 473 MODULE_LICENSE("GPL");