Version:  2.0.40 2.2.26 2.4.37 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6

Linux/drivers/hwmon/sht15.c

  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 #include <linux/bitrev.h>
 37 
 38 /* Commands */
 39 #define SHT15_MEASURE_TEMP              0x03
 40 #define SHT15_MEASURE_RH                0x05
 41 #define SHT15_WRITE_STATUS              0x06
 42 #define SHT15_READ_STATUS               0x07
 43 #define SHT15_SOFT_RESET                0x1E
 44 
 45 /* Min timings */
 46 #define SHT15_TSCKL                     100     /* (nsecs) clock low */
 47 #define SHT15_TSCKH                     100     /* (nsecs) clock high */
 48 #define SHT15_TSU                       150     /* (nsecs) data setup time */
 49 #define SHT15_TSRST                     11      /* (msecs) soft reset time */
 50 
 51 /* Status Register Bits */
 52 #define SHT15_STATUS_LOW_RESOLUTION     0x01
 53 #define SHT15_STATUS_NO_OTP_RELOAD      0x02
 54 #define SHT15_STATUS_HEATER             0x04
 55 #define SHT15_STATUS_LOW_BATTERY        0x40
 56 
 57 /* List of supported chips */
 58 enum sht15_chips { sht10, sht11, sht15, sht71, sht75 };
 59 
 60 /* Actions the driver may be doing */
 61 enum sht15_state {
 62         SHT15_READING_NOTHING,
 63         SHT15_READING_TEMP,
 64         SHT15_READING_HUMID
 65 };
 66 
 67 /**
 68  * struct sht15_temppair - elements of voltage dependent temp calc
 69  * @vdd:        supply voltage in microvolts
 70  * @d1:         see data sheet
 71  */
 72 struct sht15_temppair {
 73         int vdd; /* microvolts */
 74         int d1;
 75 };
 76 
 77 /* Table 9 from datasheet - relates temperature calculation to supply voltage */
 78 static const struct sht15_temppair temppoints[] = {
 79         { 2500000, -39400 },
 80         { 3000000, -39600 },
 81         { 3500000, -39700 },
 82         { 4000000, -39800 },
 83         { 5000000, -40100 },
 84 };
 85 
 86 /* Table from CRC datasheet, section 2.4 */
 87 static const u8 sht15_crc8_table[] = {
 88         0,      49,     98,     83,     196,    245,    166,    151,
 89         185,    136,    219,    234,    125,    76,     31,     46,
 90         67,     114,    33,     16,     135,    182,    229,    212,
 91         250,    203,    152,    169,    62,     15,     92,     109,
 92         134,    183,    228,    213,    66,     115,    32,     17,
 93         63,     14,     93,     108,    251,    202,    153,    168,
 94         197,    244,    167,    150,    1,      48,     99,     82,
 95         124,    77,     30,     47,     184,    137,    218,    235,
 96         61,     12,     95,     110,    249,    200,    155,    170,
 97         132,    181,    230,    215,    64,     113,    34,     19,
 98         126,    79,     28,     45,     186,    139,    216,    233,
 99         199,    246,    165,    148,    3,      50,     97,     80,
100         187,    138,    217,    232,    127,    78,     29,     44,
101         2,      51,     96,     81,     198,    247,    164,    149,
102         248,    201,    154,    171,    60,     13,     94,     111,
103         65,     112,    35,     18,     133,    180,    231,    214,
104         122,    75,     24,     41,     190,    143,    220,    237,
105         195,    242,    161,    144,    7,      54,     101,    84,
106         57,     8,      91,     106,    253,    204,    159,    174,
107         128,    177,    226,    211,    68,     117,    38,     23,
108         252,    205,    158,    175,    56,     9,      90,     107,
109         69,     116,    39,     22,     129,    176,    227,    210,
110         191,    142,    221,    236,    123,    74,     25,     40,
111         6,      55,     100,    85,     194,    243,    160,    145,
112         71,     118,    37,     20,     131,    178,    225,    208,
113         254,    207,    156,    173,    58,     11,     88,     105,
114         4,      53,     102,    87,     192,    241,    162,    147,
115         189,    140,    223,    238,    121,    72,     27,     42,
116         193,    240,    163,    146,    5,      52,     103,    86,
117         120,    73,     26,     43,     188,    141,    222,    239,
118         130,    179,    224,    209,    70,     119,    36,     21,
119         59,     10,     89,     104,    255,    206,    157,    172
120 };
121 
122 /**
123  * struct sht15_data - device instance specific data
124  * @pdata:              platform data (gpio's etc).
125  * @read_work:          bh of interrupt handler.
126  * @wait_queue:         wait queue for getting values from device.
127  * @val_temp:           last temperature value read from device.
128  * @val_humid:          last humidity value read from device.
129  * @val_status:         last status register value read from device.
130  * @checksum_ok:        last value read from the device passed CRC validation.
131  * @checksumming:       flag used to enable the data validation with CRC.
132  * @state:              state identifying the action the driver is doing.
133  * @measurements_valid: are the current stored measures valid (start condition).
134  * @status_valid:       is the current stored status valid (start condition).
135  * @last_measurement:   time of last measure.
136  * @last_status:        time of last status reading.
137  * @read_lock:          mutex to ensure only one read in progress at a time.
138  * @dev:                associate device structure.
139  * @hwmon_dev:          device associated with hwmon subsystem.
140  * @reg:                associated regulator (if specified).
141  * @nb:                 notifier block to handle notifications of voltage
142  *                      changes.
143  * @supply_uv:          local copy of supply voltage used to allow use of
144  *                      regulator consumer if available.
145  * @supply_uv_valid:    indicates that an updated value has not yet been
146  *                      obtained from the regulator and so any calculations
147  *                      based upon it will be invalid.
148  * @update_supply_work: work struct that is used to update the supply_uv.
149  * @interrupt_handled:  flag used to indicate a handler has been scheduled.
150  */
151 struct sht15_data {
152         struct sht15_platform_data      *pdata;
153         struct work_struct              read_work;
154         wait_queue_head_t               wait_queue;
155         uint16_t                        val_temp;
156         uint16_t                        val_humid;
157         u8                              val_status;
158         bool                            checksum_ok;
159         bool                            checksumming;
160         enum sht15_state                state;
161         bool                            measurements_valid;
162         bool                            status_valid;
163         unsigned long                   last_measurement;
164         unsigned long                   last_status;
165         struct mutex                    read_lock;
166         struct device                   *dev;
167         struct device                   *hwmon_dev;
168         struct regulator                *reg;
169         struct notifier_block           nb;
170         int                             supply_uv;
171         bool                            supply_uv_valid;
172         struct work_struct              update_supply_work;
173         atomic_t                        interrupt_handled;
174 };
175 
176 /**
177  * sht15_crc8() - compute crc8
178  * @data:       sht15 specific data.
179  * @value:      sht15 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 = gpio_direction_output(data->pdata->gpio_data, 1);
208         if (err)
209                 return err;
210         ndelay(SHT15_TSCKL);
211         gpio_set_value(data->pdata->gpio_sck, 0);
212         ndelay(SHT15_TSCKL);
213         for (i = 0; i < 9; ++i) {
214                 gpio_set_value(data->pdata->gpio_sck, 1);
215                 ndelay(SHT15_TSCKH);
216                 gpio_set_value(data->pdata->gpio_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         gpio_set_value(data->pdata->gpio_data, val);
230         ndelay(SHT15_TSU);
231         gpio_set_value(data->pdata->gpio_sck, 1);
232         ndelay(SHT15_TSCKH);
233         gpio_set_value(data->pdata->gpio_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 = gpio_direction_output(data->pdata->gpio_data, 1);
251         if (err)
252                 return err;
253         ndelay(SHT15_TSU);
254         gpio_set_value(data->pdata->gpio_sck, 0);
255         ndelay(SHT15_TSCKL);
256         gpio_set_value(data->pdata->gpio_sck, 1);
257         ndelay(SHT15_TSCKH);
258         gpio_set_value(data->pdata->gpio_data, 0);
259         ndelay(SHT15_TSU);
260         gpio_set_value(data->pdata->gpio_sck, 0);
261         ndelay(SHT15_TSCKL);
262         gpio_set_value(data->pdata->gpio_sck, 1);
263         ndelay(SHT15_TSCKH);
264         gpio_set_value(data->pdata->gpio_data, 1);
265         ndelay(SHT15_TSU);
266         gpio_set_value(data->pdata->gpio_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 = gpio_direction_input(data->pdata->gpio_data);
295         if (err)
296                 return err;
297         gpio_set_value(data->pdata->gpio_sck, 1);
298         ndelay(SHT15_TSCKH);
299         if (gpio_get_value(data->pdata->gpio_data)) {
300                 gpio_set_value(data->pdata->gpio_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         gpio_set_value(data->pdata->gpio_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 = gpio_direction_output(data->pdata->gpio_data, 0);
363         if (err)
364                 return err;
365         ndelay(SHT15_TSU);
366         gpio_set_value(data->pdata->gpio_sck, 1);
367         ndelay(SHT15_TSU);
368         gpio_set_value(data->pdata->gpio_sck, 0);
369         ndelay(SHT15_TSU);
370         gpio_set_value(data->pdata->gpio_data, 1);
371 
372         return gpio_direction_input(data->pdata->gpio_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 = gpio_direction_output(data->pdata->gpio_data, 1);
386         if (err)
387                 return err;
388         ndelay(SHT15_TSU);
389         gpio_set_value(data->pdata->gpio_sck, 1);
390         ndelay(SHT15_TSCKH);
391         gpio_set_value(data->pdata->gpio_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                 gpio_set_value(data->pdata->gpio_sck, 1);
408                 ndelay(SHT15_TSCKH);
409                 byte |= !!gpio_get_value(data->pdata->gpio_data);
410                 gpio_set_value(data->pdata->gpio_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 = gpio_direction_output(data->pdata->gpio_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 = gpio_direction_input(data->pdata->gpio_data);
531         if (ret)
532                 return ret;
533         atomic_set(&data->interrupt_handled, 0);
534 
535         enable_irq(gpio_to_irq(data->pdata->gpio_data));
536         if (gpio_get_value(data->pdata->gpio_data) == 0) {
537                 disable_irq_nosync(gpio_to_irq(data->pdata->gpio_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(gpio_to_irq(data->pdata->gpio_data));
550                 ret = sht15_connection_reset(data);
551                 if (ret)
552                         return ret;
553                 return -ETIME;
554         }
555 
556         /*
557          *  Perform checksum validation on the received data.
558          *  Specification mentions that in case a checksum verification fails,
559          *  a soft reset command must be sent to the device.
560          */
561         if (data->checksumming && !data->checksum_ok) {
562                 previous_config = data->val_status & 0x07;
563                 ret = sht15_soft_reset(data);
564                 if (ret)
565                         return ret;
566                 if (previous_config) {
567                         ret = sht15_send_status(data, previous_config);
568                         if (ret) {
569                                 dev_err(data->dev,
570                                         "CRC validation failed, unable "
571                                         "to restore device settings\n");
572                                 return ret;
573                         }
574                 }
575                 return -EAGAIN;
576         }
577 
578         return 0;
579 }
580 
581 /**
582  * sht15_update_measurements() - get updated measures from device if too old
583  * @data:       device state
584  */
585 static int sht15_update_measurements(struct sht15_data *data)
586 {
587         int ret = 0;
588         int timeout = HZ;
589 
590         mutex_lock(&data->read_lock);
591         if (time_after(jiffies, data->last_measurement + timeout)
592             || !data->measurements_valid) {
593                 data->state = SHT15_READING_HUMID;
594                 ret = sht15_measurement(data, SHT15_MEASURE_RH, 160);
595                 if (ret)
596                         goto unlock;
597                 data->state = SHT15_READING_TEMP;
598                 ret = sht15_measurement(data, SHT15_MEASURE_TEMP, 400);
599                 if (ret)
600                         goto unlock;
601                 data->measurements_valid = true;
602                 data->last_measurement = jiffies;
603         }
604 
605 unlock:
606         mutex_unlock(&data->read_lock);
607         return ret;
608 }
609 
610 /**
611  * sht15_calc_temp() - convert the raw reading to a temperature
612  * @data:       device state
613  *
614  * As per section 4.3 of the data sheet.
615  */
616 static inline int sht15_calc_temp(struct sht15_data *data)
617 {
618         int d1 = temppoints[0].d1;
619         int d2 = (data->val_status & SHT15_STATUS_LOW_RESOLUTION) ? 40 : 10;
620         int i;
621 
622         for (i = ARRAY_SIZE(temppoints) - 1; i > 0; i--)
623                 /* Find pointer to interpolate */
624                 if (data->supply_uv > temppoints[i - 1].vdd) {
625                         d1 = (data->supply_uv - temppoints[i - 1].vdd)
626                                 * (temppoints[i].d1 - temppoints[i - 1].d1)
627                                 / (temppoints[i].vdd - temppoints[i - 1].vdd)
628                                 + temppoints[i - 1].d1;
629                         break;
630                 }
631 
632         return data->val_temp * d2 + d1;
633 }
634 
635 /**
636  * sht15_calc_humid() - using last temperature convert raw to humid
637  * @data:       device state
638  *
639  * This is the temperature compensated version as per section 4.2 of
640  * the data sheet.
641  *
642  * The sensor is assumed to be V3, which is compatible with V4.
643  * Humidity conversion coefficients are shown in table 7 of the datasheet.
644  */
645 static inline int sht15_calc_humid(struct sht15_data *data)
646 {
647         int rh_linear; /* milli percent */
648         int temp = sht15_calc_temp(data);
649         int c2, c3;
650         int t2;
651         const int c1 = -4;
652 
653         if (data->val_status & SHT15_STATUS_LOW_RESOLUTION) {
654                 c2 = 648000; /* x 10 ^ -6 */
655                 c3 = -7200;  /* x 10 ^ -7 */
656                 t2 = 1280;
657         } else {
658                 c2 = 40500;  /* x 10 ^ -6 */
659                 c3 = -28;    /* x 10 ^ -7 */
660                 t2 = 80;
661         }
662 
663         rh_linear = c1 * 1000
664                 + c2 * data->val_humid / 1000
665                 + (data->val_humid * data->val_humid * c3) / 10000;
666         return (temp - 25000) * (10000 + t2 * data->val_humid)
667                 / 1000000 + rh_linear;
668 }
669 
670 /**
671  * sht15_show_status() - show status information in sysfs
672  * @dev:        device.
673  * @attr:       device attribute.
674  * @buf:        sysfs buffer where information is written to.
675  *
676  * Will be called on read access to temp1_fault, humidity1_fault
677  * and heater_enable sysfs attributes.
678  * Returns number of bytes written into buffer, negative errno on error.
679  */
680 static ssize_t sht15_show_status(struct device *dev,
681                                  struct device_attribute *attr,
682                                  char *buf)
683 {
684         int ret;
685         struct sht15_data *data = dev_get_drvdata(dev);
686         u8 bit = to_sensor_dev_attr(attr)->index;
687 
688         ret = sht15_update_status(data);
689 
690         return ret ? ret : sprintf(buf, "%d\n", !!(data->val_status & bit));
691 }
692 
693 /**
694  * sht15_store_heater() - change heater state via sysfs
695  * @dev:        device.
696  * @attr:       device attribute.
697  * @buf:        sysfs buffer to read the new heater state from.
698  * @count:      length of the data.
699  *
700  * Will be called on write access to heater_enable sysfs attribute.
701  * Returns number of bytes actually decoded, negative errno on error.
702  */
703 static ssize_t sht15_store_heater(struct device *dev,
704                                   struct device_attribute *attr,
705                                   const char *buf, size_t count)
706 {
707         int ret;
708         struct sht15_data *data = dev_get_drvdata(dev);
709         long value;
710         u8 status;
711 
712         if (kstrtol(buf, 10, &value))
713                 return -EINVAL;
714 
715         mutex_lock(&data->read_lock);
716         status = data->val_status & 0x07;
717         if (!!value)
718                 status |= SHT15_STATUS_HEATER;
719         else
720                 status &= ~SHT15_STATUS_HEATER;
721 
722         ret = sht15_send_status(data, status);
723         mutex_unlock(&data->read_lock);
724 
725         return ret ? ret : count;
726 }
727 
728 /**
729  * sht15_show_temp() - show temperature measurement value in sysfs
730  * @dev:        device.
731  * @attr:       device attribute.
732  * @buf:        sysfs buffer where measurement values are written to.
733  *
734  * Will be called on read access to temp1_input sysfs attribute.
735  * Returns number of bytes written into buffer, negative errno on error.
736  */
737 static ssize_t sht15_show_temp(struct device *dev,
738                                struct device_attribute *attr,
739                                char *buf)
740 {
741         int ret;
742         struct sht15_data *data = dev_get_drvdata(dev);
743 
744         /* Technically no need to read humidity as well */
745         ret = sht15_update_measurements(data);
746 
747         return ret ? ret : sprintf(buf, "%d\n",
748                                    sht15_calc_temp(data));
749 }
750 
751 /**
752  * sht15_show_humidity() - show humidity measurement value in sysfs
753  * @dev:        device.
754  * @attr:       device attribute.
755  * @buf:        sysfs buffer where measurement values are written to.
756  *
757  * Will be called on read access to humidity1_input sysfs attribute.
758  * Returns number of bytes written into buffer, negative errno on error.
759  */
760 static ssize_t sht15_show_humidity(struct device *dev,
761                                    struct device_attribute *attr,
762                                    char *buf)
763 {
764         int ret;
765         struct sht15_data *data = dev_get_drvdata(dev);
766 
767         ret = sht15_update_measurements(data);
768 
769         return ret ? ret : sprintf(buf, "%d\n", sht15_calc_humid(data));
770 }
771 
772 static ssize_t show_name(struct device *dev,
773                          struct device_attribute *attr,
774                          char *buf)
775 {
776         struct platform_device *pdev = to_platform_device(dev);
777         return sprintf(buf, "%s\n", pdev->name);
778 }
779 
780 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
781                           sht15_show_temp, NULL, 0);
782 static SENSOR_DEVICE_ATTR(humidity1_input, S_IRUGO,
783                           sht15_show_humidity, NULL, 0);
784 static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, sht15_show_status, NULL,
785                           SHT15_STATUS_LOW_BATTERY);
786 static SENSOR_DEVICE_ATTR(humidity1_fault, S_IRUGO, sht15_show_status, NULL,
787                           SHT15_STATUS_LOW_BATTERY);
788 static SENSOR_DEVICE_ATTR(heater_enable, S_IRUGO | S_IWUSR, sht15_show_status,
789                           sht15_store_heater, SHT15_STATUS_HEATER);
790 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
791 static struct attribute *sht15_attrs[] = {
792         &sensor_dev_attr_temp1_input.dev_attr.attr,
793         &sensor_dev_attr_humidity1_input.dev_attr.attr,
794         &sensor_dev_attr_temp1_fault.dev_attr.attr,
795         &sensor_dev_attr_humidity1_fault.dev_attr.attr,
796         &sensor_dev_attr_heater_enable.dev_attr.attr,
797         &dev_attr_name.attr,
798         NULL,
799 };
800 
801 static const struct attribute_group sht15_attr_group = {
802         .attrs = sht15_attrs,
803 };
804 
805 static irqreturn_t sht15_interrupt_fired(int irq, void *d)
806 {
807         struct sht15_data *data = d;
808 
809         /* First disable the interrupt */
810         disable_irq_nosync(irq);
811         atomic_inc(&data->interrupt_handled);
812         /* Then schedule a reading work struct */
813         if (data->state != SHT15_READING_NOTHING)
814                 schedule_work(&data->read_work);
815         return IRQ_HANDLED;
816 }
817 
818 static void sht15_bh_read_data(struct work_struct *work_s)
819 {
820         uint16_t val = 0;
821         u8 dev_checksum = 0;
822         u8 checksum_vals[3];
823         struct sht15_data *data
824                 = container_of(work_s, struct sht15_data,
825                                read_work);
826 
827         /* Firstly, verify the line is low */
828         if (gpio_get_value(data->pdata->gpio_data)) {
829                 /*
830                  * If not, then start the interrupt again - care here as could
831                  * have gone low in meantime so verify it hasn't!
832                  */
833                 atomic_set(&data->interrupt_handled, 0);
834                 enable_irq(gpio_to_irq(data->pdata->gpio_data));
835                 /* If still not occurred or another handler was scheduled */
836                 if (gpio_get_value(data->pdata->gpio_data)
837                     || atomic_read(&data->interrupt_handled))
838                         return;
839         }
840 
841         /* Read the data back from the device */
842         val = sht15_read_byte(data);
843         val <<= 8;
844         if (sht15_ack(data))
845                 goto wakeup;
846         val |= sht15_read_byte(data);
847 
848         if (data->checksumming) {
849                 /*
850                  * Ask the device for a checksum and read it back.
851                  * Note: the device sends the checksum byte reversed.
852                  */
853                 if (sht15_ack(data))
854                         goto wakeup;
855                 dev_checksum = bitrev8(sht15_read_byte(data));
856                 checksum_vals[0] = (data->state == SHT15_READING_TEMP) ?
857                         SHT15_MEASURE_TEMP : SHT15_MEASURE_RH;
858                 checksum_vals[1] = (u8) (val >> 8);
859                 checksum_vals[2] = (u8) val;
860                 data->checksum_ok
861                         = (sht15_crc8(data, checksum_vals, 3) == dev_checksum);
862         }
863 
864         /* Tell the device we are done */
865         if (sht15_end_transmission(data))
866                 goto wakeup;
867 
868         switch (data->state) {
869         case SHT15_READING_TEMP:
870                 data->val_temp = val;
871                 break;
872         case SHT15_READING_HUMID:
873                 data->val_humid = val;
874                 break;
875         default:
876                 break;
877         }
878 
879         data->state = SHT15_READING_NOTHING;
880 wakeup:
881         wake_up(&data->wait_queue);
882 }
883 
884 static void sht15_update_voltage(struct work_struct *work_s)
885 {
886         struct sht15_data *data
887                 = container_of(work_s, struct sht15_data,
888                                update_supply_work);
889         data->supply_uv = regulator_get_voltage(data->reg);
890 }
891 
892 /**
893  * sht15_invalidate_voltage() - mark supply voltage invalid when notified by reg
894  * @nb:         associated notification structure
895  * @event:      voltage regulator state change event code
896  * @ignored:    function parameter - ignored here
897  *
898  * Note that as the notification code holds the regulator lock, we have
899  * to schedule an update of the supply voltage rather than getting it directly.
900  */
901 static int sht15_invalidate_voltage(struct notifier_block *nb,
902                                     unsigned long event,
903                                     void *ignored)
904 {
905         struct sht15_data *data = container_of(nb, struct sht15_data, nb);
906 
907         if (event == REGULATOR_EVENT_VOLTAGE_CHANGE)
908                 data->supply_uv_valid = false;
909         schedule_work(&data->update_supply_work);
910 
911         return NOTIFY_OK;
912 }
913 
914 static int sht15_probe(struct platform_device *pdev)
915 {
916         int ret;
917         struct sht15_data *data;
918         u8 status = 0;
919 
920         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
921         if (!data)
922                 return -ENOMEM;
923 
924         INIT_WORK(&data->read_work, sht15_bh_read_data);
925         INIT_WORK(&data->update_supply_work, sht15_update_voltage);
926         platform_set_drvdata(pdev, data);
927         mutex_init(&data->read_lock);
928         data->dev = &pdev->dev;
929         init_waitqueue_head(&data->wait_queue);
930 
931         if (dev_get_platdata(&pdev->dev) == NULL) {
932                 dev_err(&pdev->dev, "no platform data supplied\n");
933                 return -EINVAL;
934         }
935         data->pdata = dev_get_platdata(&pdev->dev);
936         data->supply_uv = data->pdata->supply_mv * 1000;
937         if (data->pdata->checksum)
938                 data->checksumming = true;
939         if (data->pdata->no_otp_reload)
940                 status |= SHT15_STATUS_NO_OTP_RELOAD;
941         if (data->pdata->low_resolution)
942                 status |= SHT15_STATUS_LOW_RESOLUTION;
943 
944         /*
945          * If a regulator is available,
946          * query what the supply voltage actually is!
947          */
948         data->reg = devm_regulator_get_optional(data->dev, "vcc");
949         if (!IS_ERR(data->reg)) {
950                 int voltage;
951 
952                 voltage = regulator_get_voltage(data->reg);
953                 if (voltage)
954                         data->supply_uv = voltage;
955 
956                 ret = regulator_enable(data->reg);
957                 if (ret != 0) {
958                         dev_err(&pdev->dev,
959                                 "failed to enable regulator: %d\n", ret);
960                         return ret;
961                 }
962 
963                 /*
964                  * Setup a notifier block to update this if another device
965                  * causes the voltage to change
966                  */
967                 data->nb.notifier_call = &sht15_invalidate_voltage;
968                 ret = regulator_register_notifier(data->reg, &data->nb);
969                 if (ret) {
970                         dev_err(&pdev->dev,
971                                 "regulator notifier request failed\n");
972                         regulator_disable(data->reg);
973                         return ret;
974                 }
975         }
976 
977         /* Try requesting the GPIOs */
978         ret = devm_gpio_request_one(&pdev->dev, data->pdata->gpio_sck,
979                         GPIOF_OUT_INIT_LOW, "SHT15 sck");
980         if (ret) {
981                 dev_err(&pdev->dev, "clock line GPIO request failed\n");
982                 goto err_release_reg;
983         }
984 
985         ret = devm_gpio_request(&pdev->dev, data->pdata->gpio_data,
986                                 "SHT15 data");
987         if (ret) {
988                 dev_err(&pdev->dev, "data line GPIO request failed\n");
989                 goto err_release_reg;
990         }
991 
992         ret = devm_request_irq(&pdev->dev, gpio_to_irq(data->pdata->gpio_data),
993                                sht15_interrupt_fired,
994                                IRQF_TRIGGER_FALLING,
995                                "sht15 data",
996                                data);
997         if (ret) {
998                 dev_err(&pdev->dev, "failed to get irq for data line\n");
999                 goto err_release_reg;
1000         }
1001         disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data));
1002         ret = sht15_connection_reset(data);
1003         if (ret)
1004                 goto err_release_reg;
1005         ret = sht15_soft_reset(data);
1006         if (ret)
1007                 goto err_release_reg;
1008 
1009         /* write status with platform data options */
1010         if (status) {
1011                 ret = sht15_send_status(data, status);
1012                 if (ret)
1013                         goto err_release_reg;
1014         }
1015 
1016         ret = sysfs_create_group(&pdev->dev.kobj, &sht15_attr_group);
1017         if (ret) {
1018                 dev_err(&pdev->dev, "sysfs create failed\n");
1019                 goto err_release_reg;
1020         }
1021 
1022         data->hwmon_dev = hwmon_device_register(data->dev);
1023         if (IS_ERR(data->hwmon_dev)) {
1024                 ret = PTR_ERR(data->hwmon_dev);
1025                 goto err_release_sysfs_group;
1026         }
1027 
1028         return 0;
1029 
1030 err_release_sysfs_group:
1031         sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group);
1032 err_release_reg:
1033         if (!IS_ERR(data->reg)) {
1034                 regulator_unregister_notifier(data->reg, &data->nb);
1035                 regulator_disable(data->reg);
1036         }
1037         return ret;
1038 }
1039 
1040 static int sht15_remove(struct platform_device *pdev)
1041 {
1042         struct sht15_data *data = platform_get_drvdata(pdev);
1043 
1044         /*
1045          * Make sure any reads from the device are done and
1046          * prevent new ones beginning
1047          */
1048         mutex_lock(&data->read_lock);
1049         if (sht15_soft_reset(data)) {
1050                 mutex_unlock(&data->read_lock);
1051                 return -EFAULT;
1052         }
1053         hwmon_device_unregister(data->hwmon_dev);
1054         sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group);
1055         if (!IS_ERR(data->reg)) {
1056                 regulator_unregister_notifier(data->reg, &data->nb);
1057                 regulator_disable(data->reg);
1058         }
1059 
1060         mutex_unlock(&data->read_lock);
1061 
1062         return 0;
1063 }
1064 
1065 static const struct platform_device_id sht15_device_ids[] = {
1066         { "sht10", sht10 },
1067         { "sht11", sht11 },
1068         { "sht15", sht15 },
1069         { "sht71", sht71 },
1070         { "sht75", sht75 },
1071         { }
1072 };
1073 MODULE_DEVICE_TABLE(platform, sht15_device_ids);
1074 
1075 static struct platform_driver sht15_driver = {
1076         .driver = {
1077                 .name = "sht15",
1078         },
1079         .probe = sht15_probe,
1080         .remove = sht15_remove,
1081         .id_table = sht15_device_ids,
1082 };
1083 module_platform_driver(sht15_driver);
1084 
1085 MODULE_LICENSE("GPL");
1086 MODULE_DESCRIPTION("Sensirion SHT15 temperature and humidity sensor driver");
1087 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us