1 /* Sensirion SHT3x-DIS humidity and temperature sensor driver. 2 * The SHT3x comes in many different versions, this driver is for the 3 * I2C version only. 4 * 5 * Copyright (C) 2016 Sensirion AG, Switzerland 6 * Author: David Frey <david.frey@sensirion.com> 7 * Author: Pascal Sachs <pascal.sachs@sensirion.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 */ 20 21 #include <asm/page.h> 22 #include <linux/crc8.h> 23 #include <linux/delay.h> 24 #include <linux/err.h> 25 #include <linux/hwmon.h> 26 #include <linux/hwmon-sysfs.h> 27 #include <linux/i2c.h> 28 #include <linux/init.h> 29 #include <linux/kernel.h> 30 #include <linux/module.h> 31 #include <linux/slab.h> 32 #include <linux/jiffies.h> 33 #include <linux/platform_data/sht3x.h> 34 35 /* commands (high precision mode) */ 36 static const unsigned char sht3x_cmd_measure_blocking_hpm[] = { 0x2c, 0x06 }; 37 static const unsigned char sht3x_cmd_measure_nonblocking_hpm[] = { 0x24, 0x00 }; 38 39 /* commands (low power mode) */ 40 static const unsigned char sht3x_cmd_measure_blocking_lpm[] = { 0x2c, 0x10 }; 41 static const unsigned char sht3x_cmd_measure_nonblocking_lpm[] = { 0x24, 0x16 }; 42 43 /* commands for periodic mode */ 44 static const unsigned char sht3x_cmd_measure_periodic_mode[] = { 0xe0, 0x00 }; 45 static const unsigned char sht3x_cmd_break[] = { 0x30, 0x93 }; 46 47 /* commands for heater control */ 48 static const unsigned char sht3x_cmd_heater_on[] = { 0x30, 0x6d }; 49 static const unsigned char sht3x_cmd_heater_off[] = { 0x30, 0x66 }; 50 51 /* other commands */ 52 static const unsigned char sht3x_cmd_read_status_reg[] = { 0xf3, 0x2d }; 53 static const unsigned char sht3x_cmd_clear_status_reg[] = { 0x30, 0x41 }; 54 55 /* delays for non-blocking i2c commands, both in us */ 56 #define SHT3X_NONBLOCKING_WAIT_TIME_HPM 15000 57 #define SHT3X_NONBLOCKING_WAIT_TIME_LPM 4000 58 59 #define SHT3X_WORD_LEN 2 60 #define SHT3X_CMD_LENGTH 2 61 #define SHT3X_CRC8_LEN 1 62 #define SHT3X_RESPONSE_LENGTH 6 63 #define SHT3X_CRC8_POLYNOMIAL 0x31 64 #define SHT3X_CRC8_INIT 0xFF 65 #define SHT3X_MIN_TEMPERATURE -45000 66 #define SHT3X_MAX_TEMPERATURE 130000 67 #define SHT3X_MIN_HUMIDITY 0 68 #define SHT3X_MAX_HUMIDITY 100000 69 70 enum sht3x_chips { 71 sht3x, 72 sts3x, 73 }; 74 75 enum sht3x_limits { 76 limit_max = 0, 77 limit_max_hyst, 78 limit_min, 79 limit_min_hyst, 80 }; 81 82 DECLARE_CRC8_TABLE(sht3x_crc8_table); 83 84 /* periodic measure commands (high precision mode) */ 85 static const char periodic_measure_commands_hpm[][SHT3X_CMD_LENGTH] = { 86 /* 0.5 measurements per second */ 87 {0x20, 0x32}, 88 /* 1 measurements per second */ 89 {0x21, 0x30}, 90 /* 2 measurements per second */ 91 {0x22, 0x36}, 92 /* 4 measurements per second */ 93 {0x23, 0x34}, 94 /* 10 measurements per second */ 95 {0x27, 0x37}, 96 }; 97 98 /* periodic measure commands (low power mode) */ 99 static const char periodic_measure_commands_lpm[][SHT3X_CMD_LENGTH] = { 100 /* 0.5 measurements per second */ 101 {0x20, 0x2f}, 102 /* 1 measurements per second */ 103 {0x21, 0x2d}, 104 /* 2 measurements per second */ 105 {0x22, 0x2b}, 106 /* 4 measurements per second */ 107 {0x23, 0x29}, 108 /* 10 measurements per second */ 109 {0x27, 0x2a}, 110 }; 111 112 struct sht3x_limit_commands { 113 const char read_command[SHT3X_CMD_LENGTH]; 114 const char write_command[SHT3X_CMD_LENGTH]; 115 }; 116 117 static const struct sht3x_limit_commands limit_commands[] = { 118 /* temp1_max, humidity1_max */ 119 [limit_max] = { {0xe1, 0x1f}, {0x61, 0x1d} }, 120 /* temp_1_max_hyst, humidity1_max_hyst */ 121 [limit_max_hyst] = { {0xe1, 0x14}, {0x61, 0x16} }, 122 /* temp1_min, humidity1_min */ 123 [limit_min] = { {0xe1, 0x02}, {0x61, 0x00} }, 124 /* temp_1_min_hyst, humidity1_min_hyst */ 125 [limit_min_hyst] = { {0xe1, 0x09}, {0x61, 0x0B} }, 126 }; 127 128 #define SHT3X_NUM_LIMIT_CMD ARRAY_SIZE(limit_commands) 129 130 static const u16 mode_to_update_interval[] = { 131 0, 132 2000, 133 1000, 134 500, 135 250, 136 100, 137 }; 138 139 struct sht3x_data { 140 struct i2c_client *client; 141 struct mutex i2c_lock; /* lock for sending i2c commands */ 142 struct mutex data_lock; /* lock for updating driver data */ 143 144 u8 mode; 145 const unsigned char *command; 146 u32 wait_time; /* in us*/ 147 unsigned long last_update; /* last update in periodic mode*/ 148 149 struct sht3x_platform_data setup; 150 151 /* 152 * cached values for temperature and humidity and limits 153 * the limits arrays have the following order: 154 * max, max_hyst, min, min_hyst 155 */ 156 int temperature; 157 int temperature_limits[SHT3X_NUM_LIMIT_CMD]; 158 u32 humidity; 159 u32 humidity_limits[SHT3X_NUM_LIMIT_CMD]; 160 }; 161 162 static u8 get_mode_from_update_interval(u16 value) 163 { 164 size_t index; 165 u8 number_of_modes = ARRAY_SIZE(mode_to_update_interval); 166 167 if (value == 0) 168 return 0; 169 170 /* find next faster update interval */ 171 for (index = 1; index < number_of_modes; index++) { 172 if (mode_to_update_interval[index] <= value) 173 return index; 174 } 175 176 return number_of_modes - 1; 177 } 178 179 static int sht3x_read_from_command(struct i2c_client *client, 180 struct sht3x_data *data, 181 const char *command, 182 char *buf, int length, u32 wait_time) 183 { 184 int ret; 185 186 mutex_lock(&data->i2c_lock); 187 ret = i2c_master_send(client, command, SHT3X_CMD_LENGTH); 188 189 if (ret != SHT3X_CMD_LENGTH) { 190 ret = ret < 0 ? ret : -EIO; 191 goto out; 192 } 193 194 if (wait_time) 195 usleep_range(wait_time, wait_time + 1000); 196 197 ret = i2c_master_recv(client, buf, length); 198 if (ret != length) { 199 ret = ret < 0 ? ret : -EIO; 200 goto out; 201 } 202 203 ret = 0; 204 out: 205 mutex_unlock(&data->i2c_lock); 206 return ret; 207 } 208 209 static int sht3x_extract_temperature(u16 raw) 210 { 211 /* 212 * From datasheet: 213 * T = -45 + 175 * ST / 2^16 214 * Adapted for integer fixed point (3 digit) arithmetic. 215 */ 216 return ((21875 * (int)raw) >> 13) - 45000; 217 } 218 219 static u32 sht3x_extract_humidity(u16 raw) 220 { 221 /* 222 * From datasheet: 223 * RH = 100 * SRH / 2^16 224 * Adapted for integer fixed point (3 digit) arithmetic. 225 */ 226 return (12500 * (u32)raw) >> 13; 227 } 228 229 static struct sht3x_data *sht3x_update_client(struct device *dev) 230 { 231 struct sht3x_data *data = dev_get_drvdata(dev); 232 struct i2c_client *client = data->client; 233 u16 interval_ms = mode_to_update_interval[data->mode]; 234 unsigned long interval_jiffies = msecs_to_jiffies(interval_ms); 235 unsigned char buf[SHT3X_RESPONSE_LENGTH]; 236 u16 val; 237 int ret = 0; 238 239 mutex_lock(&data->data_lock); 240 /* 241 * Only update cached readings once per update interval in periodic 242 * mode. In single shot mode the sensor measures values on demand, so 243 * every time the sysfs interface is called, a measurement is triggered. 244 * In periodic mode however, the measurement process is handled 245 * internally by the sensor and reading out sensor values only makes 246 * sense if a new reading is available. 247 */ 248 if (time_after(jiffies, data->last_update + interval_jiffies)) { 249 ret = sht3x_read_from_command(client, data, data->command, buf, 250 sizeof(buf), data->wait_time); 251 if (ret) 252 goto out; 253 254 val = be16_to_cpup((__be16 *)buf); 255 data->temperature = sht3x_extract_temperature(val); 256 val = be16_to_cpup((__be16 *)(buf + 3)); 257 data->humidity = sht3x_extract_humidity(val); 258 data->last_update = jiffies; 259 } 260 261 out: 262 mutex_unlock(&data->data_lock); 263 if (ret) 264 return ERR_PTR(ret); 265 266 return data; 267 } 268 269 /* sysfs attributes */ 270 static ssize_t temp1_input_show(struct device *dev, 271 struct device_attribute *attr, char *buf) 272 { 273 struct sht3x_data *data = sht3x_update_client(dev); 274 275 if (IS_ERR(data)) 276 return PTR_ERR(data); 277 278 return sprintf(buf, "%d\n", data->temperature); 279 } 280 281 static ssize_t humidity1_input_show(struct device *dev, 282 struct device_attribute *attr, char *buf) 283 { 284 struct sht3x_data *data = sht3x_update_client(dev); 285 286 if (IS_ERR(data)) 287 return PTR_ERR(data); 288 289 return sprintf(buf, "%u\n", data->humidity); 290 } 291 292 /* 293 * limits_update must only be called from probe or with data_lock held 294 */ 295 static int limits_update(struct sht3x_data *data) 296 { 297 int ret; 298 u8 index; 299 int temperature; 300 u32 humidity; 301 u16 raw; 302 char buffer[SHT3X_RESPONSE_LENGTH]; 303 const struct sht3x_limit_commands *commands; 304 struct i2c_client *client = data->client; 305 306 for (index = 0; index < SHT3X_NUM_LIMIT_CMD; index++) { 307 commands = &limit_commands[index]; 308 ret = sht3x_read_from_command(client, data, 309 commands->read_command, buffer, 310 SHT3X_RESPONSE_LENGTH, 0); 311 312 if (ret) 313 return ret; 314 315 raw = be16_to_cpup((__be16 *)buffer); 316 temperature = sht3x_extract_temperature((raw & 0x01ff) << 7); 317 humidity = sht3x_extract_humidity(raw & 0xfe00); 318 data->temperature_limits[index] = temperature; 319 data->humidity_limits[index] = humidity; 320 } 321 322 return ret; 323 } 324 325 static ssize_t temp1_limit_show(struct device *dev, 326 struct device_attribute *attr, 327 char *buf) 328 { 329 struct sht3x_data *data = dev_get_drvdata(dev); 330 u8 index = to_sensor_dev_attr(attr)->index; 331 int temperature_limit = data->temperature_limits[index]; 332 333 return scnprintf(buf, PAGE_SIZE, "%d\n", temperature_limit); 334 } 335 336 static ssize_t humidity1_limit_show(struct device *dev, 337 struct device_attribute *attr, 338 char *buf) 339 { 340 struct sht3x_data *data = dev_get_drvdata(dev); 341 u8 index = to_sensor_dev_attr(attr)->index; 342 u32 humidity_limit = data->humidity_limits[index]; 343 344 return scnprintf(buf, PAGE_SIZE, "%u\n", humidity_limit); 345 } 346 347 /* 348 * limit_store must only be called with data_lock held 349 */ 350 static size_t limit_store(struct device *dev, 351 size_t count, 352 u8 index, 353 int temperature, 354 u32 humidity) 355 { 356 char buffer[SHT3X_CMD_LENGTH + SHT3X_WORD_LEN + SHT3X_CRC8_LEN]; 357 char *position = buffer; 358 int ret; 359 u16 raw; 360 struct sht3x_data *data = dev_get_drvdata(dev); 361 struct i2c_client *client = data->client; 362 const struct sht3x_limit_commands *commands; 363 364 commands = &limit_commands[index]; 365 366 memcpy(position, commands->write_command, SHT3X_CMD_LENGTH); 367 position += SHT3X_CMD_LENGTH; 368 /* 369 * ST = (T + 45) / 175 * 2^16 370 * SRH = RH / 100 * 2^16 371 * adapted for fixed point arithmetic and packed the same as 372 * in limit_show() 373 */ 374 raw = ((u32)(temperature + 45000) * 24543) >> (16 + 7); 375 raw |= ((humidity * 42950) >> 16) & 0xfe00; 376 377 *((__be16 *)position) = cpu_to_be16(raw); 378 position += SHT3X_WORD_LEN; 379 *position = crc8(sht3x_crc8_table, 380 position - SHT3X_WORD_LEN, 381 SHT3X_WORD_LEN, 382 SHT3X_CRC8_INIT); 383 384 mutex_lock(&data->i2c_lock); 385 ret = i2c_master_send(client, buffer, sizeof(buffer)); 386 mutex_unlock(&data->i2c_lock); 387 388 if (ret != sizeof(buffer)) 389 return ret < 0 ? ret : -EIO; 390 391 data->temperature_limits[index] = temperature; 392 data->humidity_limits[index] = humidity; 393 return count; 394 } 395 396 static ssize_t temp1_limit_store(struct device *dev, 397 struct device_attribute *attr, 398 const char *buf, 399 size_t count) 400 { 401 int temperature; 402 int ret; 403 struct sht3x_data *data = dev_get_drvdata(dev); 404 u8 index = to_sensor_dev_attr(attr)->index; 405 406 ret = kstrtoint(buf, 0, &temperature); 407 if (ret) 408 return ret; 409 410 temperature = clamp_val(temperature, SHT3X_MIN_TEMPERATURE, 411 SHT3X_MAX_TEMPERATURE); 412 mutex_lock(&data->data_lock); 413 ret = limit_store(dev, count, index, temperature, 414 data->humidity_limits[index]); 415 mutex_unlock(&data->data_lock); 416 417 return ret; 418 } 419 420 static ssize_t humidity1_limit_store(struct device *dev, 421 struct device_attribute *attr, 422 const char *buf, 423 size_t count) 424 { 425 u32 humidity; 426 int ret; 427 struct sht3x_data *data = dev_get_drvdata(dev); 428 u8 index = to_sensor_dev_attr(attr)->index; 429 430 ret = kstrtou32(buf, 0, &humidity); 431 if (ret) 432 return ret; 433 434 humidity = clamp_val(humidity, SHT3X_MIN_HUMIDITY, SHT3X_MAX_HUMIDITY); 435 mutex_lock(&data->data_lock); 436 ret = limit_store(dev, count, index, data->temperature_limits[index], 437 humidity); 438 mutex_unlock(&data->data_lock); 439 440 return ret; 441 } 442 443 static void sht3x_select_command(struct sht3x_data *data) 444 { 445 /* 446 * In blocking mode (clock stretching mode) the I2C bus 447 * is blocked for other traffic, thus the call to i2c_master_recv() 448 * will wait until the data is ready. For non blocking mode, we 449 * have to wait ourselves. 450 */ 451 if (data->mode > 0) { 452 data->command = sht3x_cmd_measure_periodic_mode; 453 data->wait_time = 0; 454 } else if (data->setup.blocking_io) { 455 data->command = data->setup.high_precision ? 456 sht3x_cmd_measure_blocking_hpm : 457 sht3x_cmd_measure_blocking_lpm; 458 data->wait_time = 0; 459 } else { 460 if (data->setup.high_precision) { 461 data->command = sht3x_cmd_measure_nonblocking_hpm; 462 data->wait_time = SHT3X_NONBLOCKING_WAIT_TIME_HPM; 463 } else { 464 data->command = sht3x_cmd_measure_nonblocking_lpm; 465 data->wait_time = SHT3X_NONBLOCKING_WAIT_TIME_LPM; 466 } 467 } 468 } 469 470 static int status_register_read(struct device *dev, 471 struct device_attribute *attr, 472 char *buffer, int length) 473 { 474 int ret; 475 struct sht3x_data *data = dev_get_drvdata(dev); 476 struct i2c_client *client = data->client; 477 478 ret = sht3x_read_from_command(client, data, sht3x_cmd_read_status_reg, 479 buffer, length, 0); 480 481 return ret; 482 } 483 484 static ssize_t temp1_alarm_show(struct device *dev, 485 struct device_attribute *attr, 486 char *buf) 487 { 488 char buffer[SHT3X_WORD_LEN + SHT3X_CRC8_LEN]; 489 int ret; 490 491 ret = status_register_read(dev, attr, buffer, 492 SHT3X_WORD_LEN + SHT3X_CRC8_LEN); 493 if (ret) 494 return ret; 495 496 return scnprintf(buf, PAGE_SIZE, "%d\n", !!(buffer[0] & 0x04)); 497 } 498 499 static ssize_t humidity1_alarm_show(struct device *dev, 500 struct device_attribute *attr, 501 char *buf) 502 { 503 char buffer[SHT3X_WORD_LEN + SHT3X_CRC8_LEN]; 504 int ret; 505 506 ret = status_register_read(dev, attr, buffer, 507 SHT3X_WORD_LEN + SHT3X_CRC8_LEN); 508 if (ret) 509 return ret; 510 511 return scnprintf(buf, PAGE_SIZE, "%d\n", !!(buffer[0] & 0x08)); 512 } 513 514 static ssize_t heater_enable_show(struct device *dev, 515 struct device_attribute *attr, 516 char *buf) 517 { 518 char buffer[SHT3X_WORD_LEN + SHT3X_CRC8_LEN]; 519 int ret; 520 521 ret = status_register_read(dev, attr, buffer, 522 SHT3X_WORD_LEN + SHT3X_CRC8_LEN); 523 if (ret) 524 return ret; 525 526 return scnprintf(buf, PAGE_SIZE, "%d\n", !!(buffer[0] & 0x20)); 527 } 528 529 static ssize_t heater_enable_store(struct device *dev, 530 struct device_attribute *attr, 531 const char *buf, 532 size_t count) 533 { 534 struct sht3x_data *data = dev_get_drvdata(dev); 535 struct i2c_client *client = data->client; 536 int ret; 537 bool status; 538 539 ret = kstrtobool(buf, &status); 540 if (ret) 541 return ret; 542 543 mutex_lock(&data->i2c_lock); 544 545 if (status) 546 ret = i2c_master_send(client, (char *)&sht3x_cmd_heater_on, 547 SHT3X_CMD_LENGTH); 548 else 549 ret = i2c_master_send(client, (char *)&sht3x_cmd_heater_off, 550 SHT3X_CMD_LENGTH); 551 552 mutex_unlock(&data->i2c_lock); 553 554 return ret; 555 } 556 557 static ssize_t update_interval_show(struct device *dev, 558 struct device_attribute *attr, 559 char *buf) 560 { 561 struct sht3x_data *data = dev_get_drvdata(dev); 562 563 return scnprintf(buf, PAGE_SIZE, "%u\n", 564 mode_to_update_interval[data->mode]); 565 } 566 567 static ssize_t update_interval_store(struct device *dev, 568 struct device_attribute *attr, 569 const char *buf, 570 size_t count) 571 { 572 u16 update_interval; 573 u8 mode; 574 int ret; 575 const char *command; 576 struct sht3x_data *data = dev_get_drvdata(dev); 577 struct i2c_client *client = data->client; 578 579 ret = kstrtou16(buf, 0, &update_interval); 580 if (ret) 581 return ret; 582 583 mode = get_mode_from_update_interval(update_interval); 584 585 mutex_lock(&data->data_lock); 586 /* mode did not change */ 587 if (mode == data->mode) { 588 mutex_unlock(&data->data_lock); 589 return count; 590 } 591 592 mutex_lock(&data->i2c_lock); 593 /* 594 * Abort periodic measure mode. 595 * To do any changes to the configuration while in periodic mode, we 596 * have to send a break command to the sensor, which then falls back 597 * to single shot (mode = 0). 598 */ 599 if (data->mode > 0) { 600 ret = i2c_master_send(client, sht3x_cmd_break, 601 SHT3X_CMD_LENGTH); 602 if (ret != SHT3X_CMD_LENGTH) 603 goto out; 604 data->mode = 0; 605 } 606 607 if (mode > 0) { 608 if (data->setup.high_precision) 609 command = periodic_measure_commands_hpm[mode - 1]; 610 else 611 command = periodic_measure_commands_lpm[mode - 1]; 612 613 /* select mode */ 614 ret = i2c_master_send(client, command, SHT3X_CMD_LENGTH); 615 if (ret != SHT3X_CMD_LENGTH) 616 goto out; 617 } 618 619 /* select mode and command */ 620 data->mode = mode; 621 sht3x_select_command(data); 622 623 out: 624 mutex_unlock(&data->i2c_lock); 625 mutex_unlock(&data->data_lock); 626 if (ret != SHT3X_CMD_LENGTH) 627 return ret < 0 ? ret : -EIO; 628 629 return count; 630 } 631 632 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp1_input, 0); 633 static SENSOR_DEVICE_ATTR_RO(humidity1_input, humidity1_input, 0); 634 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp1_limit, limit_max); 635 static SENSOR_DEVICE_ATTR_RW(humidity1_max, humidity1_limit, limit_max); 636 static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, temp1_limit, limit_max_hyst); 637 static SENSOR_DEVICE_ATTR_RW(humidity1_max_hyst, humidity1_limit, 638 limit_max_hyst); 639 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp1_limit, limit_min); 640 static SENSOR_DEVICE_ATTR_RW(humidity1_min, humidity1_limit, limit_min); 641 static SENSOR_DEVICE_ATTR_RW(temp1_min_hyst, temp1_limit, limit_min_hyst); 642 static SENSOR_DEVICE_ATTR_RW(humidity1_min_hyst, humidity1_limit, 643 limit_min_hyst); 644 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, temp1_alarm, 0); 645 static SENSOR_DEVICE_ATTR_RO(humidity1_alarm, humidity1_alarm, 0); 646 static SENSOR_DEVICE_ATTR_RW(heater_enable, heater_enable, 0); 647 static SENSOR_DEVICE_ATTR_RW(update_interval, update_interval, 0); 648 649 static struct attribute *sht3x_attrs[] = { 650 &sensor_dev_attr_temp1_input.dev_attr.attr, 651 &sensor_dev_attr_humidity1_input.dev_attr.attr, 652 &sensor_dev_attr_temp1_max.dev_attr.attr, 653 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 654 &sensor_dev_attr_humidity1_max.dev_attr.attr, 655 &sensor_dev_attr_humidity1_max_hyst.dev_attr.attr, 656 &sensor_dev_attr_temp1_min.dev_attr.attr, 657 &sensor_dev_attr_temp1_min_hyst.dev_attr.attr, 658 &sensor_dev_attr_humidity1_min.dev_attr.attr, 659 &sensor_dev_attr_humidity1_min_hyst.dev_attr.attr, 660 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 661 &sensor_dev_attr_humidity1_alarm.dev_attr.attr, 662 &sensor_dev_attr_heater_enable.dev_attr.attr, 663 &sensor_dev_attr_update_interval.dev_attr.attr, 664 NULL 665 }; 666 667 static struct attribute *sts3x_attrs[] = { 668 &sensor_dev_attr_temp1_input.dev_attr.attr, 669 NULL 670 }; 671 672 ATTRIBUTE_GROUPS(sht3x); 673 ATTRIBUTE_GROUPS(sts3x); 674 675 static int sht3x_probe(struct i2c_client *client, 676 const struct i2c_device_id *id) 677 { 678 int ret; 679 struct sht3x_data *data; 680 struct device *hwmon_dev; 681 struct i2c_adapter *adap = client->adapter; 682 struct device *dev = &client->dev; 683 const struct attribute_group **attribute_groups; 684 685 /* 686 * we require full i2c support since the sht3x uses multi-byte read and 687 * writes as well as multi-byte commands which are not supported by 688 * the smbus protocol 689 */ 690 if (!i2c_check_functionality(adap, I2C_FUNC_I2C)) 691 return -ENODEV; 692 693 ret = i2c_master_send(client, sht3x_cmd_clear_status_reg, 694 SHT3X_CMD_LENGTH); 695 if (ret != SHT3X_CMD_LENGTH) 696 return ret < 0 ? ret : -ENODEV; 697 698 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 699 if (!data) 700 return -ENOMEM; 701 702 data->setup.blocking_io = false; 703 data->setup.high_precision = true; 704 data->mode = 0; 705 data->last_update = jiffies - msecs_to_jiffies(3000); 706 data->client = client; 707 crc8_populate_msb(sht3x_crc8_table, SHT3X_CRC8_POLYNOMIAL); 708 709 if (client->dev.platform_data) 710 data->setup = *(struct sht3x_platform_data *)dev->platform_data; 711 712 sht3x_select_command(data); 713 714 mutex_init(&data->i2c_lock); 715 mutex_init(&data->data_lock); 716 717 /* 718 * An attempt to read limits register too early 719 * causes a NACK response from the chip. 720 * Waiting for an empirical delay of 500 us solves the issue. 721 */ 722 usleep_range(500, 600); 723 724 ret = limits_update(data); 725 if (ret) 726 return ret; 727 728 if (id->driver_data == sts3x) 729 attribute_groups = sts3x_groups; 730 else 731 attribute_groups = sht3x_groups; 732 733 hwmon_dev = devm_hwmon_device_register_with_groups(dev, 734 client->name, 735 data, 736 attribute_groups); 737 738 if (IS_ERR(hwmon_dev)) 739 dev_dbg(dev, "unable to register hwmon device\n"); 740 741 return PTR_ERR_OR_ZERO(hwmon_dev); 742 } 743 744 /* device ID table */ 745 static const struct i2c_device_id sht3x_ids[] = { 746 {"sht3x", sht3x}, 747 {"sts3x", sts3x}, 748 {} 749 }; 750 751 MODULE_DEVICE_TABLE(i2c, sht3x_ids); 752 753 static struct i2c_driver sht3x_i2c_driver = { 754 .driver.name = "sht3x", 755 .probe = sht3x_probe, 756 .id_table = sht3x_ids, 757 }; 758 759 module_i2c_driver(sht3x_i2c_driver); 760 761 MODULE_AUTHOR("David Frey <david.frey@sensirion.com>"); 762 MODULE_AUTHOR("Pascal Sachs <pascal.sachs@sensirion.com>"); 763 MODULE_DESCRIPTION("Sensirion SHT3x humidity and temperature sensor driver"); 764 MODULE_LICENSE("GPL"); 765