tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

drm/amd/pm: drop the unnecessary intermediate percent-based transition

Currently, the readout of fan speed pwm is transited into percent-based
and then pwm-based. However, the transition into percent-based is totally
unnecessary and make the final output less accurate.

Signed-off-by: Evan Quan <evan.quan@amd.com>
Reviewed-by: Lijo Lazar <lijo.lazar@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

authored by

Evan Quan and committed by
Alex Deucher 0d8318e1 d9ca7567

+112 -140
+2
drivers/gpu/drm/amd/amdgpu/amdgpu.h
··· 1271 1271 1272 1272 #define amdgpu_inc_vram_lost(adev) atomic_inc(&((adev)->vram_lost_counter)); 1273 1273 1274 + #define MIN(X, Y) ((X) < (Y) ? (X) : (Y)) 1275 + 1274 1276 /* Common functions */ 1275 1277 bool amdgpu_device_has_job_running(struct amdgpu_device *adev); 1276 1278 bool amdgpu_device_should_recover_gpu(struct amdgpu_device *adev);
+2 -2
drivers/gpu/drm/amd/include/kgd_pp_interface.h
··· 306 306 /* export for sysfs */ 307 307 void (*set_fan_control_mode)(void *handle, u32 mode); 308 308 u32 (*get_fan_control_mode)(void *handle); 309 - int (*set_fan_speed_percent)(void *handle, u32 speed); 310 - int (*get_fan_speed_percent)(void *handle, u32 *speed); 309 + int (*set_fan_speed_pwm)(void *handle, u32 speed); 310 + int (*get_fan_speed_pwm)(void *handle, u32 *speed); 311 311 int (*force_clock_level)(void *handle, enum pp_clock_type type, uint32_t mask); 312 312 int (*print_clock_levels)(void *handle, enum pp_clock_type type, char *buf); 313 313 int (*force_performance_level)(void *handle, enum amd_dpm_forced_level level);
+8 -12
drivers/gpu/drm/amd/pm/amdgpu_pm.c
··· 2474 2474 return err; 2475 2475 } 2476 2476 2477 - value = (value * 100) / 255; 2478 - 2479 - if (adev->powerplay.pp_funcs->set_fan_speed_percent) 2480 - err = amdgpu_dpm_set_fan_speed_percent(adev, value); 2477 + if (adev->powerplay.pp_funcs->set_fan_speed_pwm) 2478 + err = amdgpu_dpm_set_fan_speed_pwm(adev, value); 2481 2479 else 2482 2480 err = -EINVAL; 2483 2481 ··· 2507 2509 return err; 2508 2510 } 2509 2511 2510 - if (adev->powerplay.pp_funcs->get_fan_speed_percent) 2511 - err = amdgpu_dpm_get_fan_speed_percent(adev, &speed); 2512 + if (adev->powerplay.pp_funcs->get_fan_speed_pwm) 2513 + err = amdgpu_dpm_get_fan_speed_pwm(adev, &speed); 2512 2514 else 2513 2515 err = -EINVAL; 2514 2516 ··· 2517 2519 2518 2520 if (err) 2519 2521 return err; 2520 - 2521 - speed = (speed * 255) / 100; 2522 2522 2523 2523 return sysfs_emit(buf, "%i\n", speed); 2524 2524 } ··· 3353 3357 3354 3358 if (!is_support_sw_smu(adev)) { 3355 3359 /* mask fan attributes if we have no bindings for this asic to expose */ 3356 - if ((!adev->powerplay.pp_funcs->get_fan_speed_percent && 3360 + if ((!adev->powerplay.pp_funcs->get_fan_speed_pwm && 3357 3361 attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't query fan */ 3358 3362 (!adev->powerplay.pp_funcs->get_fan_control_mode && 3359 3363 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't query state */ 3360 3364 effective_mode &= ~S_IRUGO; 3361 3365 3362 - if ((!adev->powerplay.pp_funcs->set_fan_speed_percent && 3366 + if ((!adev->powerplay.pp_funcs->set_fan_speed_pwm && 3363 3367 attr == &sensor_dev_attr_pwm1.dev_attr.attr) || /* can't manage fan */ 3364 3368 (!adev->powerplay.pp_funcs->set_fan_control_mode && 3365 3369 attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr)) /* can't manage state */ ··· 3383 3387 3384 3388 if (!is_support_sw_smu(adev)) { 3385 3389 /* hide max/min values if we can't both query and manage the fan */ 3386 - if ((!adev->powerplay.pp_funcs->set_fan_speed_percent && 3387 - !adev->powerplay.pp_funcs->get_fan_speed_percent) && 3390 + if ((!adev->powerplay.pp_funcs->set_fan_speed_pwm && 3391 + !adev->powerplay.pp_funcs->get_fan_speed_pwm) && 3388 3392 (!adev->powerplay.pp_funcs->set_fan_speed_rpm && 3389 3393 !adev->powerplay.pp_funcs->get_fan_speed_rpm) && 3390 3394 (attr == &sensor_dev_attr_pwm1_max.dev_attr.attr ||
+4 -4
drivers/gpu/drm/amd/pm/inc/amdgpu_dpm.h
··· 280 280 #define amdgpu_dpm_get_fan_control_mode(adev) \ 281 281 ((adev)->powerplay.pp_funcs->get_fan_control_mode((adev)->powerplay.pp_handle)) 282 282 283 - #define amdgpu_dpm_set_fan_speed_percent(adev, s) \ 284 - ((adev)->powerplay.pp_funcs->set_fan_speed_percent((adev)->powerplay.pp_handle, (s))) 283 + #define amdgpu_dpm_set_fan_speed_pwm(adev, s) \ 284 + ((adev)->powerplay.pp_funcs->set_fan_speed_pwm((adev)->powerplay.pp_handle, (s))) 285 285 286 - #define amdgpu_dpm_get_fan_speed_percent(adev, s) \ 287 - ((adev)->powerplay.pp_funcs->get_fan_speed_percent((adev)->powerplay.pp_handle, (s))) 286 + #define amdgpu_dpm_get_fan_speed_pwm(adev, s) \ 287 + ((adev)->powerplay.pp_funcs->get_fan_speed_pwm((adev)->powerplay.pp_handle, (s))) 288 288 289 289 #define amdgpu_dpm_get_fan_speed_rpm(adev, s) \ 290 290 ((adev)->powerplay.pp_funcs->get_fan_speed_rpm)((adev)->powerplay.pp_handle, (s))
+6 -6
drivers/gpu/drm/amd/pm/inc/amdgpu_smu.h
··· 231 231 struct smu_user_dpm_profile { 232 232 uint32_t fan_mode; 233 233 uint32_t power_limit; 234 - uint32_t fan_speed_percent; 234 + uint32_t fan_speed_pwm; 235 235 uint32_t fan_speed_rpm; 236 236 uint32_t flags; 237 237 uint32_t user_od; ··· 543 543 struct work_struct interrupt_work; 544 544 545 545 unsigned fan_max_rpm; 546 - unsigned manual_fan_speed_percent; 546 + unsigned manual_fan_speed_pwm; 547 547 548 548 uint32_t gfx_default_hard_min_freq; 549 549 uint32_t gfx_default_soft_max_freq; ··· 725 725 bool (*is_dpm_running)(struct smu_context *smu); 726 726 727 727 /** 728 - * @get_fan_speed_percent: Get the current fan speed in percent. 728 + * @get_fan_speed_pwm: Get the current fan speed in PWM. 729 729 */ 730 - int (*get_fan_speed_percent)(struct smu_context *smu, uint32_t *speed); 730 + int (*get_fan_speed_pwm)(struct smu_context *smu, uint32_t *speed); 731 731 732 732 /** 733 733 * @get_fan_speed_rpm: Get the current fan speed in rpm. ··· 1051 1051 int (*set_fan_control_mode)(struct smu_context *smu, uint32_t mode); 1052 1052 1053 1053 /** 1054 - * @set_fan_speed_percent: Set a static fan speed in percent. 1054 + * @set_fan_speed_pwm: Set a static fan speed in PWM. 1055 1055 */ 1056 - int (*set_fan_speed_percent)(struct smu_context *smu, uint32_t speed); 1056 + int (*set_fan_speed_pwm)(struct smu_context *smu, uint32_t speed); 1057 1057 1058 1058 /** 1059 1059 * @set_fan_speed_rpm: Set a static fan speed in rpm.
+3 -3
drivers/gpu/drm/amd/pm/inc/hwmgr.h
··· 278 278 int (*get_fan_speed_info)(struct pp_hwmgr *hwmgr, struct phm_fan_speed_info *fan_speed_info); 279 279 void (*set_fan_control_mode)(struct pp_hwmgr *hwmgr, uint32_t mode); 280 280 uint32_t (*get_fan_control_mode)(struct pp_hwmgr *hwmgr); 281 - int (*set_fan_speed_percent)(struct pp_hwmgr *hwmgr, uint32_t percent); 282 - int (*get_fan_speed_percent)(struct pp_hwmgr *hwmgr, uint32_t *speed); 283 - int (*set_fan_speed_rpm)(struct pp_hwmgr *hwmgr, uint32_t percent); 281 + int (*set_fan_speed_pwm)(struct pp_hwmgr *hwmgr, uint32_t speed); 282 + int (*get_fan_speed_pwm)(struct pp_hwmgr *hwmgr, uint32_t *speed); 283 + int (*set_fan_speed_rpm)(struct pp_hwmgr *hwmgr, uint32_t speed); 284 284 int (*get_fan_speed_rpm)(struct pp_hwmgr *hwmgr, uint32_t *speed); 285 285 int (*reset_fan_speed_to_default)(struct pp_hwmgr *hwmgr); 286 286 int (*uninitialize_thermal_controller)(struct pp_hwmgr *hwmgr);
+2 -2
drivers/gpu/drm/amd/pm/inc/smu_v11_0.h
··· 221 221 smu_v11_0_set_fan_control_mode(struct smu_context *smu, 222 222 uint32_t mode); 223 223 224 - int smu_v11_0_set_fan_speed_percent(struct smu_context *smu, 224 + int smu_v11_0_set_fan_speed_pwm(struct smu_context *smu, 225 225 uint32_t speed); 226 226 227 227 int smu_v11_0_set_fan_speed_rpm(struct smu_context *smu, 228 228 uint32_t speed); 229 229 230 - int smu_v11_0_get_fan_speed_percent(struct smu_context *smu, 230 + int smu_v11_0_get_fan_speed_pwm(struct smu_context *smu, 231 231 uint32_t *speed); 232 232 233 233 int smu_v11_0_get_fan_speed_rpm(struct smu_context *smu,
+8 -8
drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c
··· 533 533 return mode; 534 534 } 535 535 536 - static int pp_dpm_set_fan_speed_percent(void *handle, uint32_t percent) 536 + static int pp_dpm_set_fan_speed_pwm(void *handle, uint32_t speed) 537 537 { 538 538 struct pp_hwmgr *hwmgr = handle; 539 539 int ret = 0; ··· 541 541 if (!hwmgr || !hwmgr->pm_en) 542 542 return -EINVAL; 543 543 544 - if (hwmgr->hwmgr_func->set_fan_speed_percent == NULL) { 544 + if (hwmgr->hwmgr_func->set_fan_speed_pwm == NULL) { 545 545 pr_info_ratelimited("%s was not implemented.\n", __func__); 546 546 return 0; 547 547 } 548 548 mutex_lock(&hwmgr->smu_lock); 549 - ret = hwmgr->hwmgr_func->set_fan_speed_percent(hwmgr, percent); 549 + ret = hwmgr->hwmgr_func->set_fan_speed_pwm(hwmgr, speed); 550 550 mutex_unlock(&hwmgr->smu_lock); 551 551 return ret; 552 552 } 553 553 554 - static int pp_dpm_get_fan_speed_percent(void *handle, uint32_t *speed) 554 + static int pp_dpm_get_fan_speed_pwm(void *handle, uint32_t *speed) 555 555 { 556 556 struct pp_hwmgr *hwmgr = handle; 557 557 int ret = 0; ··· 559 559 if (!hwmgr || !hwmgr->pm_en) 560 560 return -EINVAL; 561 561 562 - if (hwmgr->hwmgr_func->get_fan_speed_percent == NULL) { 562 + if (hwmgr->hwmgr_func->get_fan_speed_pwm == NULL) { 563 563 pr_info_ratelimited("%s was not implemented.\n", __func__); 564 564 return 0; 565 565 } 566 566 567 567 mutex_lock(&hwmgr->smu_lock); 568 - ret = hwmgr->hwmgr_func->get_fan_speed_percent(hwmgr, speed); 568 + ret = hwmgr->hwmgr_func->get_fan_speed_pwm(hwmgr, speed); 569 569 mutex_unlock(&hwmgr->smu_lock); 570 570 return ret; 571 571 } ··· 1691 1691 .dispatch_tasks = pp_dpm_dispatch_tasks, 1692 1692 .set_fan_control_mode = pp_dpm_set_fan_control_mode, 1693 1693 .get_fan_control_mode = pp_dpm_get_fan_control_mode, 1694 - .set_fan_speed_percent = pp_dpm_set_fan_speed_percent, 1695 - .get_fan_speed_percent = pp_dpm_get_fan_speed_percent, 1694 + .set_fan_speed_pwm = pp_dpm_set_fan_speed_pwm, 1695 + .get_fan_speed_pwm = pp_dpm_get_fan_speed_pwm, 1696 1696 .get_fan_speed_rpm = pp_dpm_get_fan_speed_rpm, 1697 1697 .set_fan_speed_rpm = pp_dpm_set_fan_speed_rpm, 1698 1698 .get_pp_num_states = pp_dpm_get_pp_num_states,
+4 -4
drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c
··· 3212 3212 3213 3213 if (!ret) { 3214 3214 if (level == AMD_DPM_FORCED_LEVEL_PROFILE_PEAK && hwmgr->dpm_level != AMD_DPM_FORCED_LEVEL_PROFILE_PEAK) 3215 - smu7_fan_ctrl_set_fan_speed_percent(hwmgr, 100); 3215 + smu7_fan_ctrl_set_fan_speed_pwm(hwmgr, 255); 3216 3216 else if (level != AMD_DPM_FORCED_LEVEL_PROFILE_PEAK && hwmgr->dpm_level == AMD_DPM_FORCED_LEVEL_PROFILE_PEAK) 3217 3217 smu7_fan_ctrl_reset_fan_speed_to_default(hwmgr); 3218 3218 } ··· 4988 4988 { 4989 4989 switch (mode) { 4990 4990 case AMD_FAN_CTRL_NONE: 4991 - smu7_fan_ctrl_set_fan_speed_percent(hwmgr, 100); 4991 + smu7_fan_ctrl_set_fan_speed_pwm(hwmgr, 255); 4992 4992 break; 4993 4993 case AMD_FAN_CTRL_MANUAL: 4994 4994 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps, ··· 5692 5692 .set_max_fan_rpm_output = smu7_set_max_fan_rpm_output, 5693 5693 .stop_thermal_controller = smu7_thermal_stop_thermal_controller, 5694 5694 .get_fan_speed_info = smu7_fan_ctrl_get_fan_speed_info, 5695 - .get_fan_speed_percent = smu7_fan_ctrl_get_fan_speed_percent, 5696 - .set_fan_speed_percent = smu7_fan_ctrl_set_fan_speed_percent, 5695 + .get_fan_speed_pwm = smu7_fan_ctrl_get_fan_speed_pwm, 5696 + .set_fan_speed_pwm = smu7_fan_ctrl_set_fan_speed_pwm, 5697 5697 .reset_fan_speed_to_default = smu7_fan_ctrl_reset_fan_speed_to_default, 5698 5698 .get_fan_speed_rpm = smu7_fan_ctrl_get_fan_speed_rpm, 5699 5699 .set_fan_speed_rpm = smu7_fan_ctrl_set_fan_speed_rpm,
+8 -13
drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_thermal.c
··· 51 51 return 0; 52 52 } 53 53 54 - int smu7_fan_ctrl_get_fan_speed_percent(struct pp_hwmgr *hwmgr, 54 + int smu7_fan_ctrl_get_fan_speed_pwm(struct pp_hwmgr *hwmgr, 55 55 uint32_t *speed) 56 56 { 57 57 uint32_t duty100; ··· 70 70 return -EINVAL; 71 71 72 72 73 - tmp64 = (uint64_t)duty * 100; 73 + tmp64 = (uint64_t)duty * 255; 74 74 do_div(tmp64, duty100); 75 - *speed = (uint32_t)tmp64; 76 - 77 - if (*speed > 100) 78 - *speed = 100; 75 + *speed = MIN((uint32_t)tmp64, 255); 79 76 80 77 return 0; 81 78 } ··· 196 199 } 197 200 198 201 /** 199 - * smu7_fan_ctrl_set_fan_speed_percent - Set Fan Speed in percent. 202 + * smu7_fan_ctrl_set_fan_speed_pwm - Set Fan Speed in PWM. 200 203 * @hwmgr: the address of the powerplay hardware manager. 201 - * @speed: is the percentage value (0% - 100%) to be set. 202 - * Exception: Fails is the 100% setting appears to be 0. 204 + * @speed: is the pwm value (0 - 255) to be set. 203 205 */ 204 - int smu7_fan_ctrl_set_fan_speed_percent(struct pp_hwmgr *hwmgr, 206 + int smu7_fan_ctrl_set_fan_speed_pwm(struct pp_hwmgr *hwmgr, 205 207 uint32_t speed) 206 208 { 207 209 uint32_t duty100; ··· 210 214 if (hwmgr->thermal_controller.fanInfo.bNoFan) 211 215 return 0; 212 216 213 - if (speed > 100) 214 - speed = 100; 217 + speed = MIN(speed, 255); 215 218 216 219 if (PP_CAP(PHM_PlatformCaps_MicrocodeFanControl)) 217 220 smu7_fan_ctrl_stop_smc_fan_control(hwmgr); ··· 222 227 return -EINVAL; 223 228 224 229 tmp64 = (uint64_t)speed * duty100; 225 - do_div(tmp64, 100); 230 + do_div(tmp64, 255); 226 231 duty = (uint32_t)tmp64; 227 232 228 233 PHM_WRITE_VFPF_INDIRECT_FIELD(hwmgr->device, CGS_IND_REG__SMC,
+2 -2
drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_thermal.h
··· 41 41 extern int smu7_thermal_get_temperature(struct pp_hwmgr *hwmgr); 42 42 extern int smu7_thermal_stop_thermal_controller(struct pp_hwmgr *hwmgr); 43 43 extern int smu7_fan_ctrl_get_fan_speed_info(struct pp_hwmgr *hwmgr, struct phm_fan_speed_info *fan_speed_info); 44 - extern int smu7_fan_ctrl_get_fan_speed_percent(struct pp_hwmgr *hwmgr, uint32_t *speed); 44 + extern int smu7_fan_ctrl_get_fan_speed_pwm(struct pp_hwmgr *hwmgr, uint32_t *speed); 45 45 extern int smu7_fan_ctrl_set_default_mode(struct pp_hwmgr *hwmgr); 46 46 extern int smu7_fan_ctrl_set_static_mode(struct pp_hwmgr *hwmgr, uint32_t mode); 47 - extern int smu7_fan_ctrl_set_fan_speed_percent(struct pp_hwmgr *hwmgr, uint32_t speed); 47 + extern int smu7_fan_ctrl_set_fan_speed_pwm(struct pp_hwmgr *hwmgr, uint32_t speed); 48 48 extern int smu7_fan_ctrl_reset_fan_speed_to_default(struct pp_hwmgr *hwmgr); 49 49 extern int smu7_thermal_ctrl_uninitialize_thermal_controller(struct pp_hwmgr *hwmgr); 50 50 extern int smu7_fan_ctrl_set_fan_speed_rpm(struct pp_hwmgr *hwmgr, uint32_t speed);
+3 -3
drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_hwmgr.c
··· 4199 4199 4200 4200 switch (mode) { 4201 4201 case AMD_FAN_CTRL_NONE: 4202 - vega10_fan_ctrl_set_fan_speed_percent(hwmgr, 100); 4202 + vega10_fan_ctrl_set_fan_speed_pwm(hwmgr, 255); 4203 4203 break; 4204 4204 case AMD_FAN_CTRL_MANUAL: 4205 4205 if (PP_CAP(PHM_PlatformCaps_MicrocodeFanControl)) ··· 5536 5536 .force_dpm_level = vega10_dpm_force_dpm_level, 5537 5537 .stop_thermal_controller = vega10_thermal_stop_thermal_controller, 5538 5538 .get_fan_speed_info = vega10_fan_ctrl_get_fan_speed_info, 5539 - .get_fan_speed_percent = vega10_fan_ctrl_get_fan_speed_percent, 5540 - .set_fan_speed_percent = vega10_fan_ctrl_set_fan_speed_percent, 5539 + .get_fan_speed_pwm = vega10_fan_ctrl_get_fan_speed_pwm, 5540 + .set_fan_speed_pwm = vega10_fan_ctrl_set_fan_speed_pwm, 5541 5541 .reset_fan_speed_to_default = 5542 5542 vega10_fan_ctrl_reset_fan_speed_to_default, 5543 5543 .get_fan_speed_rpm = vega10_fan_ctrl_get_fan_speed_rpm,
+8 -10
drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_thermal.c
··· 64 64 return 0; 65 65 } 66 66 67 - int vega10_fan_ctrl_get_fan_speed_percent(struct pp_hwmgr *hwmgr, 67 + int vega10_fan_ctrl_get_fan_speed_pwm(struct pp_hwmgr *hwmgr, 68 68 uint32_t *speed) 69 69 { 70 70 uint32_t current_rpm; ··· 78 78 79 79 if (hwmgr->thermal_controller. 80 80 advanceFanControlParameters.usMaxFanRPM != 0) 81 - percent = current_rpm * 100 / 81 + percent = current_rpm * 255 / 82 82 hwmgr->thermal_controller. 83 83 advanceFanControlParameters.usMaxFanRPM; 84 84 85 - *speed = percent > 100 ? 100 : percent; 85 + *speed = MIN(percent, 255); 86 86 87 87 return 0; 88 88 } ··· 241 241 } 242 242 243 243 /** 244 - * vega10_fan_ctrl_set_fan_speed_percent - Set Fan Speed in percent. 244 + * vega10_fan_ctrl_set_fan_speed_pwm - Set Fan Speed in PWM. 245 245 * @hwmgr: the address of the powerplay hardware manager. 246 - * @speed: is the percentage value (0% - 100%) to be set. 247 - * Exception: Fails is the 100% setting appears to be 0. 246 + * @speed: is the percentage value (0 - 255) to be set. 248 247 */ 249 - int vega10_fan_ctrl_set_fan_speed_percent(struct pp_hwmgr *hwmgr, 248 + int vega10_fan_ctrl_set_fan_speed_pwm(struct pp_hwmgr *hwmgr, 250 249 uint32_t speed) 251 250 { 252 251 struct amdgpu_device *adev = hwmgr->adev; ··· 256 257 if (hwmgr->thermal_controller.fanInfo.bNoFan) 257 258 return 0; 258 259 259 - if (speed > 100) 260 - speed = 100; 260 + speed = MIN(speed, 255); 261 261 262 262 if (PP_CAP(PHM_PlatformCaps_MicrocodeFanControl)) 263 263 vega10_fan_ctrl_stop_smc_fan_control(hwmgr); ··· 268 270 return -EINVAL; 269 271 270 272 tmp64 = (uint64_t)speed * duty100; 271 - do_div(tmp64, 100); 273 + do_div(tmp64, 255); 272 274 duty = (uint32_t)tmp64; 273 275 274 276 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL0,
+2 -2
drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_thermal.h
··· 54 54 extern int vega10_thermal_stop_thermal_controller(struct pp_hwmgr *hwmgr); 55 55 extern int vega10_fan_ctrl_get_fan_speed_info(struct pp_hwmgr *hwmgr, 56 56 struct phm_fan_speed_info *fan_speed_info); 57 - extern int vega10_fan_ctrl_get_fan_speed_percent(struct pp_hwmgr *hwmgr, 57 + extern int vega10_fan_ctrl_get_fan_speed_pwm(struct pp_hwmgr *hwmgr, 58 58 uint32_t *speed); 59 59 extern int vega10_fan_ctrl_set_default_mode(struct pp_hwmgr *hwmgr); 60 60 extern int vega10_fan_ctrl_set_static_mode(struct pp_hwmgr *hwmgr, 61 61 uint32_t mode); 62 - extern int vega10_fan_ctrl_set_fan_speed_percent(struct pp_hwmgr *hwmgr, 62 + extern int vega10_fan_ctrl_set_fan_speed_pwm(struct pp_hwmgr *hwmgr, 63 63 uint32_t speed); 64 64 extern int vega10_fan_ctrl_reset_fan_speed_to_default(struct pp_hwmgr *hwmgr); 65 65 extern int vega10_thermal_ctrl_uninitialize_thermal_controller(
+3 -3
drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega20_hwmgr.c
··· 2769 2769 { 2770 2770 switch (mode) { 2771 2771 case AMD_FAN_CTRL_NONE: 2772 - vega20_fan_ctrl_set_fan_speed_percent(hwmgr, 100); 2772 + vega20_fan_ctrl_set_fan_speed_pwm(hwmgr, 255); 2773 2773 break; 2774 2774 case AMD_FAN_CTRL_MANUAL: 2775 2775 if (PP_CAP(PHM_PlatformCaps_MicrocodeFanControl)) ··· 4409 4409 .register_irq_handlers = smu9_register_irq_handlers, 4410 4410 .disable_smc_firmware_ctf = vega20_thermal_disable_alert, 4411 4411 /* fan control related */ 4412 - .get_fan_speed_percent = vega20_fan_ctrl_get_fan_speed_percent, 4413 - .set_fan_speed_percent = vega20_fan_ctrl_set_fan_speed_percent, 4412 + .get_fan_speed_pwm = vega20_fan_ctrl_get_fan_speed_pwm, 4413 + .set_fan_speed_pwm = vega20_fan_ctrl_set_fan_speed_pwm, 4414 4414 .get_fan_speed_info = vega20_fan_ctrl_get_fan_speed_info, 4415 4415 .get_fan_speed_rpm = vega20_fan_ctrl_get_fan_speed_rpm, 4416 4416 .set_fan_speed_rpm = vega20_fan_ctrl_set_fan_speed_rpm,
+6 -10
drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega20_thermal.c
··· 114 114 return 0; 115 115 } 116 116 117 - int vega20_fan_ctrl_get_fan_speed_percent(struct pp_hwmgr *hwmgr, 117 + int vega20_fan_ctrl_get_fan_speed_pwm(struct pp_hwmgr *hwmgr, 118 118 uint32_t *speed) 119 119 { 120 120 struct amdgpu_device *adev = hwmgr->adev; ··· 129 129 if (!duty100) 130 130 return -EINVAL; 131 131 132 - tmp64 = (uint64_t)duty * 100; 132 + tmp64 = (uint64_t)duty * 255; 133 133 do_div(tmp64, duty100); 134 - *speed = (uint32_t)tmp64; 135 - 136 - if (*speed > 100) 137 - *speed = 100; 134 + *speed = MIN((uint32_t)tmp64, 255); 138 135 139 136 return 0; 140 137 } 141 138 142 - int vega20_fan_ctrl_set_fan_speed_percent(struct pp_hwmgr *hwmgr, 139 + int vega20_fan_ctrl_set_fan_speed_pwm(struct pp_hwmgr *hwmgr, 143 140 uint32_t speed) 144 141 { 145 142 struct amdgpu_device *adev = hwmgr->adev; ··· 144 147 uint32_t duty; 145 148 uint64_t tmp64; 146 149 147 - if (speed > 100) 148 - speed = 100; 150 + speed = MIN(speed, 255); 149 151 150 152 if (PP_CAP(PHM_PlatformCaps_MicrocodeFanControl)) 151 153 vega20_fan_ctrl_stop_smc_fan_control(hwmgr); ··· 156 160 return -EINVAL; 157 161 158 162 tmp64 = (uint64_t)speed * duty100; 159 - do_div(tmp64, 100); 163 + do_div(tmp64, 255); 160 164 duty = (uint32_t)tmp64; 161 165 162 166 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL0,
+2 -2
drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega20_thermal.h
··· 56 56 uint32_t *speed); 57 57 extern int vega20_fan_ctrl_set_fan_speed_rpm(struct pp_hwmgr *hwmgr, 58 58 uint32_t speed); 59 - extern int vega20_fan_ctrl_get_fan_speed_percent(struct pp_hwmgr *hwmgr, 59 + extern int vega20_fan_ctrl_get_fan_speed_pwm(struct pp_hwmgr *hwmgr, 60 60 uint32_t *speed); 61 - extern int vega20_fan_ctrl_set_fan_speed_percent(struct pp_hwmgr *hwmgr, 61 + extern int vega20_fan_ctrl_set_fan_speed_pwm(struct pp_hwmgr *hwmgr, 62 62 uint32_t speed); 63 63 extern int vega20_fan_ctrl_stop_smc_fan_control(struct pp_hwmgr *hwmgr); 64 64 extern int vega20_fan_ctrl_start_smc_fan_control(struct pp_hwmgr *hwmgr);
+8 -11
drivers/gpu/drm/amd/pm/powerplay/si_dpm.c
··· 6539 6539 } 6540 6540 } 6541 6541 6542 - static int si_dpm_get_fan_speed_percent(void *handle, 6542 + static int si_dpm_get_fan_speed_pwm(void *handle, 6543 6543 u32 *speed) 6544 6544 { 6545 6545 u32 duty, duty100; ··· 6555 6555 if (duty100 == 0) 6556 6556 return -EINVAL; 6557 6557 6558 - tmp64 = (u64)duty * 100; 6558 + tmp64 = (u64)duty * 255; 6559 6559 do_div(tmp64, duty100); 6560 - *speed = (u32)tmp64; 6561 - 6562 - if (*speed > 100) 6563 - *speed = 100; 6560 + *speed = MIN((u32)tmp64, 255); 6564 6561 6565 6562 return 0; 6566 6563 } 6567 6564 6568 - static int si_dpm_set_fan_speed_percent(void *handle, 6565 + static int si_dpm_set_fan_speed_pwm(void *handle, 6569 6566 u32 speed) 6570 6567 { 6571 6568 struct amdgpu_device *adev = (struct amdgpu_device *)handle; ··· 6577 6580 if (si_pi->fan_is_controlled_by_smc) 6578 6581 return -EINVAL; 6579 6582 6580 - if (speed > 100) 6583 + if (speed > 255) 6581 6584 return -EINVAL; 6582 6585 6583 6586 duty100 = (RREG32(CG_FDO_CTRL1) & FMAX_DUTY100_MASK) >> FMAX_DUTY100_SHIFT; ··· 6586 6589 return -EINVAL; 6587 6590 6588 6591 tmp64 = (u64)speed * duty100; 6589 - do_div(tmp64, 100); 6592 + do_div(tmp64, 255); 6590 6593 duty = (u32)tmp64; 6591 6594 6592 6595 tmp = RREG32(CG_FDO_CTRL0) & ~FDO_STATIC_DUTY_MASK; ··· 8056 8059 .vblank_too_short = &si_dpm_vblank_too_short, 8057 8060 .set_fan_control_mode = &si_dpm_set_fan_control_mode, 8058 8061 .get_fan_control_mode = &si_dpm_get_fan_control_mode, 8059 - .set_fan_speed_percent = &si_dpm_set_fan_speed_percent, 8060 - .get_fan_speed_percent = &si_dpm_get_fan_speed_percent, 8062 + .set_fan_speed_pwm = &si_dpm_set_fan_speed_pwm, 8063 + .get_fan_speed_pwm = &si_dpm_get_fan_speed_pwm, 8061 8064 .check_state_equal = &si_check_state_equal, 8062 8065 .get_vce_clock_state = amdgpu_get_vce_clock_state, 8063 8066 .read_sensor = &si_dpm_read_sensor,
+16 -24
drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
··· 58 58 enum amd_pp_task task_id, 59 59 bool lock_needed); 60 60 static int smu_reset(struct smu_context *smu); 61 - static int smu_set_fan_speed_percent(void *handle, u32 speed); 61 + static int smu_set_fan_speed_pwm(void *handle, u32 speed); 62 62 static int smu_set_fan_control_mode(struct smu_context *smu, int value); 63 63 static int smu_set_power_limit(void *handle, uint32_t limit); 64 64 static int smu_set_fan_speed_rpm(void *handle, uint32_t speed); ··· 407 407 smu->user_dpm_profile.fan_mode == AMD_FAN_CTRL_NONE) { 408 408 ret = smu_set_fan_control_mode(smu, smu->user_dpm_profile.fan_mode); 409 409 if (ret) { 410 - smu->user_dpm_profile.fan_speed_percent = 0; 410 + smu->user_dpm_profile.fan_speed_pwm = 0; 411 411 smu->user_dpm_profile.fan_speed_rpm = 0; 412 412 smu->user_dpm_profile.fan_mode = AMD_FAN_CTRL_AUTO; 413 413 dev_err(smu->adev->dev, "Failed to set manual fan control mode\n"); 414 414 } 415 415 416 - if (smu->user_dpm_profile.fan_speed_percent) { 417 - ret = smu_set_fan_speed_percent(smu, smu->user_dpm_profile.fan_speed_percent); 416 + if (smu->user_dpm_profile.fan_speed_pwm) { 417 + ret = smu_set_fan_speed_pwm(smu, smu->user_dpm_profile.fan_speed_pwm); 418 418 if (ret) 419 - dev_err(smu->adev->dev, "Failed to set manual fan speed in percent\n"); 419 + dev_err(smu->adev->dev, "Failed to set manual fan speed in pwm\n"); 420 420 } 421 421 422 422 if (smu->user_dpm_profile.fan_speed_rpm) { ··· 2204 2204 2205 2205 /* Override custom PWM setting as they cannot co-exist */ 2206 2206 smu->user_dpm_profile.flags &= ~SMU_CUSTOM_FAN_SPEED_PWM; 2207 - smu->user_dpm_profile.fan_speed_percent = 0; 2207 + smu->user_dpm_profile.fan_speed_pwm = 0; 2208 2208 } 2209 2209 } 2210 2210 ··· 2566 2566 /* reset user dpm fan speed */ 2567 2567 if (!ret && value != AMD_FAN_CTRL_MANUAL && 2568 2568 !(smu->user_dpm_profile.flags & SMU_DPM_USER_PROFILE_RESTORE)) { 2569 - smu->user_dpm_profile.fan_speed_percent = 0; 2569 + smu->user_dpm_profile.fan_speed_pwm = 0; 2570 2570 smu->user_dpm_profile.fan_speed_rpm = 0; 2571 2571 smu->user_dpm_profile.flags &= ~(SMU_CUSTOM_FAN_SPEED_RPM | SMU_CUSTOM_FAN_SPEED_PWM); 2572 2572 } ··· 2582 2582 } 2583 2583 2584 2584 2585 - static int smu_get_fan_speed_percent(void *handle, u32 *speed) 2585 + static int smu_get_fan_speed_pwm(void *handle, u32 *speed) 2586 2586 { 2587 2587 struct smu_context *smu = handle; 2588 2588 int ret = 0; 2589 - uint32_t percent; 2590 2589 2591 2590 if (!smu->pm_enabled || !smu->adev->pm.dpm_enabled) 2592 2591 return -EOPNOTSUPP; 2593 2592 2594 2593 mutex_lock(&smu->mutex); 2595 2594 2596 - if (smu->ppt_funcs->get_fan_speed_percent) { 2597 - ret = smu->ppt_funcs->get_fan_speed_percent(smu, &percent); 2598 - if (!ret) { 2599 - *speed = percent > 100 ? 100 : percent; 2600 - } 2601 - } 2595 + if (smu->ppt_funcs->get_fan_speed_pwm) 2596 + ret = smu->ppt_funcs->get_fan_speed_pwm(smu, speed); 2602 2597 2603 2598 mutex_unlock(&smu->mutex); 2604 - 2605 2599 2606 2600 return ret; 2607 2601 } 2608 2602 2609 - static int smu_set_fan_speed_percent(void *handle, u32 speed) 2603 + static int smu_set_fan_speed_pwm(void *handle, u32 speed) 2610 2604 { 2611 2605 struct smu_context *smu = handle; 2612 2606 int ret = 0; ··· 2610 2616 2611 2617 mutex_lock(&smu->mutex); 2612 2618 2613 - if (smu->ppt_funcs->set_fan_speed_percent) { 2614 - if (speed > 100) 2615 - speed = 100; 2616 - ret = smu->ppt_funcs->set_fan_speed_percent(smu, speed); 2619 + if (smu->ppt_funcs->set_fan_speed_pwm) { 2620 + ret = smu->ppt_funcs->set_fan_speed_pwm(smu, speed); 2617 2621 if (!ret && !(smu->user_dpm_profile.flags & SMU_DPM_USER_PROFILE_RESTORE)) { 2618 2622 smu->user_dpm_profile.flags |= SMU_CUSTOM_FAN_SPEED_PWM; 2619 - smu->user_dpm_profile.fan_speed_percent = speed; 2623 + smu->user_dpm_profile.fan_speed_pwm = speed; 2620 2624 2621 2625 /* Override custom RPM setting as they cannot co-exist */ 2622 2626 smu->user_dpm_profile.flags &= ~SMU_CUSTOM_FAN_SPEED_RPM; ··· 3055 3063 /* export for sysfs */ 3056 3064 .set_fan_control_mode = smu_pp_set_fan_control_mode, 3057 3065 .get_fan_control_mode = smu_get_fan_control_mode, 3058 - .set_fan_speed_percent = smu_set_fan_speed_percent, 3059 - .get_fan_speed_percent = smu_get_fan_speed_percent, 3066 + .set_fan_speed_pwm = smu_set_fan_speed_pwm, 3067 + .get_fan_speed_pwm = smu_get_fan_speed_pwm, 3060 3068 .force_clock_level = smu_force_ppclk_levels, 3061 3069 .print_clock_levels = smu_print_ppclk_levels, 3062 3070 .force_performance_level = smu_force_performance_level,
+2 -2
drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c
··· 2270 2270 .print_clk_levels = arcturus_print_clk_levels, 2271 2271 .force_clk_levels = arcturus_force_clk_levels, 2272 2272 .read_sensor = arcturus_read_sensor, 2273 - .get_fan_speed_percent = smu_v11_0_get_fan_speed_percent, 2273 + .get_fan_speed_pwm = smu_v11_0_get_fan_speed_pwm, 2274 2274 .get_fan_speed_rpm = arcturus_get_fan_speed_rpm, 2275 2275 .get_power_profile_mode = arcturus_get_power_profile_mode, 2276 2276 .set_power_profile_mode = arcturus_set_power_profile_mode, ··· 2316 2316 .display_clock_voltage_request = smu_v11_0_display_clock_voltage_request, 2317 2317 .get_fan_control_mode = smu_v11_0_get_fan_control_mode, 2318 2318 .set_fan_control_mode = smu_v11_0_set_fan_control_mode, 2319 - .set_fan_speed_percent = smu_v11_0_set_fan_speed_percent, 2319 + .set_fan_speed_pwm = smu_v11_0_set_fan_speed_pwm, 2320 2320 .set_fan_speed_rpm = smu_v11_0_set_fan_speed_rpm, 2321 2321 .set_xgmi_pstate = smu_v11_0_set_xgmi_pstate, 2322 2322 .gfx_off_control = smu_v11_0_gfx_off_control,
+2 -2
drivers/gpu/drm/amd/pm/swsmu/smu11/navi10_ppt.c
··· 3227 3227 .display_config_changed = navi10_display_config_changed, 3228 3228 .notify_smc_display_config = navi10_notify_smc_display_config, 3229 3229 .is_dpm_running = navi10_is_dpm_running, 3230 - .get_fan_speed_percent = smu_v11_0_get_fan_speed_percent, 3230 + .get_fan_speed_pwm = smu_v11_0_get_fan_speed_pwm, 3231 3231 .get_fan_speed_rpm = navi10_get_fan_speed_rpm, 3232 3232 .get_power_profile_mode = navi10_get_power_profile_mode, 3233 3233 .set_power_profile_mode = navi10_set_power_profile_mode, ··· 3271 3271 .display_clock_voltage_request = smu_v11_0_display_clock_voltage_request, 3272 3272 .get_fan_control_mode = smu_v11_0_get_fan_control_mode, 3273 3273 .set_fan_control_mode = smu_v11_0_set_fan_control_mode, 3274 - .set_fan_speed_percent = smu_v11_0_set_fan_speed_percent, 3274 + .set_fan_speed_pwm = smu_v11_0_set_fan_speed_pwm, 3275 3275 .set_fan_speed_rpm = smu_v11_0_set_fan_speed_rpm, 3276 3276 .set_xgmi_pstate = smu_v11_0_set_xgmi_pstate, 3277 3277 .gfx_off_control = smu_v11_0_gfx_off_control,
+2 -2
drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c
··· 3852 3852 .display_config_changed = sienna_cichlid_display_config_changed, 3853 3853 .notify_smc_display_config = sienna_cichlid_notify_smc_display_config, 3854 3854 .is_dpm_running = sienna_cichlid_is_dpm_running, 3855 - .get_fan_speed_percent = smu_v11_0_get_fan_speed_percent, 3855 + .get_fan_speed_pwm = smu_v11_0_get_fan_speed_pwm, 3856 3856 .get_fan_speed_rpm = sienna_cichlid_get_fan_speed_rpm, 3857 3857 .get_power_profile_mode = sienna_cichlid_get_power_profile_mode, 3858 3858 .set_power_profile_mode = sienna_cichlid_set_power_profile_mode, ··· 3896 3896 .display_clock_voltage_request = smu_v11_0_display_clock_voltage_request, 3897 3897 .get_fan_control_mode = smu_v11_0_get_fan_control_mode, 3898 3898 .set_fan_control_mode = smu_v11_0_set_fan_control_mode, 3899 - .set_fan_speed_percent = smu_v11_0_set_fan_speed_percent, 3899 + .set_fan_speed_pwm = smu_v11_0_set_fan_speed_pwm, 3900 3900 .set_fan_speed_rpm = smu_v11_0_set_fan_speed_rpm, 3901 3901 .set_xgmi_pstate = smu_v11_0_set_xgmi_pstate, 3902 3902 .gfx_off_control = smu_v11_0_gfx_off_control,
+9 -13
drivers/gpu/drm/amd/pm/swsmu/smu11/smu_v11_0.c
··· 1200 1200 } 1201 1201 1202 1202 int 1203 - smu_v11_0_set_fan_speed_percent(struct smu_context *smu, uint32_t speed) 1203 + smu_v11_0_set_fan_speed_pwm(struct smu_context *smu, uint32_t speed) 1204 1204 { 1205 1205 struct amdgpu_device *adev = smu->adev; 1206 1206 uint32_t duty100, duty; 1207 1207 uint64_t tmp64; 1208 1208 1209 - if (speed > 100) 1210 - speed = 100; 1209 + speed = MIN(speed, 255); 1211 1210 1212 1211 if (smu_v11_0_auto_fan_control(smu, 0)) 1213 1212 return -EINVAL; ··· 1217 1218 return -EINVAL; 1218 1219 1219 1220 tmp64 = (uint64_t)speed * duty100; 1220 - do_div(tmp64, 100); 1221 + do_div(tmp64, 255); 1221 1222 duty = (uint32_t)tmp64; 1222 1223 1223 1224 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL0, ··· 1262 1263 return ret; 1263 1264 } 1264 1265 1265 - int smu_v11_0_get_fan_speed_percent(struct smu_context *smu, 1266 - uint32_t *speed) 1266 + int smu_v11_0_get_fan_speed_pwm(struct smu_context *smu, 1267 + uint32_t *speed) 1267 1268 { 1268 1269 struct amdgpu_device *adev = smu->adev; 1269 1270 uint32_t duty100, duty; ··· 1275 1276 * report the fan speed as 0 PWM if user just requested such. 1276 1277 */ 1277 1278 if ((smu->user_dpm_profile.flags & SMU_CUSTOM_FAN_SPEED_PWM) 1278 - && !smu->user_dpm_profile.fan_speed_percent) { 1279 + && !smu->user_dpm_profile.fan_speed_pwm) { 1279 1280 *speed = 0; 1280 1281 return 0; 1281 1282 } ··· 1287 1288 if (!duty100) 1288 1289 return -EINVAL; 1289 1290 1290 - tmp64 = (uint64_t)duty * 100; 1291 + tmp64 = (uint64_t)duty * 255; 1291 1292 do_div(tmp64, duty100); 1292 - *speed = (uint32_t)tmp64; 1293 - 1294 - if (*speed > 100) 1295 - *speed = 100; 1293 + *speed = MIN((uint32_t)tmp64, 255); 1296 1294 1297 1295 return 0; 1298 1296 } ··· 1330 1334 1331 1335 switch (mode) { 1332 1336 case AMD_FAN_CTRL_NONE: 1333 - ret = smu_v11_0_set_fan_speed_percent(smu, 100); 1337 + ret = smu_v11_0_set_fan_speed_pwm(smu, 255); 1334 1338 break; 1335 1339 case AMD_FAN_CTRL_MANUAL: 1336 1340 ret = smu_v11_0_auto_fan_control(smu, 0);