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