This source file includes following definitions.
- raw_to_mcelsius
- mtk_thermal_get_bank
- mtk_thermal_put_bank
- mtk_thermal_bank_temperature
- mtk_read_temp
- mtk_thermal_init_bank
- of_get_phys_base
- mtk_thermal_get_calibration_data
- mtk_thermal_probe
- mtk_thermal_remove
1
2
3
4
5
6
7
8
9
10 #include <linux/clk.h>
11 #include <linux/delay.h>
12 #include <linux/interrupt.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/nvmem-consumer.h>
16 #include <linux/of.h>
17 #include <linux/of_address.h>
18 #include <linux/of_device.h>
19 #include <linux/platform_device.h>
20 #include <linux/slab.h>
21 #include <linux/io.h>
22 #include <linux/thermal.h>
23 #include <linux/reset.h>
24 #include <linux/types.h>
25
26
27 #define AUXADC_CON1_SET_V 0x008
28 #define AUXADC_CON1_CLR_V 0x00c
29 #define AUXADC_CON2_V 0x010
30 #define AUXADC_DATA(channel) (0x14 + (channel) * 4)
31
32 #define APMIXED_SYS_TS_CON1 0x604
33
34
35 #define TEMP_MONCTL0 0x000
36 #define TEMP_MONCTL1 0x004
37 #define TEMP_MONCTL2 0x008
38 #define TEMP_MONIDET0 0x014
39 #define TEMP_MONIDET1 0x018
40 #define TEMP_MSRCTL0 0x038
41 #define TEMP_AHBPOLL 0x040
42 #define TEMP_AHBTO 0x044
43 #define TEMP_ADCPNP0 0x048
44 #define TEMP_ADCPNP1 0x04c
45 #define TEMP_ADCPNP2 0x050
46 #define TEMP_ADCPNP3 0x0b4
47
48 #define TEMP_ADCMUX 0x054
49 #define TEMP_ADCEN 0x060
50 #define TEMP_PNPMUXADDR 0x064
51 #define TEMP_ADCMUXADDR 0x068
52 #define TEMP_ADCENADDR 0x074
53 #define TEMP_ADCVALIDADDR 0x078
54 #define TEMP_ADCVOLTADDR 0x07c
55 #define TEMP_RDCTRL 0x080
56 #define TEMP_ADCVALIDMASK 0x084
57 #define TEMP_ADCVOLTAGESHIFT 0x088
58 #define TEMP_ADCWRITECTRL 0x08c
59 #define TEMP_MSR0 0x090
60 #define TEMP_MSR1 0x094
61 #define TEMP_MSR2 0x098
62 #define TEMP_MSR3 0x0B8
63
64 #define TEMP_SPARE0 0x0f0
65
66 #define TEMP_ADCPNP0_1 0x148
67 #define TEMP_ADCPNP1_1 0x14c
68 #define TEMP_ADCPNP2_1 0x150
69 #define TEMP_MSR0_1 0x190
70 #define TEMP_MSR1_1 0x194
71 #define TEMP_MSR2_1 0x198
72 #define TEMP_ADCPNP3_1 0x1b4
73 #define TEMP_MSR3_1 0x1B8
74
75 #define PTPCORESEL 0x400
76
77 #define TEMP_MONCTL1_PERIOD_UNIT(x) ((x) & 0x3ff)
78
79 #define TEMP_MONCTL2_FILTER_INTERVAL(x) (((x) & 0x3ff) << 16)
80 #define TEMP_MONCTL2_SENSOR_INTERVAL(x) ((x) & 0x3ff)
81
82 #define TEMP_AHBPOLL_ADC_POLL_INTERVAL(x) (x)
83
84 #define TEMP_ADCWRITECTRL_ADC_PNP_WRITE BIT(0)
85 #define TEMP_ADCWRITECTRL_ADC_MUX_WRITE BIT(1)
86
87 #define TEMP_ADCVALIDMASK_VALID_HIGH BIT(5)
88 #define TEMP_ADCVALIDMASK_VALID_POS(bit) (bit)
89
90
91 #define MT8173_TS1 0
92 #define MT8173_TS2 1
93 #define MT8173_TS3 2
94 #define MT8173_TS4 3
95 #define MT8173_TSABB 4
96
97
98 #define MT8173_TEMP_AUXADC_CHANNEL 11
99
100
101 #define MT8173_NUM_SENSORS 5
102
103
104 #define MT8173_NUM_ZONES 4
105
106
107 #define MT8173_NUM_SENSORS_PER_ZONE 4
108
109
110 #define MT8173_NUM_CONTROLLER 1
111
112
113 #define MT8173_CALIBRATION 165
114
115
116
117
118
119
120
121
122
123 #define CALIB_BUF0_VALID BIT(0)
124 #define CALIB_BUF1_ADC_GE(x) (((x) >> 22) & 0x3ff)
125 #define CALIB_BUF0_VTS_TS1(x) (((x) >> 17) & 0x1ff)
126 #define CALIB_BUF0_VTS_TS2(x) (((x) >> 8) & 0x1ff)
127 #define CALIB_BUF1_VTS_TS3(x) (((x) >> 0) & 0x1ff)
128 #define CALIB_BUF2_VTS_TS4(x) (((x) >> 23) & 0x1ff)
129 #define CALIB_BUF2_VTS_TS5(x) (((x) >> 5) & 0x1ff)
130 #define CALIB_BUF2_VTS_TSABB(x) (((x) >> 14) & 0x1ff)
131 #define CALIB_BUF0_DEGC_CALI(x) (((x) >> 1) & 0x3f)
132 #define CALIB_BUF0_O_SLOPE(x) (((x) >> 26) & 0x3f)
133 #define CALIB_BUF0_O_SLOPE_SIGN(x) (((x) >> 7) & 0x1)
134 #define CALIB_BUF1_ID(x) (((x) >> 9) & 0x1)
135
136 enum {
137 VTS1,
138 VTS2,
139 VTS3,
140 VTS4,
141 VTS5,
142 VTSABB,
143 MAX_NUM_VTS,
144 };
145
146
147 #define MT2701_TS1 0
148 #define MT2701_TS2 1
149 #define MT2701_TSABB 2
150
151
152 #define MT2701_TEMP_AUXADC_CHANNEL 11
153
154
155 #define MT2701_NUM_SENSORS 3
156
157
158 #define MT2701_NUM_SENSORS_PER_ZONE 3
159
160
161 #define MT2701_NUM_CONTROLLER 1
162
163
164 #define MT2701_CALIBRATION 165
165
166
167 #define MT2712_TS1 0
168 #define MT2712_TS2 1
169 #define MT2712_TS3 2
170 #define MT2712_TS4 3
171
172
173 #define MT2712_TEMP_AUXADC_CHANNEL 11
174
175
176 #define MT2712_NUM_SENSORS 4
177
178
179 #define MT2712_NUM_SENSORS_PER_ZONE 4
180
181
182 #define MT2712_NUM_CONTROLLER 1
183
184
185 #define MT2712_CALIBRATION 165
186
187 #define MT7622_TEMP_AUXADC_CHANNEL 11
188 #define MT7622_NUM_SENSORS 1
189 #define MT7622_NUM_ZONES 1
190 #define MT7622_NUM_SENSORS_PER_ZONE 1
191 #define MT7622_TS1 0
192 #define MT7622_NUM_CONTROLLER 1
193
194
195 #define MAX_NUM_ZONES 8
196
197
198 #define MT7622_CALIBRATION 165
199
200
201 #define MT8183_TS1 0
202 #define MT8183_TS2 1
203 #define MT8183_TS3 2
204 #define MT8183_TS4 3
205 #define MT8183_TS5 4
206 #define MT8183_TSABB 5
207
208
209 #define MT8183_TEMP_AUXADC_CHANNEL 11
210
211
212 #define MT8183_NUM_SENSORS 6
213
214
215 #define MT8183_NUM_SENSORS_PER_ZONE 6
216
217
218 #define MT8183_NUM_CONTROLLER 2
219
220
221 #define MT8183_CALIBRATION 153
222
223 struct mtk_thermal;
224
225 struct thermal_bank_cfg {
226 unsigned int num_sensors;
227 const int *sensors;
228 };
229
230 struct mtk_thermal_bank {
231 struct mtk_thermal *mt;
232 int id;
233 };
234
235 struct mtk_thermal_data {
236 s32 num_banks;
237 s32 num_sensors;
238 s32 auxadc_channel;
239 const int *vts_index;
240 const int *sensor_mux_values;
241 const int *msr;
242 const int *adcpnp;
243 const int cali_val;
244 const int num_controller;
245 const int *controller_offset;
246 bool need_switch_bank;
247 struct thermal_bank_cfg bank_data[MAX_NUM_ZONES];
248 };
249
250 struct mtk_thermal {
251 struct device *dev;
252 void __iomem *thermal_base;
253
254 struct clk *clk_peri_therm;
255 struct clk *clk_auxadc;
256
257 struct mutex lock;
258
259
260 s32 adc_ge;
261 s32 degc_cali;
262 s32 o_slope;
263 s32 vts[MAX_NUM_VTS];
264
265 const struct mtk_thermal_data *conf;
266 struct mtk_thermal_bank banks[MAX_NUM_ZONES];
267 };
268
269
270 static const int mt8183_bank_data[MT8183_NUM_SENSORS] = {
271 MT8183_TS1, MT8183_TS2, MT8183_TS3, MT8183_TS4, MT8183_TS5, MT8183_TSABB
272 };
273
274 static const int mt8183_msr[MT8183_NUM_SENSORS_PER_ZONE] = {
275 TEMP_MSR0_1, TEMP_MSR1_1, TEMP_MSR2_1, TEMP_MSR1, TEMP_MSR0, TEMP_MSR3_1
276 };
277
278 static const int mt8183_adcpnp[MT8183_NUM_SENSORS_PER_ZONE] = {
279 TEMP_ADCPNP0_1, TEMP_ADCPNP1_1, TEMP_ADCPNP2_1,
280 TEMP_ADCPNP1, TEMP_ADCPNP0, TEMP_ADCPNP3_1
281 };
282
283 static const int mt8183_mux_values[MT8183_NUM_SENSORS] = { 0, 1, 2, 3, 4, 0 };
284 static const int mt8183_tc_offset[MT8183_NUM_CONTROLLER] = {0x0, 0x100};
285
286 static const int mt8183_vts_index[MT8183_NUM_SENSORS] = {
287 VTS1, VTS2, VTS3, VTS4, VTS5, VTSABB
288 };
289
290
291 static const int mt8173_bank_data[MT8173_NUM_ZONES][3] = {
292 { MT8173_TS2, MT8173_TS3 },
293 { MT8173_TS2, MT8173_TS4 },
294 { MT8173_TS1, MT8173_TS2, MT8173_TSABB },
295 { MT8173_TS2 },
296 };
297
298 static const int mt8173_msr[MT8173_NUM_SENSORS_PER_ZONE] = {
299 TEMP_MSR0, TEMP_MSR1, TEMP_MSR2, TEMP_MSR3
300 };
301
302 static const int mt8173_adcpnp[MT8173_NUM_SENSORS_PER_ZONE] = {
303 TEMP_ADCPNP0, TEMP_ADCPNP1, TEMP_ADCPNP2, TEMP_ADCPNP3
304 };
305
306 static const int mt8173_mux_values[MT8173_NUM_SENSORS] = { 0, 1, 2, 3, 16 };
307 static const int mt8173_tc_offset[MT8173_NUM_CONTROLLER] = { 0x0, };
308
309 static const int mt8173_vts_index[MT8173_NUM_SENSORS] = {
310 VTS1, VTS2, VTS3, VTS4, VTSABB
311 };
312
313
314 static const int mt2701_bank_data[MT2701_NUM_SENSORS] = {
315 MT2701_TS1, MT2701_TS2, MT2701_TSABB
316 };
317
318 static const int mt2701_msr[MT2701_NUM_SENSORS_PER_ZONE] = {
319 TEMP_MSR0, TEMP_MSR1, TEMP_MSR2
320 };
321
322 static const int mt2701_adcpnp[MT2701_NUM_SENSORS_PER_ZONE] = {
323 TEMP_ADCPNP0, TEMP_ADCPNP1, TEMP_ADCPNP2
324 };
325
326 static const int mt2701_mux_values[MT2701_NUM_SENSORS] = { 0, 1, 16 };
327 static const int mt2701_tc_offset[MT2701_NUM_CONTROLLER] = { 0x0, };
328
329 static const int mt2701_vts_index[MT2701_NUM_SENSORS] = {
330 VTS1, VTS2, VTS3
331 };
332
333
334 static const int mt2712_bank_data[MT2712_NUM_SENSORS] = {
335 MT2712_TS1, MT2712_TS2, MT2712_TS3, MT2712_TS4
336 };
337
338 static const int mt2712_msr[MT2712_NUM_SENSORS_PER_ZONE] = {
339 TEMP_MSR0, TEMP_MSR1, TEMP_MSR2, TEMP_MSR3
340 };
341
342 static const int mt2712_adcpnp[MT2712_NUM_SENSORS_PER_ZONE] = {
343 TEMP_ADCPNP0, TEMP_ADCPNP1, TEMP_ADCPNP2, TEMP_ADCPNP3
344 };
345
346 static const int mt2712_mux_values[MT2712_NUM_SENSORS] = { 0, 1, 2, 3 };
347 static const int mt2712_tc_offset[MT2712_NUM_CONTROLLER] = { 0x0, };
348
349 static const int mt2712_vts_index[MT2712_NUM_SENSORS] = {
350 VTS1, VTS2, VTS3, VTS4
351 };
352
353
354 static const int mt7622_bank_data[MT7622_NUM_SENSORS] = { MT7622_TS1, };
355 static const int mt7622_msr[MT7622_NUM_SENSORS_PER_ZONE] = { TEMP_MSR0, };
356 static const int mt7622_adcpnp[MT7622_NUM_SENSORS_PER_ZONE] = { TEMP_ADCPNP0, };
357 static const int mt7622_mux_values[MT7622_NUM_SENSORS] = { 0, };
358 static const int mt7622_vts_index[MT7622_NUM_SENSORS] = { VTS1 };
359 static const int mt7622_tc_offset[MT7622_NUM_CONTROLLER] = { 0x0, };
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374 static const struct mtk_thermal_data mt8173_thermal_data = {
375 .auxadc_channel = MT8173_TEMP_AUXADC_CHANNEL,
376 .num_banks = MT8173_NUM_ZONES,
377 .num_sensors = MT8173_NUM_SENSORS,
378 .vts_index = mt8173_vts_index,
379 .cali_val = MT8173_CALIBRATION,
380 .num_controller = MT8173_NUM_CONTROLLER,
381 .controller_offset = mt8173_tc_offset,
382 .need_switch_bank = true,
383 .bank_data = {
384 {
385 .num_sensors = 2,
386 .sensors = mt8173_bank_data[0],
387 }, {
388 .num_sensors = 2,
389 .sensors = mt8173_bank_data[1],
390 }, {
391 .num_sensors = 3,
392 .sensors = mt8173_bank_data[2],
393 }, {
394 .num_sensors = 1,
395 .sensors = mt8173_bank_data[3],
396 },
397 },
398 .msr = mt8173_msr,
399 .adcpnp = mt8173_adcpnp,
400 .sensor_mux_values = mt8173_mux_values,
401 };
402
403
404
405
406
407
408
409
410
411
412
413 static const struct mtk_thermal_data mt2701_thermal_data = {
414 .auxadc_channel = MT2701_TEMP_AUXADC_CHANNEL,
415 .num_banks = 1,
416 .num_sensors = MT2701_NUM_SENSORS,
417 .vts_index = mt2701_vts_index,
418 .cali_val = MT2701_CALIBRATION,
419 .num_controller = MT2701_NUM_CONTROLLER,
420 .controller_offset = mt2701_tc_offset,
421 .need_switch_bank = true,
422 .bank_data = {
423 {
424 .num_sensors = 3,
425 .sensors = mt2701_bank_data,
426 },
427 },
428 .msr = mt2701_msr,
429 .adcpnp = mt2701_adcpnp,
430 .sensor_mux_values = mt2701_mux_values,
431 };
432
433
434
435
436
437
438
439
440
441
442
443 static const struct mtk_thermal_data mt2712_thermal_data = {
444 .auxadc_channel = MT2712_TEMP_AUXADC_CHANNEL,
445 .num_banks = 1,
446 .num_sensors = MT2712_NUM_SENSORS,
447 .vts_index = mt2712_vts_index,
448 .cali_val = MT2712_CALIBRATION,
449 .num_controller = MT2712_NUM_CONTROLLER,
450 .controller_offset = mt2712_tc_offset,
451 .need_switch_bank = true,
452 .bank_data = {
453 {
454 .num_sensors = 4,
455 .sensors = mt2712_bank_data,
456 },
457 },
458 .msr = mt2712_msr,
459 .adcpnp = mt2712_adcpnp,
460 .sensor_mux_values = mt2712_mux_values,
461 };
462
463
464
465
466
467 static const struct mtk_thermal_data mt7622_thermal_data = {
468 .auxadc_channel = MT7622_TEMP_AUXADC_CHANNEL,
469 .num_banks = MT7622_NUM_ZONES,
470 .num_sensors = MT7622_NUM_SENSORS,
471 .vts_index = mt7622_vts_index,
472 .cali_val = MT7622_CALIBRATION,
473 .num_controller = MT7622_NUM_CONTROLLER,
474 .controller_offset = mt7622_tc_offset,
475 .need_switch_bank = true,
476 .bank_data = {
477 {
478 .num_sensors = 1,
479 .sensors = mt7622_bank_data,
480 },
481 },
482 .msr = mt7622_msr,
483 .adcpnp = mt7622_adcpnp,
484 .sensor_mux_values = mt7622_mux_values,
485 };
486
487
488
489
490
491
492
493
494
495
496
497
498
499 static const struct mtk_thermal_data mt8183_thermal_data = {
500 .auxadc_channel = MT8183_TEMP_AUXADC_CHANNEL,
501 .num_banks = MT8183_NUM_SENSORS_PER_ZONE,
502 .num_sensors = MT8183_NUM_SENSORS,
503 .vts_index = mt8183_vts_index,
504 .cali_val = MT8183_CALIBRATION,
505 .num_controller = MT8183_NUM_CONTROLLER,
506 .controller_offset = mt8183_tc_offset,
507 .need_switch_bank = false,
508 .bank_data = {
509 {
510 .num_sensors = 6,
511 .sensors = mt8183_bank_data,
512 },
513 },
514
515 .msr = mt8183_msr,
516 .adcpnp = mt8183_adcpnp,
517 .sensor_mux_values = mt8183_mux_values,
518 };
519
520
521
522
523
524
525
526
527
528 static int raw_to_mcelsius(struct mtk_thermal *mt, int sensno, s32 raw)
529 {
530 s32 tmp;
531
532 raw &= 0xfff;
533
534 tmp = 203450520 << 3;
535 tmp /= mt->conf->cali_val + mt->o_slope;
536 tmp /= 10000 + mt->adc_ge;
537 tmp *= raw - mt->vts[sensno] - 3350;
538 tmp >>= 3;
539
540 return mt->degc_cali * 500 - tmp;
541 }
542
543
544
545
546
547
548
549
550 static void mtk_thermal_get_bank(struct mtk_thermal_bank *bank)
551 {
552 struct mtk_thermal *mt = bank->mt;
553 u32 val;
554
555 if (mt->conf->need_switch_bank) {
556 mutex_lock(&mt->lock);
557
558 val = readl(mt->thermal_base + PTPCORESEL);
559 val &= ~0xf;
560 val |= bank->id;
561 writel(val, mt->thermal_base + PTPCORESEL);
562 }
563 }
564
565
566
567
568
569
570
571 static void mtk_thermal_put_bank(struct mtk_thermal_bank *bank)
572 {
573 struct mtk_thermal *mt = bank->mt;
574
575 if (mt->conf->need_switch_bank)
576 mutex_unlock(&mt->lock);
577 }
578
579
580
581
582
583
584
585
586 static int mtk_thermal_bank_temperature(struct mtk_thermal_bank *bank)
587 {
588 struct mtk_thermal *mt = bank->mt;
589 const struct mtk_thermal_data *conf = mt->conf;
590 int i, temp = INT_MIN, max = INT_MIN;
591 u32 raw;
592
593 for (i = 0; i < conf->bank_data[bank->id].num_sensors; i++) {
594 raw = readl(mt->thermal_base +
595 conf->msr[conf->bank_data[bank->id].sensors[i]]);
596
597 temp = raw_to_mcelsius(mt,
598 conf->bank_data[bank->id].sensors[i],
599 raw);
600
601
602
603
604
605
606 if (temp > 200000)
607 temp = 0;
608
609 if (temp > max)
610 max = temp;
611 }
612
613 return max;
614 }
615
616 static int mtk_read_temp(void *data, int *temperature)
617 {
618 struct mtk_thermal *mt = data;
619 int i;
620 int tempmax = INT_MIN;
621
622 for (i = 0; i < mt->conf->num_banks; i++) {
623 struct mtk_thermal_bank *bank = &mt->banks[i];
624
625 mtk_thermal_get_bank(bank);
626
627 tempmax = max(tempmax, mtk_thermal_bank_temperature(bank));
628
629 mtk_thermal_put_bank(bank);
630 }
631
632 *temperature = tempmax;
633
634 return 0;
635 }
636
637 static const struct thermal_zone_of_device_ops mtk_thermal_ops = {
638 .get_temp = mtk_read_temp,
639 };
640
641 static void mtk_thermal_init_bank(struct mtk_thermal *mt, int num,
642 u32 apmixed_phys_base, u32 auxadc_phys_base,
643 int ctrl_id)
644 {
645 struct mtk_thermal_bank *bank = &mt->banks[num];
646 const struct mtk_thermal_data *conf = mt->conf;
647 int i;
648
649 int offset = mt->conf->controller_offset[ctrl_id];
650 void __iomem *controller_base = mt->thermal_base + offset;
651
652 bank->id = num;
653 bank->mt = mt;
654
655 mtk_thermal_get_bank(bank);
656
657
658 writel(TEMP_MONCTL1_PERIOD_UNIT(12), controller_base + TEMP_MONCTL1);
659
660
661
662
663
664 writel(TEMP_MONCTL2_FILTER_INTERVAL(1) |
665 TEMP_MONCTL2_SENSOR_INTERVAL(429),
666 controller_base + TEMP_MONCTL2);
667
668
669 writel(TEMP_AHBPOLL_ADC_POLL_INTERVAL(768),
670 controller_base + TEMP_AHBPOLL);
671
672
673 writel(0x0, controller_base + TEMP_MSRCTL0);
674
675
676 writel(0xffffffff, controller_base + TEMP_AHBTO);
677
678
679 writel(0x0, controller_base + TEMP_MONIDET0);
680 writel(0x0, controller_base + TEMP_MONIDET1);
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695 writel(BIT(conf->auxadc_channel), controller_base + TEMP_ADCMUX);
696
697
698 writel(auxadc_phys_base + AUXADC_CON1_CLR_V,
699 controller_base + TEMP_ADCMUXADDR);
700
701
702 writel(apmixed_phys_base + APMIXED_SYS_TS_CON1,
703 controller_base + TEMP_PNPMUXADDR);
704
705
706 writel(BIT(conf->auxadc_channel), controller_base + TEMP_ADCEN);
707
708
709 writel(auxadc_phys_base + AUXADC_CON1_SET_V,
710 controller_base + TEMP_ADCENADDR);
711
712
713 writel(auxadc_phys_base + AUXADC_DATA(conf->auxadc_channel),
714 controller_base + TEMP_ADCVALIDADDR);
715
716
717 writel(auxadc_phys_base + AUXADC_DATA(conf->auxadc_channel),
718 controller_base + TEMP_ADCVOLTADDR);
719
720
721 writel(0x0, controller_base + TEMP_RDCTRL);
722
723
724 writel(TEMP_ADCVALIDMASK_VALID_HIGH | TEMP_ADCVALIDMASK_VALID_POS(12),
725 controller_base + TEMP_ADCVALIDMASK);
726
727
728 writel(0x0, controller_base + TEMP_ADCVOLTAGESHIFT);
729
730
731 writel(TEMP_ADCWRITECTRL_ADC_MUX_WRITE,
732 controller_base + TEMP_ADCWRITECTRL);
733
734 for (i = 0; i < conf->bank_data[num].num_sensors; i++)
735 writel(conf->sensor_mux_values[conf->bank_data[num].sensors[i]],
736 mt->thermal_base +
737 conf->adcpnp[conf->bank_data[num].sensors[i]]);
738
739 writel((1 << conf->bank_data[num].num_sensors) - 1,
740 controller_base + TEMP_MONCTL0);
741
742 writel(TEMP_ADCWRITECTRL_ADC_PNP_WRITE |
743 TEMP_ADCWRITECTRL_ADC_MUX_WRITE,
744 controller_base + TEMP_ADCWRITECTRL);
745
746 mtk_thermal_put_bank(bank);
747 }
748
749 static u64 of_get_phys_base(struct device_node *np)
750 {
751 u64 size64;
752 const __be32 *regaddr_p;
753
754 regaddr_p = of_get_address(np, 0, &size64, NULL);
755 if (!regaddr_p)
756 return OF_BAD_ADDR;
757
758 return of_translate_address(np, regaddr_p);
759 }
760
761 static int mtk_thermal_get_calibration_data(struct device *dev,
762 struct mtk_thermal *mt)
763 {
764 struct nvmem_cell *cell;
765 u32 *buf;
766 size_t len;
767 int i, ret = 0;
768
769
770 mt->adc_ge = 512;
771 for (i = 0; i < mt->conf->num_sensors; i++)
772 mt->vts[i] = 260;
773 mt->degc_cali = 40;
774 mt->o_slope = 0;
775
776 cell = nvmem_cell_get(dev, "calibration-data");
777 if (IS_ERR(cell)) {
778 if (PTR_ERR(cell) == -EPROBE_DEFER)
779 return PTR_ERR(cell);
780 return 0;
781 }
782
783 buf = (u32 *)nvmem_cell_read(cell, &len);
784
785 nvmem_cell_put(cell);
786
787 if (IS_ERR(buf))
788 return PTR_ERR(buf);
789
790 if (len < 3 * sizeof(u32)) {
791 dev_warn(dev, "invalid calibration data\n");
792 ret = -EINVAL;
793 goto out;
794 }
795
796 if (buf[0] & CALIB_BUF0_VALID) {
797 mt->adc_ge = CALIB_BUF1_ADC_GE(buf[1]);
798
799 for (i = 0; i < mt->conf->num_sensors; i++) {
800 switch (mt->conf->vts_index[i]) {
801 case VTS1:
802 mt->vts[VTS1] = CALIB_BUF0_VTS_TS1(buf[0]);
803 break;
804 case VTS2:
805 mt->vts[VTS2] = CALIB_BUF0_VTS_TS2(buf[0]);
806 break;
807 case VTS3:
808 mt->vts[VTS3] = CALIB_BUF1_VTS_TS3(buf[1]);
809 break;
810 case VTS4:
811 mt->vts[VTS4] = CALIB_BUF2_VTS_TS4(buf[2]);
812 break;
813 case VTS5:
814 mt->vts[VTS5] = CALIB_BUF2_VTS_TS5(buf[2]);
815 break;
816 case VTSABB:
817 mt->vts[VTSABB] = CALIB_BUF2_VTS_TSABB(buf[2]);
818 break;
819 default:
820 break;
821 }
822 }
823
824 mt->degc_cali = CALIB_BUF0_DEGC_CALI(buf[0]);
825 if (CALIB_BUF1_ID(buf[1]) &
826 CALIB_BUF0_O_SLOPE_SIGN(buf[0]))
827 mt->o_slope = -CALIB_BUF0_O_SLOPE(buf[0]);
828 else
829 mt->o_slope = CALIB_BUF0_O_SLOPE(buf[0]);
830 } else {
831 dev_info(dev, "Device not calibrated, using default calibration values\n");
832 }
833
834 out:
835 kfree(buf);
836
837 return ret;
838 }
839
840 static const struct of_device_id mtk_thermal_of_match[] = {
841 {
842 .compatible = "mediatek,mt8173-thermal",
843 .data = (void *)&mt8173_thermal_data,
844 },
845 {
846 .compatible = "mediatek,mt2701-thermal",
847 .data = (void *)&mt2701_thermal_data,
848 },
849 {
850 .compatible = "mediatek,mt2712-thermal",
851 .data = (void *)&mt2712_thermal_data,
852 },
853 {
854 .compatible = "mediatek,mt7622-thermal",
855 .data = (void *)&mt7622_thermal_data,
856 },
857 {
858 .compatible = "mediatek,mt8183-thermal",
859 .data = (void *)&mt8183_thermal_data,
860 }, {
861 },
862 };
863 MODULE_DEVICE_TABLE(of, mtk_thermal_of_match);
864
865 static int mtk_thermal_probe(struct platform_device *pdev)
866 {
867 int ret, i, ctrl_id;
868 struct device_node *auxadc, *apmixedsys, *np = pdev->dev.of_node;
869 struct mtk_thermal *mt;
870 struct resource *res;
871 u64 auxadc_phys_base, apmixed_phys_base;
872 struct thermal_zone_device *tzdev;
873
874 mt = devm_kzalloc(&pdev->dev, sizeof(*mt), GFP_KERNEL);
875 if (!mt)
876 return -ENOMEM;
877
878 mt->conf = of_device_get_match_data(&pdev->dev);
879
880 mt->clk_peri_therm = devm_clk_get(&pdev->dev, "therm");
881 if (IS_ERR(mt->clk_peri_therm))
882 return PTR_ERR(mt->clk_peri_therm);
883
884 mt->clk_auxadc = devm_clk_get(&pdev->dev, "auxadc");
885 if (IS_ERR(mt->clk_auxadc))
886 return PTR_ERR(mt->clk_auxadc);
887
888 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
889 mt->thermal_base = devm_ioremap_resource(&pdev->dev, res);
890 if (IS_ERR(mt->thermal_base))
891 return PTR_ERR(mt->thermal_base);
892
893 ret = mtk_thermal_get_calibration_data(&pdev->dev, mt);
894 if (ret)
895 return ret;
896
897 mutex_init(&mt->lock);
898
899 mt->dev = &pdev->dev;
900
901 auxadc = of_parse_phandle(np, "mediatek,auxadc", 0);
902 if (!auxadc) {
903 dev_err(&pdev->dev, "missing auxadc node\n");
904 return -ENODEV;
905 }
906
907 auxadc_phys_base = of_get_phys_base(auxadc);
908
909 of_node_put(auxadc);
910
911 if (auxadc_phys_base == OF_BAD_ADDR) {
912 dev_err(&pdev->dev, "Can't get auxadc phys address\n");
913 return -EINVAL;
914 }
915
916 apmixedsys = of_parse_phandle(np, "mediatek,apmixedsys", 0);
917 if (!apmixedsys) {
918 dev_err(&pdev->dev, "missing apmixedsys node\n");
919 return -ENODEV;
920 }
921
922 apmixed_phys_base = of_get_phys_base(apmixedsys);
923
924 of_node_put(apmixedsys);
925
926 if (apmixed_phys_base == OF_BAD_ADDR) {
927 dev_err(&pdev->dev, "Can't get auxadc phys address\n");
928 return -EINVAL;
929 }
930
931 ret = device_reset(&pdev->dev);
932 if (ret)
933 return ret;
934
935 ret = clk_prepare_enable(mt->clk_auxadc);
936 if (ret) {
937 dev_err(&pdev->dev, "Can't enable auxadc clk: %d\n", ret);
938 return ret;
939 }
940
941 ret = clk_prepare_enable(mt->clk_peri_therm);
942 if (ret) {
943 dev_err(&pdev->dev, "Can't enable peri clk: %d\n", ret);
944 goto err_disable_clk_auxadc;
945 }
946
947 for (ctrl_id = 0; ctrl_id < mt->conf->num_controller ; ctrl_id++)
948 for (i = 0; i < mt->conf->num_banks; i++)
949 mtk_thermal_init_bank(mt, i, apmixed_phys_base,
950 auxadc_phys_base, ctrl_id);
951
952 platform_set_drvdata(pdev, mt);
953
954 tzdev = devm_thermal_zone_of_sensor_register(&pdev->dev, 0, mt,
955 &mtk_thermal_ops);
956 if (IS_ERR(tzdev)) {
957 ret = PTR_ERR(tzdev);
958 goto err_disable_clk_peri_therm;
959 }
960
961 return 0;
962
963 err_disable_clk_peri_therm:
964 clk_disable_unprepare(mt->clk_peri_therm);
965 err_disable_clk_auxadc:
966 clk_disable_unprepare(mt->clk_auxadc);
967
968 return ret;
969 }
970
971 static int mtk_thermal_remove(struct platform_device *pdev)
972 {
973 struct mtk_thermal *mt = platform_get_drvdata(pdev);
974
975 clk_disable_unprepare(mt->clk_peri_therm);
976 clk_disable_unprepare(mt->clk_auxadc);
977
978 return 0;
979 }
980
981 static struct platform_driver mtk_thermal_driver = {
982 .probe = mtk_thermal_probe,
983 .remove = mtk_thermal_remove,
984 .driver = {
985 .name = "mtk-thermal",
986 .of_match_table = mtk_thermal_of_match,
987 },
988 };
989
990 module_platform_driver(mtk_thermal_driver);
991
992 MODULE_AUTHOR("Michael Kao <michael.kao@mediatek.com>");
993 MODULE_AUTHOR("Louis Yu <louis.yu@mediatek.com>");
994 MODULE_AUTHOR("Dawei Chien <dawei.chien@mediatek.com>");
995 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
996 MODULE_AUTHOR("Hanyi Wu <hanyi.wu@mediatek.com>");
997 MODULE_DESCRIPTION("Mediatek thermal driver");
998 MODULE_LICENSE("GPL v2");