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