1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * sht15.c - support for the SHT15 Temperature and Humidity Sensor |
4 | * |
5 | * Portions Copyright (c) 2010-2012 Savoir-faire Linux Inc. |
6 | * Jerome Oufella <jerome.oufella@savoirfairelinux.com> |
7 | * Vivien Didelot <vivien.didelot@savoirfairelinux.com> |
8 | * |
9 | * Copyright (c) 2009 Jonathan Cameron |
10 | * |
11 | * Copyright (c) 2007 Wouter Horre |
12 | * |
13 | * For further information, see the Documentation/hwmon/sht15.rst file. |
14 | */ |
15 | |
16 | #include <linux/interrupt.h> |
17 | #include <linux/irq.h> |
18 | #include <linux/module.h> |
19 | #include <linux/init.h> |
20 | #include <linux/hwmon.h> |
21 | #include <linux/hwmon-sysfs.h> |
22 | #include <linux/mutex.h> |
23 | #include <linux/platform_device.h> |
24 | #include <linux/sched.h> |
25 | #include <linux/delay.h> |
26 | #include <linux/jiffies.h> |
27 | #include <linux/err.h> |
28 | #include <linux/regulator/consumer.h> |
29 | #include <linux/slab.h> |
30 | #include <linux/atomic.h> |
31 | #include <linux/bitrev.h> |
32 | #include <linux/gpio/consumer.h> |
33 | #include <linux/of.h> |
34 | |
35 | /* Commands */ |
36 | #define SHT15_MEASURE_TEMP 0x03 |
37 | #define SHT15_MEASURE_RH 0x05 |
38 | #define SHT15_WRITE_STATUS 0x06 |
39 | #define SHT15_READ_STATUS 0x07 |
40 | #define SHT15_SOFT_RESET 0x1E |
41 | |
42 | /* Min timings */ |
43 | #define SHT15_TSCKL 100 /* (nsecs) clock low */ |
44 | #define SHT15_TSCKH 100 /* (nsecs) clock high */ |
45 | #define SHT15_TSU 150 /* (nsecs) data setup time */ |
46 | #define SHT15_TSRST 11 /* (msecs) soft reset time */ |
47 | |
48 | /* Status Register Bits */ |
49 | #define SHT15_STATUS_LOW_RESOLUTION 0x01 |
50 | #define SHT15_STATUS_NO_OTP_RELOAD 0x02 |
51 | #define SHT15_STATUS_HEATER 0x04 |
52 | #define SHT15_STATUS_LOW_BATTERY 0x40 |
53 | |
54 | /* List of supported chips */ |
55 | enum sht15_chips { sht10, sht11, sht15, sht71, sht75 }; |
56 | |
57 | /* Actions the driver may be doing */ |
58 | enum sht15_state { |
59 | SHT15_READING_NOTHING, |
60 | SHT15_READING_TEMP, |
61 | SHT15_READING_HUMID |
62 | }; |
63 | |
64 | /** |
65 | * struct sht15_temppair - elements of voltage dependent temp calc |
66 | * @vdd: supply voltage in microvolts |
67 | * @d1: see data sheet |
68 | */ |
69 | struct sht15_temppair { |
70 | int vdd; /* microvolts */ |
71 | int d1; |
72 | }; |
73 | |
74 | /* Table 9 from datasheet - relates temperature calculation to supply voltage */ |
75 | static const struct sht15_temppair temppoints[] = { |
76 | { 2500000, -39400 }, |
77 | { 3000000, -39600 }, |
78 | { 3500000, -39700 }, |
79 | { 4000000, -39800 }, |
80 | { 5000000, -40100 }, |
81 | }; |
82 | |
83 | /* Table from CRC datasheet, section 2.4 */ |
84 | static const u8 sht15_crc8_table[] = { |
85 | 0, 49, 98, 83, 196, 245, 166, 151, |
86 | 185, 136, 219, 234, 125, 76, 31, 46, |
87 | 67, 114, 33, 16, 135, 182, 229, 212, |
88 | 250, 203, 152, 169, 62, 15, 92, 109, |
89 | 134, 183, 228, 213, 66, 115, 32, 17, |
90 | 63, 14, 93, 108, 251, 202, 153, 168, |
91 | 197, 244, 167, 150, 1, 48, 99, 82, |
92 | 124, 77, 30, 47, 184, 137, 218, 235, |
93 | 61, 12, 95, 110, 249, 200, 155, 170, |
94 | 132, 181, 230, 215, 64, 113, 34, 19, |
95 | 126, 79, 28, 45, 186, 139, 216, 233, |
96 | 199, 246, 165, 148, 3, 50, 97, 80, |
97 | 187, 138, 217, 232, 127, 78, 29, 44, |
98 | 2, 51, 96, 81, 198, 247, 164, 149, |
99 | 248, 201, 154, 171, 60, 13, 94, 111, |
100 | 65, 112, 35, 18, 133, 180, 231, 214, |
101 | 122, 75, 24, 41, 190, 143, 220, 237, |
102 | 195, 242, 161, 144, 7, 54, 101, 84, |
103 | 57, 8, 91, 106, 253, 204, 159, 174, |
104 | 128, 177, 226, 211, 68, 117, 38, 23, |
105 | 252, 205, 158, 175, 56, 9, 90, 107, |
106 | 69, 116, 39, 22, 129, 176, 227, 210, |
107 | 191, 142, 221, 236, 123, 74, 25, 40, |
108 | 6, 55, 100, 85, 194, 243, 160, 145, |
109 | 71, 118, 37, 20, 131, 178, 225, 208, |
110 | 254, 207, 156, 173, 58, 11, 88, 105, |
111 | 4, 53, 102, 87, 192, 241, 162, 147, |
112 | 189, 140, 223, 238, 121, 72, 27, 42, |
113 | 193, 240, 163, 146, 5, 52, 103, 86, |
114 | 120, 73, 26, 43, 188, 141, 222, 239, |
115 | 130, 179, 224, 209, 70, 119, 36, 21, |
116 | 59, 10, 89, 104, 255, 206, 157, 172 |
117 | }; |
118 | |
119 | /** |
120 | * struct sht15_data - device instance specific data |
121 | * @sck: clock GPIO line |
122 | * @data: data GPIO line |
123 | * @read_work: bh of interrupt handler. |
124 | * @wait_queue: wait queue for getting values from device. |
125 | * @val_temp: last temperature value read from device. |
126 | * @val_humid: last humidity value read from device. |
127 | * @val_status: last status register value read from device. |
128 | * @checksum_ok: last value read from the device passed CRC validation. |
129 | * @checksumming: flag used to enable the data validation with CRC. |
130 | * @state: state identifying the action the driver is doing. |
131 | * @measurements_valid: are the current stored measures valid (start condition). |
132 | * @status_valid: is the current stored status valid (start condition). |
133 | * @last_measurement: time of last measure. |
134 | * @last_status: time of last status reading. |
135 | * @read_lock: mutex to ensure only one read in progress at a time. |
136 | * @dev: associate device structure. |
137 | * @hwmon_dev: device associated with hwmon subsystem. |
138 | * @reg: associated regulator (if specified). |
139 | * @nb: notifier block to handle notifications of voltage |
140 | * changes. |
141 | * @supply_uv: local copy of supply voltage used to allow use of |
142 | * regulator consumer if available. |
143 | * @supply_uv_valid: indicates that an updated value has not yet been |
144 | * obtained from the regulator and so any calculations |
145 | * based upon it will be invalid. |
146 | * @update_supply_work: work struct that is used to update the supply_uv. |
147 | * @interrupt_handled: flag used to indicate a handler has been scheduled. |
148 | */ |
149 | struct sht15_data { |
150 | struct gpio_desc *sck; |
151 | struct gpio_desc *data; |
152 | struct work_struct read_work; |
153 | wait_queue_head_t wait_queue; |
154 | uint16_t val_temp; |
155 | uint16_t val_humid; |
156 | u8 val_status; |
157 | bool checksum_ok; |
158 | bool checksumming; |
159 | enum sht15_state state; |
160 | bool measurements_valid; |
161 | bool status_valid; |
162 | unsigned long last_measurement; |
163 | unsigned long last_status; |
164 | struct mutex read_lock; |
165 | struct device *dev; |
166 | struct device *hwmon_dev; |
167 | struct regulator *reg; |
168 | struct notifier_block nb; |
169 | int supply_uv; |
170 | bool supply_uv_valid; |
171 | struct work_struct update_supply_work; |
172 | atomic_t interrupt_handled; |
173 | }; |
174 | |
175 | /** |
176 | * sht15_crc8() - compute crc8 |
177 | * @data: sht15 specific data. |
178 | * @value: sht15 retrieved data. |
179 | * @len: Length of retrieved data |
180 | * |
181 | * This implements section 2 of the CRC datasheet. |
182 | */ |
183 | static u8 sht15_crc8(struct sht15_data *data, |
184 | const u8 *value, |
185 | int len) |
186 | { |
187 | u8 crc = bitrev8(data->val_status & 0x0F); |
188 | |
189 | while (len--) { |
190 | crc = sht15_crc8_table[*value ^ crc]; |
191 | value++; |
192 | } |
193 | |
194 | return crc; |
195 | } |
196 | |
197 | /** |
198 | * sht15_connection_reset() - reset the comms interface |
199 | * @data: sht15 specific data |
200 | * |
201 | * This implements section 3.4 of the data sheet |
202 | */ |
203 | static int sht15_connection_reset(struct sht15_data *data) |
204 | { |
205 | int i, err; |
206 | |
207 | err = gpiod_direction_output(desc: data->data, value: 1); |
208 | if (err) |
209 | return err; |
210 | ndelay(SHT15_TSCKL); |
211 | gpiod_set_value(desc: data->sck, value: 0); |
212 | ndelay(SHT15_TSCKL); |
213 | for (i = 0; i < 9; ++i) { |
214 | gpiod_set_value(desc: data->sck, value: 1); |
215 | ndelay(SHT15_TSCKH); |
216 | gpiod_set_value(desc: data->sck, value: 0); |
217 | ndelay(SHT15_TSCKL); |
218 | } |
219 | return 0; |
220 | } |
221 | |
222 | /** |
223 | * sht15_send_bit() - send an individual bit to the device |
224 | * @data: device state data |
225 | * @val: value of bit to be sent |
226 | */ |
227 | static inline void sht15_send_bit(struct sht15_data *data, int val) |
228 | { |
229 | gpiod_set_value(desc: data->data, value: val); |
230 | ndelay(SHT15_TSU); |
231 | gpiod_set_value(desc: data->sck, value: 1); |
232 | ndelay(SHT15_TSCKH); |
233 | gpiod_set_value(desc: data->sck, value: 0); |
234 | ndelay(SHT15_TSCKL); /* clock low time */ |
235 | } |
236 | |
237 | /** |
238 | * sht15_transmission_start() - specific sequence for new transmission |
239 | * @data: device state data |
240 | * |
241 | * Timings for this are not documented on the data sheet, so very |
242 | * conservative ones used in implementation. This implements |
243 | * figure 12 on the data sheet. |
244 | */ |
245 | static int sht15_transmission_start(struct sht15_data *data) |
246 | { |
247 | int err; |
248 | |
249 | /* ensure data is high and output */ |
250 | err = gpiod_direction_output(desc: data->data, value: 1); |
251 | if (err) |
252 | return err; |
253 | ndelay(SHT15_TSU); |
254 | gpiod_set_value(desc: data->sck, value: 0); |
255 | ndelay(SHT15_TSCKL); |
256 | gpiod_set_value(desc: data->sck, value: 1); |
257 | ndelay(SHT15_TSCKH); |
258 | gpiod_set_value(desc: data->data, value: 0); |
259 | ndelay(SHT15_TSU); |
260 | gpiod_set_value(desc: data->sck, value: 0); |
261 | ndelay(SHT15_TSCKL); |
262 | gpiod_set_value(desc: data->sck, value: 1); |
263 | ndelay(SHT15_TSCKH); |
264 | gpiod_set_value(desc: data->data, value: 1); |
265 | ndelay(SHT15_TSU); |
266 | gpiod_set_value(desc: data->sck, value: 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, val: !!(byte & 0x80)); |
282 | byte <<= 1; |
283 | } |
284 | } |
285 | |
286 | /** |
287 | * sht15_wait_for_response() - checks for ack from device |
288 | * @data: device state |
289 | */ |
290 | static int sht15_wait_for_response(struct sht15_data *data) |
291 | { |
292 | int err; |
293 | |
294 | err = gpiod_direction_input(desc: data->data); |
295 | if (err) |
296 | return err; |
297 | gpiod_set_value(desc: data->sck, value: 1); |
298 | ndelay(SHT15_TSCKH); |
299 | if (gpiod_get_value(desc: data->data)) { |
300 | gpiod_set_value(desc: data->sck, value: 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(desc: data->sck, value: 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, byte: cmd); |
328 | return sht15_wait_for_response(data); |
329 | } |
330 | |
331 | /** |
332 | * sht15_soft_reset() - send a soft reset command |
333 | * @data: sht15 specific data. |
334 | * |
335 | * As described in section 3.2 of the datasheet. |
336 | */ |
337 | static int sht15_soft_reset(struct sht15_data *data) |
338 | { |
339 | int ret; |
340 | |
341 | ret = sht15_send_cmd(data, SHT15_SOFT_RESET); |
342 | if (ret) |
343 | return ret; |
344 | msleep(SHT15_TSRST); |
345 | /* device resets default hardware status register value */ |
346 | data->val_status = 0; |
347 | |
348 | return ret; |
349 | } |
350 | |
351 | /** |
352 | * sht15_ack() - send a ack |
353 | * @data: sht15 specific data. |
354 | * |
355 | * Each byte of data is acknowledged by pulling the data line |
356 | * low for one clock pulse. |
357 | */ |
358 | static int sht15_ack(struct sht15_data *data) |
359 | { |
360 | int err; |
361 | |
362 | err = gpiod_direction_output(desc: data->data, value: 0); |
363 | if (err) |
364 | return err; |
365 | ndelay(SHT15_TSU); |
366 | gpiod_set_value(desc: data->sck, value: 1); |
367 | ndelay(SHT15_TSU); |
368 | gpiod_set_value(desc: data->sck, value: 0); |
369 | ndelay(SHT15_TSU); |
370 | gpiod_set_value(desc: data->data, value: 1); |
371 | |
372 | return gpiod_direction_input(desc: data->data); |
373 | } |
374 | |
375 | /** |
376 | * sht15_end_transmission() - notify device of end of transmission |
377 | * @data: device state. |
378 | * |
379 | * This is basically a NAK (single clock pulse, data high). |
380 | */ |
381 | static int sht15_end_transmission(struct sht15_data *data) |
382 | { |
383 | int err; |
384 | |
385 | err = gpiod_direction_output(desc: data->data, value: 1); |
386 | if (err) |
387 | return err; |
388 | ndelay(SHT15_TSU); |
389 | gpiod_set_value(desc: data->sck, value: 1); |
390 | ndelay(SHT15_TSCKH); |
391 | gpiod_set_value(desc: data->sck, value: 0); |
392 | ndelay(SHT15_TSCKL); |
393 | return 0; |
394 | } |
395 | |
396 | /** |
397 | * sht15_read_byte() - Read a byte back from the device |
398 | * @data: device state. |
399 | */ |
400 | static u8 sht15_read_byte(struct sht15_data *data) |
401 | { |
402 | int i; |
403 | u8 byte = 0; |
404 | |
405 | for (i = 0; i < 8; ++i) { |
406 | byte <<= 1; |
407 | gpiod_set_value(desc: data->sck, value: 1); |
408 | ndelay(SHT15_TSCKH); |
409 | byte |= !!gpiod_get_value(desc: data->data); |
410 | gpiod_set_value(desc: data->sck, value: 0); |
411 | ndelay(SHT15_TSCKL); |
412 | } |
413 | return byte; |
414 | } |
415 | |
416 | /** |
417 | * sht15_send_status() - write the status register byte |
418 | * @data: sht15 specific data. |
419 | * @status: the byte to set the status register with. |
420 | * |
421 | * As described in figure 14 and table 5 of the datasheet. |
422 | */ |
423 | static int sht15_send_status(struct sht15_data *data, u8 status) |
424 | { |
425 | int err; |
426 | |
427 | err = sht15_send_cmd(data, SHT15_WRITE_STATUS); |
428 | if (err) |
429 | return err; |
430 | err = gpiod_direction_output(desc: data->data, value: 1); |
431 | if (err) |
432 | return err; |
433 | ndelay(SHT15_TSU); |
434 | sht15_send_byte(data, byte: 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, value: checksum_vals, len: 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, status: 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(lock: &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, cmd: command); |
527 | if (ret) |
528 | return ret; |
529 | |
530 | ret = gpiod_direction_input(desc: data->data); |
531 | if (ret) |
532 | return ret; |
533 | atomic_set(v: &data->interrupt_handled, i: 0); |
534 | |
535 | enable_irq(irq: gpiod_to_irq(desc: data->data)); |
536 | if (gpiod_get_value(desc: data->data) == 0) { |
537 | disable_irq_nosync(irq: gpiod_to_irq(desc: data->data)); |
538 | /* Only relevant if the interrupt hasn't occurred. */ |
539 | if (!atomic_read(v: &data->interrupt_handled)) |
540 | schedule_work(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(irq: gpiod_to_irq(desc: 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, status: 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, timeout_msecs: 160); |
595 | if (ret) |
596 | goto unlock; |
597 | data->state = SHT15_READING_TEMP; |
598 | ret = sht15_measurement(data, SHT15_MEASURE_TEMP, timeout_msecs: 400); |
599 | if (ret) |
600 | goto unlock; |
601 | data->measurements_valid = true; |
602 | data->last_measurement = jiffies; |
603 | } |
604 | |
605 | unlock: |
606 | mutex_unlock(lock: &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_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 | */ |
680 | static ssize_t sht15_status_show(struct device *dev, |
681 | struct device_attribute *attr, char *buf) |
682 | { |
683 | int ret; |
684 | struct sht15_data *data = dev_get_drvdata(dev); |
685 | u8 bit = to_sensor_dev_attr(attr)->index; |
686 | |
687 | ret = sht15_update_status(data); |
688 | |
689 | return ret ? ret : sprintf(buf, fmt: "%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 | */ |
702 | static ssize_t sht15_status_store(struct device *dev, |
703 | struct device_attribute *attr, |
704 | const char *buf, size_t count) |
705 | { |
706 | int ret; |
707 | struct sht15_data *data = dev_get_drvdata(dev); |
708 | long value; |
709 | u8 status; |
710 | |
711 | if (kstrtol(s: buf, base: 10, res: &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(lock: &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 | */ |
736 | static ssize_t sht15_temp_show(struct device *dev, |
737 | struct device_attribute *attr, char *buf) |
738 | { |
739 | int ret; |
740 | struct sht15_data *data = dev_get_drvdata(dev); |
741 | |
742 | /* Technically no need to read humidity as well */ |
743 | ret = sht15_update_measurements(data); |
744 | |
745 | return ret ? ret : sprintf(buf, fmt: "%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 | */ |
758 | static ssize_t sht15_humidity_show(struct device *dev, |
759 | struct device_attribute *attr, char *buf) |
760 | { |
761 | int ret; |
762 | struct sht15_data *data = dev_get_drvdata(dev); |
763 | |
764 | ret = sht15_update_measurements(data); |
765 | |
766 | return ret ? ret : sprintf(buf, fmt: "%d\n" , sht15_calc_humid(data)); |
767 | } |
768 | |
769 | static ssize_t name_show(struct device *dev, |
770 | struct device_attribute *attr, |
771 | char *buf) |
772 | { |
773 | struct platform_device *pdev = to_platform_device(dev); |
774 | return sprintf(buf, fmt: "%s\n" , pdev->name); |
775 | } |
776 | |
777 | static SENSOR_DEVICE_ATTR_RO(temp1_input, sht15_temp, 0); |
778 | static SENSOR_DEVICE_ATTR_RO(humidity1_input, sht15_humidity, 0); |
779 | static SENSOR_DEVICE_ATTR_RO(temp1_fault, sht15_status, |
780 | SHT15_STATUS_LOW_BATTERY); |
781 | static SENSOR_DEVICE_ATTR_RO(humidity1_fault, sht15_status, |
782 | SHT15_STATUS_LOW_BATTERY); |
783 | static SENSOR_DEVICE_ATTR_RW(heater_enable, sht15_status, SHT15_STATUS_HEATER); |
784 | static DEVICE_ATTR_RO(name); |
785 | static struct attribute *sht15_attrs[] = { |
786 | &sensor_dev_attr_temp1_input.dev_attr.attr, |
787 | &sensor_dev_attr_humidity1_input.dev_attr.attr, |
788 | &sensor_dev_attr_temp1_fault.dev_attr.attr, |
789 | &sensor_dev_attr_humidity1_fault.dev_attr.attr, |
790 | &sensor_dev_attr_heater_enable.dev_attr.attr, |
791 | &dev_attr_name.attr, |
792 | NULL, |
793 | }; |
794 | |
795 | static const struct attribute_group sht15_attr_group = { |
796 | .attrs = sht15_attrs, |
797 | }; |
798 | |
799 | static irqreturn_t sht15_interrupt_fired(int irq, void *d) |
800 | { |
801 | struct sht15_data *data = d; |
802 | |
803 | /* First disable the interrupt */ |
804 | disable_irq_nosync(irq); |
805 | atomic_inc(v: &data->interrupt_handled); |
806 | /* Then schedule a reading work struct */ |
807 | if (data->state != SHT15_READING_NOTHING) |
808 | schedule_work(work: &data->read_work); |
809 | return IRQ_HANDLED; |
810 | } |
811 | |
812 | static void sht15_bh_read_data(struct work_struct *work_s) |
813 | { |
814 | uint16_t val = 0; |
815 | u8 dev_checksum = 0; |
816 | u8 checksum_vals[3]; |
817 | struct sht15_data *data |
818 | = container_of(work_s, struct sht15_data, |
819 | read_work); |
820 | |
821 | /* Firstly, verify the line is low */ |
822 | if (gpiod_get_value(desc: 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(v: &data->interrupt_handled, i: 0); |
828 | enable_irq(irq: gpiod_to_irq(desc: data->data)); |
829 | /* If still not occurred or another handler was scheduled */ |
830 | if (gpiod_get_value(desc: data->data) |
831 | || atomic_read(v: &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, value: checksum_vals, len: 3) == dev_checksum); |
856 | } |
857 | |
858 | /* Tell the device we are done */ |
859 | if (sht15_end_transmission(data)) |
860 | goto wakeup; |
861 | |
862 | switch (data->state) { |
863 | case SHT15_READING_TEMP: |
864 | data->val_temp = val; |
865 | break; |
866 | case SHT15_READING_HUMID: |
867 | data->val_humid = val; |
868 | break; |
869 | default: |
870 | break; |
871 | } |
872 | |
873 | data->state = SHT15_READING_NOTHING; |
874 | wakeup: |
875 | wake_up(&data->wait_queue); |
876 | } |
877 | |
878 | static void sht15_update_voltage(struct work_struct *work_s) |
879 | { |
880 | struct sht15_data *data |
881 | = container_of(work_s, struct sht15_data, |
882 | update_supply_work); |
883 | data->supply_uv = regulator_get_voltage(regulator: data->reg); |
884 | } |
885 | |
886 | /** |
887 | * sht15_invalidate_voltage() - mark supply voltage invalid when notified by reg |
888 | * @nb: associated notification structure |
889 | * @event: voltage regulator state change event code |
890 | * @ignored: function parameter - ignored here |
891 | * |
892 | * Note that as the notification code holds the regulator lock, we have |
893 | * to schedule an update of the supply voltage rather than getting it directly. |
894 | */ |
895 | static int sht15_invalidate_voltage(struct notifier_block *nb, |
896 | unsigned long event, |
897 | void *ignored) |
898 | { |
899 | struct sht15_data *data = container_of(nb, struct sht15_data, nb); |
900 | |
901 | if (event == REGULATOR_EVENT_VOLTAGE_CHANGE) |
902 | data->supply_uv_valid = false; |
903 | schedule_work(work: &data->update_supply_work); |
904 | |
905 | return NOTIFY_OK; |
906 | } |
907 | |
908 | #ifdef CONFIG_OF |
909 | static const struct of_device_id sht15_dt_match[] = { |
910 | { .compatible = "sensirion,sht15" }, |
911 | { }, |
912 | }; |
913 | MODULE_DEVICE_TABLE(of, sht15_dt_match); |
914 | #endif |
915 | |
916 | static int sht15_probe(struct platform_device *pdev) |
917 | { |
918 | int ret; |
919 | struct sht15_data *data; |
920 | |
921 | data = devm_kzalloc(dev: &pdev->dev, size: 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(dev: data->dev, id: "vcc" ); |
937 | if (!IS_ERR(ptr: data->reg)) { |
938 | int voltage; |
939 | |
940 | voltage = regulator_get_voltage(regulator: data->reg); |
941 | if (voltage) |
942 | data->supply_uv = voltage; |
943 | |
944 | ret = regulator_enable(regulator: 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(regulator: data->reg, nb: &data->nb); |
957 | if (ret) { |
958 | dev_err(&pdev->dev, |
959 | "regulator notifier request failed\n" ); |
960 | regulator_disable(regulator: data->reg); |
961 | return ret; |
962 | } |
963 | } |
964 | |
965 | /* Try requesting the GPIOs */ |
966 | data->sck = devm_gpiod_get(dev: &pdev->dev, con_id: "clk" , flags: GPIOD_OUT_LOW); |
967 | if (IS_ERR(ptr: data->sck)) { |
968 | ret = PTR_ERR(ptr: 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(dev: &pdev->dev, con_id: "data" , flags: GPIOD_IN); |
973 | if (IS_ERR(ptr: data->data)) { |
974 | ret = PTR_ERR(ptr: 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(dev: &pdev->dev, irq: gpiod_to_irq(desc: data->data), |
980 | handler: sht15_interrupt_fired, |
981 | IRQF_TRIGGER_FALLING, |
982 | devname: "sht15 data" , |
983 | dev_id: 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(irq: gpiod_to_irq(desc: 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(kobj: &pdev->dev.kobj, grp: &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(dev: data->dev); |
1003 | if (IS_ERR(ptr: data->hwmon_dev)) { |
1004 | ret = PTR_ERR(ptr: data->hwmon_dev); |
1005 | goto err_release_sysfs_group; |
1006 | } |
1007 | |
1008 | return 0; |
1009 | |
1010 | err_release_sysfs_group: |
1011 | sysfs_remove_group(kobj: &pdev->dev.kobj, grp: &sht15_attr_group); |
1012 | err_release_reg: |
1013 | if (!IS_ERR(ptr: data->reg)) { |
1014 | regulator_unregister_notifier(regulator: data->reg, nb: &data->nb); |
1015 | regulator_disable(regulator: data->reg); |
1016 | } |
1017 | return ret; |
1018 | } |
1019 | |
1020 | static 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(dev: data->hwmon_dev); |
1026 | sysfs_remove_group(kobj: &pdev->dev.kobj, grp: &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(ptr: data->reg)) { |
1033 | regulator_unregister_notifier(regulator: data->reg, nb: &data->nb); |
1034 | regulator_disable(regulator: data->reg); |
1035 | } |
1036 | } |
1037 | |
1038 | static 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 | }; |
1046 | MODULE_DEVICE_TABLE(platform, sht15_device_ids); |
1047 | |
1048 | static 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_new = sht15_remove, |
1055 | .id_table = sht15_device_ids, |
1056 | }; |
1057 | module_platform_driver(sht15_driver); |
1058 | |
1059 | MODULE_LICENSE("GPL" ); |
1060 | MODULE_DESCRIPTION("Sensirion SHT15 temperature and humidity sensor driver" ); |
1061 | |