drivers/gpu/drm/amd/powerplay/hwmgr/vega10_thermal.c

   1 /*
   2  * Copyright 2016 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  */
  23
  24 #include "vega10_thermal.h"
  25 #include "vega10_hwmgr.h"
  26 #include "vega10_smumgr.h"
  27 #include "vega10_ppsmc.h"
  28 #include "vega10_inc.h"
  29 #include "pp_soc15.h"
  30 #include "pp_debug.h"
  31
  32 static int vega10_get_current_rpm(struct pp_hwmgr *hwmgr, uint32_t *current_rpm)
  33 {
  34         PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc(hwmgr->smumgr,
  35                                 PPSMC_MSG_GetCurrentRpm),
  36                         "Attempt to get current RPM from SMC Failed!",
  37                         return -1);
  38         PP_ASSERT_WITH_CODE(!vega10_read_arg_from_smc(hwmgr->smumgr,
  39                         current_rpm),
  40                         "Attempt to read current RPM from SMC Failed!",
  41                         return -1);
  42         return 0;
  43 }
  44
  45 int vega10_fan_ctrl_get_fan_speed_info(struct pp_hwmgr *hwmgr,
  46                 struct phm_fan_speed_info *fan_speed_info)
  47 {
  48
  49         if (hwmgr->thermal_controller.fanInfo.bNoFan)
  50                 return 0;
  51
  52         fan_speed_info->supports_percent_read = true;
  53         fan_speed_info->supports_percent_write = true;
  54         fan_speed_info->min_percent = 0;
  55         fan_speed_info->max_percent = 100;
  56
  57         if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
  58                         PHM_PlatformCaps_FanSpeedInTableIsRPM) &&
  59                 hwmgr->thermal_controller.fanInfo.
  60                 ucTachometerPulsesPerRevolution) {
  61                 fan_speed_info->supports_rpm_read = true;
  62                 fan_speed_info->supports_rpm_write = true;
  63                 fan_speed_info->min_rpm =
  64                                 hwmgr->thermal_controller.fanInfo.ulMinRPM;
  65                 fan_speed_info->max_rpm =
  66                                 hwmgr->thermal_controller.fanInfo.ulMaxRPM;
  67         } else {
  68                 fan_speed_info->min_rpm = 0;
  69                 fan_speed_info->max_rpm = 0;
  70         }
  71
  72         return 0;
  73 }
  74
  75 int vega10_fan_ctrl_get_fan_speed_percent(struct pp_hwmgr *hwmgr,
  76                 uint32_t *speed)
  77 {
  78         uint32_t current_rpm;
  79         uint32_t percent = 0;
  80
  81         if (hwmgr->thermal_controller.fanInfo.bNoFan)
  82                 return 0;
  83
  84         if (vega10_get_current_rpm(hwmgr, &current_rpm))
  85                 return -1;
  86
  87         if (hwmgr->thermal_controller.
  88                         advanceFanControlParameters.usMaxFanRPM != 0)
  89                 percent = current_rpm * 100 /
  90                         hwmgr->thermal_controller.
  91                         advanceFanControlParameters.usMaxFanRPM;
  92
  93         *speed = percent > 100 ? 100 : percent;
  94
  95         return 0;
  96 }
  97
  98 int vega10_fan_ctrl_get_fan_speed_rpm(struct pp_hwmgr *hwmgr, uint32_t *speed)
  99 {
 100         struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
 101         uint32_t tach_period;
 102         uint32_t crystal_clock_freq;
 103         int result = 0;
 104
 105         if (hwmgr->thermal_controller.fanInfo.bNoFan)
 106                 return -1;
 107
 108         if (data->smu_features[GNLD_FAN_CONTROL].supported)
 109                 result = vega10_get_current_rpm(hwmgr, speed);
 110         else {
 111                 uint32_t reg = soc15_get_register_offset(THM_HWID, 0,
 112                                 mmCG_TACH_STATUS_BASE_IDX, mmCG_TACH_STATUS);
 113                 tach_period = (cgs_read_register(hwmgr->device,
 114                                 reg) & CG_TACH_STATUS__TACH_PERIOD_MASK) >>
 115                                 CG_TACH_STATUS__TACH_PERIOD__SHIFT;
 116
 117                 if (tach_period == 0)
 118                         return -EINVAL;
 119
 120                 crystal_clock_freq = smu7_get_xclk(hwmgr);
 121
 122                 *speed = 60 * crystal_clock_freq * 10000 / tach_period;
 123         }
 124
 125         return result;
 126 }
 127
 128 /**
 129 * Set Fan Speed Control to static mode,
 130 * so that the user can decide what speed to use.
 131 * @param    hwmgr  the address of the powerplay hardware manager.
 132 *           mode the fan control mode, 0 default, 1 by percent, 5, by RPM
 133 * @exception Should always succeed.
 134 */
 135 int vega10_fan_ctrl_set_static_mode(struct pp_hwmgr *hwmgr, uint32_t mode)
 136 {
 137         uint32_t reg;
 138
 139         reg = soc15_get_register_offset(THM_HWID, 0,
 140                         mmCG_FDO_CTRL2_BASE_IDX, mmCG_FDO_CTRL2);
 141
 142         if (hwmgr->fan_ctrl_is_in_default_mode) {
 143                 hwmgr->fan_ctrl_default_mode =
 144                                 (cgs_read_register(hwmgr->device, reg) &
 145                                 CG_FDO_CTRL2__FDO_PWM_MODE_MASK) >>
 146                                 CG_FDO_CTRL2__FDO_PWM_MODE__SHIFT;
 147                 hwmgr->tmin = (cgs_read_register(hwmgr->device, reg) &
 148                                 CG_FDO_CTRL2__TMIN_MASK) >>
 149                                 CG_FDO_CTRL2__TMIN__SHIFT;
 150                 hwmgr->fan_ctrl_is_in_default_mode = false;
 151         }
 152
 153         cgs_write_register(hwmgr->device, reg,
 154                         (cgs_read_register(hwmgr->device, reg) &
 155                         ~CG_FDO_CTRL2__TMIN_MASK) |
 156                         (0 << CG_FDO_CTRL2__TMIN__SHIFT));
 157         cgs_write_register(hwmgr->device, reg,
 158                         (cgs_read_register(hwmgr->device, reg) &
 159                         ~CG_FDO_CTRL2__FDO_PWM_MODE_MASK) |
 160                         (mode << CG_FDO_CTRL2__FDO_PWM_MODE__SHIFT));
 161
 162         return 0;
 163 }
 164
 165 /**
 166 * Reset Fan Speed Control to default mode.
 167 * @param    hwmgr  the address of the powerplay hardware manager.
 168 * @exception Should always succeed.
 169 */
 170 int vega10_fan_ctrl_set_default_mode(struct pp_hwmgr *hwmgr)
 171 {
 172         uint32_t reg;
 173
 174         reg = soc15_get_register_offset(THM_HWID, 0,
 175                         mmCG_FDO_CTRL2_BASE_IDX, mmCG_FDO_CTRL2);
 176
 177         if (!hwmgr->fan_ctrl_is_in_default_mode) {
 178                 cgs_write_register(hwmgr->device, reg,
 179                                 (cgs_read_register(hwmgr->device, reg) &
 180                                 ~CG_FDO_CTRL2__FDO_PWM_MODE_MASK) |
 181                                 (hwmgr->fan_ctrl_default_mode <<
 182                                 CG_FDO_CTRL2__FDO_PWM_MODE__SHIFT));
 183                 cgs_write_register(hwmgr->device, reg,
 184                                 (cgs_read_register(hwmgr->device, reg) &
 185                                 ~CG_FDO_CTRL2__TMIN_MASK) |
 186                                 (hwmgr->tmin << CG_FDO_CTRL2__TMIN__SHIFT));
 187                 hwmgr->fan_ctrl_is_in_default_mode = true;
 188         }
 189
 190         return 0;
 191 }
 192
 193 /**
 194  * @fn vega10_enable_fan_control_feature
 195  * @brief Enables the SMC Fan Control Feature.
 196  *
 197  * @param    hwmgr - the address of the powerplay hardware manager.
 198  * @return   0 on success. -1 otherwise.
 199  */
 200 static int vega10_enable_fan_control_feature(struct pp_hwmgr *hwmgr)
 201 {
 202         struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
 203
 204         if (data->smu_features[GNLD_FAN_CONTROL].supported) {
 205                 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(
 206                                 hwmgr->smumgr, true,
 207                                 data->smu_features[GNLD_FAN_CONTROL].
 208                                 smu_feature_bitmap),
 209                                 "Attempt to Enable FAN CONTROL feature Failed!",
 210                                 return -1);
 211                 data->smu_features[GNLD_FAN_CONTROL].enabled = true;
 212         }
 213
 214         return 0;
 215 }
 216
 217 static int vega10_disable_fan_control_feature(struct pp_hwmgr *hwmgr)
 218 {
 219         struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
 220
 221         if (data->smu_features[GNLD_FAN_CONTROL].supported) {
 222                 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(
 223                                 hwmgr->smumgr, false,
 224                                 data->smu_features[GNLD_FAN_CONTROL].
 225                                 smu_feature_bitmap),
 226                                 "Attempt to Enable FAN CONTROL feature Failed!",
 227                                 return -1);
 228                 data->smu_features[GNLD_FAN_CONTROL].enabled = false;
 229         }
 230
 231         return 0;
 232 }
 233
 234 int vega10_fan_ctrl_start_smc_fan_control(struct pp_hwmgr *hwmgr)
 235 {
 236         if (hwmgr->thermal_controller.fanInfo.bNoFan)
 237                 return -1;
 238
 239         PP_ASSERT_WITH_CODE(!vega10_enable_fan_control_feature(hwmgr),
 240                         "Attempt to Enable SMC FAN CONTROL Feature Failed!",
 241                         return -1);
 242
 243         return 0;
 244 }
 245
 246
 247 int vega10_fan_ctrl_stop_smc_fan_control(struct pp_hwmgr *hwmgr)
 248 {
 249         struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
 250
 251         if (hwmgr->thermal_controller.fanInfo.bNoFan)
 252                 return -1;
 253
 254         if (data->smu_features[GNLD_FAN_CONTROL].supported) {
 255                 PP_ASSERT_WITH_CODE(!vega10_disable_fan_control_feature(hwmgr),
 256                                 "Attempt to Disable SMC FAN CONTROL Feature Failed!",
 257                                 return -1);
 258         }
 259         return 0;
 260 }
 261
 262 /**
 263 * Set Fan Speed in percent.
 264 * @param    hwmgr  the address of the powerplay hardware manager.
 265 * @param    speed is the percentage value (0% - 100%) to be set.
 266 * @exception Fails is the 100% setting appears to be 0.
 267 */
 268 int vega10_fan_ctrl_set_fan_speed_percent(struct pp_hwmgr *hwmgr,
 269                 uint32_t speed)
 270 {
 271         uint32_t duty100;
 272         uint32_t duty;
 273         uint64_t tmp64;
 274         uint32_t reg;
 275
 276         if (hwmgr->thermal_controller.fanInfo.bNoFan)
 277                 return 0;
 278
 279         if (speed > 100)
 280                 speed = 100;
 281
 282         if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
 283                         PHM_PlatformCaps_MicrocodeFanControl))
 284                 vega10_fan_ctrl_stop_smc_fan_control(hwmgr);
 285
 286         reg = soc15_get_register_offset(THM_HWID, 0,
 287                         mmCG_FDO_CTRL1_BASE_IDX, mmCG_FDO_CTRL1);
 288
 289         duty100 = (cgs_read_register(hwmgr->device, reg) &
 290                         CG_FDO_CTRL1__FMAX_DUTY100_MASK) >>
 291                         CG_FDO_CTRL1__FMAX_DUTY100__SHIFT;
 292
 293         if (duty100 == 0)
 294                 return -EINVAL;
 295
 296         tmp64 = (uint64_t)speed * duty100;
 297         do_div(tmp64, 100);
 298         duty = (uint32_t)tmp64;
 299
 300         reg = soc15_get_register_offset(THM_HWID, 0,
 301                         mmCG_FDO_CTRL0_BASE_IDX, mmCG_FDO_CTRL0);
 302         cgs_write_register(hwmgr->device, reg,
 303                         (cgs_read_register(hwmgr->device, reg) &
 304                         ~CG_FDO_CTRL0__FDO_STATIC_DUTY_MASK) |
 305                         (duty << CG_FDO_CTRL0__FDO_STATIC_DUTY__SHIFT));
 306
 307         return vega10_fan_ctrl_set_static_mode(hwmgr, FDO_PWM_MODE_STATIC);
 308 }
 309
 310 /**
 311 * Reset Fan Speed to default.
 312 * @param    hwmgr  the address of the powerplay hardware manager.
 313 * @exception Always succeeds.
 314 */
 315 int vega10_fan_ctrl_reset_fan_speed_to_default(struct pp_hwmgr *hwmgr)
 316 {
 317         int result;
 318
 319         if (hwmgr->thermal_controller.fanInfo.bNoFan)
 320                 return 0;
 321
 322         if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
 323                         PHM_PlatformCaps_MicrocodeFanControl)) {
 324                 result = vega10_fan_ctrl_set_static_mode(hwmgr,
 325                                 FDO_PWM_MODE_STATIC);
 326                 if (!result)
 327                         result = vega10_fan_ctrl_start_smc_fan_control(hwmgr);
 328         } else
 329                 result = vega10_fan_ctrl_set_default_mode(hwmgr);
 330
 331         return result;
 332 }
 333
 334 /**
 335 * Set Fan Speed in RPM.
 336 * @param    hwmgr  the address of the powerplay hardware manager.
 337 * @param    speed is the percentage value (min - max) to be set.
 338 * @exception Fails is the speed not lie between min and max.
 339 */
 340 int vega10_fan_ctrl_set_fan_speed_rpm(struct pp_hwmgr *hwmgr, uint32_t speed)
 341 {
 342         uint32_t tach_period;
 343         uint32_t crystal_clock_freq;
 344         int result = 0;
 345         uint32_t reg;
 346
 347         if (hwmgr->thermal_controller.fanInfo.bNoFan ||
 348                         (speed < hwmgr->thermal_controller.fanInfo.ulMinRPM) ||
 349                         (speed > hwmgr->thermal_controller.fanInfo.ulMaxRPM))
 350                 return -1;
 351
 352         if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
 353                         PHM_PlatformCaps_MicrocodeFanControl))
 354                 result = vega10_fan_ctrl_stop_smc_fan_control(hwmgr);
 355
 356         if (!result) {
 357                 crystal_clock_freq = smu7_get_xclk(hwmgr);
 358                 tach_period = 60 * crystal_clock_freq * 10000 / (8 * speed);
 359                 reg = soc15_get_register_offset(THM_HWID, 0,
 360                                 mmCG_TACH_STATUS_BASE_IDX, mmCG_TACH_STATUS);
 361                 cgs_write_register(hwmgr->device, reg,
 362                                 (cgs_read_register(hwmgr->device, reg) &
 363                                 ~CG_TACH_STATUS__TACH_PERIOD_MASK) |
 364                                 (tach_period << CG_TACH_STATUS__TACH_PERIOD__SHIFT));
 365         }
 366         return vega10_fan_ctrl_set_static_mode(hwmgr, FDO_PWM_MODE_STATIC_RPM);
 367 }
 368
 369 /**
 370 * Reads the remote temperature from the SIslands thermal controller.
 371 *
 372 * @param    hwmgr The address of the hardware manager.
 373 */
 374 int vega10_thermal_get_temperature(struct pp_hwmgr *hwmgr)
 375 {
 376         int temp;
 377         uint32_t reg;
 378
 379         reg = soc15_get_register_offset(THM_HWID, 0,
 380                         mmCG_TACH_STATUS_BASE_IDX,  mmCG_MULT_THERMAL_STATUS);
 381
 382         temp = cgs_read_register(hwmgr->device, reg);
 383
 384         temp = (temp & CG_MULT_THERMAL_STATUS__ASIC_MAX_TEMP_MASK) >>
 385                         CG_MULT_THERMAL_STATUS__ASIC_MAX_TEMP__SHIFT;
 386
 387         temp = temp & 0x1ff;
 388
 389         temp *= PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
 390
 391         return temp;
 392 }
 393
 394 /**
 395 * Set the requested temperature range for high and low alert signals
 396 *
 397 * @param    hwmgr The address of the hardware manager.
 398 * @param    range Temperature range to be programmed for
 399 *           high and low alert signals
 400 * @exception PP_Result_BadInput if the input data is not valid.
 401 */
 402 static int vega10_thermal_set_temperature_range(struct pp_hwmgr *hwmgr,
 403                 struct PP_TemperatureRange *range)
 404 {
 405         uint32_t low = VEGA10_THERMAL_MINIMUM_ALERT_TEMP *
 406                         PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
 407         uint32_t high = VEGA10_THERMAL_MAXIMUM_ALERT_TEMP *
 408                         PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
 409         uint32_t val, reg;
 410
 411         if (low < range->min)
 412                 low = range->min;
 413         if (high > range->max)
 414                 high = range->max;
 415
 416         if (low > high)
 417                 return -EINVAL;
 418
 419         reg = soc15_get_register_offset(THM_HWID, 0,
 420                         mmTHM_THERMAL_INT_CTRL_BASE_IDX, mmTHM_THERMAL_INT_CTRL);
 421
 422         val = cgs_read_register(hwmgr->device, reg);
 423
 424         val &= (~THM_THERMAL_INT_CTRL__MAX_IH_CREDIT_MASK);
 425         val |=  (5 << THM_THERMAL_INT_CTRL__MAX_IH_CREDIT__SHIFT);
 426
 427         val &= (~THM_THERMAL_INT_CTRL__THERM_IH_HW_ENA_MASK);
 428         val |= (1 << THM_THERMAL_INT_CTRL__THERM_IH_HW_ENA__SHIFT);
 429
 430         val &= (~THM_THERMAL_INT_CTRL__DIG_THERM_INTH_MASK);
 431         val |= ((high / PP_TEMPERATURE_UNITS_PER_CENTIGRADES)
 432                         << THM_THERMAL_INT_CTRL__DIG_THERM_INTH__SHIFT);
 433
 434         val &= (~THM_THERMAL_INT_CTRL__DIG_THERM_INTL_MASK);
 435         val |= ((low / PP_TEMPERATURE_UNITS_PER_CENTIGRADES)
 436                         << THM_THERMAL_INT_CTRL__DIG_THERM_INTL__SHIFT);
 437
 438         val = val & (~THM_THERMAL_INT_CTRL__THERM_TRIGGER_MASK_MASK);
 439
 440         cgs_write_register(hwmgr->device, reg, val);
 441
 442         return 0;
 443 }
 444
 445 /**
 446 * Programs thermal controller one-time setting registers
 447 *
 448 * @param    hwmgr The address of the hardware manager.
 449 */
 450 static int vega10_thermal_initialize(struct pp_hwmgr *hwmgr)
 451 {
 452         uint32_t reg;
 453
 454         if (hwmgr->thermal_controller.fanInfo.ucTachometerPulsesPerRevolution) {
 455                 reg = soc15_get_register_offset(THM_HWID, 0,
 456                                 mmCG_TACH_CTRL_BASE_IDX, mmCG_TACH_CTRL);
 457                 cgs_write_register(hwmgr->device, reg,
 458                                 (cgs_read_register(hwmgr->device, reg) &
 459                                 ~CG_TACH_CTRL__EDGE_PER_REV_MASK) |
 460                                 ((hwmgr->thermal_controller.fanInfo.
 461                                 ucTachometerPulsesPerRevolution - 1) <<
 462                                 CG_TACH_CTRL__EDGE_PER_REV__SHIFT));
 463         }
 464
 465         reg = soc15_get_register_offset(THM_HWID, 0,
 466                         mmCG_FDO_CTRL2_BASE_IDX, mmCG_FDO_CTRL2);
 467         cgs_write_register(hwmgr->device, reg,
 468                         (cgs_read_register(hwmgr->device, reg) &
 469                         ~CG_FDO_CTRL2__TACH_PWM_RESP_RATE_MASK) |
 470                         (0x28 << CG_FDO_CTRL2__TACH_PWM_RESP_RATE__SHIFT));
 471
 472         return 0;
 473 }
 474
 475 /**
 476 * Enable thermal alerts on the RV770 thermal controller.
 477 *
 478 * @param    hwmgr The address of the hardware manager.
 479 */
 480 static int vega10_thermal_enable_alert(struct pp_hwmgr *hwmgr)
 481 {
 482         struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
 483         uint32_t val = 0;
 484         uint32_t reg;
 485
 486         if (data->smu_features[GNLD_FW_CTF].supported) {
 487                 if (data->smu_features[GNLD_FW_CTF].enabled)
 488                         printk("[Thermal_EnableAlert] FW CTF Already Enabled!\n");
 489
 490                 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
 491                                 true,
 492                                 data->smu_features[GNLD_FW_CTF].smu_feature_bitmap),
 493                                 "Attempt to Enable FW CTF feature Failed!",
 494                                 return -1);
 495                 data->smu_features[GNLD_FW_CTF].enabled = true;
 496         }
 497
 498         val |= (1 << THM_THERMAL_INT_ENA__THERM_INTH_CLR__SHIFT);
 499         val |= (1 << THM_THERMAL_INT_ENA__THERM_INTL_CLR__SHIFT);
 500         val |= (1 << THM_THERMAL_INT_ENA__THERM_TRIGGER_CLR__SHIFT);
 501
 502         reg = soc15_get_register_offset(THM_HWID, 0, mmTHM_THERMAL_INT_ENA_BASE_IDX, mmTHM_THERMAL_INT_ENA);
 503         cgs_write_register(hwmgr->device, reg, val);
 504
 505         return 0;
 506 }
 507
 508 /**
 509 * Disable thermal alerts on the RV770 thermal controller.
 510 * @param    hwmgr The address of the hardware manager.
 511 */
 512 int vega10_thermal_disable_alert(struct pp_hwmgr *hwmgr)
 513 {
 514         struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
 515         uint32_t reg;
 516
 517         if (data->smu_features[GNLD_FW_CTF].supported) {
 518                 if (!data->smu_features[GNLD_FW_CTF].enabled)
 519                         printk("[Thermal_EnableAlert] FW CTF Already disabled!\n");
 520
 521
 522                 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
 523                         false,
 524                         data->smu_features[GNLD_FW_CTF].smu_feature_bitmap),
 525                         "Attempt to disable FW CTF feature Failed!",
 526                         return -1);
 527                 data->smu_features[GNLD_FW_CTF].enabled = false;
 528         }
 529
 530         reg = soc15_get_register_offset(THM_HWID, 0, mmTHM_THERMAL_INT_ENA_BASE_IDX, mmTHM_THERMAL_INT_ENA);
 531         cgs_write_register(hwmgr->device, reg, 0);
 532
 533         return 0;
 534 }
 535
 536 /**
 537 * Uninitialize the thermal controller.
 538 * Currently just disables alerts.
 539 * @param    hwmgr The address of the hardware manager.
 540 */
 541 int vega10_thermal_stop_thermal_controller(struct pp_hwmgr *hwmgr)
 542 {
 543         int result = vega10_thermal_disable_alert(hwmgr);
 544
 545         if (!hwmgr->thermal_controller.fanInfo.bNoFan)
 546                 vega10_fan_ctrl_set_default_mode(hwmgr);
 547
 548         return result;
 549 }
 550
 551 /**
 552 * Set up the fan table to control the fan using the SMC.
 553 * @param    hwmgr  the address of the powerplay hardware manager.
 554 * @param    pInput the pointer to input data
 555 * @param    pOutput the pointer to output data
 556 * @param    pStorage the pointer to temporary storage
 557 * @param    Result the last failure code
 558 * @return   result from set temperature range routine
 559 */
 560 int tf_vega10_thermal_setup_fan_table(struct pp_hwmgr *hwmgr,
 561                 void *input, void *output, void *storage, int result)
 562 {
 563         int ret;
 564         struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
 565         PPTable_t *table = &(data->smc_state_table.pp_table);
 566
 567         if (!data->smu_features[GNLD_FAN_CONTROL].supported)
 568                 return 0;
 569
 570         table->FanMaximumRpm = (uint16_t)hwmgr->thermal_controller.
 571                         advanceFanControlParameters.usMaxFanRPM;
 572         table->FanThrottlingRpm = hwmgr->thermal_controller.
 573                         advanceFanControlParameters.usFanRPMMaxLimit;
 574         table->FanAcousticLimitRpm = (uint16_t)(hwmgr->thermal_controller.
 575                         advanceFanControlParameters.ulMinFanSCLKAcousticLimit);
 576         table->FanTargetTemperature = hwmgr->thermal_controller.
 577                         advanceFanControlParameters.usTMax;
 578
 579         smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
 580                                 PPSMC_MSG_SetFanTemperatureTarget,
 581                                 (uint32_t)table->FanTargetTemperature);
 582
 583         table->FanPwmMin = hwmgr->thermal_controller.
 584                         advanceFanControlParameters.usPWMMin * 255 / 100;
 585         table->FanTargetGfxclk = (uint16_t)(hwmgr->thermal_controller.
 586                         advanceFanControlParameters.ulTargetGfxClk);
 587         table->FanGainEdge = hwmgr->thermal_controller.
 588                         advanceFanControlParameters.usFanGainEdge;
 589         table->FanGainHotspot = hwmgr->thermal_controller.
 590                         advanceFanControlParameters.usFanGainHotspot;
 591         table->FanGainLiquid = hwmgr->thermal_controller.
 592                         advanceFanControlParameters.usFanGainLiquid;
 593         table->FanGainVrVddc = hwmgr->thermal_controller.
 594                         advanceFanControlParameters.usFanGainVrVddc;
 595         table->FanGainVrMvdd = hwmgr->thermal_controller.
 596                         advanceFanControlParameters.usFanGainVrMvdd;
 597         table->FanGainPlx = hwmgr->thermal_controller.
 598                         advanceFanControlParameters.usFanGainPlx;
 599         table->FanGainHbm = hwmgr->thermal_controller.
 600                         advanceFanControlParameters.usFanGainHbm;
 601         table->FanZeroRpmEnable = hwmgr->thermal_controller.
 602                         advanceFanControlParameters.ucEnableZeroRPM;
 603         table->FanStopTemp = hwmgr->thermal_controller.
 604                         advanceFanControlParameters.usZeroRPMStopTemperature;
 605         table->FanStartTemp = hwmgr->thermal_controller.
 606                         advanceFanControlParameters.usZeroRPMStartTemperature;
 607
 608         ret = vega10_copy_table_to_smc(hwmgr->smumgr,
 609                         (uint8_t *)(&(data->smc_state_table.pp_table)), PPTABLE);
 610         if (ret)
 611                 pr_info("Failed to update Fan Control Table in PPTable!");
 612
 613         return ret;
 614 }
 615
 616 /**
 617 * Start the fan control on the SMC.
 618 * @param    hwmgr  the address of the powerplay hardware manager.
 619 * @param    pInput the pointer to input data
 620 * @param    pOutput the pointer to output data
 621 * @param    pStorage the pointer to temporary storage
 622 * @param    Result the last failure code
 623 * @return   result from set temperature range routine
 624 */
 625 int tf_vega10_thermal_start_smc_fan_control(struct pp_hwmgr *hwmgr,
 626                 void *input, void *output, void *storage, int result)
 627 {
 628 /* If the fantable setup has failed we could have disabled
 629  * PHM_PlatformCaps_MicrocodeFanControl even after
 630  * this function was included in the table.
 631  * Make sure that we still think controlling the fan is OK.
 632 */
 633         if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
 634                         PHM_PlatformCaps_MicrocodeFanControl)) {
 635                 vega10_fan_ctrl_start_smc_fan_control(hwmgr);
 636                 vega10_fan_ctrl_set_static_mode(hwmgr, FDO_PWM_MODE_STATIC);
 637         }
 638
 639         return 0;
 640 }
 641
 642 /**
 643 * Set temperature range for high and low alerts
 644 * @param    hwmgr  the address of the powerplay hardware manager.
 645 * @param    pInput the pointer to input data
 646 * @param    pOutput the pointer to output data
 647 * @param    pStorage the pointer to temporary storage
 648 * @param    Result the last failure code
 649 * @return   result from set temperature range routine
 650 */
 651 int tf_vega10_thermal_set_temperature_range(struct pp_hwmgr *hwmgr,
 652                 void *input, void *output, void *storage, int result)
 653 {
 654         struct PP_TemperatureRange *range = (struct PP_TemperatureRange *)input;
 655
 656         if (range == NULL)
 657                 return -EINVAL;
 658
 659         return vega10_thermal_set_temperature_range(hwmgr, range);
 660 }
 661
 662 /**
 663 * Programs one-time setting registers
 664 * @param    hwmgr  the address of the powerplay hardware manager.
 665 * @param    pInput the pointer to input data
 666 * @param    pOutput the pointer to output data
 667 * @param    pStorage the pointer to temporary storage
 668 * @param    Result the last failure code
 669 * @return   result from initialize thermal controller routine
 670 */
 671 int tf_vega10_thermal_initialize(struct pp_hwmgr *hwmgr,
 672                 void *input, void *output, void *storage, int result)
 673 {
 674         return vega10_thermal_initialize(hwmgr);
 675 }
 676
 677 /**
 678 * Enable high and low alerts
 679 * @param    hwmgr  the address of the powerplay hardware manager.
 680 * @param    pInput the pointer to input data
 681 * @param    pOutput the pointer to output data
 682 * @param    pStorage the pointer to temporary storage
 683 * @param    Result the last failure code
 684 * @return   result from enable alert routine
 685 */
 686 int tf_vega10_thermal_enable_alert(struct pp_hwmgr *hwmgr,
 687                 void *input, void *output, void *storage, int result)
 688 {
 689         return vega10_thermal_enable_alert(hwmgr);
 690 }
 691
 692 /**
 693 * Disable high and low alerts
 694 * @param    hwmgr  the address of the powerplay hardware manager.
 695 * @param    pInput the pointer to input data
 696 * @param    pOutput the pointer to output data
 697 * @param    pStorage the pointer to temporary storage
 698 * @param    Result the last failure code
 699 * @return   result from disable alert routine
 700 */
 701 static int tf_vega10_thermal_disable_alert(struct pp_hwmgr *hwmgr,
 702                 void *input, void *output, void *storage, int result)
 703 {
 704         return vega10_thermal_disable_alert(hwmgr);
 705 }
 706
 707 static struct phm_master_table_item
 708 vega10_thermal_start_thermal_controller_master_list[] = {
 709         { .tableFunction = tf_vega10_thermal_initialize },
 710         { .tableFunction = tf_vega10_thermal_set_temperature_range },
 711         { .tableFunction = tf_vega10_thermal_enable_alert },
 712 /* We should restrict performance levels to low before we halt the SMC.
 713  * On the other hand we are still in boot state when we do this
 714  * so it would be pointless.
 715  * If this assumption changes we have to revisit this table.
 716  */
 717         { .tableFunction = tf_vega10_thermal_setup_fan_table },
 718         { .tableFunction = tf_vega10_thermal_start_smc_fan_control },
 719         { }
 720 };
 721
 722 static struct phm_master_table_header
 723 vega10_thermal_start_thermal_controller_master = {
 724         0,
 725         PHM_MasterTableFlag_None,
 726         vega10_thermal_start_thermal_controller_master_list
 727 };
 728
 729 static struct phm_master_table_item
 730 vega10_thermal_set_temperature_range_master_list[] = {
 731         { .tableFunction = tf_vega10_thermal_disable_alert },
 732         { .tableFunction = tf_vega10_thermal_set_temperature_range },
 733         { .tableFunction = tf_vega10_thermal_enable_alert },
 734         { }
 735 };
 736
 737 struct phm_master_table_header
 738 vega10_thermal_set_temperature_range_master = {
 739         0,
 740         PHM_MasterTableFlag_None,
 741         vega10_thermal_set_temperature_range_master_list
 742 };
 743
 744 int vega10_thermal_ctrl_uninitialize_thermal_controller(struct pp_hwmgr *hwmgr)
 745 {
 746         if (!hwmgr->thermal_controller.fanInfo.bNoFan) {
 747                 vega10_fan_ctrl_set_default_mode(hwmgr);
 748                 vega10_fan_ctrl_stop_smc_fan_control(hwmgr);
 749         }
 750         return 0;
 751 }
 752
 753 /**
 754 * Initializes the thermal controller related functions
 755 * in the Hardware Manager structure.
 756 * @param    hwmgr The address of the hardware manager.
 757 * @exception Any error code from the low-level communication.
 758 */
 759 int pp_vega10_thermal_initialize(struct pp_hwmgr *hwmgr)
 760 {
 761         int result;
 762
 763         result = phm_construct_table(hwmgr,
 764                         &vega10_thermal_set_temperature_range_master,
 765                         &(hwmgr->set_temperature_range));
 766
 767         if (!result) {
 768                 result = phm_construct_table(hwmgr,
 769                                 &vega10_thermal_start_thermal_controller_master,
 770                                 &(hwmgr->start_thermal_controller));
 771                 if (result)
 772                         phm_destroy_table(hwmgr,
 773                                         &(hwmgr->set_temperature_range));
 774         }
 775
 776         if (!result)
 777                 hwmgr->fan_ctrl_is_in_default_mode = true;
 778         return result;
 779 }
 780