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 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 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 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 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 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 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 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 */ 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 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 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 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 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 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 = kcalloc(TABLE_SIZE, sizeof(*ref_table), GFP_KERNEL); 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 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 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 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