1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * TI Bandgap temperature sensor driver for J72XX SoC Family
4 *
5 * Copyright (C) 2021 Texas Instruments Incorporated - http://www.ti.com/
6 */
7
8 #include <linux/math.h>
9 #include <linux/math64.h>
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/platform_device.h>
14 #include <linux/pm_runtime.h>
15 #include <linux/err.h>
16 #include <linux/types.h>
17 #include <linux/io.h>
18 #include <linux/thermal.h>
19 #include <linux/of.h>
20 #include <linux/delay.h>
21 #include <linux/slab.h>
22
23 #include "thermal_hwmon.h"
24
25 #define K3_VTM_DEVINFO_PWR0_OFFSET 0x4
26 #define K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK 0xf0
27 #define K3_VTM_TMPSENS0_CTRL_OFFSET 0x300
28 #define K3_VTM_MISC_CTRL_OFFSET 0xc
29 #define K3_VTM_TMPSENS_STAT_OFFSET 0x8
30 #define K3_VTM_ANYMAXT_OUTRG_ALERT_EN 0x1
31 #define K3_VTM_MISC_CTRL2_OFFSET 0x10
32 #define K3_VTM_TS_STAT_DTEMP_MASK 0x3ff
33 #define K3_VTM_MAX_NUM_TS 8
34 #define K3_VTM_TMPSENS_CTRL_SOC BIT(5)
35 #define K3_VTM_TMPSENS_CTRL_CLRZ BIT(6)
36 #define K3_VTM_TMPSENS_CTRL_CLKON_REQ BIT(7)
37 #define K3_VTM_TMPSENS_CTRL_MAXT_OUTRG_EN BIT(11)
38
39 #define K3_VTM_CORRECTION_TEMP_CNT 3
40
41 #define MINUS40CREF 5
42 #define PLUS30CREF 253
43 #define PLUS125CREF 730
44 #define PLUS150CREF 940
45
46 #define TABLE_SIZE 1024
47 #define MAX_TEMP 123000
48 #define COOL_DOWN_TEMP 105000
49
50 #define FACTORS_REDUCTION 13
51 static int *derived_table;
52
compute_value(int index,const s64 * factors,int nr_factors,int reduction)53 static int compute_value(int index, const s64 *factors, int nr_factors,
54 int reduction)
55 {
56 s64 value = 0;
57 int i;
58
59 for (i = 0; i < nr_factors; i++)
60 value += factors[i] * int_pow(index, i);
61
62 return (int)div64_s64(value, int_pow(10, reduction));
63 }
64
init_table(int factors_size,int * table,const s64 * factors)65 static void init_table(int factors_size, int *table, const s64 *factors)
66 {
67 int i;
68
69 for (i = 0; i < TABLE_SIZE; i++)
70 table[i] = compute_value(i, factors, factors_size,
71 FACTORS_REDUCTION);
72 }
73
74 /**
75 * struct err_values - structure containing error/reference values
76 * @refs: reference error values for -40C, 30C, 125C & 150C
77 * @errs: Actual error values for -40C, 30C, 125C & 150C read from the efuse
78 */
79 struct err_values {
80 int refs[4];
81 int errs[4];
82 };
83
create_table_segments(struct err_values * err_vals,int seg,int * ref_table)84 static void create_table_segments(struct err_values *err_vals, int seg,
85 int *ref_table)
86 {
87 int m = 0, c, num, den, i, err, idx1, idx2, err1, err2, ref1, ref2;
88
89 if (seg == 0)
90 idx1 = 0;
91 else
92 idx1 = err_vals->refs[seg];
93
94 idx2 = err_vals->refs[seg + 1];
95 err1 = err_vals->errs[seg];
96 err2 = err_vals->errs[seg + 1];
97 ref1 = err_vals->refs[seg];
98 ref2 = err_vals->refs[seg + 1];
99
100 /*
101 * Calculate the slope with adc values read from the register
102 * as the y-axis param and err in adc value as x-axis param
103 */
104 num = ref2 - ref1;
105 den = err2 - err1;
106 if (den)
107 m = num / den;
108 c = ref2 - m * err2;
109
110 /*
111 * Take care of divide by zero error if error values are same
112 * Or when the slope is 0
113 */
114 if (den != 0 && m != 0) {
115 for (i = idx1; i <= idx2; i++) {
116 err = (i - c) / m;
117 if (((i + err) < 0) || ((i + err) >= TABLE_SIZE))
118 continue;
119 derived_table[i] = ref_table[i + err];
120 }
121 } else { /* Constant error take care of divide by zero */
122 for (i = idx1; i <= idx2; i++) {
123 if (((i + err1) < 0) || ((i + err1) >= TABLE_SIZE))
124 continue;
125 derived_table[i] = ref_table[i + err1];
126 }
127 }
128 }
129
prep_lookup_table(struct err_values * err_vals,int * ref_table)130 static int prep_lookup_table(struct err_values *err_vals, int *ref_table)
131 {
132 int inc, i, seg;
133
134 /*
135 * Fill up the lookup table under 3 segments
136 * region -40C to +30C
137 * region +30C to +125C
138 * region +125C to +150C
139 */
140 for (seg = 0; seg < 3; seg++)
141 create_table_segments(err_vals, seg, ref_table);
142
143 /* Get to the first valid temperature */
144 i = 0;
145 while (!derived_table[i])
146 i++;
147
148 /*
149 * Get to the last zero index and back fill the temperature for
150 * sake of continuity
151 */
152 if (i) {
153 /* 300 milli celsius steps */
154 while (i--)
155 derived_table[i] = derived_table[i + 1] - 300;
156 }
157
158 /*
159 * Fill the last trailing 0s which are unfilled with increments of
160 * 100 milli celsius till 1023 code
161 */
162 i = TABLE_SIZE - 1;
163 while (!derived_table[i])
164 i--;
165
166 i++;
167 inc = 1;
168 while (i < TABLE_SIZE) {
169 derived_table[i] = derived_table[i - 1] + inc * 100;
170 i++;
171 }
172
173 return 0;
174 }
175
176 struct k3_thermal_data;
177
178 struct k3_j72xx_bandgap {
179 struct device *dev;
180 void __iomem *base;
181 void __iomem *cfg2_base;
182 struct k3_thermal_data *ts_data[K3_VTM_MAX_NUM_TS];
183 int cnt;
184 };
185
186 /* common data structures */
187 struct k3_thermal_data {
188 struct k3_j72xx_bandgap *bgp;
189 u32 ctrl_offset;
190 u32 stat_offset;
191 };
192
two_cmp(int tmp,int mask)193 static int two_cmp(int tmp, int mask)
194 {
195 tmp = ~(tmp);
196 tmp &= mask;
197 tmp += 1;
198
199 /* Return negative value */
200 return (0 - tmp);
201 }
202
vtm_get_best_value(unsigned int s0,unsigned int s1,unsigned int s2)203 static unsigned int vtm_get_best_value(unsigned int s0, unsigned int s1,
204 unsigned int s2)
205 {
206 int d01 = abs(s0 - s1);
207 int d02 = abs(s0 - s2);
208 int d12 = abs(s1 - s2);
209
210 if (d01 <= d02 && d01 <= d12)
211 return (s0 + s1) / 2;
212
213 if (d02 <= d01 && d02 <= d12)
214 return (s0 + s2) / 2;
215
216 return (s1 + s2) / 2;
217 }
218
k3_bgp_read_temp(struct k3_thermal_data * devdata,int * temp)219 static inline int k3_bgp_read_temp(struct k3_thermal_data *devdata,
220 int *temp)
221 {
222 struct k3_j72xx_bandgap *bgp;
223 unsigned int dtemp, s0, s1, s2;
224
225 bgp = devdata->bgp;
226 /*
227 * Errata is applicable for am654 pg 1.0 silicon/J7ES. There
228 * is a variation of the order for certain degree centigrade on AM654.
229 * Work around that by getting the average of two closest
230 * readings out of three readings everytime we want to
231 * report temperatures.
232 *
233 * Errata workaround.
234 */
235 s0 = readl(bgp->base + devdata->stat_offset) &
236 K3_VTM_TS_STAT_DTEMP_MASK;
237 s1 = readl(bgp->base + devdata->stat_offset) &
238 K3_VTM_TS_STAT_DTEMP_MASK;
239 s2 = readl(bgp->base + devdata->stat_offset) &
240 K3_VTM_TS_STAT_DTEMP_MASK;
241 dtemp = vtm_get_best_value(s0, s1, s2);
242
243 if (dtemp >= TABLE_SIZE)
244 return -EINVAL;
245
246 *temp = derived_table[dtemp];
247
248 return 0;
249 }
250
251 /* Get temperature callback function for thermal zone */
k3_thermal_get_temp(struct thermal_zone_device * tz,int * temp)252 static int k3_thermal_get_temp(struct thermal_zone_device *tz, int *temp)
253 {
254 return k3_bgp_read_temp(thermal_zone_device_priv(tz), temp);
255 }
256
257 static const struct thermal_zone_device_ops k3_of_thermal_ops = {
258 .get_temp = k3_thermal_get_temp,
259 };
260
k3_j72xx_bandgap_temp_to_adc_code(int temp)261 static int k3_j72xx_bandgap_temp_to_adc_code(int temp)
262 {
263 int low = 0, high = TABLE_SIZE - 1, mid;
264
265 if (temp > 160000 || temp < -50000)
266 return -EINVAL;
267
268 /* Binary search to find the adc code */
269 while (low < (high - 1)) {
270 mid = (low + high) / 2;
271 if (temp <= derived_table[mid])
272 high = mid;
273 else
274 low = mid;
275 }
276
277 return mid;
278 }
279
get_efuse_values(int id,struct k3_thermal_data * data,int * err,void __iomem * fuse_base)280 static void get_efuse_values(int id, struct k3_thermal_data *data, int *err,
281 void __iomem *fuse_base)
282 {
283 int i, tmp, pow;
284 int ct_offsets[5][K3_VTM_CORRECTION_TEMP_CNT] = {
285 { 0x0, 0x8, 0x4 },
286 { 0x0, 0x8, 0x4 },
287 { 0x0, -1, 0x4 },
288 { 0x0, 0xC, -1 },
289 { 0x0, 0xc, 0x8 }
290 };
291 int ct_bm[5][K3_VTM_CORRECTION_TEMP_CNT] = {
292 { 0x3f, 0x1fe000, 0x1ff },
293 { 0xfc0, 0x1fe000, 0x3fe00 },
294 { 0x3f000, 0x7f800000, 0x7fc0000 },
295 { 0xfc0000, 0x1fe0, 0x1f800000 },
296 { 0x3f000000, 0x1fe000, 0x1ff0 }
297 };
298
299 for (i = 0; i < 3; i++) {
300 /* Extract the offset value using bit-mask */
301 if (ct_offsets[id][i] == -1 && i == 1) {
302 /* 25C offset Case of Sensor 2 split between 2 regs */
303 tmp = (readl(fuse_base + 0x8) & 0xE0000000) >> (29);
304 tmp |= ((readl(fuse_base + 0xC) & 0x1F) << 3);
305 pow = tmp & 0x80;
306 } else if (ct_offsets[id][i] == -1 && i == 2) {
307 /* 125C Case of Sensor 3 split between 2 regs */
308 tmp = (readl(fuse_base + 0x4) & 0xF8000000) >> (27);
309 tmp |= ((readl(fuse_base + 0x8) & 0xF) << 5);
310 pow = tmp & 0x100;
311 } else {
312 tmp = readl(fuse_base + ct_offsets[id][i]);
313 tmp &= ct_bm[id][i];
314 tmp = tmp >> __ffs(ct_bm[id][i]);
315
316 /* Obtain the sign bit pow*/
317 pow = ct_bm[id][i] >> __ffs(ct_bm[id][i]);
318 pow += 1;
319 pow /= 2;
320 }
321
322 /* Check for negative value */
323 if (tmp & pow) {
324 /* 2's complement value */
325 tmp = two_cmp(tmp, ct_bm[id][i] >> __ffs(ct_bm[id][i]));
326 }
327 err[i] = tmp;
328 }
329
330 /* Err value for 150C is set to 0 */
331 err[i] = 0;
332 }
333
print_look_up_table(struct device * dev,int * ref_table)334 static void print_look_up_table(struct device *dev, int *ref_table)
335 {
336 int i;
337
338 dev_dbg(dev, "The contents of derived array\n");
339 dev_dbg(dev, "Code Temperature\n");
340 for (i = 0; i < TABLE_SIZE; i++)
341 dev_dbg(dev, "%d %d %d\n", i, derived_table[i], ref_table[i]);
342 }
343
k3_j72xx_bandgap_init_hw(struct k3_j72xx_bandgap * bgp)344 static void k3_j72xx_bandgap_init_hw(struct k3_j72xx_bandgap *bgp)
345 {
346 struct k3_thermal_data *data;
347 int id, high_max, low_temp;
348 u32 val;
349
350 for (id = 0; id < bgp->cnt; id++) {
351 data = bgp->ts_data[id];
352 val = readl(bgp->cfg2_base + data->ctrl_offset);
353 val |= (K3_VTM_TMPSENS_CTRL_MAXT_OUTRG_EN |
354 K3_VTM_TMPSENS_CTRL_SOC |
355 K3_VTM_TMPSENS_CTRL_CLRZ | BIT(4));
356 writel(val, bgp->cfg2_base + data->ctrl_offset);
357 }
358
359 /*
360 * Program TSHUT thresholds
361 * Step 1: set the thresholds to ~123C and 105C WKUP_VTM_MISC_CTRL2
362 * Step 2: WKUP_VTM_TMPSENS_CTRL_j set the MAXT_OUTRG_EN bit
363 * This is already taken care as per of init
364 * Step 3: WKUP_VTM_MISC_CTRL set the ANYMAXT_OUTRG_ALERT_EN bit
365 */
366 high_max = k3_j72xx_bandgap_temp_to_adc_code(MAX_TEMP);
367 low_temp = k3_j72xx_bandgap_temp_to_adc_code(COOL_DOWN_TEMP);
368
369 writel((low_temp << 16) | high_max, bgp->cfg2_base + K3_VTM_MISC_CTRL2_OFFSET);
370 writel(K3_VTM_ANYMAXT_OUTRG_ALERT_EN, bgp->cfg2_base + K3_VTM_MISC_CTRL_OFFSET);
371 }
372
373 struct k3_j72xx_bandgap_data {
374 const bool has_errata_i2128;
375 };
376
k3_j72xx_bandgap_probe(struct platform_device * pdev)377 static int k3_j72xx_bandgap_probe(struct platform_device *pdev)
378 {
379 const struct k3_j72xx_bandgap_data *driver_data;
380 struct thermal_zone_device *ti_thermal;
381 struct device *dev = &pdev->dev;
382 bool workaround_needed = false;
383 struct k3_j72xx_bandgap *bgp;
384 struct k3_thermal_data *data;
385 struct err_values err_vals;
386 void __iomem *fuse_base;
387 int ret = 0, val, id;
388 struct resource *res;
389 int *ref_table;
390
391 const s64 golden_factors[] = {
392 -490019999999999936,
393 3251200000000000,
394 -1705800000000,
395 603730000,
396 -92627,
397 };
398
399 const s64 pvt_wa_factors[] = {
400 -415230000000000000,
401 3126600000000000,
402 -1157800000000,
403 };
404
405 bgp = devm_kzalloc(&pdev->dev, sizeof(*bgp), GFP_KERNEL);
406 if (!bgp)
407 return -ENOMEM;
408
409 bgp->dev = dev;
410 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
411 bgp->base = devm_ioremap_resource(dev, res);
412 if (IS_ERR(bgp->base))
413 return PTR_ERR(bgp->base);
414
415 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
416 bgp->cfg2_base = devm_ioremap_resource(dev, res);
417 if (IS_ERR(bgp->cfg2_base))
418 return PTR_ERR(bgp->cfg2_base);
419
420 driver_data = of_device_get_match_data(dev);
421 if (driver_data)
422 workaround_needed = driver_data->has_errata_i2128;
423
424 /*
425 * Some of TI's J721E SoCs require a software trimming procedure
426 * for the temperature monitors to function properly. To determine
427 * if this particular SoC is NOT affected, both bits in the
428 * WKUP_SPARE_FUSE0[31:30] will be set (0xC0000000) indicating
429 * when software trimming should NOT be applied.
430 *
431 * https://www.ti.com/lit/er/sprz455c/sprz455c.pdf
432 */
433 if (workaround_needed) {
434 res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
435 fuse_base = devm_ioremap_resource(dev, res);
436 if (IS_ERR(fuse_base))
437 return PTR_ERR(fuse_base);
438
439 if ((readl(fuse_base) & 0xc0000000) == 0xc0000000)
440 workaround_needed = false;
441 }
442
443 dev_dbg(bgp->dev, "Work around %sneeded\n",
444 workaround_needed ? "" : "not ");
445
446 pm_runtime_enable(dev);
447 ret = pm_runtime_get_sync(dev);
448 if (ret < 0) {
449 pm_runtime_put_noidle(dev);
450 pm_runtime_disable(dev);
451 return ret;
452 }
453
454 /* Get the sensor count in the VTM */
455 val = readl(bgp->base + K3_VTM_DEVINFO_PWR0_OFFSET);
456 bgp->cnt = val & K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK;
457 bgp->cnt >>= __ffs(K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK);
458
459 data = devm_kcalloc(bgp->dev, bgp->cnt, sizeof(*data), GFP_KERNEL);
460 if (!data) {
461 ret = -ENOMEM;
462 goto err_alloc;
463 }
464
465 ref_table = kzalloc_objs(*ref_table, TABLE_SIZE);
466 if (!ref_table) {
467 ret = -ENOMEM;
468 goto err_alloc;
469 }
470
471 derived_table = devm_kcalloc(bgp->dev, TABLE_SIZE, sizeof(*derived_table),
472 GFP_KERNEL);
473 if (!derived_table) {
474 ret = -ENOMEM;
475 goto err_free_ref_table;
476 }
477
478 if (!workaround_needed)
479 init_table(5, ref_table, golden_factors);
480 else
481 init_table(3, ref_table, pvt_wa_factors);
482
483 /* Precompute the derived table & fill each thermal sensor struct */
484 for (id = 0; id < bgp->cnt; id++) {
485 data[id].bgp = bgp;
486 data[id].ctrl_offset = K3_VTM_TMPSENS0_CTRL_OFFSET + id * 0x20;
487 data[id].stat_offset = data[id].ctrl_offset +
488 K3_VTM_TMPSENS_STAT_OFFSET;
489
490 if (workaround_needed) {
491 /* ref adc values for -40C, 30C & 125C respectively */
492 err_vals.refs[0] = MINUS40CREF;
493 err_vals.refs[1] = PLUS30CREF;
494 err_vals.refs[2] = PLUS125CREF;
495 err_vals.refs[3] = PLUS150CREF;
496 get_efuse_values(id, &data[id], err_vals.errs, fuse_base);
497 }
498
499 if (id == 0 && workaround_needed)
500 prep_lookup_table(&err_vals, ref_table);
501 else if (id == 0 && !workaround_needed)
502 memcpy(derived_table, ref_table, TABLE_SIZE * 4);
503
504 bgp->ts_data[id] = &data[id];
505 }
506
507 k3_j72xx_bandgap_init_hw(bgp);
508
509 /* Register the thermal sensors */
510 for (id = 0; id < bgp->cnt; id++) {
511 ti_thermal = devm_thermal_of_zone_register(bgp->dev, id, &data[id],
512 &k3_of_thermal_ops);
513 if (IS_ERR(ti_thermal)) {
514 dev_err(bgp->dev, "thermal zone device is NULL\n");
515 ret = PTR_ERR(ti_thermal);
516 goto err_free_ref_table;
517 }
518
519 devm_thermal_add_hwmon_sysfs(bgp->dev, ti_thermal);
520 }
521
522 platform_set_drvdata(pdev, bgp);
523
524 print_look_up_table(dev, ref_table);
525 /*
526 * Now that the derived_table has the appropriate look up values
527 * Free up the ref_table
528 */
529 kfree(ref_table);
530
531 return 0;
532
533 err_free_ref_table:
534 kfree(ref_table);
535
536 err_alloc:
537 pm_runtime_put_sync(&pdev->dev);
538 pm_runtime_disable(&pdev->dev);
539
540 return ret;
541 }
542
k3_j72xx_bandgap_remove(struct platform_device * pdev)543 static void k3_j72xx_bandgap_remove(struct platform_device *pdev)
544 {
545 pm_runtime_put_sync(&pdev->dev);
546 pm_runtime_disable(&pdev->dev);
547 }
548
k3_j72xx_bandgap_suspend(struct device * dev)549 static int k3_j72xx_bandgap_suspend(struct device *dev)
550 {
551 pm_runtime_put_sync(dev);
552 pm_runtime_disable(dev);
553 return 0;
554 }
555
k3_j72xx_bandgap_resume(struct device * dev)556 static int k3_j72xx_bandgap_resume(struct device *dev)
557 {
558 struct k3_j72xx_bandgap *bgp = dev_get_drvdata(dev);
559 int ret;
560
561 pm_runtime_enable(dev);
562 ret = pm_runtime_get_sync(dev);
563 if (ret < 0) {
564 pm_runtime_put_noidle(dev);
565 pm_runtime_disable(dev);
566 return ret;
567 }
568
569 k3_j72xx_bandgap_init_hw(bgp);
570
571 return 0;
572 }
573
574 static DEFINE_SIMPLE_DEV_PM_OPS(k3_j72xx_bandgap_pm_ops,
575 k3_j72xx_bandgap_suspend,
576 k3_j72xx_bandgap_resume);
577
578 static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j721e_data = {
579 .has_errata_i2128 = true,
580 };
581
582 static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j7200_data = {
583 .has_errata_i2128 = false,
584 };
585
586 static const struct of_device_id of_k3_j72xx_bandgap_match[] = {
587 {
588 .compatible = "ti,j721e-vtm",
589 .data = &k3_j72xx_bandgap_j721e_data,
590 },
591 {
592 .compatible = "ti,j7200-vtm",
593 .data = &k3_j72xx_bandgap_j7200_data,
594 },
595 { /* sentinel */ },
596 };
597 MODULE_DEVICE_TABLE(of, of_k3_j72xx_bandgap_match);
598
599 static struct platform_driver k3_j72xx_bandgap_sensor_driver = {
600 .probe = k3_j72xx_bandgap_probe,
601 .remove = k3_j72xx_bandgap_remove,
602 .driver = {
603 .name = "k3-j72xx-soc-thermal",
604 .of_match_table = of_k3_j72xx_bandgap_match,
605 .pm = pm_sleep_ptr(&k3_j72xx_bandgap_pm_ops),
606 },
607 };
608
609 module_platform_driver(k3_j72xx_bandgap_sensor_driver);
610
611 MODULE_DESCRIPTION("K3 bandgap temperature sensor driver");
612 MODULE_LICENSE("GPL");
613 MODULE_AUTHOR("J Keerthy <j-keerthy@ti.com>");
614