1 /* 2 * sht15.c - support for the SHT15 Temperature and Humidity Sensor 3 * 4 * Copyright (c) 2009 Jonathan Cameron 5 * 6 * Copyright (c) 2007 Wouter Horre 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 * Currently ignoring checksum on readings. 13 * Default resolution only (14bit temp, 12bit humidity) 14 * Ignoring battery status. 15 * Heater not enabled. 16 * Timings are all conservative. 17 * 18 * Data sheet available (1/2009) at 19 * http://www.sensirion.ch/en/pdf/product_information/Datasheet-humidity-sensor-SHT1x.pdf 20 * 21 * Regulator supply name = vcc 22 */ 23 24 #include <linux/interrupt.h> 25 #include <linux/irq.h> 26 #include <linux/gpio.h> 27 #include <linux/module.h> 28 #include <linux/init.h> 29 #include <linux/hwmon.h> 30 #include <linux/hwmon-sysfs.h> 31 #include <linux/mutex.h> 32 #include <linux/platform_device.h> 33 #include <linux/delay.h> 34 #include <linux/jiffies.h> 35 #include <linux/err.h> 36 #include <linux/sht15.h> 37 #include <linux/regulator/consumer.h> 38 #include <asm/atomic.h> 39 40 #define SHT15_MEASURE_TEMP 3 41 #define SHT15_MEASURE_RH 5 42 43 #define SHT15_READING_NOTHING 0 44 #define SHT15_READING_TEMP 1 45 #define SHT15_READING_HUMID 2 46 47 /* Min timings in nsecs */ 48 #define SHT15_TSCKL 100 /* clock low */ 49 #define SHT15_TSCKH 100 /* clock high */ 50 #define SHT15_TSU 150 /* data setup time */ 51 52 /** 53 * struct sht15_temppair - elements of voltage dependant temp calc 54 * @vdd: supply voltage in microvolts 55 * @d1: see data sheet 56 */ 57 struct sht15_temppair { 58 int vdd; /* microvolts */ 59 int d1; 60 }; 61 62 /* Table 9 from data sheet - relates temperature calculation 63 * to supply voltage. 64 */ 65 static const struct sht15_temppair temppoints[] = { 66 { 2500000, -39400 }, 67 { 3000000, -39600 }, 68 { 3500000, -39700 }, 69 { 4000000, -39800 }, 70 { 5000000, -40100 }, 71 }; 72 73 /** 74 * struct sht15_data - device instance specific data 75 * @pdata: platform data (gpio's etc) 76 * @read_work: bh of interrupt handler 77 * @wait_queue: wait queue for getting values from device 78 * @val_temp: last temperature value read from device 79 * @val_humid: last humidity value read from device 80 * @flag: status flag used to identify what the last request was 81 * @valid: are the current stored values valid (start condition) 82 * @last_updat: time of last update 83 * @read_lock: mutex to ensure only one read in progress 84 * at a time. 85 * @dev: associate device structure 86 * @hwmon_dev: device associated with hwmon subsystem 87 * @reg: associated regulator (if specified) 88 * @nb: notifier block to handle notifications of voltage changes 89 * @supply_uV: local copy of supply voltage used to allow 90 * use of regulator consumer if available 91 * @supply_uV_valid: indicates that an updated value has not yet 92 * been obtained from the regulator and so any calculations 93 * based upon it will be invalid. 94 * @update_supply_work: work struct that is used to update the supply_uV 95 * @interrupt_handled: flag used to indicate a hander has been scheduled 96 */ 97 struct sht15_data { 98 struct sht15_platform_data *pdata; 99 struct work_struct read_work; 100 wait_queue_head_t wait_queue; 101 uint16_t val_temp; 102 uint16_t val_humid; 103 u8 flag; 104 u8 valid; 105 unsigned long last_updat; 106 struct mutex read_lock; 107 struct device *dev; 108 struct device *hwmon_dev; 109 struct regulator *reg; 110 struct notifier_block nb; 111 int supply_uV; 112 int supply_uV_valid; 113 struct work_struct update_supply_work; 114 atomic_t interrupt_handled; 115 }; 116 117 /** 118 * sht15_connection_reset() - reset the comms interface 119 * @data: sht15 specific data 120 * 121 * This implements section 3.4 of the data sheet 122 */ 123 static void sht15_connection_reset(struct sht15_data *data) 124 { 125 int i; 126 gpio_direction_output(data->pdata->gpio_data, 1); 127 ndelay(SHT15_TSCKL); 128 gpio_set_value(data->pdata->gpio_sck, 0); 129 ndelay(SHT15_TSCKL); 130 for (i = 0; i < 9; ++i) { 131 gpio_set_value(data->pdata->gpio_sck, 1); 132 ndelay(SHT15_TSCKH); 133 gpio_set_value(data->pdata->gpio_sck, 0); 134 ndelay(SHT15_TSCKL); 135 } 136 } 137 /** 138 * sht15_send_bit() - send an individual bit to the device 139 * @data: device state data 140 * @val: value of bit to be sent 141 **/ 142 static inline void sht15_send_bit(struct sht15_data *data, int val) 143 { 144 145 gpio_set_value(data->pdata->gpio_data, val); 146 ndelay(SHT15_TSU); 147 gpio_set_value(data->pdata->gpio_sck, 1); 148 ndelay(SHT15_TSCKH); 149 gpio_set_value(data->pdata->gpio_sck, 0); 150 ndelay(SHT15_TSCKL); /* clock low time */ 151 } 152 153 /** 154 * sht15_transmission_start() - specific sequence for new transmission 155 * 156 * @data: device state data 157 * Timings for this are not documented on the data sheet, so very 158 * conservative ones used in implementation. This implements 159 * figure 12 on the data sheet. 160 **/ 161 static void sht15_transmission_start(struct sht15_data *data) 162 { 163 /* ensure data is high and output */ 164 gpio_direction_output(data->pdata->gpio_data, 1); 165 ndelay(SHT15_TSU); 166 gpio_set_value(data->pdata->gpio_sck, 0); 167 ndelay(SHT15_TSCKL); 168 gpio_set_value(data->pdata->gpio_sck, 1); 169 ndelay(SHT15_TSCKH); 170 gpio_set_value(data->pdata->gpio_data, 0); 171 ndelay(SHT15_TSU); 172 gpio_set_value(data->pdata->gpio_sck, 0); 173 ndelay(SHT15_TSCKL); 174 gpio_set_value(data->pdata->gpio_sck, 1); 175 ndelay(SHT15_TSCKH); 176 gpio_set_value(data->pdata->gpio_data, 1); 177 ndelay(SHT15_TSU); 178 gpio_set_value(data->pdata->gpio_sck, 0); 179 ndelay(SHT15_TSCKL); 180 } 181 /** 182 * sht15_send_byte() - send a single byte to the device 183 * @data: device state 184 * @byte: value to be sent 185 **/ 186 static void sht15_send_byte(struct sht15_data *data, u8 byte) 187 { 188 int i; 189 for (i = 0; i < 8; i++) { 190 sht15_send_bit(data, !!(byte & 0x80)); 191 byte <<= 1; 192 } 193 } 194 /** 195 * sht15_wait_for_response() - checks for ack from device 196 * @data: device state 197 **/ 198 static int sht15_wait_for_response(struct sht15_data *data) 199 { 200 gpio_direction_input(data->pdata->gpio_data); 201 gpio_set_value(data->pdata->gpio_sck, 1); 202 ndelay(SHT15_TSCKH); 203 if (gpio_get_value(data->pdata->gpio_data)) { 204 gpio_set_value(data->pdata->gpio_sck, 0); 205 dev_err(data->dev, "Command not acknowledged\n"); 206 sht15_connection_reset(data); 207 return -EIO; 208 } 209 gpio_set_value(data->pdata->gpio_sck, 0); 210 ndelay(SHT15_TSCKL); 211 return 0; 212 } 213 214 /** 215 * sht15_send_cmd() - Sends a command to the device. 216 * @data: device state 217 * @cmd: command byte to be sent 218 * 219 * On entry, sck is output low, data is output pull high 220 * and the interrupt disabled. 221 **/ 222 static int sht15_send_cmd(struct sht15_data *data, u8 cmd) 223 { 224 int ret = 0; 225 sht15_transmission_start(data); 226 sht15_send_byte(data, cmd); 227 ret = sht15_wait_for_response(data); 228 return ret; 229 } 230 /** 231 * sht15_update_single_val() - get a new value from device 232 * @data: device instance specific data 233 * @command: command sent to request value 234 * @timeout_msecs: timeout after which comms are assumed 235 * to have failed are reset. 236 **/ 237 static inline int sht15_update_single_val(struct sht15_data *data, 238 int command, 239 int timeout_msecs) 240 { 241 int ret; 242 ret = sht15_send_cmd(data, command); 243 if (ret) 244 return ret; 245 246 gpio_direction_input(data->pdata->gpio_data); 247 atomic_set(&data->interrupt_handled, 0); 248 249 enable_irq(gpio_to_irq(data->pdata->gpio_data)); 250 if (gpio_get_value(data->pdata->gpio_data) == 0) { 251 disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data)); 252 /* Only relevant if the interrupt hasn't occured. */ 253 if (!atomic_read(&data->interrupt_handled)) 254 schedule_work(&data->read_work); 255 } 256 ret = wait_event_timeout(data->wait_queue, 257 (data->flag == SHT15_READING_NOTHING), 258 msecs_to_jiffies(timeout_msecs)); 259 if (ret == 0) {/* timeout occurred */ 260 disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data));; 261 sht15_connection_reset(data); 262 return -ETIME; 263 } 264 return 0; 265 } 266 267 /** 268 * sht15_update_vals() - get updated readings from device if too old 269 * @data: device state 270 **/ 271 static int sht15_update_vals(struct sht15_data *data) 272 { 273 int ret = 0; 274 int timeout = HZ; 275 276 mutex_lock(&data->read_lock); 277 if (time_after(jiffies, data->last_updat + timeout) 278 || !data->valid) { 279 data->flag = SHT15_READING_HUMID; 280 ret = sht15_update_single_val(data, SHT15_MEASURE_RH, 160); 281 if (ret) 282 goto error_ret; 283 data->flag = SHT15_READING_TEMP; 284 ret = sht15_update_single_val(data, SHT15_MEASURE_TEMP, 400); 285 if (ret) 286 goto error_ret; 287 data->valid = 1; 288 data->last_updat = jiffies; 289 } 290 error_ret: 291 mutex_unlock(&data->read_lock); 292 293 return ret; 294 } 295 296 /** 297 * sht15_calc_temp() - convert the raw reading to a temperature 298 * @data: device state 299 * 300 * As per section 4.3 of the data sheet. 301 **/ 302 static inline int sht15_calc_temp(struct sht15_data *data) 303 { 304 int d1 = 0; 305 int i; 306 307 for (i = 1; i < ARRAY_SIZE(temppoints) - 1; i++) 308 /* Find pointer to interpolate */ 309 if (data->supply_uV > temppoints[i - 1].vdd) { 310 d1 = (data->supply_uV/1000 - temppoints[i - 1].vdd) 311 * (temppoints[i].d1 - temppoints[i - 1].d1) 312 / (temppoints[i].vdd - temppoints[i - 1].vdd) 313 + temppoints[i - 1].d1; 314 break; 315 } 316 317 return data->val_temp*10 + d1; 318 } 319 320 /** 321 * sht15_calc_humid() - using last temperature convert raw to humid 322 * @data: device state 323 * 324 * This is the temperature compensated version as per section 4.2 of 325 * the data sheet. 326 **/ 327 static inline int sht15_calc_humid(struct sht15_data *data) 328 { 329 int RHlinear; /* milli percent */ 330 int temp = sht15_calc_temp(data); 331 332 const int c1 = -4; 333 const int c2 = 40500; /* x 10 ^ -6 */ 334 const int c3 = 2800; /* x10 ^ -9 */ 335 336 RHlinear = c1*1000 337 + c2 * data->val_humid/1000 338 + (data->val_humid * data->val_humid * c3)/1000000; 339 return (temp - 25000) * (10000 + 800 * data->val_humid) 340 / 1000000 + RHlinear; 341 } 342 343 static ssize_t sht15_show_temp(struct device *dev, 344 struct device_attribute *attr, 345 char *buf) 346 { 347 int ret; 348 struct sht15_data *data = dev_get_drvdata(dev); 349 350 /* Technically no need to read humidity as well */ 351 ret = sht15_update_vals(data); 352 353 return ret ? ret : sprintf(buf, "%d\n", 354 sht15_calc_temp(data)); 355 } 356 357 static ssize_t sht15_show_humidity(struct device *dev, 358 struct device_attribute *attr, 359 char *buf) 360 { 361 int ret; 362 struct sht15_data *data = dev_get_drvdata(dev); 363 364 ret = sht15_update_vals(data); 365 366 return ret ? ret : sprintf(buf, "%d\n", sht15_calc_humid(data)); 367 368 }; 369 static ssize_t show_name(struct device *dev, 370 struct device_attribute *attr, 371 char *buf) 372 { 373 struct platform_device *pdev = to_platform_device(dev); 374 return sprintf(buf, "%s\n", pdev->name); 375 } 376 377 static SENSOR_DEVICE_ATTR(temp1_input, 378 S_IRUGO, sht15_show_temp, 379 NULL, 0); 380 static SENSOR_DEVICE_ATTR(humidity1_input, 381 S_IRUGO, sht15_show_humidity, 382 NULL, 0); 383 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 384 static struct attribute *sht15_attrs[] = { 385 &sensor_dev_attr_temp1_input.dev_attr.attr, 386 &sensor_dev_attr_humidity1_input.dev_attr.attr, 387 &dev_attr_name.attr, 388 NULL, 389 }; 390 391 static const struct attribute_group sht15_attr_group = { 392 .attrs = sht15_attrs, 393 }; 394 395 static irqreturn_t sht15_interrupt_fired(int irq, void *d) 396 { 397 struct sht15_data *data = d; 398 /* First disable the interrupt */ 399 disable_irq_nosync(irq); 400 atomic_inc(&data->interrupt_handled); 401 /* Then schedule a reading work struct */ 402 if (data->flag != SHT15_READING_NOTHING) 403 schedule_work(&data->read_work); 404 return IRQ_HANDLED; 405 } 406 407 /* Each byte of data is acknowledged by pulling the data line 408 * low for one clock pulse. 409 */ 410 static void sht15_ack(struct sht15_data *data) 411 { 412 gpio_direction_output(data->pdata->gpio_data, 0); 413 ndelay(SHT15_TSU); 414 gpio_set_value(data->pdata->gpio_sck, 1); 415 ndelay(SHT15_TSU); 416 gpio_set_value(data->pdata->gpio_sck, 0); 417 ndelay(SHT15_TSU); 418 gpio_set_value(data->pdata->gpio_data, 1); 419 420 gpio_direction_input(data->pdata->gpio_data); 421 } 422 /** 423 * sht15_end_transmission() - notify device of end of transmission 424 * @data: device state 425 * 426 * This is basically a NAK. (single clock pulse, data high) 427 **/ 428 static void sht15_end_transmission(struct sht15_data *data) 429 { 430 gpio_direction_output(data->pdata->gpio_data, 1); 431 ndelay(SHT15_TSU); 432 gpio_set_value(data->pdata->gpio_sck, 1); 433 ndelay(SHT15_TSCKH); 434 gpio_set_value(data->pdata->gpio_sck, 0); 435 ndelay(SHT15_TSCKL); 436 } 437 438 static void sht15_bh_read_data(struct work_struct *work_s) 439 { 440 int i; 441 uint16_t val = 0; 442 struct sht15_data *data 443 = container_of(work_s, struct sht15_data, 444 read_work); 445 /* Firstly, verify the line is low */ 446 if (gpio_get_value(data->pdata->gpio_data)) { 447 /* If not, then start the interrupt again - care 448 here as could have gone low in meantime so verify 449 it hasn't! 450 */ 451 atomic_set(&data->interrupt_handled, 0); 452 enable_irq(gpio_to_irq(data->pdata->gpio_data)); 453 /* If still not occured or another handler has been scheduled */ 454 if (gpio_get_value(data->pdata->gpio_data) 455 || atomic_read(&data->interrupt_handled)) 456 return; 457 } 458 /* Read the data back from the device */ 459 for (i = 0; i < 16; ++i) { 460 val <<= 1; 461 gpio_set_value(data->pdata->gpio_sck, 1); 462 ndelay(SHT15_TSCKH); 463 val |= !!gpio_get_value(data->pdata->gpio_data); 464 gpio_set_value(data->pdata->gpio_sck, 0); 465 ndelay(SHT15_TSCKL); 466 if (i == 7) 467 sht15_ack(data); 468 } 469 /* Tell the device we are done */ 470 sht15_end_transmission(data); 471 472 switch (data->flag) { 473 case SHT15_READING_TEMP: 474 data->val_temp = val; 475 break; 476 case SHT15_READING_HUMID: 477 data->val_humid = val; 478 break; 479 } 480 481 data->flag = SHT15_READING_NOTHING; 482 wake_up(&data->wait_queue); 483 } 484 485 static void sht15_update_voltage(struct work_struct *work_s) 486 { 487 struct sht15_data *data 488 = container_of(work_s, struct sht15_data, 489 update_supply_work); 490 data->supply_uV = regulator_get_voltage(data->reg); 491 } 492 493 /** 494 * sht15_invalidate_voltage() - mark supply voltage invalid when notified by reg 495 * @nb: associated notification structure 496 * @event: voltage regulator state change event code 497 * @ignored: function parameter - ignored here 498 * 499 * Note that as the notification code holds the regulator lock, we have 500 * to schedule an update of the supply voltage rather than getting it directly. 501 **/ 502 static int sht15_invalidate_voltage(struct notifier_block *nb, 503 unsigned long event, 504 void *ignored) 505 { 506 struct sht15_data *data = container_of(nb, struct sht15_data, nb); 507 508 if (event == REGULATOR_EVENT_VOLTAGE_CHANGE) 509 data->supply_uV_valid = false; 510 schedule_work(&data->update_supply_work); 511 512 return NOTIFY_OK; 513 } 514 515 static int __devinit sht15_probe(struct platform_device *pdev) 516 { 517 int ret = 0; 518 struct sht15_data *data = kzalloc(sizeof(*data), GFP_KERNEL); 519 520 if (!data) { 521 ret = -ENOMEM; 522 dev_err(&pdev->dev, "kzalloc failed"); 523 goto error_ret; 524 } 525 526 INIT_WORK(&data->read_work, sht15_bh_read_data); 527 INIT_WORK(&data->update_supply_work, sht15_update_voltage); 528 platform_set_drvdata(pdev, data); 529 mutex_init(&data->read_lock); 530 data->dev = &pdev->dev; 531 init_waitqueue_head(&data->wait_queue); 532 533 if (pdev->dev.platform_data == NULL) { 534 dev_err(&pdev->dev, "no platform data supplied"); 535 goto err_free_data; 536 } 537 data->pdata = pdev->dev.platform_data; 538 data->supply_uV = data->pdata->supply_mv*1000; 539 540 /* If a regulator is available, query what the supply voltage actually is!*/ 541 data->reg = regulator_get(data->dev, "vcc"); 542 if (!IS_ERR(data->reg)) { 543 data->supply_uV = regulator_get_voltage(data->reg); 544 regulator_enable(data->reg); 545 /* setup a notifier block to update this if another device 546 * causes the voltage to change */ 547 data->nb.notifier_call = &sht15_invalidate_voltage; 548 ret = regulator_register_notifier(data->reg, &data->nb); 549 } 550 /* Try requesting the GPIOs */ 551 ret = gpio_request(data->pdata->gpio_sck, "SHT15 sck"); 552 if (ret) { 553 dev_err(&pdev->dev, "gpio request failed"); 554 goto err_free_data; 555 } 556 gpio_direction_output(data->pdata->gpio_sck, 0); 557 ret = gpio_request(data->pdata->gpio_data, "SHT15 data"); 558 if (ret) { 559 dev_err(&pdev->dev, "gpio request failed"); 560 goto err_release_gpio_sck; 561 } 562 ret = sysfs_create_group(&pdev->dev.kobj, &sht15_attr_group); 563 if (ret) { 564 dev_err(&pdev->dev, "sysfs create failed"); 565 goto err_free_data; 566 } 567 568 ret = request_irq(gpio_to_irq(data->pdata->gpio_data), 569 sht15_interrupt_fired, 570 IRQF_TRIGGER_FALLING, 571 "sht15 data", 572 data); 573 if (ret) { 574 dev_err(&pdev->dev, "failed to get irq for data line"); 575 goto err_release_gpio_data; 576 } 577 disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data)); 578 sht15_connection_reset(data); 579 sht15_send_cmd(data, 0x1E); 580 581 data->hwmon_dev = hwmon_device_register(data->dev); 582 if (IS_ERR(data->hwmon_dev)) { 583 ret = PTR_ERR(data->hwmon_dev); 584 goto err_release_gpio_data; 585 } 586 return 0; 587 588 err_release_gpio_data: 589 gpio_free(data->pdata->gpio_data); 590 err_release_gpio_sck: 591 gpio_free(data->pdata->gpio_sck); 592 err_free_data: 593 kfree(data); 594 error_ret: 595 596 return ret; 597 } 598 599 static int __devexit sht15_remove(struct platform_device *pdev) 600 { 601 struct sht15_data *data = platform_get_drvdata(pdev); 602 603 /* Make sure any reads from the device are done and 604 * prevent new ones beginnning */ 605 mutex_lock(&data->read_lock); 606 hwmon_device_unregister(data->hwmon_dev); 607 sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group); 608 if (!IS_ERR(data->reg)) { 609 regulator_unregister_notifier(data->reg, &data->nb); 610 regulator_disable(data->reg); 611 regulator_put(data->reg); 612 } 613 614 free_irq(gpio_to_irq(data->pdata->gpio_data), data); 615 gpio_free(data->pdata->gpio_data); 616 gpio_free(data->pdata->gpio_sck); 617 mutex_unlock(&data->read_lock); 618 kfree(data); 619 return 0; 620 } 621 622 623 static struct platform_driver sht_drivers[] = { 624 { 625 .driver = { 626 .name = "sht10", 627 .owner = THIS_MODULE, 628 }, 629 .probe = sht15_probe, 630 .remove = sht15_remove, 631 }, { 632 .driver = { 633 .name = "sht11", 634 .owner = THIS_MODULE, 635 }, 636 .probe = sht15_probe, 637 .remove = sht15_remove, 638 }, { 639 .driver = { 640 .name = "sht15", 641 .owner = THIS_MODULE, 642 }, 643 .probe = sht15_probe, 644 .remove = sht15_remove, 645 }, { 646 .driver = { 647 .name = "sht71", 648 .owner = THIS_MODULE, 649 }, 650 .probe = sht15_probe, 651 .remove = sht15_remove, 652 }, { 653 .driver = { 654 .name = "sht75", 655 .owner = THIS_MODULE, 656 }, 657 .probe = sht15_probe, 658 .remove = sht15_remove, 659 }, 660 }; 661 662 663 static int __init sht15_init(void) 664 { 665 int ret; 666 int i; 667 668 for (i = 0; i < ARRAY_SIZE(sht_drivers); i++) { 669 ret = platform_driver_register(&sht_drivers[i]); 670 if (ret) 671 goto error_unreg; 672 } 673 674 return 0; 675 676 error_unreg: 677 while (--i >= 0) 678 platform_driver_unregister(&sht_drivers[i]); 679 680 return ret; 681 } 682 module_init(sht15_init); 683 684 static void __exit sht15_exit(void) 685 { 686 int i; 687 for (i = ARRAY_SIZE(sht_drivers) - 1; i >= 0; i--) 688 platform_driver_unregister(&sht_drivers[i]); 689 } 690 module_exit(sht15_exit); 691 692 MODULE_LICENSE("GPL"); 693