Blame view
drivers/thermal/tegra/soctherm.c
42.1 KB
65b6d57c2 thermal: tegra: s... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
/* * Copyright (c) 2014, NVIDIA CORPORATION. All rights reserved. * * Author: * Mikko Perttunen <mperttunen@nvidia.com> * * This software is licensed under the terms of the GNU General Public * License version 2, as published by the Free Software Foundation, and * may be copied, distributed, and modified under those terms. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * */ |
d753b22d8 thermal: tegra: a... |
17 |
#include <linux/debugfs.h> |
65b6d57c2 thermal: tegra: s... |
18 19 20 21 22 23 24 25 26 27 28 29 30 |
#include <linux/bitops.h> #include <linux/clk.h> #include <linux/delay.h> #include <linux/err.h> #include <linux/interrupt.h> #include <linux/io.h> #include <linux/module.h> #include <linux/of.h> #include <linux/platform_device.h> #include <linux/reset.h> #include <linux/thermal.h> #include <dt-bindings/thermal/tegra124-soctherm.h> |
ce0dbf04f thermal: tegra: a... |
31 |
#include "../thermal_core.h" |
65b6d57c2 thermal: tegra: s... |
32 33 34 35 |
#include "soctherm.h" #define SENSOR_CONFIG0 0 #define SENSOR_CONFIG0_STOP BIT(0) |
65b6d57c2 thermal: tegra: s... |
36 |
#define SENSOR_CONFIG0_CPTR_OVER BIT(2) |
d753b22d8 thermal: tegra: a... |
37 38 39 40 |
#define SENSOR_CONFIG0_OVER BIT(3) #define SENSOR_CONFIG0_TCALC_OVER BIT(4) #define SENSOR_CONFIG0_TALL_MASK (0xfffff << 8) #define SENSOR_CONFIG0_TALL_SHIFT 8 |
65b6d57c2 thermal: tegra: s... |
41 42 |
#define SENSOR_CONFIG1 4 |
d753b22d8 thermal: tegra: a... |
43 |
#define SENSOR_CONFIG1_TSAMPLE_MASK 0x3ff |
65b6d57c2 thermal: tegra: s... |
44 |
#define SENSOR_CONFIG1_TSAMPLE_SHIFT 0 |
d753b22d8 thermal: tegra: a... |
45 |
#define SENSOR_CONFIG1_TIDDQ_EN_MASK (0x3f << 15) |
65b6d57c2 thermal: tegra: s... |
46 |
#define SENSOR_CONFIG1_TIDDQ_EN_SHIFT 15 |
d753b22d8 thermal: tegra: a... |
47 |
#define SENSOR_CONFIG1_TEN_COUNT_MASK (0x3f << 24) |
65b6d57c2 thermal: tegra: s... |
48 49 50 51 52 53 54 |
#define SENSOR_CONFIG1_TEN_COUNT_SHIFT 24 #define SENSOR_CONFIG1_TEMP_ENABLE BIT(31) /* * SENSOR_CONFIG2 is defined in soctherm.h * because, it will be used by tegra_soctherm_fuse.c */ |
d753b22d8 thermal: tegra: a... |
55 56 57 58 59 60 61 |
#define SENSOR_STATUS0 0xc #define SENSOR_STATUS0_VALID_MASK BIT(31) #define SENSOR_STATUS0_CAPTURE_MASK 0xffff #define SENSOR_STATUS1 0x10 #define SENSOR_STATUS1_TEMP_VALID_MASK BIT(31) #define SENSOR_STATUS1_TEMP_MASK 0xffff |
65b6d57c2 thermal: tegra: s... |
62 63 64 65 |
#define READBACK_VALUE_MASK 0xff00 #define READBACK_VALUE_SHIFT 8 #define READBACK_ADD_HALF BIT(7) #define READBACK_NEGATE BIT(0) |
ce0dbf04f thermal: tegra: a... |
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
/* * THERMCTL_LEVEL0_GROUP_CPU is defined in soctherm.h * because it will be used by tegraxxx_soctherm.c */ #define THERMCTL_LVL0_CPU0_EN_MASK BIT(8) #define THERMCTL_LVL0_CPU0_CPU_THROT_MASK (0x3 << 5) #define THERMCTL_LVL0_CPU0_CPU_THROT_LIGHT 0x1 #define THERMCTL_LVL0_CPU0_CPU_THROT_HEAVY 0x2 #define THERMCTL_LVL0_CPU0_GPU_THROT_MASK (0x3 << 3) #define THERMCTL_LVL0_CPU0_GPU_THROT_LIGHT 0x1 #define THERMCTL_LVL0_CPU0_GPU_THROT_HEAVY 0x2 #define THERMCTL_LVL0_CPU0_MEM_THROT_MASK BIT(2) #define THERMCTL_LVL0_CPU0_STATUS_MASK 0x3 #define THERMCTL_LVL0_UP_STATS 0x10 #define THERMCTL_LVL0_DN_STATS 0x14 #define THERMCTL_STATS_CTL 0x94 #define STATS_CTL_CLR_DN 0x8 #define STATS_CTL_EN_DN 0x4 #define STATS_CTL_CLR_UP 0x2 #define STATS_CTL_EN_UP 0x1 #define THROT_GLOBAL_CFG 0x400 #define THROT_GLOBAL_ENB_MASK BIT(0) #define CPU_PSKIP_STATUS 0x418 #define XPU_PSKIP_STATUS_M_MASK (0xff << 12) #define XPU_PSKIP_STATUS_N_MASK (0xff << 4) #define XPU_PSKIP_STATUS_SW_OVERRIDE_MASK BIT(1) #define XPU_PSKIP_STATUS_ENABLED_MASK BIT(0) #define THROT_PRIORITY_LOCK 0x424 #define THROT_PRIORITY_LOCK_PRIORITY_MASK 0xff #define THROT_STATUS 0x428 #define THROT_STATUS_BREACH_MASK BIT(12) #define THROT_STATUS_STATE_MASK (0xff << 4) #define THROT_STATUS_ENABLED_MASK BIT(0) #define THROT_PSKIP_CTRL_LITE_CPU 0x430 #define THROT_PSKIP_CTRL_ENABLE_MASK BIT(31) #define THROT_PSKIP_CTRL_DIVIDEND_MASK (0xff << 8) #define THROT_PSKIP_CTRL_DIVISOR_MASK 0xff #define THROT_PSKIP_CTRL_VECT_GPU_MASK (0x7 << 16) #define THROT_PSKIP_CTRL_VECT_CPU_MASK (0x7 << 8) #define THROT_PSKIP_CTRL_VECT2_CPU_MASK 0x7 #define THROT_VECT_NONE 0x0 /* 3'b000 */ #define THROT_VECT_LOW 0x1 /* 3'b001 */ #define THROT_VECT_MED 0x3 /* 3'b011 */ #define THROT_VECT_HIGH 0x7 /* 3'b111 */ #define THROT_PSKIP_RAMP_LITE_CPU 0x434 #define THROT_PSKIP_RAMP_SEQ_BYPASS_MODE_MASK BIT(31) #define THROT_PSKIP_RAMP_DURATION_MASK (0xffff << 8) #define THROT_PSKIP_RAMP_STEP_MASK 0xff #define THROT_PRIORITY_LITE 0x444 #define THROT_PRIORITY_LITE_PRIO_MASK 0xff #define THROT_DELAY_LITE 0x448 #define THROT_DELAY_LITE_DELAY_MASK 0xff /* car register offsets needed for enabling HW throttling */ #define CAR_SUPER_CCLKG_DIVIDER 0x36c #define CDIVG_USE_THERM_CONTROLS_MASK BIT(30) |
6c7c32457 thermal: tegra: a... |
133 134 135 136 137 138 139 140 141 142 143 144 145 146 |
/* ccroc register offsets needed for enabling HW throttling for Tegra132 */ #define CCROC_SUPER_CCLKG_DIVIDER 0x024 #define CCROC_GLOBAL_CFG 0x148 #define CCROC_THROT_PSKIP_RAMP_CPU 0x150 #define CCROC_THROT_PSKIP_RAMP_SEQ_BYPASS_MODE_MASK BIT(31) #define CCROC_THROT_PSKIP_RAMP_DURATION_MASK (0xffff << 8) #define CCROC_THROT_PSKIP_RAMP_STEP_MASK 0xff #define CCROC_THROT_PSKIP_CTRL_CPU 0x154 #define CCROC_THROT_PSKIP_CTRL_ENB_MASK BIT(31) #define CCROC_THROT_PSKIP_CTRL_DIVIDEND_MASK (0xff << 8) #define CCROC_THROT_PSKIP_CTRL_DIVISOR_MASK 0xff |
65b6d57c2 thermal: tegra: s... |
147 148 149 150 151 |
/* get val from register(r) mask bits(m) */ #define REG_GET_MASK(r, m) (((r) & (m)) >> (ffs(m) - 1)) /* set val(v) to mask bits(m) of register(r) */ #define REG_SET_MASK(r, m, v) (((r) & ~(m)) | \ (((v) & (m >> (ffs(m) - 1))) << (ffs(m) - 1))) |
ce0dbf04f thermal: tegra: a... |
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 |
/* get dividend from the depth */ #define THROT_DEPTH_DIVIDEND(depth) ((256 * (100 - (depth)) / 100) - 1) /* get THROT_PSKIP_xxx offset per LIGHT/HEAVY throt and CPU/GPU dev */ #define THROT_OFFSET 0x30 #define THROT_PSKIP_CTRL(throt, dev) (THROT_PSKIP_CTRL_LITE_CPU + \ (THROT_OFFSET * throt) + (8 * dev)) #define THROT_PSKIP_RAMP(throt, dev) (THROT_PSKIP_RAMP_LITE_CPU + \ (THROT_OFFSET * throt) + (8 * dev)) /* get THROT_xxx_CTRL offset per LIGHT/HEAVY throt */ #define THROT_PRIORITY_CTRL(throt) (THROT_PRIORITY_LITE + \ (THROT_OFFSET * throt)) #define THROT_DELAY_CTRL(throt) (THROT_DELAY_LITE + \ (THROT_OFFSET * throt)) |
6c7c32457 thermal: tegra: a... |
167 168 169 170 171 172 |
/* get CCROC_THROT_PSKIP_xxx offset per HIGH/MED/LOW vect*/ #define CCROC_THROT_OFFSET 0x0c #define CCROC_THROT_PSKIP_CTRL_CPU_REG(vect) (CCROC_THROT_PSKIP_CTRL_CPU + \ (CCROC_THROT_OFFSET * vect)) #define CCROC_THROT_PSKIP_RAMP_CPU_REG(vect) (CCROC_THROT_PSKIP_RAMP_CPU + \ (CCROC_THROT_OFFSET * vect)) |
ce0dbf04f thermal: tegra: a... |
173 174 175 |
/* get THERMCTL_LEVELx offset per CPU/GPU/MEM/TSENSE rg and LEVEL0~3 lv */ #define THERMCTL_LVL_REGS_SIZE 0x20 #define THERMCTL_LVL_REG(rg, lv) ((rg) + ((lv) * THERMCTL_LVL_REGS_SIZE)) |
2a895871f thermal: tegra: a... |
176 177 |
static const int min_low_temp = -127000; static const int max_high_temp = 127000; |
ce0dbf04f thermal: tegra: a... |
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 |
enum soctherm_throttle_id { THROTTLE_LIGHT = 0, THROTTLE_HEAVY, THROTTLE_SIZE, }; enum soctherm_throttle_dev_id { THROTTLE_DEV_CPU = 0, THROTTLE_DEV_GPU, THROTTLE_DEV_SIZE, }; static const char *const throt_names[] = { [THROTTLE_LIGHT] = "light", [THROTTLE_HEAVY] = "heavy", }; struct tegra_soctherm; |
65b6d57c2 thermal: tegra: s... |
196 197 |
struct tegra_thermctl_zone { void __iomem *reg; |
2a895871f thermal: tegra: a... |
198 |
struct device *dev; |
ce0dbf04f thermal: tegra: a... |
199 |
struct tegra_soctherm *ts; |
2a895871f thermal: tegra: a... |
200 201 |
struct thermal_zone_device *tz; const struct tegra_tsensor_group *sg; |
65b6d57c2 thermal: tegra: s... |
202 |
}; |
ce0dbf04f thermal: tegra: a... |
203 204 205 206 |
struct soctherm_throt_cfg { const char *name; unsigned int id; u8 priority; |
6c7c32457 thermal: tegra: a... |
207 |
u8 cpu_throt_level; |
ce0dbf04f thermal: tegra: a... |
208 209 210 211 |
u32 cpu_throt_depth; struct thermal_cooling_device *cdev; bool init; }; |
65b6d57c2 thermal: tegra: s... |
212 213 214 215 216 |
struct tegra_soctherm { struct reset_control *reset; struct clk *clock_tsensor; struct clk *clock_soctherm; void __iomem *regs; |
ce0dbf04f thermal: tegra: a... |
217 |
void __iomem *clk_regs; |
6c7c32457 thermal: tegra: a... |
218 |
void __iomem *ccroc_regs; |
65b6d57c2 thermal: tegra: s... |
219 220 |
u32 *calib; |
ce0dbf04f thermal: tegra: a... |
221 |
struct thermal_zone_device **thermctl_tzs; |
65b6d57c2 thermal: tegra: s... |
222 |
struct tegra_soctherm_soc *soc; |
d753b22d8 thermal: tegra: a... |
223 |
|
ce0dbf04f thermal: tegra: a... |
224 |
struct soctherm_throt_cfg throt_cfgs[THROTTLE_SIZE]; |
d753b22d8 thermal: tegra: a... |
225 |
struct dentry *debugfs_dir; |
65b6d57c2 thermal: tegra: s... |
226 |
}; |
ce0dbf04f thermal: tegra: a... |
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 |
/** * clk_writel() - writes a value to a CAR register * @ts: pointer to a struct tegra_soctherm * @v: the value to write * @reg: the register offset * * Writes @v to @reg. No return value. */ static inline void clk_writel(struct tegra_soctherm *ts, u32 value, u32 reg) { writel(value, (ts->clk_regs + reg)); } /** * clk_readl() - reads specified register from CAR IP block * @ts: pointer to a struct tegra_soctherm * @reg: register address to be read * * Return: the value of the register */ static inline u32 clk_readl(struct tegra_soctherm *ts, u32 reg) { return readl(ts->clk_regs + reg); } |
6c7c32457 thermal: tegra: a... |
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 |
/** * ccroc_writel() - writes a value to a CCROC register * @ts: pointer to a struct tegra_soctherm * @v: the value to write * @reg: the register offset * * Writes @v to @reg. No return value. */ static inline void ccroc_writel(struct tegra_soctherm *ts, u32 value, u32 reg) { writel(value, (ts->ccroc_regs + reg)); } /** * ccroc_readl() - reads specified register from CCROC IP block * @ts: pointer to a struct tegra_soctherm * @reg: register address to be read * * Return: the value of the register */ static inline u32 ccroc_readl(struct tegra_soctherm *ts, u32 reg) { return readl(ts->ccroc_regs + reg); } |
1ed895c2a thermal: tegra: h... |
275 |
static void enable_tsensor(struct tegra_soctherm *tegra, unsigned int i) |
65b6d57c2 thermal: tegra: s... |
276 277 278 |
{ const struct tegra_tsensor *sensor = &tegra->soc->tsensors[i]; void __iomem *base = tegra->regs + sensor->base; |
65b6d57c2 thermal: tegra: s... |
279 |
unsigned int val; |
65b6d57c2 thermal: tegra: s... |
280 281 282 283 284 285 286 287 288 |
val = sensor->config->tall << SENSOR_CONFIG0_TALL_SHIFT; writel(val, base + SENSOR_CONFIG0); val = (sensor->config->tsample - 1) << SENSOR_CONFIG1_TSAMPLE_SHIFT; val |= sensor->config->tiddq_en << SENSOR_CONFIG1_TIDDQ_EN_SHIFT; val |= sensor->config->ten_count << SENSOR_CONFIG1_TEN_COUNT_SHIFT; val |= SENSOR_CONFIG1_TEMP_ENABLE; writel(val, base + SENSOR_CONFIG1); |
1ed895c2a thermal: tegra: h... |
289 |
writel(tegra->calib[i], base + SENSOR_CONFIG2); |
65b6d57c2 thermal: tegra: s... |
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 |
} /* * Translate from soctherm readback format to millicelsius. * The soctherm readback format in bits is as follows: * TTTTTTTT H______N * where T's contain the temperature in Celsius, * H denotes an addition of 0.5 Celsius and N denotes negation * of the final value. */ static int translate_temp(u16 val) { int t; t = ((val & READBACK_VALUE_MASK) >> READBACK_VALUE_SHIFT) * 1000; if (val & READBACK_ADD_HALF) t += 500; if (val & READBACK_NEGATE) t *= -1; return t; } static int tegra_thermctl_get_temp(void *data, int *out_temp) { struct tegra_thermctl_zone *zone = data; u32 val; val = readl(zone->reg); |
2a895871f thermal: tegra: a... |
319 |
val = REG_GET_MASK(val, zone->sg->sensor_temp_mask); |
65b6d57c2 thermal: tegra: s... |
320 321 322 323 |
*out_temp = translate_temp(val); return 0; } |
2a895871f thermal: tegra: a... |
324 325 326 |
static int thermtrip_program(struct device *dev, const struct tegra_tsensor_group *sg, int trip_temp); |
ce0dbf04f thermal: tegra: a... |
327 328 329 330 331 |
static int throttrip_program(struct device *dev, const struct tegra_tsensor_group *sg, struct soctherm_throt_cfg *stc, int trip_temp); static struct soctherm_throt_cfg * find_throttle_cfg_by_name(struct tegra_soctherm *ts, const char *name); |
2a895871f thermal: tegra: a... |
332 333 334 335 336 |
static int tegra_thermctl_set_trip_temp(void *data, int trip, int temp) { struct tegra_thermctl_zone *zone = data; struct thermal_zone_device *tz = zone->tz; |
ce0dbf04f thermal: tegra: a... |
337 |
struct tegra_soctherm *ts = zone->ts; |
2a895871f thermal: tegra: a... |
338 339 340 341 342 343 344 345 346 347 348 |
const struct tegra_tsensor_group *sg = zone->sg; struct device *dev = zone->dev; enum thermal_trip_type type; int ret; if (!tz) return -EINVAL; ret = tz->ops->get_trip_type(tz, trip, &type); if (ret) return ret; |
ce0dbf04f thermal: tegra: a... |
349 350 351 352 353 354 355 356 |
if (type == THERMAL_TRIP_CRITICAL) { return thermtrip_program(dev, sg, temp); } else if (type == THERMAL_TRIP_HOT) { int i; for (i = 0; i < THROTTLE_SIZE; i++) { struct thermal_cooling_device *cdev; struct soctherm_throt_cfg *stc; |
2a895871f thermal: tegra: a... |
357 |
|
ce0dbf04f thermal: tegra: a... |
358 359 360 361 362 363 364 365 366 367 368 369 370 371 |
if (!ts->throt_cfgs[i].init) continue; cdev = ts->throt_cfgs[i].cdev; if (get_thermal_instance(tz, cdev, trip)) stc = find_throttle_cfg_by_name(ts, cdev->type); else continue; return throttrip_program(dev, sg, stc, temp); } } return 0; |
2a895871f thermal: tegra: a... |
372 |
} |
65b6d57c2 thermal: tegra: s... |
373 374 |
static const struct thermal_zone_of_device_ops tegra_of_thermal_ops = { .get_temp = tegra_thermctl_get_temp, |
2a895871f thermal: tegra: a... |
375 |
.set_trip_temp = tegra_thermctl_set_trip_temp, |
65b6d57c2 thermal: tegra: s... |
376 |
}; |
2a895871f thermal: tegra: a... |
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 |
/** * enforce_temp_range() - check and enforce temperature range [min, max] * @trip_temp: the trip temperature to check * * Checks and enforces the permitted temperature range that SOC_THERM * HW can support This is * done while taking care of precision. * * Return: The precision adjusted capped temperature in millicelsius. */ static int enforce_temp_range(struct device *dev, int trip_temp) { int temp; temp = clamp_val(trip_temp, min_low_temp, max_high_temp); if (temp != trip_temp) dev_info(dev, "soctherm: trip temperature %d forced to %d ", trip_temp, temp); return temp; } /** * thermtrip_program() - Configures the hardware to shut down the * system if a given sensor group reaches a given temperature * @dev: ptr to the struct device for the SOC_THERM IP block * @sg: pointer to the sensor group to set the thermtrip temperature for * @trip_temp: the temperature in millicelsius to trigger the thermal trip at * * Sets the thermal trip threshold of the given sensor group to be the * @trip_temp. If this threshold is crossed, the hardware will shut * down. * * Note that, although @trip_temp is specified in millicelsius, the * hardware is programmed in degrees Celsius. * * Return: 0 upon success, or %-EINVAL upon failure. */ static int thermtrip_program(struct device *dev, const struct tegra_tsensor_group *sg, int trip_temp) { struct tegra_soctherm *ts = dev_get_drvdata(dev); int temp; u32 r; |
f35009807 thermal: tegra: f... |
422 |
if (!sg || !sg->thermtrip_threshold_mask) |
2a895871f thermal: tegra: a... |
423 424 425 426 427 428 429 430 431 432 433 434 435 436 |
return -EINVAL; temp = enforce_temp_range(dev, trip_temp) / ts->soc->thresh_grain; r = readl(ts->regs + THERMCTL_THERMTRIP_CTL); r = REG_SET_MASK(r, sg->thermtrip_threshold_mask, temp); r = REG_SET_MASK(r, sg->thermtrip_enable_mask, 1); r = REG_SET_MASK(r, sg->thermtrip_any_en_mask, 0); writel(r, ts->regs + THERMCTL_THERMTRIP_CTL); return 0; } /** |
ce0dbf04f thermal: tegra: a... |
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 |
* throttrip_program() - Configures the hardware to throttle the * pulse if a given sensor group reaches a given temperature * @dev: ptr to the struct device for the SOC_THERM IP block * @sg: pointer to the sensor group to set the thermtrip temperature for * @stc: pointer to the throttle need to be triggered * @trip_temp: the temperature in millicelsius to trigger the thermal trip at * * Sets the thermal trip threshold and throttle event of the given sensor * group. If this threshold is crossed, the hardware will trigger the * throttle. * * Note that, although @trip_temp is specified in millicelsius, the * hardware is programmed in degrees Celsius. * * Return: 0 upon success, or %-EINVAL upon failure. */ static int throttrip_program(struct device *dev, const struct tegra_tsensor_group *sg, struct soctherm_throt_cfg *stc, int trip_temp) { struct tegra_soctherm *ts = dev_get_drvdata(dev); int temp, cpu_throt, gpu_throt; unsigned int throt; u32 r, reg_off; if (!dev || !sg || !stc || !stc->init) return -EINVAL; temp = enforce_temp_range(dev, trip_temp) / ts->soc->thresh_grain; /* Hardcode LIGHT on LEVEL1 and HEAVY on LEVEL2 */ throt = stc->id; reg_off = THERMCTL_LVL_REG(sg->thermctl_lvl0_offset, throt + 1); if (throt == THROTTLE_LIGHT) { cpu_throt = THERMCTL_LVL0_CPU0_CPU_THROT_LIGHT; gpu_throt = THERMCTL_LVL0_CPU0_GPU_THROT_LIGHT; } else { cpu_throt = THERMCTL_LVL0_CPU0_CPU_THROT_HEAVY; gpu_throt = THERMCTL_LVL0_CPU0_GPU_THROT_HEAVY; if (throt != THROTTLE_HEAVY) dev_warn(dev, "invalid throt id %d - assuming HEAVY", throt); } r = readl(ts->regs + reg_off); r = REG_SET_MASK(r, sg->thermctl_lvl0_up_thresh_mask, temp); r = REG_SET_MASK(r, sg->thermctl_lvl0_dn_thresh_mask, temp); r = REG_SET_MASK(r, THERMCTL_LVL0_CPU0_CPU_THROT_MASK, cpu_throt); r = REG_SET_MASK(r, THERMCTL_LVL0_CPU0_GPU_THROT_MASK, gpu_throt); r = REG_SET_MASK(r, THERMCTL_LVL0_CPU0_EN_MASK, 1); writel(r, ts->regs + reg_off); return 0; } static struct soctherm_throt_cfg * find_throttle_cfg_by_name(struct tegra_soctherm *ts, const char *name) { unsigned int i; for (i = 0; ts->throt_cfgs[i].name; i++) if (!strcmp(ts->throt_cfgs[i].name, name)) return &ts->throt_cfgs[i]; return NULL; } static int get_hot_temp(struct thermal_zone_device *tz, int *trip, int *temp) { int ntrips, i, ret; enum thermal_trip_type type; ntrips = of_thermal_get_ntrips(tz); if (ntrips <= 0) return -EINVAL; for (i = 0; i < ntrips; i++) { ret = tz->ops->get_trip_type(tz, i, &type); if (ret) return -EINVAL; if (type == THERMAL_TRIP_HOT) { ret = tz->ops->get_trip_temp(tz, i, temp); if (!ret) *trip = i; return ret; } } return -EINVAL; } /** |
2a895871f thermal: tegra: a... |
533 534 535 536 |
* tegra_soctherm_set_hwtrips() - set HW trip point from DT data * @dev: struct device * of the SOC_THERM instance * * Configure the SOC_THERM HW trip points, setting "THERMTRIP" |
ce0dbf04f thermal: tegra: a... |
537 538 539 540 |
* "THROTTLE" trip points , using "critical" or "hot" type trip_temp * from thermal zone. * After they have been configured, THERMTRIP or THROTTLE will take * action when the configured SoC thermal sensor group reaches a |
2a895871f thermal: tegra: a... |
541 542 543 544 545 546 547 548 |
* certain temperature. * * Return: 0 upon success, or a negative error code on failure. * "Success" does not mean that trips was enabled; it could also * mean that no node was found in DT. * THERMTRIP has been enabled successfully when a message similar to * this one appears on the serial console: * "thermtrip: will shut down when sensor group XXX reaches YYYYYY mC" |
ce0dbf04f thermal: tegra: a... |
549 550 551 |
* THROTTLE has been enabled successfully when a message similar to * this one appears on the serial console: * ""throttrip: will throttle when sensor group XXX reaches YYYYYY mC" |
2a895871f thermal: tegra: a... |
552 553 554 555 556 |
*/ static int tegra_soctherm_set_hwtrips(struct device *dev, const struct tegra_tsensor_group *sg, struct thermal_zone_device *tz) { |
ce0dbf04f thermal: tegra: a... |
557 558 559 |
struct tegra_soctherm *ts = dev_get_drvdata(dev); struct soctherm_throt_cfg *stc; int i, trip, temperature; |
2a895871f thermal: tegra: a... |
560 561 562 563 564 565 566 |
int ret; ret = tz->ops->get_crit_temp(tz, &temperature); if (ret) { dev_warn(dev, "thermtrip: %s: missing critical temperature ", sg->name); |
ce0dbf04f thermal: tegra: a... |
567 |
goto set_throttle; |
2a895871f thermal: tegra: a... |
568 569 570 571 572 573 574 575 576 577 578 579 580 581 |
} ret = thermtrip_program(dev, sg, temperature); if (ret) { dev_err(dev, "thermtrip: %s: error during enable ", sg->name); return ret; } dev_info(dev, "thermtrip: will shut down when %s reaches %d mC ", sg->name, temperature); |
ce0dbf04f thermal: tegra: a... |
582 |
set_throttle: |
ce0dbf04f thermal: tegra: a... |
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 |
ret = get_hot_temp(tz, &trip, &temperature); if (ret) { dev_warn(dev, "throttrip: %s: missing hot temperature ", sg->name); return 0; } for (i = 0; i < THROTTLE_SIZE; i++) { struct thermal_cooling_device *cdev; if (!ts->throt_cfgs[i].init) continue; cdev = ts->throt_cfgs[i].cdev; if (get_thermal_instance(tz, cdev, trip)) stc = find_throttle_cfg_by_name(ts, cdev->type); else continue; ret = throttrip_program(dev, sg, stc, temperature); if (ret) { dev_err(dev, "throttrip: %s: error during enable ", sg->name); return ret; } dev_info(dev, "throttrip: will throttle when %s reaches %d mC ", sg->name, temperature); break; } if (i == THROTTLE_SIZE) dev_warn(dev, "throttrip: %s: missing throttle cdev ", sg->name); |
2a895871f thermal: tegra: a... |
622 623 |
return 0; } |
d753b22d8 thermal: tegra: a... |
624 625 626 627 628 629 |
#ifdef CONFIG_DEBUG_FS static int regs_show(struct seq_file *s, void *data) { struct platform_device *pdev = s->private; struct tegra_soctherm *ts = platform_get_drvdata(pdev); const struct tegra_tsensor *tsensors = ts->soc->tsensors; |
2a895871f thermal: tegra: a... |
630 |
const struct tegra_tsensor_group **ttgs = ts->soc->ttgs; |
d753b22d8 thermal: tegra: a... |
631 |
u32 r, state; |
ce0dbf04f thermal: tegra: a... |
632 |
int i, level; |
d753b22d8 thermal: tegra: a... |
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 |
seq_puts(s, "-----TSENSE (convert HW)----- "); for (i = 0; i < ts->soc->num_tsensors; i++) { r = readl(ts->regs + tsensors[i].base + SENSOR_CONFIG1); state = REG_GET_MASK(r, SENSOR_CONFIG1_TEMP_ENABLE); seq_printf(s, "%s: ", tsensors[i].name); seq_printf(s, "En(%d) ", state); if (!state) { seq_puts(s, " "); continue; } state = REG_GET_MASK(r, SENSOR_CONFIG1_TIDDQ_EN_MASK); seq_printf(s, "tiddq(%d) ", state); state = REG_GET_MASK(r, SENSOR_CONFIG1_TEN_COUNT_MASK); seq_printf(s, "ten_count(%d) ", state); state = REG_GET_MASK(r, SENSOR_CONFIG1_TSAMPLE_MASK); seq_printf(s, "tsample(%d) ", state + 1); r = readl(ts->regs + tsensors[i].base + SENSOR_STATUS1); state = REG_GET_MASK(r, SENSOR_STATUS1_TEMP_VALID_MASK); seq_printf(s, "Temp(%d/", state); state = REG_GET_MASK(r, SENSOR_STATUS1_TEMP_MASK); seq_printf(s, "%d) ", translate_temp(state)); r = readl(ts->regs + tsensors[i].base + SENSOR_STATUS0); state = REG_GET_MASK(r, SENSOR_STATUS0_VALID_MASK); seq_printf(s, "Capture(%d/", state); state = REG_GET_MASK(r, SENSOR_STATUS0_CAPTURE_MASK); seq_printf(s, "%d) ", state); r = readl(ts->regs + tsensors[i].base + SENSOR_CONFIG0); state = REG_GET_MASK(r, SENSOR_CONFIG0_STOP); seq_printf(s, "Stop(%d) ", state); state = REG_GET_MASK(r, SENSOR_CONFIG0_TALL_MASK); seq_printf(s, "Tall(%d) ", state); state = REG_GET_MASK(r, SENSOR_CONFIG0_TCALC_OVER); seq_printf(s, "Over(%d/", state); state = REG_GET_MASK(r, SENSOR_CONFIG0_OVER); seq_printf(s, "%d/", state); state = REG_GET_MASK(r, SENSOR_CONFIG0_CPTR_OVER); seq_printf(s, "%d) ", state); r = readl(ts->regs + tsensors[i].base + SENSOR_CONFIG2); state = REG_GET_MASK(r, SENSOR_CONFIG2_THERMA_MASK); seq_printf(s, "Therm_A/B(%d/", state); state = REG_GET_MASK(r, SENSOR_CONFIG2_THERMB_MASK); seq_printf(s, "%d) ", (s16)state); } r = readl(ts->regs + SENSOR_PDIV); seq_printf(s, "PDIV: 0x%x ", r); r = readl(ts->regs + SENSOR_HOTSPOT_OFF); seq_printf(s, "HOTSPOT: 0x%x ", r); seq_puts(s, " "); seq_puts(s, "-----SOC_THERM----- "); r = readl(ts->regs + SENSOR_TEMP1); state = REG_GET_MASK(r, SENSOR_TEMP1_CPU_TEMP_MASK); seq_printf(s, "Temperatures: CPU(%d) ", translate_temp(state)); state = REG_GET_MASK(r, SENSOR_TEMP1_GPU_TEMP_MASK); seq_printf(s, " GPU(%d) ", translate_temp(state)); r = readl(ts->regs + SENSOR_TEMP2); state = REG_GET_MASK(r, SENSOR_TEMP2_PLLX_TEMP_MASK); seq_printf(s, " PLLX(%d) ", translate_temp(state)); state = REG_GET_MASK(r, SENSOR_TEMP2_MEM_TEMP_MASK); seq_printf(s, " MEM(%d) ", translate_temp(state)); |
ce0dbf04f thermal: tegra: a... |
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 |
for (i = 0; i < ts->soc->num_ttgs; i++) { seq_printf(s, "%s: ", ttgs[i]->name); for (level = 0; level < 4; level++) { s32 v; u32 mask; u16 off = ttgs[i]->thermctl_lvl0_offset; r = readl(ts->regs + THERMCTL_LVL_REG(off, level)); mask = ttgs[i]->thermctl_lvl0_up_thresh_mask; state = REG_GET_MASK(r, mask); v = sign_extend32(state, ts->soc->bptt - 1); v *= ts->soc->thresh_grain; seq_printf(s, " %d: Up/Dn(%d /", level, v); mask = ttgs[i]->thermctl_lvl0_dn_thresh_mask; state = REG_GET_MASK(r, mask); v = sign_extend32(state, ts->soc->bptt - 1); v *= ts->soc->thresh_grain; seq_printf(s, "%d ) ", v); mask = THERMCTL_LVL0_CPU0_EN_MASK; state = REG_GET_MASK(r, mask); seq_printf(s, "En(%d) ", state); mask = THERMCTL_LVL0_CPU0_CPU_THROT_MASK; state = REG_GET_MASK(r, mask); seq_puts(s, "CPU Throt"); if (!state) seq_printf(s, "(%s) ", "none"); else if (state == THERMCTL_LVL0_CPU0_CPU_THROT_LIGHT) seq_printf(s, "(%s) ", "L"); else if (state == THERMCTL_LVL0_CPU0_CPU_THROT_HEAVY) seq_printf(s, "(%s) ", "H"); else seq_printf(s, "(%s) ", "H+L"); mask = THERMCTL_LVL0_CPU0_GPU_THROT_MASK; state = REG_GET_MASK(r, mask); seq_puts(s, "GPU Throt"); if (!state) seq_printf(s, "(%s) ", "none"); else if (state == THERMCTL_LVL0_CPU0_GPU_THROT_LIGHT) seq_printf(s, "(%s) ", "L"); else if (state == THERMCTL_LVL0_CPU0_GPU_THROT_HEAVY) seq_printf(s, "(%s) ", "H"); else seq_printf(s, "(%s) ", "H+L"); mask = THERMCTL_LVL0_CPU0_STATUS_MASK; state = REG_GET_MASK(r, mask); seq_printf(s, "Status(%s) ", state == 0 ? "LO" : state == 1 ? "In" : state == 2 ? "Res" : "HI"); } } r = readl(ts->regs + THERMCTL_STATS_CTL); seq_printf(s, "STATS: Up(%s) Dn(%s) ", r & STATS_CTL_EN_UP ? "En" : "--", r & STATS_CTL_EN_DN ? "En" : "--"); for (level = 0; level < 4; level++) { u16 off; off = THERMCTL_LVL0_UP_STATS; r = readl(ts->regs + THERMCTL_LVL_REG(off, level)); seq_printf(s, " Level_%d Up(%d) ", level, r); off = THERMCTL_LVL0_DN_STATS; r = readl(ts->regs + THERMCTL_LVL_REG(off, level)); seq_printf(s, "Dn(%d) ", r); } |
2a895871f thermal: tegra: a... |
791 792 793 794 795 796 797 798 799 800 801 802 |
r = readl(ts->regs + THERMCTL_THERMTRIP_CTL); state = REG_GET_MASK(r, ttgs[0]->thermtrip_any_en_mask); seq_printf(s, "Thermtrip Any En(%d) ", state); for (i = 0; i < ts->soc->num_ttgs; i++) { state = REG_GET_MASK(r, ttgs[i]->thermtrip_enable_mask); seq_printf(s, " %s En(%d) ", ttgs[i]->name, state); state = REG_GET_MASK(r, ttgs[i]->thermtrip_threshold_mask); state *= ts->soc->thresh_grain; seq_printf(s, "Thresh(%d) ", state); } |
ce0dbf04f thermal: tegra: a... |
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 |
r = readl(ts->regs + THROT_GLOBAL_CFG); seq_puts(s, " "); seq_printf(s, "GLOBAL THROTTLE CONFIG: 0x%08x ", r); seq_puts(s, "--------------------------------------------------- "); r = readl(ts->regs + THROT_STATUS); state = REG_GET_MASK(r, THROT_STATUS_BREACH_MASK); seq_printf(s, "THROT STATUS: breach(%d) ", state); state = REG_GET_MASK(r, THROT_STATUS_STATE_MASK); seq_printf(s, "state(%d) ", state); state = REG_GET_MASK(r, THROT_STATUS_ENABLED_MASK); seq_printf(s, "enabled(%d) ", state); r = readl(ts->regs + CPU_PSKIP_STATUS); |
6c7c32457 thermal: tegra: a... |
821 822 823 824 825 826 827 828 829 830 831 832 833 |
if (ts->soc->use_ccroc) { state = REG_GET_MASK(r, XPU_PSKIP_STATUS_ENABLED_MASK); seq_printf(s, "CPU PSKIP STATUS: enabled(%d) ", state); } else { state = REG_GET_MASK(r, XPU_PSKIP_STATUS_M_MASK); seq_printf(s, "CPU PSKIP STATUS: M(%d) ", state); state = REG_GET_MASK(r, XPU_PSKIP_STATUS_N_MASK); seq_printf(s, "N(%d) ", state); state = REG_GET_MASK(r, XPU_PSKIP_STATUS_ENABLED_MASK); seq_printf(s, "enabled(%d) ", state); } |
ce0dbf04f thermal: tegra: a... |
834 |
|
d753b22d8 thermal: tegra: a... |
835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 |
return 0; } static int regs_open(struct inode *inode, struct file *file) { return single_open(file, regs_show, inode->i_private); } static const struct file_operations regs_fops = { .open = regs_open, .read = seq_read, .llseek = seq_lseek, .release = single_release, }; static void soctherm_debug_init(struct platform_device *pdev) { struct tegra_soctherm *tegra = platform_get_drvdata(pdev); struct dentry *root, *file; root = debugfs_create_dir("soctherm", NULL); if (!root) { dev_err(&pdev->dev, "failed to create debugfs directory "); return; } tegra->debugfs_dir = root; file = debugfs_create_file("reg_contents", 0644, root, pdev, ®s_fops); if (!file) { dev_err(&pdev->dev, "failed to create debugfs file "); debugfs_remove_recursive(tegra->debugfs_dir); tegra->debugfs_dir = NULL; } } #else static inline void soctherm_debug_init(struct platform_device *pdev) {} #endif |
8de2ab023 thermal: tegra: h... |
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 |
static int soctherm_clk_enable(struct platform_device *pdev, bool enable) { struct tegra_soctherm *tegra = platform_get_drvdata(pdev); int err; if (!tegra->clock_soctherm || !tegra->clock_tsensor) return -EINVAL; reset_control_assert(tegra->reset); if (enable) { err = clk_prepare_enable(tegra->clock_soctherm); if (err) { reset_control_deassert(tegra->reset); return err; } err = clk_prepare_enable(tegra->clock_tsensor); if (err) { clk_disable_unprepare(tegra->clock_soctherm); reset_control_deassert(tegra->reset); return err; } } else { clk_disable_unprepare(tegra->clock_tsensor); clk_disable_unprepare(tegra->clock_soctherm); } reset_control_deassert(tegra->reset); return 0; } |
ce0dbf04f thermal: tegra: a... |
908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 |
static int throt_get_cdev_max_state(struct thermal_cooling_device *cdev, unsigned long *max_state) { *max_state = 1; return 0; } static int throt_get_cdev_cur_state(struct thermal_cooling_device *cdev, unsigned long *cur_state) { struct tegra_soctherm *ts = cdev->devdata; u32 r; r = readl(ts->regs + THROT_STATUS); if (REG_GET_MASK(r, THROT_STATUS_STATE_MASK)) *cur_state = 1; else *cur_state = 0; return 0; } static int throt_set_cdev_state(struct thermal_cooling_device *cdev, unsigned long cur_state) { return 0; } static struct thermal_cooling_device_ops throt_cooling_ops = { .get_max_state = throt_get_cdev_max_state, .get_cur_state = throt_get_cdev_cur_state, .set_cur_state = throt_set_cdev_state, }; /** * soctherm_init_hw_throt_cdev() - Parse the HW throttle configurations * and register them as cooling devices. */ static void soctherm_init_hw_throt_cdev(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct tegra_soctherm *ts = dev_get_drvdata(dev); struct device_node *np_stc, *np_stcc; const char *name; u32 val; int i, r; for (i = 0; i < THROTTLE_SIZE; i++) { ts->throt_cfgs[i].name = throt_names[i]; ts->throt_cfgs[i].id = i; ts->throt_cfgs[i].init = false; } np_stc = of_get_child_by_name(dev->of_node, "throttle-cfgs"); if (!np_stc) { dev_info(dev, "throttle-cfg: no throttle-cfgs - not enabling "); return; } for_each_child_of_node(np_stc, np_stcc) { struct soctherm_throt_cfg *stc; struct thermal_cooling_device *tcd; name = np_stcc->name; stc = find_throttle_cfg_by_name(ts, name); if (!stc) { dev_err(dev, "throttle-cfg: could not find %s ", name); continue; } r = of_property_read_u32(np_stcc, "nvidia,priority", &val); if (r) { dev_info(dev, "throttle-cfg: %s: missing priority ", name); continue; } stc->priority = val; |
6c7c32457 thermal: tegra: a... |
990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 |
if (ts->soc->use_ccroc) { r = of_property_read_u32(np_stcc, "nvidia,cpu-throt-level", &val); if (r) { dev_info(dev, "throttle-cfg: %s: missing cpu-throt-level ", name); continue; } stc->cpu_throt_level = val; } else { r = of_property_read_u32(np_stcc, "nvidia,cpu-throt-percent", &val); if (r) { dev_info(dev, "throttle-cfg: %s: missing cpu-throt-percent ", name); continue; } stc->cpu_throt_depth = val; |
ce0dbf04f thermal: tegra: a... |
1014 |
} |
ce0dbf04f thermal: tegra: a... |
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 |
tcd = thermal_of_cooling_device_register(np_stcc, (char *)name, ts, &throt_cooling_ops); of_node_put(np_stcc); if (IS_ERR_OR_NULL(tcd)) { dev_err(dev, "throttle-cfg: %s: failed to register cooling device ", name); continue; } stc->cdev = tcd; stc->init = true; } of_node_put(np_stc); } /** |
6c7c32457 thermal: tegra: a... |
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 |
* throttlectl_cpu_level_cfg() - programs CCROC NV_THERM level config * @level: describing the level LOW/MED/HIGH of throttling * * It's necessary to set up the CPU-local CCROC NV_THERM instance with * the M/N values desired for each level. This function does this. * * This function pre-programs the CCROC NV_THERM levels in terms of * pre-configured "Low", "Medium" or "Heavy" throttle levels which are * mapped to THROT_LEVEL_LOW, THROT_LEVEL_MED and THROT_LEVEL_HVY. */ static void throttlectl_cpu_level_cfg(struct tegra_soctherm *ts, int level) { u8 depth, dividend; u32 r; switch (level) { case TEGRA_SOCTHERM_THROT_LEVEL_LOW: depth = 50; break; case TEGRA_SOCTHERM_THROT_LEVEL_MED: depth = 75; break; case TEGRA_SOCTHERM_THROT_LEVEL_HIGH: depth = 80; break; case TEGRA_SOCTHERM_THROT_LEVEL_NONE: return; default: return; } dividend = THROT_DEPTH_DIVIDEND(depth); /* setup PSKIP in ccroc nv_therm registers */ r = ccroc_readl(ts, CCROC_THROT_PSKIP_RAMP_CPU_REG(level)); r = REG_SET_MASK(r, CCROC_THROT_PSKIP_RAMP_DURATION_MASK, 0xff); r = REG_SET_MASK(r, CCROC_THROT_PSKIP_RAMP_STEP_MASK, 0xf); ccroc_writel(ts, r, CCROC_THROT_PSKIP_RAMP_CPU_REG(level)); r = ccroc_readl(ts, CCROC_THROT_PSKIP_CTRL_CPU_REG(level)); r = REG_SET_MASK(r, CCROC_THROT_PSKIP_CTRL_ENB_MASK, 1); r = REG_SET_MASK(r, CCROC_THROT_PSKIP_CTRL_DIVIDEND_MASK, dividend); r = REG_SET_MASK(r, CCROC_THROT_PSKIP_CTRL_DIVISOR_MASK, 0xff); ccroc_writel(ts, r, CCROC_THROT_PSKIP_CTRL_CPU_REG(level)); } /** * throttlectl_cpu_level_select() - program CPU pulse skipper config * @throt: the LIGHT/HEAVY of throttle event id * * Pulse skippers are used to throttle clock frequencies. This * function programs the pulse skippers based on @throt and platform * data. This function is used on SoCs which have CPU-local pulse * skipper control, such as T13x. It programs soctherm's interface to * Denver:CCROC NV_THERM in terms of Low, Medium and HIGH throttling * vectors. PSKIP_BYPASS mode is set as required per HW spec. */ static void throttlectl_cpu_level_select(struct tegra_soctherm *ts, enum soctherm_throttle_id throt) { u32 r, throt_vect; /* Denver:CCROC NV_THERM interface N:3 Mapping */ switch (ts->throt_cfgs[throt].cpu_throt_level) { case TEGRA_SOCTHERM_THROT_LEVEL_LOW: throt_vect = THROT_VECT_LOW; break; case TEGRA_SOCTHERM_THROT_LEVEL_MED: throt_vect = THROT_VECT_MED; break; case TEGRA_SOCTHERM_THROT_LEVEL_HIGH: throt_vect = THROT_VECT_HIGH; break; default: throt_vect = THROT_VECT_NONE; break; } r = readl(ts->regs + THROT_PSKIP_CTRL(throt, THROTTLE_DEV_CPU)); r = REG_SET_MASK(r, THROT_PSKIP_CTRL_ENABLE_MASK, 1); r = REG_SET_MASK(r, THROT_PSKIP_CTRL_VECT_CPU_MASK, throt_vect); r = REG_SET_MASK(r, THROT_PSKIP_CTRL_VECT2_CPU_MASK, throt_vect); writel(r, ts->regs + THROT_PSKIP_CTRL(throt, THROTTLE_DEV_CPU)); /* bypass sequencer in soc_therm as it is programmed in ccroc */ r = REG_SET_MASK(0, THROT_PSKIP_RAMP_SEQ_BYPASS_MODE_MASK, 1); writel(r, ts->regs + THROT_PSKIP_RAMP(throt, THROTTLE_DEV_CPU)); } /** |
ce0dbf04f thermal: tegra: a... |
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 |
* throttlectl_cpu_mn() - program CPU pulse skipper configuration * @throt: the LIGHT/HEAVY of throttle event id * * Pulse skippers are used to throttle clock frequencies. This * function programs the pulse skippers based on @throt and platform * data. This function is used for CPUs that have "remote" pulse * skipper control, e.g., the CPU pulse skipper is controlled by the * SOC_THERM IP block. (SOC_THERM is located outside the CPU * complex.) */ static void throttlectl_cpu_mn(struct tegra_soctherm *ts, enum soctherm_throttle_id throt) { u32 r; int depth; u8 dividend; depth = ts->throt_cfgs[throt].cpu_throt_depth; dividend = THROT_DEPTH_DIVIDEND(depth); r = readl(ts->regs + THROT_PSKIP_CTRL(throt, THROTTLE_DEV_CPU)); r = REG_SET_MASK(r, THROT_PSKIP_CTRL_ENABLE_MASK, 1); r = REG_SET_MASK(r, THROT_PSKIP_CTRL_DIVIDEND_MASK, dividend); r = REG_SET_MASK(r, THROT_PSKIP_CTRL_DIVISOR_MASK, 0xff); writel(r, ts->regs + THROT_PSKIP_CTRL(throt, THROTTLE_DEV_CPU)); r = readl(ts->regs + THROT_PSKIP_RAMP(throt, THROTTLE_DEV_CPU)); r = REG_SET_MASK(r, THROT_PSKIP_RAMP_DURATION_MASK, 0xff); r = REG_SET_MASK(r, THROT_PSKIP_RAMP_STEP_MASK, 0xf); writel(r, ts->regs + THROT_PSKIP_RAMP(throt, THROTTLE_DEV_CPU)); } /** * soctherm_throttle_program() - programs pulse skippers' configuration * @throt: the LIGHT/HEAVY of the throttle event id. * * Pulse skippers are used to throttle clock frequencies. * This function programs the pulse skippers. */ static void soctherm_throttle_program(struct tegra_soctherm *ts, enum soctherm_throttle_id throt) { u32 r; struct soctherm_throt_cfg stc = ts->throt_cfgs[throt]; if (!stc.init) return; /* Setup PSKIP parameters */ |
6c7c32457 thermal: tegra: a... |
1175 1176 1177 1178 |
if (ts->soc->use_ccroc) throttlectl_cpu_level_select(ts, throt); else throttlectl_cpu_mn(ts, throt); |
ce0dbf04f thermal: tegra: a... |
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 |
r = REG_SET_MASK(0, THROT_PRIORITY_LITE_PRIO_MASK, stc.priority); writel(r, ts->regs + THROT_PRIORITY_CTRL(throt)); r = REG_SET_MASK(0, THROT_DELAY_LITE_DELAY_MASK, 0); writel(r, ts->regs + THROT_DELAY_CTRL(throt)); r = readl(ts->regs + THROT_PRIORITY_LOCK); r = REG_GET_MASK(r, THROT_PRIORITY_LOCK_PRIORITY_MASK); if (r >= stc.priority) return; r = REG_SET_MASK(0, THROT_PRIORITY_LOCK_PRIORITY_MASK, stc.priority); writel(r, ts->regs + THROT_PRIORITY_LOCK); } static void tegra_soctherm_throttle(struct device *dev) { struct tegra_soctherm *ts = dev_get_drvdata(dev); u32 v; int i; |
6c7c32457 thermal: tegra: a... |
1200 1201 1202 1203 1204 1205 |
/* configure LOW, MED and HIGH levels for CCROC NV_THERM */ if (ts->soc->use_ccroc) { throttlectl_cpu_level_cfg(ts, TEGRA_SOCTHERM_THROT_LEVEL_LOW); throttlectl_cpu_level_cfg(ts, TEGRA_SOCTHERM_THROT_LEVEL_MED); throttlectl_cpu_level_cfg(ts, TEGRA_SOCTHERM_THROT_LEVEL_HIGH); } |
ce0dbf04f thermal: tegra: a... |
1206 1207 1208 1209 1210 |
/* Thermal HW throttle programming */ for (i = 0; i < THROTTLE_SIZE; i++) soctherm_throttle_program(ts, i); v = REG_SET_MASK(0, THROT_GLOBAL_ENB_MASK, 1); |
6c7c32457 thermal: tegra: a... |
1211 1212 |
if (ts->soc->use_ccroc) { ccroc_writel(ts, v, CCROC_GLOBAL_CFG); |
ce0dbf04f thermal: tegra: a... |
1213 |
|
6c7c32457 thermal: tegra: a... |
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 |
v = ccroc_readl(ts, CCROC_SUPER_CCLKG_DIVIDER); v = REG_SET_MASK(v, CDIVG_USE_THERM_CONTROLS_MASK, 1); ccroc_writel(ts, v, CCROC_SUPER_CCLKG_DIVIDER); } else { writel(v, ts->regs + THROT_GLOBAL_CFG); v = clk_readl(ts, CAR_SUPER_CCLKG_DIVIDER); v = REG_SET_MASK(v, CDIVG_USE_THERM_CONTROLS_MASK, 1); clk_writel(ts, v, CAR_SUPER_CCLKG_DIVIDER); } |
ce0dbf04f thermal: tegra: a... |
1224 1225 1226 1227 1228 1229 |
/* initialize stats collection */ v = STATS_CTL_CLR_DN | STATS_CTL_EN_DN | STATS_CTL_CLR_UP | STATS_CTL_EN_UP; writel(v, ts->regs + THERMCTL_STATS_CTL); } |
1ed895c2a thermal: tegra: h... |
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 |
static void soctherm_init(struct platform_device *pdev) { struct tegra_soctherm *tegra = platform_get_drvdata(pdev); const struct tegra_tsensor_group **ttgs = tegra->soc->ttgs; int i; u32 pdiv, hotspot; /* Initialize raw sensors */ for (i = 0; i < tegra->soc->num_tsensors; ++i) enable_tsensor(tegra, i); /* program pdiv and hotspot offsets per THERM */ pdiv = readl(tegra->regs + SENSOR_PDIV); hotspot = readl(tegra->regs + SENSOR_HOTSPOT_OFF); for (i = 0; i < tegra->soc->num_ttgs; ++i) { pdiv = REG_SET_MASK(pdiv, ttgs[i]->pdiv_mask, ttgs[i]->pdiv); /* hotspot offset from PLLX, doesn't need to configure PLLX */ if (ttgs[i]->id == TEGRA124_SOCTHERM_SENSOR_PLLX) continue; hotspot = REG_SET_MASK(hotspot, ttgs[i]->pllx_hotspot_mask, ttgs[i]->pllx_hotspot_diff); } writel(pdiv, tegra->regs + SENSOR_PDIV); writel(hotspot, tegra->regs + SENSOR_HOTSPOT_OFF); |
ce0dbf04f thermal: tegra: a... |
1256 |
|
ce0dbf04f thermal: tegra: a... |
1257 1258 |
/* Configure hw throttle */ tegra_soctherm_throttle(&pdev->dev); |
1ed895c2a thermal: tegra: h... |
1259 |
} |
65b6d57c2 thermal: tegra: s... |
1260 1261 1262 1263 1264 1265 1266 |
static const struct of_device_id tegra_soctherm_of_match[] = { #ifdef CONFIG_ARCH_TEGRA_124_SOC { .compatible = "nvidia,tegra124-soctherm", .data = &tegra124_soctherm, }, #endif |
44cb6a7df thermal: tegra: a... |
1267 1268 1269 1270 1271 1272 |
#ifdef CONFIG_ARCH_TEGRA_132_SOC { .compatible = "nvidia,tegra132-soctherm", .data = &tegra132_soctherm, }, #endif |
8204104f3 thermal: tegra: a... |
1273 1274 1275 1276 1277 1278 |
#ifdef CONFIG_ARCH_TEGRA_210_SOC { .compatible = "nvidia,tegra210-soctherm", .data = &tegra210_soctherm, }, #endif |
65b6d57c2 thermal: tegra: s... |
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 |
{ }, }; MODULE_DEVICE_TABLE(of, tegra_soctherm_of_match); static int tegra_soctherm_probe(struct platform_device *pdev) { const struct of_device_id *match; struct tegra_soctherm *tegra; struct thermal_zone_device *z; struct tsensor_shared_calib shared_calib; struct resource *res; struct tegra_soctherm_soc *soc; unsigned int i; int err; |
65b6d57c2 thermal: tegra: s... |
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 |
match = of_match_node(tegra_soctherm_of_match, pdev->dev.of_node); if (!match) return -ENODEV; soc = (struct tegra_soctherm_soc *)match->data; if (soc->num_ttgs > TEGRA124_SOCTHERM_SENSOR_NUM) return -EINVAL; tegra = devm_kzalloc(&pdev->dev, sizeof(*tegra), GFP_KERNEL); if (!tegra) return -ENOMEM; dev_set_drvdata(&pdev->dev, tegra); tegra->soc = soc; |
ce0dbf04f thermal: tegra: a... |
1309 1310 |
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "soctherm-reg"); |
65b6d57c2 thermal: tegra: s... |
1311 |
tegra->regs = devm_ioremap_resource(&pdev->dev, res); |
ce0dbf04f thermal: tegra: a... |
1312 1313 |
if (IS_ERR(tegra->regs)) { dev_err(&pdev->dev, "can't get soctherm registers"); |
65b6d57c2 thermal: tegra: s... |
1314 |
return PTR_ERR(tegra->regs); |
ce0dbf04f thermal: tegra: a... |
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 |
} if (!tegra->soc->use_ccroc) { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "car-reg"); tegra->clk_regs = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(tegra->clk_regs)) { dev_err(&pdev->dev, "can't get car clk registers"); return PTR_ERR(tegra->clk_regs); } |
6c7c32457 thermal: tegra: a... |
1325 1326 1327 1328 1329 1330 1331 1332 |
} else { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ccroc-reg"); tegra->ccroc_regs = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(tegra->ccroc_regs)) { dev_err(&pdev->dev, "can't get ccroc registers"); return PTR_ERR(tegra->ccroc_regs); } |
ce0dbf04f thermal: tegra: a... |
1333 |
} |
65b6d57c2 thermal: tegra: s... |
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 |
tegra->reset = devm_reset_control_get(&pdev->dev, "soctherm"); if (IS_ERR(tegra->reset)) { dev_err(&pdev->dev, "can't get soctherm reset "); return PTR_ERR(tegra->reset); } tegra->clock_tsensor = devm_clk_get(&pdev->dev, "tsensor"); if (IS_ERR(tegra->clock_tsensor)) { dev_err(&pdev->dev, "can't get tsensor clock "); return PTR_ERR(tegra->clock_tsensor); } tegra->clock_soctherm = devm_clk_get(&pdev->dev, "soctherm"); if (IS_ERR(tegra->clock_soctherm)) { dev_err(&pdev->dev, "can't get soctherm clock "); return PTR_ERR(tegra->clock_soctherm); } |
65b6d57c2 thermal: tegra: s... |
1355 1356 1357 |
tegra->calib = devm_kzalloc(&pdev->dev, sizeof(u32) * soc->num_tsensors, GFP_KERNEL); |
1ed895c2a thermal: tegra: h... |
1358 1359 |
if (!tegra->calib) return -ENOMEM; |
65b6d57c2 thermal: tegra: s... |
1360 |
|
1ed895c2a thermal: tegra: h... |
1361 |
/* calculate shared calibration data */ |
65b6d57c2 thermal: tegra: s... |
1362 1363 |
err = tegra_calc_shared_calib(soc->tfuse, &shared_calib); if (err) |
1ed895c2a thermal: tegra: h... |
1364 |
return err; |
65b6d57c2 thermal: tegra: s... |
1365 |
|
1ed895c2a thermal: tegra: h... |
1366 |
/* calculate tsensor calibaration data */ |
65b6d57c2 thermal: tegra: s... |
1367 |
for (i = 0; i < soc->num_tsensors; ++i) { |
1ed895c2a thermal: tegra: h... |
1368 1369 1370 |
err = tegra_calc_tsensor_calib(&soc->tsensors[i], &shared_calib, &tegra->calib[i]); |
65b6d57c2 thermal: tegra: s... |
1371 |
if (err) |
1ed895c2a thermal: tegra: h... |
1372 |
return err; |
65b6d57c2 thermal: tegra: s... |
1373 |
} |
f09d69849 thermal: tegra: a... |
1374 1375 1376 1377 1378 |
tegra->thermctl_tzs = devm_kzalloc(&pdev->dev, sizeof(*z) * soc->num_ttgs, GFP_KERNEL); if (!tegra->thermctl_tzs) return -ENOMEM; |
1ed895c2a thermal: tegra: h... |
1379 1380 1381 |
err = soctherm_clk_enable(pdev, true); if (err) return err; |
6c7c32457 thermal: tegra: a... |
1382 |
soctherm_init_hw_throt_cdev(pdev); |
ce0dbf04f thermal: tegra: a... |
1383 |
|
1ed895c2a thermal: tegra: h... |
1384 |
soctherm_init(pdev); |
65b6d57c2 thermal: tegra: s... |
1385 |
|
65b6d57c2 thermal: tegra: s... |
1386 1387 1388 1389 1390 1391 1392 1393 1394 |
for (i = 0; i < soc->num_ttgs; ++i) { struct tegra_thermctl_zone *zone = devm_kzalloc(&pdev->dev, sizeof(*zone), GFP_KERNEL); if (!zone) { err = -ENOMEM; goto disable_clocks; } zone->reg = tegra->regs + soc->ttgs[i]->sensor_temp_offset; |
2a895871f thermal: tegra: a... |
1395 1396 |
zone->dev = &pdev->dev; zone->sg = soc->ttgs[i]; |
ce0dbf04f thermal: tegra: a... |
1397 |
zone->ts = tegra; |
65b6d57c2 thermal: tegra: s... |
1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 |
z = devm_thermal_zone_of_sensor_register(&pdev->dev, soc->ttgs[i]->id, zone, &tegra_of_thermal_ops); if (IS_ERR(z)) { err = PTR_ERR(z); dev_err(&pdev->dev, "failed to register sensor: %d ", err); goto disable_clocks; } |
2a895871f thermal: tegra: a... |
1409 1410 |
zone->tz = z; |
f09d69849 thermal: tegra: a... |
1411 |
tegra->thermctl_tzs[soc->ttgs[i]->id] = z; |
2a895871f thermal: tegra: a... |
1412 1413 |
/* Configure hw trip points */ |
ce0dbf04f thermal: tegra: a... |
1414 1415 1416 |
err = tegra_soctherm_set_hwtrips(&pdev->dev, soc->ttgs[i], z); if (err) goto disable_clocks; |
65b6d57c2 thermal: tegra: s... |
1417 |
} |
d753b22d8 thermal: tegra: a... |
1418 |
soctherm_debug_init(pdev); |
65b6d57c2 thermal: tegra: s... |
1419 1420 1421 |
return 0; disable_clocks: |
8de2ab023 thermal: tegra: h... |
1422 |
soctherm_clk_enable(pdev, false); |
65b6d57c2 thermal: tegra: s... |
1423 1424 1425 1426 1427 1428 1429 |
return err; } static int tegra_soctherm_remove(struct platform_device *pdev) { struct tegra_soctherm *tegra = platform_get_drvdata(pdev); |
d753b22d8 thermal: tegra: a... |
1430 |
debugfs_remove_recursive(tegra->debugfs_dir); |
8de2ab023 thermal: tegra: h... |
1431 |
soctherm_clk_enable(pdev, false); |
65b6d57c2 thermal: tegra: s... |
1432 1433 1434 |
return 0; } |
a977c41ec thermal: tegra: m... |
1435 |
static int __maybe_unused soctherm_suspend(struct device *dev) |
f09d69849 thermal: tegra: a... |
1436 1437 1438 1439 1440 1441 1442 |
{ struct platform_device *pdev = to_platform_device(dev); soctherm_clk_enable(pdev, false); return 0; } |
a977c41ec thermal: tegra: m... |
1443 |
static int __maybe_unused soctherm_resume(struct device *dev) |
f09d69849 thermal: tegra: a... |
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 |
{ struct platform_device *pdev = to_platform_device(dev); struct tegra_soctherm *tegra = platform_get_drvdata(pdev); struct tegra_soctherm_soc *soc = tegra->soc; int err, i; err = soctherm_clk_enable(pdev, true); if (err) { dev_err(&pdev->dev, "Resume failed: enable clocks failed "); return err; } soctherm_init(pdev); for (i = 0; i < soc->num_ttgs; ++i) { struct thermal_zone_device *tz; tz = tegra->thermctl_tzs[soc->ttgs[i]->id]; |
ce0dbf04f thermal: tegra: a... |
1464 1465 1466 1467 1468 1469 1470 |
err = tegra_soctherm_set_hwtrips(dev, soc->ttgs[i], tz); if (err) { dev_err(&pdev->dev, "Resume failed: set hwtrips failed "); return err; } |
f09d69849 thermal: tegra: a... |
1471 1472 1473 1474 1475 1476 |
} return 0; } static SIMPLE_DEV_PM_OPS(tegra_soctherm_pm, soctherm_suspend, soctherm_resume); |
65b6d57c2 thermal: tegra: s... |
1477 1478 1479 1480 1481 |
static struct platform_driver tegra_soctherm_driver = { .probe = tegra_soctherm_probe, .remove = tegra_soctherm_remove, .driver = { .name = "tegra_soctherm", |
f09d69849 thermal: tegra: a... |
1482 |
.pm = &tegra_soctherm_pm, |
65b6d57c2 thermal: tegra: s... |
1483 1484 1485 1486 1487 1488 1489 1490 |
.of_match_table = tegra_soctherm_of_match, }, }; module_platform_driver(tegra_soctherm_driver); MODULE_AUTHOR("Mikko Perttunen <mperttunen@nvidia.com>"); MODULE_DESCRIPTION("NVIDIA Tegra SOCTHERM thermal management driver"); MODULE_LICENSE("GPL v2"); |