1
2
3
4
5
6
7
8
9
10
11
12#include <linux/clk.h>
13#include <linux/cpu_pm.h>
14#include <linux/device.h>
15#include <linux/err.h>
16#include <linux/export.h>
17#include <linux/gpio/consumer.h>
18#include <linux/init.h>
19#include <linux/interrupt.h>
20#include <linux/io.h>
21#include <linux/iopoll.h>
22#include <linux/kernel.h>
23#include <linux/module.h>
24#include <linux/of.h>
25#include <linux/of_device.h>
26#include <linux/of_irq.h>
27#include <linux/of_platform.h>
28#include <linux/platform_device.h>
29#include <linux/pm.h>
30#include <linux/pm_runtime.h>
31#include <linux/reboot.h>
32#include <linux/spinlock.h>
33#include <linux/sys_soc.h>
34#include <linux/types.h>
35
36#include "ti-bandgap.h"
37
38static int ti_bandgap_force_single_read(struct ti_bandgap *bgp, int id);
39#ifdef CONFIG_PM_SLEEP
40static int bandgap_omap_cpu_notifier(struct notifier_block *nb,
41 unsigned long cmd, void *v);
42#endif
43
44
45
46
47
48
49
50
51
52
53
54static u32 ti_bandgap_readl(struct ti_bandgap *bgp, u32 reg)
55{
56 return readl(bgp->base + reg);
57}
58
59
60
61
62
63
64
65
66
67static void ti_bandgap_writel(struct ti_bandgap *bgp, u32 val, u32 reg)
68{
69 writel(val, bgp->base + reg);
70}
71
72
73
74
75
76
77
78#define RMW_BITS(bgp, id, reg, mask, val) \
79do { \
80 struct temp_sensor_registers *t; \
81 u32 r; \
82 \
83 t = bgp->conf->sensors[(id)].registers; \
84 r = ti_bandgap_readl(bgp, t->reg); \
85 r &= ~t->mask; \
86 r |= (val) << __ffs(t->mask); \
87 ti_bandgap_writel(bgp, r, t->reg); \
88} while (0)
89
90
91
92
93
94
95
96
97
98
99
100
101
102static int ti_bandgap_power(struct ti_bandgap *bgp, bool on)
103{
104 int i;
105
106 if (!TI_BANDGAP_HAS(bgp, POWER_SWITCH))
107 return -ENOTSUPP;
108
109 for (i = 0; i < bgp->conf->sensor_count; i++)
110
111 RMW_BITS(bgp, i, temp_sensor_ctrl, bgap_tempsoff_mask, !on);
112 return 0;
113}
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131static u32 ti_errata814_bandgap_read_temp(struct ti_bandgap *bgp, u32 reg)
132{
133 u32 val1, val2;
134
135 val1 = ti_bandgap_readl(bgp, reg);
136 val2 = ti_bandgap_readl(bgp, reg);
137
138
139 if (val1 == val2)
140 return val1;
141
142
143 return ti_bandgap_readl(bgp, reg);
144}
145
146
147
148
149
150
151
152
153
154
155
156
157
158static u32 ti_bandgap_read_temp(struct ti_bandgap *bgp, int id)
159{
160 struct temp_sensor_registers *tsr;
161 u32 temp, reg;
162
163 tsr = bgp->conf->sensors[id].registers;
164 reg = tsr->temp_sensor_ctrl;
165
166 if (TI_BANDGAP_HAS(bgp, FREEZE_BIT)) {
167 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 1);
168
169
170
171
172 reg = tsr->ctrl_dtemp_1;
173 }
174
175
176 if (TI_BANDGAP_HAS(bgp, ERRATA_814))
177 temp = ti_errata814_bandgap_read_temp(bgp, reg);
178 else
179 temp = ti_bandgap_readl(bgp, reg);
180
181 temp &= tsr->bgap_dtemp_mask;
182
183 if (TI_BANDGAP_HAS(bgp, FREEZE_BIT))
184 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
185
186 return temp;
187}
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204static irqreturn_t ti_bandgap_talert_irq_handler(int irq, void *data)
205{
206 struct ti_bandgap *bgp = data;
207 struct temp_sensor_registers *tsr;
208 u32 t_hot = 0, t_cold = 0, ctrl;
209 int i;
210
211 spin_lock(&bgp->lock);
212 for (i = 0; i < bgp->conf->sensor_count; i++) {
213 tsr = bgp->conf->sensors[i].registers;
214 ctrl = ti_bandgap_readl(bgp, tsr->bgap_status);
215
216
217 t_hot = ctrl & tsr->status_hot_mask;
218
219
220 t_cold = ctrl & tsr->status_cold_mask;
221
222 if (!t_cold && !t_hot)
223 continue;
224
225 ctrl = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
226
227
228
229
230
231 if (t_hot) {
232 ctrl &= ~tsr->mask_hot_mask;
233 ctrl |= tsr->mask_cold_mask;
234 } else if (t_cold) {
235 ctrl &= ~tsr->mask_cold_mask;
236 ctrl |= tsr->mask_hot_mask;
237 }
238
239 ti_bandgap_writel(bgp, ctrl, tsr->bgap_mask_ctrl);
240
241 dev_dbg(bgp->dev,
242 "%s: IRQ from %s sensor: hotevent %d coldevent %d\n",
243 __func__, bgp->conf->sensors[i].domain,
244 t_hot, t_cold);
245
246
247 if (bgp->conf->report_temperature)
248 bgp->conf->report_temperature(bgp, i);
249 }
250 spin_unlock(&bgp->lock);
251
252 return IRQ_HANDLED;
253}
254
255
256
257
258
259
260
261
262
263
264
265
266static irqreturn_t ti_bandgap_tshut_irq_handler(int irq, void *data)
267{
268 pr_emerg("%s: TSHUT temperature reached. Needs shut down...\n",
269 __func__);
270
271 orderly_poweroff(true);
272
273 return IRQ_HANDLED;
274}
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291static
292int ti_bandgap_adc_to_mcelsius(struct ti_bandgap *bgp, int adc_val, int *t)
293{
294 const struct ti_bandgap_data *conf = bgp->conf;
295
296
297 if (adc_val < conf->adc_start_val || adc_val > conf->adc_end_val)
298 return -ERANGE;
299
300 *t = bgp->conf->conv_table[adc_val - conf->adc_start_val];
301 return 0;
302}
303
304
305
306
307
308
309
310
311
312
313
314
315static inline int ti_bandgap_validate(struct ti_bandgap *bgp, int id)
316{
317 if (!bgp || IS_ERR(bgp)) {
318 pr_err("%s: invalid bandgap pointer\n", __func__);
319 return -EINVAL;
320 }
321
322 if ((id < 0) || (id >= bgp->conf->sensor_count)) {
323 dev_err(bgp->dev, "%s: sensor id out of range (%d)\n",
324 __func__, id);
325 return -ERANGE;
326 }
327
328 return 0;
329}
330
331
332
333
334
335
336
337static void ti_bandgap_read_counter(struct ti_bandgap *bgp, int id,
338 int *interval)
339{
340 struct temp_sensor_registers *tsr;
341 int time;
342
343 tsr = bgp->conf->sensors[id].registers;
344 time = ti_bandgap_readl(bgp, tsr->bgap_counter);
345 time = (time & tsr->counter_mask) >>
346 __ffs(tsr->counter_mask);
347 time = time * 1000 / bgp->clk_rate;
348 *interval = time;
349}
350
351
352
353
354
355
356
357static void ti_bandgap_read_counter_delay(struct ti_bandgap *bgp, int id,
358 int *interval)
359{
360 struct temp_sensor_registers *tsr;
361 int reg_val;
362
363 tsr = bgp->conf->sensors[id].registers;
364
365 reg_val = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
366 reg_val = (reg_val & tsr->mask_counter_delay_mask) >>
367 __ffs(tsr->mask_counter_delay_mask);
368 switch (reg_val) {
369 case 0:
370 *interval = 0;
371 break;
372 case 1:
373 *interval = 1;
374 break;
375 case 2:
376 *interval = 10;
377 break;
378 case 3:
379 *interval = 100;
380 break;
381 case 4:
382 *interval = 250;
383 break;
384 case 5:
385 *interval = 500;
386 break;
387 default:
388 dev_warn(bgp->dev, "Wrong counter delay value read from register %X",
389 reg_val);
390 }
391}
392
393
394
395
396
397
398
399
400
401int ti_bandgap_read_update_interval(struct ti_bandgap *bgp, int id,
402 int *interval)
403{
404 int ret = 0;
405
406 ret = ti_bandgap_validate(bgp, id);
407 if (ret)
408 goto exit;
409
410 if (!TI_BANDGAP_HAS(bgp, COUNTER) &&
411 !TI_BANDGAP_HAS(bgp, COUNTER_DELAY)) {
412 ret = -ENOTSUPP;
413 goto exit;
414 }
415
416 if (TI_BANDGAP_HAS(bgp, COUNTER)) {
417 ti_bandgap_read_counter(bgp, id, interval);
418 goto exit;
419 }
420
421 ti_bandgap_read_counter_delay(bgp, id, interval);
422exit:
423 return ret;
424}
425
426
427
428
429
430
431
432
433
434static int ti_bandgap_write_counter_delay(struct ti_bandgap *bgp, int id,
435 u32 interval)
436{
437 int rval;
438
439 switch (interval) {
440 case 0:
441 rval = 0x0;
442 break;
443 case 1:
444 rval = 0x1;
445 break;
446 case 10:
447 rval = 0x2;
448 break;
449 case 100:
450 rval = 0x3;
451 break;
452 case 250:
453 rval = 0x4;
454 break;
455 case 500:
456 rval = 0x5;
457 break;
458 default:
459 dev_warn(bgp->dev, "Delay %d ms is not supported\n", interval);
460 return -EINVAL;
461 }
462
463 spin_lock(&bgp->lock);
464 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_counter_delay_mask, rval);
465 spin_unlock(&bgp->lock);
466
467 return 0;
468}
469
470
471
472
473
474
475
476static void ti_bandgap_write_counter(struct ti_bandgap *bgp, int id,
477 u32 interval)
478{
479 interval = interval * bgp->clk_rate / 1000;
480 spin_lock(&bgp->lock);
481 RMW_BITS(bgp, id, bgap_counter, counter_mask, interval);
482 spin_unlock(&bgp->lock);
483}
484
485
486
487
488
489
490
491
492
493int ti_bandgap_write_update_interval(struct ti_bandgap *bgp,
494 int id, u32 interval)
495{
496 int ret = ti_bandgap_validate(bgp, id);
497 if (ret)
498 goto exit;
499
500 if (!TI_BANDGAP_HAS(bgp, COUNTER) &&
501 !TI_BANDGAP_HAS(bgp, COUNTER_DELAY)) {
502 ret = -ENOTSUPP;
503 goto exit;
504 }
505
506 if (TI_BANDGAP_HAS(bgp, COUNTER)) {
507 ti_bandgap_write_counter(bgp, id, interval);
508 goto exit;
509 }
510
511 ret = ti_bandgap_write_counter_delay(bgp, id, interval);
512exit:
513 return ret;
514}
515
516
517
518
519
520
521
522
523
524int ti_bandgap_read_temperature(struct ti_bandgap *bgp, int id,
525 int *temperature)
526{
527 u32 temp;
528 int ret;
529
530 ret = ti_bandgap_validate(bgp, id);
531 if (ret)
532 return ret;
533
534 if (!TI_BANDGAP_HAS(bgp, MODE_CONFIG)) {
535 ret = ti_bandgap_force_single_read(bgp, id);
536 if (ret)
537 return ret;
538 }
539
540 spin_lock(&bgp->lock);
541 temp = ti_bandgap_read_temp(bgp, id);
542 spin_unlock(&bgp->lock);
543
544 ret = ti_bandgap_adc_to_mcelsius(bgp, temp, &temp);
545 if (ret)
546 return -EIO;
547
548 *temperature = temp;
549
550 return 0;
551}
552
553
554
555
556
557
558
559
560
561
562int ti_bandgap_set_sensor_data(struct ti_bandgap *bgp, int id, void *data)
563{
564 int ret = ti_bandgap_validate(bgp, id);
565 if (ret)
566 return ret;
567
568 bgp->regval[id].data = data;
569
570 return 0;
571}
572
573
574
575
576
577
578
579
580
581void *ti_bandgap_get_sensor_data(struct ti_bandgap *bgp, int id)
582{
583 int ret = ti_bandgap_validate(bgp, id);
584 if (ret)
585 return ERR_PTR(ret);
586
587 return bgp->regval[id].data;
588}
589
590
591
592
593
594
595
596
597
598
599
600
601
602static int
603ti_bandgap_force_single_read(struct ti_bandgap *bgp, int id)
604{
605 struct temp_sensor_registers *tsr = bgp->conf->sensors[id].registers;
606 void __iomem *temp_sensor_ctrl = bgp->base + tsr->temp_sensor_ctrl;
607 int error;
608 u32 val;
609
610
611 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG)) {
612 if (TI_BANDGAP_HAS(bgp, CONT_MODE_ONLY))
613 RMW_BITS(bgp, id, bgap_mode_ctrl, mode_ctrl_mask, 1);
614 else
615 RMW_BITS(bgp, id, bgap_mode_ctrl, mode_ctrl_mask, 0);
616 }
617
618
619 if (tsr->bgap_soc_mask) {
620 RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 1);
621
622
623 error = readl_poll_timeout_atomic(temp_sensor_ctrl, val,
624 val & tsr->bgap_eocz_mask,
625 1, 1000);
626 if (error)
627 dev_warn(bgp->dev, "eocz timed out waiting high\n");
628
629
630 RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 0);
631 }
632
633
634 error = readl_poll_timeout_atomic(temp_sensor_ctrl, val,
635 !(val & tsr->bgap_eocz_mask),
636 1, 1500);
637 if (error)
638 dev_warn(bgp->dev, "eocz timed out waiting low\n");
639
640 return 0;
641}
642
643
644
645
646
647
648
649
650
651
652
653
654static int ti_bandgap_set_continuous_mode(struct ti_bandgap *bgp)
655{
656 int i;
657
658 for (i = 0; i < bgp->conf->sensor_count; i++) {
659
660 ti_bandgap_force_single_read(bgp, i);
661 RMW_BITS(bgp, i, bgap_mode_ctrl, mode_ctrl_mask, 1);
662 }
663
664 return 0;
665}
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682int ti_bandgap_get_trend(struct ti_bandgap *bgp, int id, int *trend)
683{
684 struct temp_sensor_registers *tsr;
685 u32 temp1, temp2, reg1, reg2;
686 int t1, t2, interval, ret = 0;
687
688 ret = ti_bandgap_validate(bgp, id);
689 if (ret)
690 goto exit;
691
692 if (!TI_BANDGAP_HAS(bgp, HISTORY_BUFFER) ||
693 !TI_BANDGAP_HAS(bgp, FREEZE_BIT)) {
694 ret = -ENOTSUPP;
695 goto exit;
696 }
697
698 spin_lock(&bgp->lock);
699
700 tsr = bgp->conf->sensors[id].registers;
701
702
703 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 1);
704 reg1 = tsr->ctrl_dtemp_1;
705 reg2 = tsr->ctrl_dtemp_2;
706
707
708 temp1 = ti_bandgap_readl(bgp, reg1);
709 temp1 &= tsr->bgap_dtemp_mask;
710
711 temp2 = ti_bandgap_readl(bgp, reg2);
712 temp2 &= tsr->bgap_dtemp_mask;
713
714
715 ret = ti_bandgap_adc_to_mcelsius(bgp, temp1, &t1);
716 if (ret)
717 goto unfreeze;
718
719 ret = ti_bandgap_adc_to_mcelsius(bgp, temp2, &t2);
720 if (ret)
721 goto unfreeze;
722
723
724 ret = ti_bandgap_read_update_interval(bgp, id, &interval);
725 if (ret)
726 goto unfreeze;
727
728
729 if (interval == 0)
730 interval = 1;
731
732 *trend = (t1 - t2) / interval;
733
734 dev_dbg(bgp->dev, "The temperatures are t1 = %d and t2 = %d and trend =%d\n",
735 t1, t2, *trend);
736
737unfreeze:
738 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
739 spin_unlock(&bgp->lock);
740exit:
741 return ret;
742}
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758static int ti_bandgap_tshut_init(struct ti_bandgap *bgp,
759 struct platform_device *pdev)
760{
761 int status;
762
763 status = request_irq(gpiod_to_irq(bgp->tshut_gpiod),
764 ti_bandgap_tshut_irq_handler,
765 IRQF_TRIGGER_RISING, "tshut", NULL);
766 if (status)
767 dev_err(bgp->dev, "request irq failed for TSHUT");
768
769 return 0;
770}
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785static int ti_bandgap_talert_init(struct ti_bandgap *bgp,
786 struct platform_device *pdev)
787{
788 int ret;
789
790 bgp->irq = platform_get_irq(pdev, 0);
791 if (bgp->irq < 0)
792 return bgp->irq;
793
794 ret = request_threaded_irq(bgp->irq, NULL,
795 ti_bandgap_talert_irq_handler,
796 IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
797 "talert", bgp);
798 if (ret) {
799 dev_err(&pdev->dev, "Request threaded irq failed.\n");
800 return ret;
801 }
802
803 return 0;
804}
805
806static const struct of_device_id of_ti_bandgap_match[];
807
808
809
810
811
812
813
814
815
816
817
818static struct ti_bandgap *ti_bandgap_build(struct platform_device *pdev)
819{
820 struct device_node *node = pdev->dev.of_node;
821 const struct of_device_id *of_id;
822 struct ti_bandgap *bgp;
823 struct resource *res;
824 int i;
825
826
827 if (!node) {
828 dev_err(&pdev->dev, "no platform information available\n");
829 return ERR_PTR(-EINVAL);
830 }
831
832 bgp = devm_kzalloc(&pdev->dev, sizeof(*bgp), GFP_KERNEL);
833 if (!bgp)
834 return ERR_PTR(-ENOMEM);
835
836 of_id = of_match_device(of_ti_bandgap_match, &pdev->dev);
837 if (of_id)
838 bgp->conf = of_id->data;
839
840
841 bgp->regval = devm_kcalloc(&pdev->dev, bgp->conf->sensor_count,
842 sizeof(*bgp->regval), GFP_KERNEL);
843 if (!bgp->regval)
844 return ERR_PTR(-ENOMEM);
845
846 i = 0;
847 do {
848 void __iomem *chunk;
849
850 res = platform_get_resource(pdev, IORESOURCE_MEM, i);
851 if (!res)
852 break;
853 chunk = devm_ioremap_resource(&pdev->dev, res);
854 if (i == 0)
855 bgp->base = chunk;
856 if (IS_ERR(chunk))
857 return ERR_CAST(chunk);
858
859 i++;
860 } while (res);
861
862 if (TI_BANDGAP_HAS(bgp, TSHUT)) {
863 bgp->tshut_gpiod = devm_gpiod_get(&pdev->dev, NULL, GPIOD_IN);
864 if (IS_ERR(bgp->tshut_gpiod)) {
865 dev_err(&pdev->dev, "invalid gpio for tshut\n");
866 return ERR_CAST(bgp->tshut_gpiod);
867 }
868 }
869
870 return bgp;
871}
872
873
874
875
876
877
878
879static const struct soc_device_attribute soc_no_cpu_notifier[] = {
880 { .machine = "OMAP4430" },
881 { },
882};
883
884
885
886static
887int ti_bandgap_probe(struct platform_device *pdev)
888{
889 struct ti_bandgap *bgp;
890 int clk_rate, ret, i;
891
892 bgp = ti_bandgap_build(pdev);
893 if (IS_ERR(bgp)) {
894 dev_err(&pdev->dev, "failed to fetch platform data\n");
895 return PTR_ERR(bgp);
896 }
897 bgp->dev = &pdev->dev;
898
899 if (TI_BANDGAP_HAS(bgp, UNRELIABLE))
900 dev_warn(&pdev->dev,
901 "This OMAP thermal sensor is unreliable. You've been warned\n");
902
903 if (TI_BANDGAP_HAS(bgp, TSHUT)) {
904 ret = ti_bandgap_tshut_init(bgp, pdev);
905 if (ret) {
906 dev_err(&pdev->dev,
907 "failed to initialize system tshut IRQ\n");
908 return ret;
909 }
910 }
911
912 bgp->fclock = clk_get(NULL, bgp->conf->fclock_name);
913 if (IS_ERR(bgp->fclock)) {
914 dev_err(&pdev->dev, "failed to request fclock reference\n");
915 ret = PTR_ERR(bgp->fclock);
916 goto free_irqs;
917 }
918
919 bgp->div_clk = clk_get(NULL, bgp->conf->div_ck_name);
920 if (IS_ERR(bgp->div_clk)) {
921 dev_err(&pdev->dev, "failed to request div_ts_ck clock ref\n");
922 ret = PTR_ERR(bgp->div_clk);
923 goto put_fclock;
924 }
925
926 for (i = 0; i < bgp->conf->sensor_count; i++) {
927 struct temp_sensor_registers *tsr;
928 u32 val;
929
930 tsr = bgp->conf->sensors[i].registers;
931
932
933
934
935
936 val = ti_bandgap_readl(bgp, tsr->bgap_efuse);
937 if (!val)
938 dev_info(&pdev->dev,
939 "Non-trimmed BGAP, Temp not accurate\n");
940 }
941
942 clk_rate = clk_round_rate(bgp->div_clk,
943 bgp->conf->sensors[0].ts_data->max_freq);
944 if (clk_rate < bgp->conf->sensors[0].ts_data->min_freq ||
945 clk_rate <= 0) {
946 ret = -ENODEV;
947 dev_err(&pdev->dev, "wrong clock rate (%d)\n", clk_rate);
948 goto put_clks;
949 }
950
951 ret = clk_set_rate(bgp->div_clk, clk_rate);
952 if (ret)
953 dev_err(&pdev->dev, "Cannot re-set clock rate. Continuing\n");
954
955 bgp->clk_rate = clk_rate;
956 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
957 clk_prepare_enable(bgp->fclock);
958
959
960 spin_lock_init(&bgp->lock);
961 bgp->dev = &pdev->dev;
962 platform_set_drvdata(pdev, bgp);
963
964 ti_bandgap_power(bgp, true);
965
966
967 if (TI_BANDGAP_HAS(bgp, COUNTER))
968 for (i = 0; i < bgp->conf->sensor_count; i++)
969 RMW_BITS(bgp, i, bgap_counter, counter_mask, 1);
970
971
972 for (i = 0; i < bgp->conf->sensor_count; i++) {
973 struct temp_sensor_data *ts_data;
974
975 ts_data = bgp->conf->sensors[i].ts_data;
976
977 if (TI_BANDGAP_HAS(bgp, TALERT)) {
978
979 RMW_BITS(bgp, i, bgap_threshold,
980 threshold_tcold_mask, ts_data->t_cold);
981 RMW_BITS(bgp, i, bgap_threshold,
982 threshold_thot_mask, ts_data->t_hot);
983
984 RMW_BITS(bgp, i, bgap_mask_ctrl, mask_hot_mask, 1);
985 RMW_BITS(bgp, i, bgap_mask_ctrl, mask_cold_mask, 1);
986 }
987
988 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG)) {
989
990 RMW_BITS(bgp, i, tshut_threshold,
991 tshut_hot_mask, ts_data->tshut_hot);
992 RMW_BITS(bgp, i, tshut_threshold,
993 tshut_cold_mask, ts_data->tshut_cold);
994 }
995 }
996
997 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
998 ti_bandgap_set_continuous_mode(bgp);
999
1000
1001 if (TI_BANDGAP_HAS(bgp, COUNTER))
1002 for (i = 0; i < bgp->conf->sensor_count; i++)
1003 RMW_BITS(bgp, i, bgap_counter, counter_mask,
1004 bgp->clk_rate / 4);
1005
1006
1007 for (i = 0; i < bgp->conf->sensor_count; i++) {
1008 char *domain;
1009
1010 if (bgp->conf->sensors[i].register_cooling) {
1011 ret = bgp->conf->sensors[i].register_cooling(bgp, i);
1012 if (ret)
1013 goto remove_sensors;
1014 }
1015
1016 if (bgp->conf->expose_sensor) {
1017 domain = bgp->conf->sensors[i].domain;
1018 ret = bgp->conf->expose_sensor(bgp, i, domain);
1019 if (ret)
1020 goto remove_last_cooling;
1021 }
1022 }
1023
1024
1025
1026
1027
1028
1029 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1030 ret = ti_bandgap_talert_init(bgp, pdev);
1031 if (ret) {
1032 dev_err(&pdev->dev, "failed to initialize Talert IRQ\n");
1033 i = bgp->conf->sensor_count;
1034 goto disable_clk;
1035 }
1036 }
1037
1038#ifdef CONFIG_PM_SLEEP
1039 bgp->nb.notifier_call = bandgap_omap_cpu_notifier;
1040 if (!soc_device_match(soc_no_cpu_notifier))
1041 cpu_pm_register_notifier(&bgp->nb);
1042#endif
1043
1044 return 0;
1045
1046remove_last_cooling:
1047 if (bgp->conf->sensors[i].unregister_cooling)
1048 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1049remove_sensors:
1050 for (i--; i >= 0; i--) {
1051 if (bgp->conf->sensors[i].unregister_cooling)
1052 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1053 if (bgp->conf->remove_sensor)
1054 bgp->conf->remove_sensor(bgp, i);
1055 }
1056 ti_bandgap_power(bgp, false);
1057disable_clk:
1058 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1059 clk_disable_unprepare(bgp->fclock);
1060put_clks:
1061 clk_put(bgp->div_clk);
1062put_fclock:
1063 clk_put(bgp->fclock);
1064free_irqs:
1065 if (TI_BANDGAP_HAS(bgp, TSHUT))
1066 free_irq(gpiod_to_irq(bgp->tshut_gpiod), NULL);
1067
1068 return ret;
1069}
1070
1071static
1072int ti_bandgap_remove(struct platform_device *pdev)
1073{
1074 struct ti_bandgap *bgp = platform_get_drvdata(pdev);
1075 int i;
1076
1077 if (!soc_device_match(soc_no_cpu_notifier))
1078 cpu_pm_unregister_notifier(&bgp->nb);
1079
1080
1081 for (i = 0; i < bgp->conf->sensor_count; i++) {
1082 if (bgp->conf->sensors[i].unregister_cooling)
1083 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1084
1085 if (bgp->conf->remove_sensor)
1086 bgp->conf->remove_sensor(bgp, i);
1087 }
1088
1089 ti_bandgap_power(bgp, false);
1090
1091 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1092 clk_disable_unprepare(bgp->fclock);
1093 clk_put(bgp->fclock);
1094 clk_put(bgp->div_clk);
1095
1096 if (TI_BANDGAP_HAS(bgp, TALERT))
1097 free_irq(bgp->irq, bgp);
1098
1099 if (TI_BANDGAP_HAS(bgp, TSHUT))
1100 free_irq(gpiod_to_irq(bgp->tshut_gpiod), NULL);
1101
1102 return 0;
1103}
1104
1105#ifdef CONFIG_PM_SLEEP
1106static int ti_bandgap_save_ctxt(struct ti_bandgap *bgp)
1107{
1108 int i;
1109
1110 for (i = 0; i < bgp->conf->sensor_count; i++) {
1111 struct temp_sensor_registers *tsr;
1112 struct temp_sensor_regval *rval;
1113
1114 rval = &bgp->regval[i];
1115 tsr = bgp->conf->sensors[i].registers;
1116
1117 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1118 rval->bg_mode_ctrl = ti_bandgap_readl(bgp,
1119 tsr->bgap_mode_ctrl);
1120 if (TI_BANDGAP_HAS(bgp, COUNTER))
1121 rval->bg_counter = ti_bandgap_readl(bgp,
1122 tsr->bgap_counter);
1123 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1124 rval->bg_threshold = ti_bandgap_readl(bgp,
1125 tsr->bgap_threshold);
1126 rval->bg_ctrl = ti_bandgap_readl(bgp,
1127 tsr->bgap_mask_ctrl);
1128 }
1129
1130 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1131 rval->tshut_threshold = ti_bandgap_readl(bgp,
1132 tsr->tshut_threshold);
1133 }
1134
1135 return 0;
1136}
1137
1138static int ti_bandgap_restore_ctxt(struct ti_bandgap *bgp)
1139{
1140 int i;
1141
1142 for (i = 0; i < bgp->conf->sensor_count; i++) {
1143 struct temp_sensor_registers *tsr;
1144 struct temp_sensor_regval *rval;
1145
1146 rval = &bgp->regval[i];
1147 tsr = bgp->conf->sensors[i].registers;
1148
1149 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1150 ti_bandgap_writel(bgp, rval->tshut_threshold,
1151 tsr->tshut_threshold);
1152
1153
1154
1155 ti_bandgap_force_single_read(bgp, i);
1156
1157 if (TI_BANDGAP_HAS(bgp, COUNTER))
1158 ti_bandgap_writel(bgp, rval->bg_counter,
1159 tsr->bgap_counter);
1160 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1161 ti_bandgap_writel(bgp, rval->bg_mode_ctrl,
1162 tsr->bgap_mode_ctrl);
1163 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1164 ti_bandgap_writel(bgp, rval->bg_threshold,
1165 tsr->bgap_threshold);
1166 ti_bandgap_writel(bgp, rval->bg_ctrl,
1167 tsr->bgap_mask_ctrl);
1168 }
1169 }
1170
1171 return 0;
1172}
1173
1174static int ti_bandgap_suspend(struct device *dev)
1175{
1176 struct ti_bandgap *bgp = dev_get_drvdata(dev);
1177 int err;
1178
1179 err = ti_bandgap_save_ctxt(bgp);
1180 ti_bandgap_power(bgp, false);
1181
1182 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1183 clk_disable_unprepare(bgp->fclock);
1184
1185 bgp->is_suspended = true;
1186
1187 return err;
1188}
1189
1190static int bandgap_omap_cpu_notifier(struct notifier_block *nb,
1191 unsigned long cmd, void *v)
1192{
1193 struct ti_bandgap *bgp;
1194
1195 bgp = container_of(nb, struct ti_bandgap, nb);
1196
1197 spin_lock(&bgp->lock);
1198 switch (cmd) {
1199 case CPU_CLUSTER_PM_ENTER:
1200 if (bgp->is_suspended)
1201 break;
1202 ti_bandgap_save_ctxt(bgp);
1203 ti_bandgap_power(bgp, false);
1204 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1205 clk_disable(bgp->fclock);
1206 break;
1207 case CPU_CLUSTER_PM_ENTER_FAILED:
1208 case CPU_CLUSTER_PM_EXIT:
1209 if (bgp->is_suspended)
1210 break;
1211 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1212 clk_enable(bgp->fclock);
1213 ti_bandgap_power(bgp, true);
1214 ti_bandgap_restore_ctxt(bgp);
1215 break;
1216 }
1217 spin_unlock(&bgp->lock);
1218
1219 return NOTIFY_OK;
1220}
1221
1222static int ti_bandgap_resume(struct device *dev)
1223{
1224 struct ti_bandgap *bgp = dev_get_drvdata(dev);
1225
1226 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1227 clk_prepare_enable(bgp->fclock);
1228
1229 ti_bandgap_power(bgp, true);
1230 bgp->is_suspended = false;
1231
1232 return ti_bandgap_restore_ctxt(bgp);
1233}
1234static SIMPLE_DEV_PM_OPS(ti_bandgap_dev_pm_ops, ti_bandgap_suspend,
1235 ti_bandgap_resume);
1236
1237#define DEV_PM_OPS (&ti_bandgap_dev_pm_ops)
1238#else
1239#define DEV_PM_OPS NULL
1240#endif
1241
1242static const struct of_device_id of_ti_bandgap_match[] = {
1243#ifdef CONFIG_OMAP3_THERMAL
1244 {
1245 .compatible = "ti,omap34xx-bandgap",
1246 .data = (void *)&omap34xx_data,
1247 },
1248 {
1249 .compatible = "ti,omap36xx-bandgap",
1250 .data = (void *)&omap36xx_data,
1251 },
1252#endif
1253#ifdef CONFIG_OMAP4_THERMAL
1254 {
1255 .compatible = "ti,omap4430-bandgap",
1256 .data = (void *)&omap4430_data,
1257 },
1258 {
1259 .compatible = "ti,omap4460-bandgap",
1260 .data = (void *)&omap4460_data,
1261 },
1262 {
1263 .compatible = "ti,omap4470-bandgap",
1264 .data = (void *)&omap4470_data,
1265 },
1266#endif
1267#ifdef CONFIG_OMAP5_THERMAL
1268 {
1269 .compatible = "ti,omap5430-bandgap",
1270 .data = (void *)&omap5430_data,
1271 },
1272#endif
1273#ifdef CONFIG_DRA752_THERMAL
1274 {
1275 .compatible = "ti,dra752-bandgap",
1276 .data = (void *)&dra752_data,
1277 },
1278#endif
1279
1280 { },
1281};
1282MODULE_DEVICE_TABLE(of, of_ti_bandgap_match);
1283
1284static struct platform_driver ti_bandgap_sensor_driver = {
1285 .probe = ti_bandgap_probe,
1286 .remove = ti_bandgap_remove,
1287 .driver = {
1288 .name = "ti-soc-thermal",
1289 .pm = DEV_PM_OPS,
1290 .of_match_table = of_ti_bandgap_match,
1291 },
1292};
1293
1294module_platform_driver(ti_bandgap_sensor_driver);
1295
1296MODULE_DESCRIPTION("OMAP4+ bandgap temperature sensor driver");
1297MODULE_LICENSE("GPL v2");
1298MODULE_ALIAS("platform:ti-soc-thermal");
1299MODULE_AUTHOR("Texas Instrument Inc.");
1300