610 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * TI Bandgap temperature sensor driver for J72XX SoC Family4 *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 0x424#define K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK 0xf025#define K3_VTM_TMPSENS0_CTRL_OFFSET 0x30026#define K3_VTM_MISC_CTRL_OFFSET 0xc27#define K3_VTM_TMPSENS_STAT_OFFSET 0x828#define K3_VTM_ANYMAXT_OUTRG_ALERT_EN 0x129#define K3_VTM_MISC_CTRL2_OFFSET 0x1030#define K3_VTM_TS_STAT_DTEMP_MASK 0x3ff31#define K3_VTM_MAX_NUM_TS 832#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 338 39#define MINUS40CREF 540#define PLUS30CREF 25341#define PLUS125CREF 73042#define PLUS150CREF 94043 44#define TABLE_SIZE 102445#define MAX_TEMP 12300046#define COOL_DOWN_TEMP 10500047 48#define FACTORS_REDUCTION 1349static int *derived_table;50 51static 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 63static 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 values74 * @refs: reference error values for -40C, 30C, 125C & 150C75 * @errs: Actual error values for -40C, 30C, 125C & 150C read from the efuse76 */77struct err_values {78 int refs[4];79 int errs[4];80};81 82static 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 else90 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 register100 * as the y-axis param and err in adc value as x-axis param101 */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 same110 * Or when the slope is 0111 */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 128static 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 segments134 * region -40C to +30C135 * region +30C to +125C136 * region +125C to +150C137 */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 for148 * sake of continuity149 */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 of158 * 100 milli celsius till 1023 code159 */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 174struct k3_thermal_data;175 176struct 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 */185struct k3_thermal_data {186 struct k3_j72xx_bandgap *bgp;187 u32 ctrl_offset;188 u32 stat_offset;189};190 191static 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 201static 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 217static 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. There226 * is a variation of the order for certain degree centigrade on AM654.227 * Work around that by getting the average of two closest228 * readings out of three readings everytime we want to229 * 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 */250static 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 255static const struct thermal_zone_device_ops k3_of_thermal_ops = {256 .get_temp = k3_thermal_get_temp,257};258 259static 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 else272 low = mid;273 }274 275 return mid;276}277 278static 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 332static 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 342static 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 thresholds359 * Step 1: set the thresholds to ~123C and 105C WKUP_VTM_MISC_CTRL2360 * Step 2: WKUP_VTM_TMPSENS_CTRL_j set the MAXT_OUTRG_EN bit361 * This is already taken care as per of init362 * Step 3: WKUP_VTM_MISC_CTRL set the ANYMAXT_OUTRG_ALERT_EN bit363 */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 371struct k3_j72xx_bandgap_data {372 const bool has_errata_i2128;373};374 375static 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 procedure424 * for the temperature monitors to function properly. To determine425 * if this particular SoC is NOT affected, both bits in the426 * WKUP_SPARE_FUSE0[31:30] will be set (0xC0000000) indicating427 * when software trimming should NOT be applied.428 *429 * https://www.ti.com/lit/er/sprz455c/sprz455c.pdf430 */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 else479 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 values523 * Free up the ref_table524 */525 kfree(ref_table);526 527 return 0;528 529err_free_ref_table:530 kfree(ref_table);531 532err_alloc:533 pm_runtime_put_sync(&pdev->dev);534 pm_runtime_disable(&pdev->dev);535 536 return ret;537}538 539static 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 545static 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 552static 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 570static DEFINE_SIMPLE_DEV_PM_OPS(k3_j72xx_bandgap_pm_ops,571 k3_j72xx_bandgap_suspend,572 k3_j72xx_bandgap_resume);573 574static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j721e_data = {575 .has_errata_i2128 = true,576};577 578static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j7200_data = {579 .has_errata_i2128 = false,580};581 582static 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};593MODULE_DEVICE_TABLE(of, of_k3_j72xx_bandgap_match);594 595static 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 605module_platform_driver(k3_j72xx_bandgap_sensor_driver);606 607MODULE_DESCRIPTION("K3 bandgap temperature sensor driver");608MODULE_LICENSE("GPL");609MODULE_AUTHOR("J Keerthy <j-keerthy@ti.com>");610