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