1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * sht15.c - support for the SHT15 Temperature and Humidity Sensor 4 * 5 * Portions Copyright (c) 2010-2012 Savoir-faire Linux Inc. 6 * Jerome Oufella <jerome.oufella@savoirfairelinux.com> 7 * Vivien Didelot <vivien.didelot@savoirfairelinux.com> 8 * 9 * Copyright (c) 2009 Jonathan Cameron 10 * 11 * Copyright (c) 2007 Wouter Horre 12 * 13 * For further information, see the Documentation/hwmon/sht15 file. 14 */ 15 16 #include <linux/interrupt.h> 17 #include <linux/irq.h> 18 #include <linux/module.h> 19 #include <linux/init.h> 20 #include <linux/hwmon.h> 21 #include <linux/hwmon-sysfs.h> 22 #include <linux/mutex.h> 23 #include <linux/platform_device.h> 24 #include <linux/sched.h> 25 #include <linux/delay.h> 26 #include <linux/jiffies.h> 27 #include <linux/err.h> 28 #include <linux/regulator/consumer.h> 29 #include <linux/slab.h> 30 #include <linux/atomic.h> 31 #include <linux/bitrev.h> 32 #include <linux/gpio/consumer.h> 33 #include <linux/of.h> 34 35 /* Commands */ 36 #define SHT15_MEASURE_TEMP 0x03 37 #define SHT15_MEASURE_RH 0x05 38 #define SHT15_WRITE_STATUS 0x06 39 #define SHT15_READ_STATUS 0x07 40 #define SHT15_SOFT_RESET 0x1E 41 42 /* Min timings */ 43 #define SHT15_TSCKL 100 /* (nsecs) clock low */ 44 #define SHT15_TSCKH 100 /* (nsecs) clock high */ 45 #define SHT15_TSU 150 /* (nsecs) data setup time */ 46 #define SHT15_TSRST 11 /* (msecs) soft reset time */ 47 48 /* Status Register Bits */ 49 #define SHT15_STATUS_LOW_RESOLUTION 0x01 50 #define SHT15_STATUS_NO_OTP_RELOAD 0x02 51 #define SHT15_STATUS_HEATER 0x04 52 #define SHT15_STATUS_LOW_BATTERY 0x40 53 54 /* List of supported chips */ 55 enum sht15_chips { sht10, sht11, sht15, sht71, sht75 }; 56 57 /* Actions the driver may be doing */ 58 enum sht15_state { 59 SHT15_READING_NOTHING, 60 SHT15_READING_TEMP, 61 SHT15_READING_HUMID 62 }; 63 64 /** 65 * struct sht15_temppair - elements of voltage dependent temp calc 66 * @vdd: supply voltage in microvolts 67 * @d1: see data sheet 68 */ 69 struct sht15_temppair { 70 int vdd; /* microvolts */ 71 int d1; 72 }; 73 74 /* Table 9 from datasheet - relates temperature calculation to supply voltage */ 75 static const struct sht15_temppair temppoints[] = { 76 { 2500000, -39400 }, 77 { 3000000, -39600 }, 78 { 3500000, -39700 }, 79 { 4000000, -39800 }, 80 { 5000000, -40100 }, 81 }; 82 83 /* Table from CRC datasheet, section 2.4 */ 84 static const u8 sht15_crc8_table[] = { 85 0, 49, 98, 83, 196, 245, 166, 151, 86 185, 136, 219, 234, 125, 76, 31, 46, 87 67, 114, 33, 16, 135, 182, 229, 212, 88 250, 203, 152, 169, 62, 15, 92, 109, 89 134, 183, 228, 213, 66, 115, 32, 17, 90 63, 14, 93, 108, 251, 202, 153, 168, 91 197, 244, 167, 150, 1, 48, 99, 82, 92 124, 77, 30, 47, 184, 137, 218, 235, 93 61, 12, 95, 110, 249, 200, 155, 170, 94 132, 181, 230, 215, 64, 113, 34, 19, 95 126, 79, 28, 45, 186, 139, 216, 233, 96 199, 246, 165, 148, 3, 50, 97, 80, 97 187, 138, 217, 232, 127, 78, 29, 44, 98 2, 51, 96, 81, 198, 247, 164, 149, 99 248, 201, 154, 171, 60, 13, 94, 111, 100 65, 112, 35, 18, 133, 180, 231, 214, 101 122, 75, 24, 41, 190, 143, 220, 237, 102 195, 242, 161, 144, 7, 54, 101, 84, 103 57, 8, 91, 106, 253, 204, 159, 174, 104 128, 177, 226, 211, 68, 117, 38, 23, 105 252, 205, 158, 175, 56, 9, 90, 107, 106 69, 116, 39, 22, 129, 176, 227, 210, 107 191, 142, 221, 236, 123, 74, 25, 40, 108 6, 55, 100, 85, 194, 243, 160, 145, 109 71, 118, 37, 20, 131, 178, 225, 208, 110 254, 207, 156, 173, 58, 11, 88, 105, 111 4, 53, 102, 87, 192, 241, 162, 147, 112 189, 140, 223, 238, 121, 72, 27, 42, 113 193, 240, 163, 146, 5, 52, 103, 86, 114 120, 73, 26, 43, 188, 141, 222, 239, 115 130, 179, 224, 209, 70, 119, 36, 21, 116 59, 10, 89, 104, 255, 206, 157, 172 117 }; 118 119 /** 120 * struct sht15_data - device instance specific data 121 * @sck: clock GPIO line 122 * @data: data GPIO line 123 * @read_work: bh of interrupt handler. 124 * @wait_queue: wait queue for getting values from device. 125 * @val_temp: last temperature value read from device. 126 * @val_humid: last humidity value read from device. 127 * @val_status: last status register value read from device. 128 * @checksum_ok: last value read from the device passed CRC validation. 129 * @checksumming: flag used to enable the data validation with CRC. 130 * @state: state identifying the action the driver is doing. 131 * @measurements_valid: are the current stored measures valid (start condition). 132 * @status_valid: is the current stored status valid (start condition). 133 * @last_measurement: time of last measure. 134 * @last_status: time of last status reading. 135 * @read_lock: mutex to ensure only one read in progress at a time. 136 * @dev: associate device structure. 137 * @hwmon_dev: device associated with hwmon subsystem. 138 * @reg: associated regulator (if specified). 139 * @nb: notifier block to handle notifications of voltage 140 * changes. 141 * @supply_uv: local copy of supply voltage used to allow use of 142 * regulator consumer if available. 143 * @supply_uv_valid: indicates that an updated value has not yet been 144 * obtained from the regulator and so any calculations 145 * based upon it will be invalid. 146 * @update_supply_work: work struct that is used to update the supply_uv. 147 * @interrupt_handled: flag used to indicate a handler has been scheduled. 148 */ 149 struct sht15_data { 150 struct gpio_desc *sck; 151 struct gpio_desc *data; 152 struct work_struct read_work; 153 wait_queue_head_t wait_queue; 154 uint16_t val_temp; 155 uint16_t val_humid; 156 u8 val_status; 157 bool checksum_ok; 158 bool checksumming; 159 enum sht15_state state; 160 bool measurements_valid; 161 bool status_valid; 162 unsigned long last_measurement; 163 unsigned long last_status; 164 struct mutex read_lock; 165 struct device *dev; 166 struct device *hwmon_dev; 167 struct regulator *reg; 168 struct notifier_block nb; 169 int supply_uv; 170 bool supply_uv_valid; 171 struct work_struct update_supply_work; 172 atomic_t interrupt_handled; 173 }; 174 175 /** 176 * sht15_crc8() - compute crc8 177 * @data: sht15 specific data. 178 * @value: sht15 retrieved data. 179 * @len: Length of retrieved data 180 * 181 * This implements section 2 of the CRC datasheet. 182 */ 183 static u8 sht15_crc8(struct sht15_data *data, 184 const u8 *value, 185 int len) 186 { 187 u8 crc = bitrev8(data->val_status & 0x0F); 188 189 while (len--) { 190 crc = sht15_crc8_table[*value ^ crc]; 191 value++; 192 } 193 194 return crc; 195 } 196 197 /** 198 * sht15_connection_reset() - reset the comms interface 199 * @data: sht15 specific data 200 * 201 * This implements section 3.4 of the data sheet 202 */ 203 static int sht15_connection_reset(struct sht15_data *data) 204 { 205 int i, err; 206 207 err = gpiod_direction_output(data->data, 1); 208 if (err) 209 return err; 210 ndelay(SHT15_TSCKL); 211 gpiod_set_value(data->sck, 0); 212 ndelay(SHT15_TSCKL); 213 for (i = 0; i < 9; ++i) { 214 gpiod_set_value(data->sck, 1); 215 ndelay(SHT15_TSCKH); 216 gpiod_set_value(data->sck, 0); 217 ndelay(SHT15_TSCKL); 218 } 219 return 0; 220 } 221 222 /** 223 * sht15_send_bit() - send an individual bit to the device 224 * @data: device state data 225 * @val: value of bit to be sent 226 */ 227 static inline void sht15_send_bit(struct sht15_data *data, int val) 228 { 229 gpiod_set_value(data->data, val); 230 ndelay(SHT15_TSU); 231 gpiod_set_value(data->sck, 1); 232 ndelay(SHT15_TSCKH); 233 gpiod_set_value(data->sck, 0); 234 ndelay(SHT15_TSCKL); /* clock low time */ 235 } 236 237 /** 238 * sht15_transmission_start() - specific sequence for new transmission 239 * @data: device state data 240 * 241 * Timings for this are not documented on the data sheet, so very 242 * conservative ones used in implementation. This implements 243 * figure 12 on the data sheet. 244 */ 245 static int sht15_transmission_start(struct sht15_data *data) 246 { 247 int err; 248 249 /* ensure data is high and output */ 250 err = gpiod_direction_output(data->data, 1); 251 if (err) 252 return err; 253 ndelay(SHT15_TSU); 254 gpiod_set_value(data->sck, 0); 255 ndelay(SHT15_TSCKL); 256 gpiod_set_value(data->sck, 1); 257 ndelay(SHT15_TSCKH); 258 gpiod_set_value(data->data, 0); 259 ndelay(SHT15_TSU); 260 gpiod_set_value(data->sck, 0); 261 ndelay(SHT15_TSCKL); 262 gpiod_set_value(data->sck, 1); 263 ndelay(SHT15_TSCKH); 264 gpiod_set_value(data->data, 1); 265 ndelay(SHT15_TSU); 266 gpiod_set_value(data->sck, 0); 267 ndelay(SHT15_TSCKL); 268 return 0; 269 } 270 271 /** 272 * sht15_send_byte() - send a single byte to the device 273 * @data: device state 274 * @byte: value to be sent 275 */ 276 static void sht15_send_byte(struct sht15_data *data, u8 byte) 277 { 278 int i; 279 280 for (i = 0; i < 8; i++) { 281 sht15_send_bit(data, !!(byte & 0x80)); 282 byte <<= 1; 283 } 284 } 285 286 /** 287 * sht15_wait_for_response() - checks for ack from device 288 * @data: device state 289 */ 290 static int sht15_wait_for_response(struct sht15_data *data) 291 { 292 int err; 293 294 err = gpiod_direction_input(data->data); 295 if (err) 296 return err; 297 gpiod_set_value(data->sck, 1); 298 ndelay(SHT15_TSCKH); 299 if (gpiod_get_value(data->data)) { 300 gpiod_set_value(data->sck, 0); 301 dev_err(data->dev, "Command not acknowledged\n"); 302 err = sht15_connection_reset(data); 303 if (err) 304 return err; 305 return -EIO; 306 } 307 gpiod_set_value(data->sck, 0); 308 ndelay(SHT15_TSCKL); 309 return 0; 310 } 311 312 /** 313 * sht15_send_cmd() - Sends a command to the device. 314 * @data: device state 315 * @cmd: command byte to be sent 316 * 317 * On entry, sck is output low, data is output pull high 318 * and the interrupt disabled. 319 */ 320 static int sht15_send_cmd(struct sht15_data *data, u8 cmd) 321 { 322 int err; 323 324 err = sht15_transmission_start(data); 325 if (err) 326 return err; 327 sht15_send_byte(data, cmd); 328 return sht15_wait_for_response(data); 329 } 330 331 /** 332 * sht15_soft_reset() - send a soft reset command 333 * @data: sht15 specific data. 334 * 335 * As described in section 3.2 of the datasheet. 336 */ 337 static int sht15_soft_reset(struct sht15_data *data) 338 { 339 int ret; 340 341 ret = sht15_send_cmd(data, SHT15_SOFT_RESET); 342 if (ret) 343 return ret; 344 msleep(SHT15_TSRST); 345 /* device resets default hardware status register value */ 346 data->val_status = 0; 347 348 return ret; 349 } 350 351 /** 352 * sht15_ack() - send a ack 353 * @data: sht15 specific data. 354 * 355 * Each byte of data is acknowledged by pulling the data line 356 * low for one clock pulse. 357 */ 358 static int sht15_ack(struct sht15_data *data) 359 { 360 int err; 361 362 err = gpiod_direction_output(data->data, 0); 363 if (err) 364 return err; 365 ndelay(SHT15_TSU); 366 gpiod_set_value(data->sck, 1); 367 ndelay(SHT15_TSU); 368 gpiod_set_value(data->sck, 0); 369 ndelay(SHT15_TSU); 370 gpiod_set_value(data->data, 1); 371 372 return gpiod_direction_input(data->data); 373 } 374 375 /** 376 * sht15_end_transmission() - notify device of end of transmission 377 * @data: device state. 378 * 379 * This is basically a NAK (single clock pulse, data high). 380 */ 381 static int sht15_end_transmission(struct sht15_data *data) 382 { 383 int err; 384 385 err = gpiod_direction_output(data->data, 1); 386 if (err) 387 return err; 388 ndelay(SHT15_TSU); 389 gpiod_set_value(data->sck, 1); 390 ndelay(SHT15_TSCKH); 391 gpiod_set_value(data->sck, 0); 392 ndelay(SHT15_TSCKL); 393 return 0; 394 } 395 396 /** 397 * sht15_read_byte() - Read a byte back from the device 398 * @data: device state. 399 */ 400 static u8 sht15_read_byte(struct sht15_data *data) 401 { 402 int i; 403 u8 byte = 0; 404 405 for (i = 0; i < 8; ++i) { 406 byte <<= 1; 407 gpiod_set_value(data->sck, 1); 408 ndelay(SHT15_TSCKH); 409 byte |= !!gpiod_get_value(data->data); 410 gpiod_set_value(data->sck, 0); 411 ndelay(SHT15_TSCKL); 412 } 413 return byte; 414 } 415 416 /** 417 * sht15_send_status() - write the status register byte 418 * @data: sht15 specific data. 419 * @status: the byte to set the status register with. 420 * 421 * As described in figure 14 and table 5 of the datasheet. 422 */ 423 static int sht15_send_status(struct sht15_data *data, u8 status) 424 { 425 int err; 426 427 err = sht15_send_cmd(data, SHT15_WRITE_STATUS); 428 if (err) 429 return err; 430 err = gpiod_direction_output(data->data, 1); 431 if (err) 432 return err; 433 ndelay(SHT15_TSU); 434 sht15_send_byte(data, status); 435 err = sht15_wait_for_response(data); 436 if (err) 437 return err; 438 439 data->val_status = status; 440 return 0; 441 } 442 443 /** 444 * sht15_update_status() - get updated status register from device if too old 445 * @data: device instance specific data. 446 * 447 * As described in figure 15 and table 5 of the datasheet. 448 */ 449 static int sht15_update_status(struct sht15_data *data) 450 { 451 int ret = 0; 452 u8 status; 453 u8 previous_config; 454 u8 dev_checksum = 0; 455 u8 checksum_vals[2]; 456 int timeout = HZ; 457 458 mutex_lock(&data->read_lock); 459 if (time_after(jiffies, data->last_status + timeout) 460 || !data->status_valid) { 461 ret = sht15_send_cmd(data, SHT15_READ_STATUS); 462 if (ret) 463 goto unlock; 464 status = sht15_read_byte(data); 465 466 if (data->checksumming) { 467 sht15_ack(data); 468 dev_checksum = bitrev8(sht15_read_byte(data)); 469 checksum_vals[0] = SHT15_READ_STATUS; 470 checksum_vals[1] = status; 471 data->checksum_ok = (sht15_crc8(data, checksum_vals, 2) 472 == dev_checksum); 473 } 474 475 ret = sht15_end_transmission(data); 476 if (ret) 477 goto unlock; 478 479 /* 480 * Perform checksum validation on the received data. 481 * Specification mentions that in case a checksum verification 482 * fails, a soft reset command must be sent to the device. 483 */ 484 if (data->checksumming && !data->checksum_ok) { 485 previous_config = data->val_status & 0x07; 486 ret = sht15_soft_reset(data); 487 if (ret) 488 goto unlock; 489 if (previous_config) { 490 ret = sht15_send_status(data, previous_config); 491 if (ret) { 492 dev_err(data->dev, 493 "CRC validation failed, unable " 494 "to restore device settings\n"); 495 goto unlock; 496 } 497 } 498 ret = -EAGAIN; 499 goto unlock; 500 } 501 502 data->val_status = status; 503 data->status_valid = true; 504 data->last_status = jiffies; 505 } 506 507 unlock: 508 mutex_unlock(&data->read_lock); 509 return ret; 510 } 511 512 /** 513 * sht15_measurement() - get a new value from device 514 * @data: device instance specific data 515 * @command: command sent to request value 516 * @timeout_msecs: timeout after which comms are assumed 517 * to have failed are reset. 518 */ 519 static int sht15_measurement(struct sht15_data *data, 520 int command, 521 int timeout_msecs) 522 { 523 int ret; 524 u8 previous_config; 525 526 ret = sht15_send_cmd(data, command); 527 if (ret) 528 return ret; 529 530 ret = gpiod_direction_input(data->data); 531 if (ret) 532 return ret; 533 atomic_set(&data->interrupt_handled, 0); 534 535 enable_irq(gpiod_to_irq(data->data)); 536 if (gpiod_get_value(data->data) == 0) { 537 disable_irq_nosync(gpiod_to_irq(data->data)); 538 /* Only relevant if the interrupt hasn't occurred. */ 539 if (!atomic_read(&data->interrupt_handled)) 540 schedule_work(&data->read_work); 541 } 542 ret = wait_event_timeout(data->wait_queue, 543 (data->state == SHT15_READING_NOTHING), 544 msecs_to_jiffies(timeout_msecs)); 545 if (data->state != SHT15_READING_NOTHING) { /* I/O error occurred */ 546 data->state = SHT15_READING_NOTHING; 547 return -EIO; 548 } else if (ret == 0) { /* timeout occurred */ 549 disable_irq_nosync(gpiod_to_irq(data->data)); 550 ret = sht15_connection_reset(data); 551 if (ret) 552 return ret; 553 return -ETIME; 554 } 555 556 /* 557 * Perform checksum validation on the received data. 558 * Specification mentions that in case a checksum verification fails, 559 * a soft reset command must be sent to the device. 560 */ 561 if (data->checksumming && !data->checksum_ok) { 562 previous_config = data->val_status & 0x07; 563 ret = sht15_soft_reset(data); 564 if (ret) 565 return ret; 566 if (previous_config) { 567 ret = sht15_send_status(data, previous_config); 568 if (ret) { 569 dev_err(data->dev, 570 "CRC validation failed, unable " 571 "to restore device settings\n"); 572 return ret; 573 } 574 } 575 return -EAGAIN; 576 } 577 578 return 0; 579 } 580 581 /** 582 * sht15_update_measurements() - get updated measures from device if too old 583 * @data: device state 584 */ 585 static int sht15_update_measurements(struct sht15_data *data) 586 { 587 int ret = 0; 588 int timeout = HZ; 589 590 mutex_lock(&data->read_lock); 591 if (time_after(jiffies, data->last_measurement + timeout) 592 || !data->measurements_valid) { 593 data->state = SHT15_READING_HUMID; 594 ret = sht15_measurement(data, SHT15_MEASURE_RH, 160); 595 if (ret) 596 goto unlock; 597 data->state = SHT15_READING_TEMP; 598 ret = sht15_measurement(data, SHT15_MEASURE_TEMP, 400); 599 if (ret) 600 goto unlock; 601 data->measurements_valid = true; 602 data->last_measurement = jiffies; 603 } 604 605 unlock: 606 mutex_unlock(&data->read_lock); 607 return ret; 608 } 609 610 /** 611 * sht15_calc_temp() - convert the raw reading to a temperature 612 * @data: device state 613 * 614 * As per section 4.3 of the data sheet. 615 */ 616 static inline int sht15_calc_temp(struct sht15_data *data) 617 { 618 int d1 = temppoints[0].d1; 619 int d2 = (data->val_status & SHT15_STATUS_LOW_RESOLUTION) ? 40 : 10; 620 int i; 621 622 for (i = ARRAY_SIZE(temppoints) - 1; i > 0; i--) 623 /* Find pointer to interpolate */ 624 if (data->supply_uv > temppoints[i - 1].vdd) { 625 d1 = (data->supply_uv - temppoints[i - 1].vdd) 626 * (temppoints[i].d1 - temppoints[i - 1].d1) 627 / (temppoints[i].vdd - temppoints[i - 1].vdd) 628 + temppoints[i - 1].d1; 629 break; 630 } 631 632 return data->val_temp * d2 + d1; 633 } 634 635 /** 636 * sht15_calc_humid() - using last temperature convert raw to humid 637 * @data: device state 638 * 639 * This is the temperature compensated version as per section 4.2 of 640 * the data sheet. 641 * 642 * The sensor is assumed to be V3, which is compatible with V4. 643 * Humidity conversion coefficients are shown in table 7 of the datasheet. 644 */ 645 static inline int sht15_calc_humid(struct sht15_data *data) 646 { 647 int rh_linear; /* milli percent */ 648 int temp = sht15_calc_temp(data); 649 int c2, c3; 650 int t2; 651 const int c1 = -4; 652 653 if (data->val_status & SHT15_STATUS_LOW_RESOLUTION) { 654 c2 = 648000; /* x 10 ^ -6 */ 655 c3 = -7200; /* x 10 ^ -7 */ 656 t2 = 1280; 657 } else { 658 c2 = 40500; /* x 10 ^ -6 */ 659 c3 = -28; /* x 10 ^ -7 */ 660 t2 = 80; 661 } 662 663 rh_linear = c1 * 1000 664 + c2 * data->val_humid / 1000 665 + (data->val_humid * data->val_humid * c3) / 10000; 666 return (temp - 25000) * (10000 + t2 * data->val_humid) 667 / 1000000 + rh_linear; 668 } 669 670 /** 671 * sht15_show_status() - show status information in sysfs 672 * @dev: device. 673 * @attr: device attribute. 674 * @buf: sysfs buffer where information is written to. 675 * 676 * Will be called on read access to temp1_fault, humidity1_fault 677 * and heater_enable sysfs attributes. 678 * Returns number of bytes written into buffer, negative errno on error. 679 */ 680 static ssize_t sht15_show_status(struct device *dev, 681 struct device_attribute *attr, 682 char *buf) 683 { 684 int ret; 685 struct sht15_data *data = dev_get_drvdata(dev); 686 u8 bit = to_sensor_dev_attr(attr)->index; 687 688 ret = sht15_update_status(data); 689 690 return ret ? ret : sprintf(buf, "%d\n", !!(data->val_status & bit)); 691 } 692 693 /** 694 * sht15_store_heater() - change heater state via sysfs 695 * @dev: device. 696 * @attr: device attribute. 697 * @buf: sysfs buffer to read the new heater state from. 698 * @count: length of the data. 699 * 700 * Will be called on write access to heater_enable sysfs attribute. 701 * Returns number of bytes actually decoded, negative errno on error. 702 */ 703 static ssize_t sht15_store_heater(struct device *dev, 704 struct device_attribute *attr, 705 const char *buf, size_t count) 706 { 707 int ret; 708 struct sht15_data *data = dev_get_drvdata(dev); 709 long value; 710 u8 status; 711 712 if (kstrtol(buf, 10, &value)) 713 return -EINVAL; 714 715 mutex_lock(&data->read_lock); 716 status = data->val_status & 0x07; 717 if (!!value) 718 status |= SHT15_STATUS_HEATER; 719 else 720 status &= ~SHT15_STATUS_HEATER; 721 722 ret = sht15_send_status(data, status); 723 mutex_unlock(&data->read_lock); 724 725 return ret ? ret : count; 726 } 727 728 /** 729 * sht15_show_temp() - show temperature measurement value in sysfs 730 * @dev: device. 731 * @attr: device attribute. 732 * @buf: sysfs buffer where measurement values are written to. 733 * 734 * Will be called on read access to temp1_input sysfs attribute. 735 * Returns number of bytes written into buffer, negative errno on error. 736 */ 737 static ssize_t sht15_show_temp(struct device *dev, 738 struct device_attribute *attr, 739 char *buf) 740 { 741 int ret; 742 struct sht15_data *data = dev_get_drvdata(dev); 743 744 /* Technically no need to read humidity as well */ 745 ret = sht15_update_measurements(data); 746 747 return ret ? ret : sprintf(buf, "%d\n", 748 sht15_calc_temp(data)); 749 } 750 751 /** 752 * sht15_show_humidity() - show humidity measurement value in sysfs 753 * @dev: device. 754 * @attr: device attribute. 755 * @buf: sysfs buffer where measurement values are written to. 756 * 757 * Will be called on read access to humidity1_input sysfs attribute. 758 * Returns number of bytes written into buffer, negative errno on error. 759 */ 760 static ssize_t sht15_show_humidity(struct device *dev, 761 struct device_attribute *attr, 762 char *buf) 763 { 764 int ret; 765 struct sht15_data *data = dev_get_drvdata(dev); 766 767 ret = sht15_update_measurements(data); 768 769 return ret ? ret : sprintf(buf, "%d\n", sht15_calc_humid(data)); 770 } 771 772 static ssize_t name_show(struct device *dev, 773 struct device_attribute *attr, 774 char *buf) 775 { 776 struct platform_device *pdev = to_platform_device(dev); 777 return sprintf(buf, "%s\n", pdev->name); 778 } 779 780 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, 781 sht15_show_temp, NULL, 0); 782 static SENSOR_DEVICE_ATTR(humidity1_input, S_IRUGO, 783 sht15_show_humidity, NULL, 0); 784 static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, sht15_show_status, NULL, 785 SHT15_STATUS_LOW_BATTERY); 786 static SENSOR_DEVICE_ATTR(humidity1_fault, S_IRUGO, sht15_show_status, NULL, 787 SHT15_STATUS_LOW_BATTERY); 788 static SENSOR_DEVICE_ATTR(heater_enable, S_IRUGO | S_IWUSR, sht15_show_status, 789 sht15_store_heater, SHT15_STATUS_HEATER); 790 static DEVICE_ATTR_RO(name); 791 static struct attribute *sht15_attrs[] = { 792 &sensor_dev_attr_temp1_input.dev_attr.attr, 793 &sensor_dev_attr_humidity1_input.dev_attr.attr, 794 &sensor_dev_attr_temp1_fault.dev_attr.attr, 795 &sensor_dev_attr_humidity1_fault.dev_attr.attr, 796 &sensor_dev_attr_heater_enable.dev_attr.attr, 797 &dev_attr_name.attr, 798 NULL, 799 }; 800 801 static const struct attribute_group sht15_attr_group = { 802 .attrs = sht15_attrs, 803 }; 804 805 static irqreturn_t sht15_interrupt_fired(int irq, void *d) 806 { 807 struct sht15_data *data = d; 808 809 /* First disable the interrupt */ 810 disable_irq_nosync(irq); 811 atomic_inc(&data->interrupt_handled); 812 /* Then schedule a reading work struct */ 813 if (data->state != SHT15_READING_NOTHING) 814 schedule_work(&data->read_work); 815 return IRQ_HANDLED; 816 } 817 818 static void sht15_bh_read_data(struct work_struct *work_s) 819 { 820 uint16_t val = 0; 821 u8 dev_checksum = 0; 822 u8 checksum_vals[3]; 823 struct sht15_data *data 824 = container_of(work_s, struct sht15_data, 825 read_work); 826 827 /* Firstly, verify the line is low */ 828 if (gpiod_get_value(data->data)) { 829 /* 830 * If not, then start the interrupt again - care here as could 831 * have gone low in meantime so verify it hasn't! 832 */ 833 atomic_set(&data->interrupt_handled, 0); 834 enable_irq(gpiod_to_irq(data->data)); 835 /* If still not occurred or another handler was scheduled */ 836 if (gpiod_get_value(data->data) 837 || atomic_read(&data->interrupt_handled)) 838 return; 839 } 840 841 /* Read the data back from the device */ 842 val = sht15_read_byte(data); 843 val <<= 8; 844 if (sht15_ack(data)) 845 goto wakeup; 846 val |= sht15_read_byte(data); 847 848 if (data->checksumming) { 849 /* 850 * Ask the device for a checksum and read it back. 851 * Note: the device sends the checksum byte reversed. 852 */ 853 if (sht15_ack(data)) 854 goto wakeup; 855 dev_checksum = bitrev8(sht15_read_byte(data)); 856 checksum_vals[0] = (data->state == SHT15_READING_TEMP) ? 857 SHT15_MEASURE_TEMP : SHT15_MEASURE_RH; 858 checksum_vals[1] = (u8) (val >> 8); 859 checksum_vals[2] = (u8) val; 860 data->checksum_ok 861 = (sht15_crc8(data, checksum_vals, 3) == dev_checksum); 862 } 863 864 /* Tell the device we are done */ 865 if (sht15_end_transmission(data)) 866 goto wakeup; 867 868 switch (data->state) { 869 case SHT15_READING_TEMP: 870 data->val_temp = val; 871 break; 872 case SHT15_READING_HUMID: 873 data->val_humid = val; 874 break; 875 default: 876 break; 877 } 878 879 data->state = SHT15_READING_NOTHING; 880 wakeup: 881 wake_up(&data->wait_queue); 882 } 883 884 static void sht15_update_voltage(struct work_struct *work_s) 885 { 886 struct sht15_data *data 887 = container_of(work_s, struct sht15_data, 888 update_supply_work); 889 data->supply_uv = regulator_get_voltage(data->reg); 890 } 891 892 /** 893 * sht15_invalidate_voltage() - mark supply voltage invalid when notified by reg 894 * @nb: associated notification structure 895 * @event: voltage regulator state change event code 896 * @ignored: function parameter - ignored here 897 * 898 * Note that as the notification code holds the regulator lock, we have 899 * to schedule an update of the supply voltage rather than getting it directly. 900 */ 901 static int sht15_invalidate_voltage(struct notifier_block *nb, 902 unsigned long event, 903 void *ignored) 904 { 905 struct sht15_data *data = container_of(nb, struct sht15_data, nb); 906 907 if (event == REGULATOR_EVENT_VOLTAGE_CHANGE) 908 data->supply_uv_valid = false; 909 schedule_work(&data->update_supply_work); 910 911 return NOTIFY_OK; 912 } 913 914 #ifdef CONFIG_OF 915 static const struct of_device_id sht15_dt_match[] = { 916 { .compatible = "sensirion,sht15" }, 917 { }, 918 }; 919 MODULE_DEVICE_TABLE(of, sht15_dt_match); 920 #endif 921 922 static int sht15_probe(struct platform_device *pdev) 923 { 924 int ret; 925 struct sht15_data *data; 926 927 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 928 if (!data) 929 return -ENOMEM; 930 931 INIT_WORK(&data->read_work, sht15_bh_read_data); 932 INIT_WORK(&data->update_supply_work, sht15_update_voltage); 933 platform_set_drvdata(pdev, data); 934 mutex_init(&data->read_lock); 935 data->dev = &pdev->dev; 936 init_waitqueue_head(&data->wait_queue); 937 938 /* 939 * If a regulator is available, 940 * query what the supply voltage actually is! 941 */ 942 data->reg = devm_regulator_get_optional(data->dev, "vcc"); 943 if (!IS_ERR(data->reg)) { 944 int voltage; 945 946 voltage = regulator_get_voltage(data->reg); 947 if (voltage) 948 data->supply_uv = voltage; 949 950 ret = regulator_enable(data->reg); 951 if (ret != 0) { 952 dev_err(&pdev->dev, 953 "failed to enable regulator: %d\n", ret); 954 return ret; 955 } 956 957 /* 958 * Setup a notifier block to update this if another device 959 * causes the voltage to change 960 */ 961 data->nb.notifier_call = &sht15_invalidate_voltage; 962 ret = regulator_register_notifier(data->reg, &data->nb); 963 if (ret) { 964 dev_err(&pdev->dev, 965 "regulator notifier request failed\n"); 966 regulator_disable(data->reg); 967 return ret; 968 } 969 } 970 971 /* Try requesting the GPIOs */ 972 data->sck = devm_gpiod_get(&pdev->dev, "clk", GPIOD_OUT_LOW); 973 if (IS_ERR(data->sck)) { 974 ret = PTR_ERR(data->sck); 975 dev_err(&pdev->dev, "clock line GPIO request failed\n"); 976 goto err_release_reg; 977 } 978 data->data = devm_gpiod_get(&pdev->dev, "data", GPIOD_IN); 979 if (IS_ERR(data->data)) { 980 ret = PTR_ERR(data->data); 981 dev_err(&pdev->dev, "data line GPIO request failed\n"); 982 goto err_release_reg; 983 } 984 985 ret = devm_request_irq(&pdev->dev, gpiod_to_irq(data->data), 986 sht15_interrupt_fired, 987 IRQF_TRIGGER_FALLING, 988 "sht15 data", 989 data); 990 if (ret) { 991 dev_err(&pdev->dev, "failed to get irq for data line\n"); 992 goto err_release_reg; 993 } 994 disable_irq_nosync(gpiod_to_irq(data->data)); 995 ret = sht15_connection_reset(data); 996 if (ret) 997 goto err_release_reg; 998 ret = sht15_soft_reset(data); 999 if (ret) 1000 goto err_release_reg; 1001 1002 ret = sysfs_create_group(&pdev->dev.kobj, &sht15_attr_group); 1003 if (ret) { 1004 dev_err(&pdev->dev, "sysfs create failed\n"); 1005 goto err_release_reg; 1006 } 1007 1008 data->hwmon_dev = hwmon_device_register(data->dev); 1009 if (IS_ERR(data->hwmon_dev)) { 1010 ret = PTR_ERR(data->hwmon_dev); 1011 goto err_release_sysfs_group; 1012 } 1013 1014 return 0; 1015 1016 err_release_sysfs_group: 1017 sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group); 1018 err_release_reg: 1019 if (!IS_ERR(data->reg)) { 1020 regulator_unregister_notifier(data->reg, &data->nb); 1021 regulator_disable(data->reg); 1022 } 1023 return ret; 1024 } 1025 1026 static int sht15_remove(struct platform_device *pdev) 1027 { 1028 struct sht15_data *data = platform_get_drvdata(pdev); 1029 1030 /* 1031 * Make sure any reads from the device are done and 1032 * prevent new ones beginning 1033 */ 1034 mutex_lock(&data->read_lock); 1035 if (sht15_soft_reset(data)) { 1036 mutex_unlock(&data->read_lock); 1037 return -EFAULT; 1038 } 1039 hwmon_device_unregister(data->hwmon_dev); 1040 sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group); 1041 if (!IS_ERR(data->reg)) { 1042 regulator_unregister_notifier(data->reg, &data->nb); 1043 regulator_disable(data->reg); 1044 } 1045 1046 mutex_unlock(&data->read_lock); 1047 1048 return 0; 1049 } 1050 1051 static const struct platform_device_id sht15_device_ids[] = { 1052 { "sht10", sht10 }, 1053 { "sht11", sht11 }, 1054 { "sht15", sht15 }, 1055 { "sht71", sht71 }, 1056 { "sht75", sht75 }, 1057 { } 1058 }; 1059 MODULE_DEVICE_TABLE(platform, sht15_device_ids); 1060 1061 static struct platform_driver sht15_driver = { 1062 .driver = { 1063 .name = "sht15", 1064 .of_match_table = of_match_ptr(sht15_dt_match), 1065 }, 1066 .probe = sht15_probe, 1067 .remove = sht15_remove, 1068 .id_table = sht15_device_ids, 1069 }; 1070 module_platform_driver(sht15_driver); 1071 1072 MODULE_LICENSE("GPL"); 1073 MODULE_DESCRIPTION("Sensirion SHT15 temperature and humidity sensor driver"); 1074