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