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