1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
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
46#define SHT15_TSCKL 100
47#define SHT15_TSCKH 100
48#define SHT15_TSU 150
49#define SHT15_TSRST 11
50
51
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
58enum sht15_chips { sht10, sht11, sht15, sht71, sht75 };
59
60
61enum sht15_state {
62 SHT15_READING_NOTHING,
63 SHT15_READING_TEMP,
64 SHT15_READING_HUMID
65};
66
67
68
69
70
71
72struct sht15_temppair {
73 int vdd;
74 int d1;
75};
76
77
78static const struct sht15_temppair temppoints[] = {
79 { 2500000, -39400 },
80 { 3000000, -39600 },
81 { 3500000, -39700 },
82 { 4000000, -39800 },
83 { 5000000, -40100 },
84};
85
86
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
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
178
179
180
181
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
199
200
201
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
224
225
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);
235}
236
237
238
239
240
241
242
243
244
245static int sht15_transmission_start(struct sht15_data *data)
246{
247 int err;
248
249
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
273
274
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
288
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
314
315
316
317
318
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
333
334
335
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
346 data->val_status = 0;
347
348 return ret;
349}
350
351
352
353
354
355
356
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
377
378
379
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
398
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
418
419
420
421
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
445
446
447
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
481
482
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
514
515
516
517
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
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) {
546 data->state = SHT15_READING_NOTHING;
547 return -EIO;
548 } else if (ret == 0) {
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
558
559
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
583
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
612
613
614
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
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
637
638
639
640
641
642
643
644
645static inline int sht15_calc_humid(struct sht15_data *data)
646{
647 int rh_linear;
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;
655 c3 = -7200;
656 t2 = 1280;
657 } else {
658 c2 = 40500;
659 c3 = -28;
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
672
673
674
675
676
677
678
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
695
696
697
698
699
700
701
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
730
731
732
733
734
735
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
745 ret = sht15_update_measurements(data);
746
747 return ret ? ret : sprintf(buf, "%d\n",
748 sht15_calc_temp(data));
749}
750
751
752
753
754
755
756
757
758
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
810 disable_irq_nosync(irq);
811 atomic_inc(&data->interrupt_handled);
812
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
828 if (gpio_get_value(data->pdata->gpio_data)) {
829
830
831
832
833 atomic_set(&data->interrupt_handled, 0);
834 enable_irq(gpio_to_irq(data->pdata->gpio_data));
835
836 if (gpio_get_value(data->pdata->gpio_data)
837 || atomic_read(&data->interrupt_handled))
838 return;
839 }
840
841
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
851
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
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
894
895
896
897
898
899
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
946
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
965
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
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
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
1046
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");
1087