drivers/hwmon/sht15.c

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

DEFINITIONS
