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