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

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'amd-drm-fixes-6.12-2024-11-16' of https://gitlab.freedesktop.org/agd5f/linux into drm-fixes

amd-drm-fixes-6.12-2024-11-16:

amdgpu:
- Revert a swsmu patch to fix a regression

Signed-off-by: Dave Airlie <airlied@redhat.com>

From: Alex Deucher <alexdeucher@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20241116145320.2507156-1-alexander.deucher@amd.com

Dave Airlie f48ab0a3 21c1c6c7

+36 -84
+14 -35
drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
··· 1259 smu->watermarks_bitmap = 0; 1260 smu->power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT; 1261 smu->default_power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT; 1262 - smu->user_dpm_profile.user_workload_mask = 0; 1263 1264 atomic_set(&smu->smu_power.power_gate.vcn_gated, 1); 1265 atomic_set(&smu->smu_power.power_gate.jpeg_gated, 1); 1266 atomic_set(&smu->smu_power.power_gate.vpe_gated, 1); 1267 atomic_set(&smu->smu_power.power_gate.umsch_mm_gated, 1); 1268 1269 - smu->workload_priority[PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT] = 0; 1270 - smu->workload_priority[PP_SMC_POWER_PROFILE_FULLSCREEN3D] = 1; 1271 - smu->workload_priority[PP_SMC_POWER_PROFILE_POWERSAVING] = 2; 1272 - smu->workload_priority[PP_SMC_POWER_PROFILE_VIDEO] = 3; 1273 - smu->workload_priority[PP_SMC_POWER_PROFILE_VR] = 4; 1274 - smu->workload_priority[PP_SMC_POWER_PROFILE_COMPUTE] = 5; 1275 - smu->workload_priority[PP_SMC_POWER_PROFILE_CUSTOM] = 6; 1276 1277 if (smu->is_apu || 1278 - !smu_is_workload_profile_available(smu, PP_SMC_POWER_PROFILE_FULLSCREEN3D)) { 1279 - smu->driver_workload_mask = 1280 - 1 << smu->workload_priority[PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT]; 1281 - } else { 1282 - smu->driver_workload_mask = 1283 - 1 << smu->workload_priority[PP_SMC_POWER_PROFILE_FULLSCREEN3D]; 1284 - smu->default_power_profile_mode = PP_SMC_POWER_PROFILE_FULLSCREEN3D; 1285 - } 1286 1287 - smu->workload_mask = smu->driver_workload_mask | 1288 - smu->user_dpm_profile.user_workload_mask; 1289 smu->workload_setting[0] = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT; 1290 smu->workload_setting[1] = PP_SMC_POWER_PROFILE_FULLSCREEN3D; 1291 smu->workload_setting[2] = PP_SMC_POWER_PROFILE_POWERSAVING; ··· 2348 return -EINVAL; 2349 2350 if (!en) { 2351 - smu->driver_workload_mask &= ~(1 << smu->workload_priority[type]); 2352 index = fls(smu->workload_mask); 2353 index = index > 0 && index <= WORKLOAD_POLICY_MAX ? index - 1 : 0; 2354 workload[0] = smu->workload_setting[index]; 2355 } else { 2356 - smu->driver_workload_mask |= (1 << smu->workload_priority[type]); 2357 index = fls(smu->workload_mask); 2358 index = index <= WORKLOAD_POLICY_MAX ? index - 1 : 0; 2359 workload[0] = smu->workload_setting[index]; 2360 } 2361 - 2362 - smu->workload_mask = smu->driver_workload_mask | 2363 - smu->user_dpm_profile.user_workload_mask; 2364 2365 if (smu_dpm_ctx->dpm_level != AMD_DPM_FORCED_LEVEL_MANUAL && 2366 smu_dpm_ctx->dpm_level != AMD_DPM_FORCED_LEVEL_PERF_DETERMINISM) ··· 3049 uint32_t param_size) 3050 { 3051 struct smu_context *smu = handle; 3052 - int ret; 3053 3054 if (!smu->pm_enabled || !smu->adev->pm.dpm_enabled || 3055 !smu->ppt_funcs->set_power_profile_mode) 3056 return -EOPNOTSUPP; 3057 3058 - if (smu->user_dpm_profile.user_workload_mask & 3059 - (1 << smu->workload_priority[param[param_size]])) 3060 - return 0; 3061 - 3062 - smu->user_dpm_profile.user_workload_mask = 3063 - (1 << smu->workload_priority[param[param_size]]); 3064 - smu->workload_mask = smu->user_dpm_profile.user_workload_mask | 3065 - smu->driver_workload_mask; 3066 - ret = smu_bump_power_profile_mode(smu, param, param_size); 3067 - 3068 - return ret; 3069 } 3070 3071 static int smu_get_fan_control_mode(void *handle, u32 *fan_mode)
··· 1259 smu->watermarks_bitmap = 0; 1260 smu->power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT; 1261 smu->default_power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT; 1262 1263 atomic_set(&smu->smu_power.power_gate.vcn_gated, 1); 1264 atomic_set(&smu->smu_power.power_gate.jpeg_gated, 1); 1265 atomic_set(&smu->smu_power.power_gate.vpe_gated, 1); 1266 atomic_set(&smu->smu_power.power_gate.umsch_mm_gated, 1); 1267 1268 + smu->workload_prority[PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT] = 0; 1269 + smu->workload_prority[PP_SMC_POWER_PROFILE_FULLSCREEN3D] = 1; 1270 + smu->workload_prority[PP_SMC_POWER_PROFILE_POWERSAVING] = 2; 1271 + smu->workload_prority[PP_SMC_POWER_PROFILE_VIDEO] = 3; 1272 + smu->workload_prority[PP_SMC_POWER_PROFILE_VR] = 4; 1273 + smu->workload_prority[PP_SMC_POWER_PROFILE_COMPUTE] = 5; 1274 + smu->workload_prority[PP_SMC_POWER_PROFILE_CUSTOM] = 6; 1275 1276 if (smu->is_apu || 1277 + !smu_is_workload_profile_available(smu, PP_SMC_POWER_PROFILE_FULLSCREEN3D)) 1278 + smu->workload_mask = 1 << smu->workload_prority[PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT]; 1279 + else 1280 + smu->workload_mask = 1 << smu->workload_prority[PP_SMC_POWER_PROFILE_FULLSCREEN3D]; 1281 1282 smu->workload_setting[0] = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT; 1283 smu->workload_setting[1] = PP_SMC_POWER_PROFILE_FULLSCREEN3D; 1284 smu->workload_setting[2] = PP_SMC_POWER_PROFILE_POWERSAVING; ··· 2355 return -EINVAL; 2356 2357 if (!en) { 2358 + smu->workload_mask &= ~(1 << smu->workload_prority[type]); 2359 index = fls(smu->workload_mask); 2360 index = index > 0 && index <= WORKLOAD_POLICY_MAX ? index - 1 : 0; 2361 workload[0] = smu->workload_setting[index]; 2362 } else { 2363 + smu->workload_mask |= (1 << smu->workload_prority[type]); 2364 index = fls(smu->workload_mask); 2365 index = index <= WORKLOAD_POLICY_MAX ? index - 1 : 0; 2366 workload[0] = smu->workload_setting[index]; 2367 } 2368 2369 if (smu_dpm_ctx->dpm_level != AMD_DPM_FORCED_LEVEL_MANUAL && 2370 smu_dpm_ctx->dpm_level != AMD_DPM_FORCED_LEVEL_PERF_DETERMINISM) ··· 3059 uint32_t param_size) 3060 { 3061 struct smu_context *smu = handle; 3062 3063 if (!smu->pm_enabled || !smu->adev->pm.dpm_enabled || 3064 !smu->ppt_funcs->set_power_profile_mode) 3065 return -EOPNOTSUPP; 3066 3067 + return smu_bump_power_profile_mode(smu, param, param_size); 3068 } 3069 3070 static int smu_get_fan_control_mode(void *handle, u32 *fan_mode)
+1 -3
drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h
··· 240 /* user clock state information */ 241 uint32_t clk_mask[SMU_CLK_COUNT]; 242 uint32_t clk_dependency; 243 - uint32_t user_workload_mask; 244 }; 245 246 #define SMU_TABLE_INIT(tables, table_id, s, a, d) \ ··· 557 bool disable_uclk_switch; 558 559 uint32_t workload_mask; 560 - uint32_t driver_workload_mask; 561 - uint32_t workload_priority[WORKLOAD_POLICY_MAX]; 562 uint32_t workload_setting[WORKLOAD_POLICY_MAX]; 563 uint32_t power_profile_mode; 564 uint32_t default_power_profile_mode;
··· 240 /* user clock state information */ 241 uint32_t clk_mask[SMU_CLK_COUNT]; 242 uint32_t clk_dependency; 243 }; 244 245 #define SMU_TABLE_INIT(tables, table_id, s, a, d) \ ··· 558 bool disable_uclk_switch; 559 560 uint32_t workload_mask; 561 + uint32_t workload_prority[WORKLOAD_POLICY_MAX]; 562 uint32_t workload_setting[WORKLOAD_POLICY_MAX]; 563 uint32_t power_profile_mode; 564 uint32_t default_power_profile_mode;
+3 -2
drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c
··· 1455 return -EINVAL; 1456 } 1457 1458 if ((profile_mode == PP_SMC_POWER_PROFILE_CUSTOM) && 1459 (smu->smc_fw_version >= 0x360d00)) { 1460 if (size != 10) ··· 1523 1524 ret = smu_cmn_send_smc_msg_with_param(smu, 1525 SMU_MSG_SetWorkloadMask, 1526 - smu->workload_mask, 1527 NULL); 1528 if (ret) { 1529 dev_err(smu->adev->dev, "Fail to set workload type %d\n", workload_type); 1530 return ret; 1531 } 1532 1533 - smu_cmn_assign_power_profile(smu); 1534 1535 return 0; 1536 }
··· 1455 return -EINVAL; 1456 } 1457 1458 + 1459 if ((profile_mode == PP_SMC_POWER_PROFILE_CUSTOM) && 1460 (smu->smc_fw_version >= 0x360d00)) { 1461 if (size != 10) ··· 1522 1523 ret = smu_cmn_send_smc_msg_with_param(smu, 1524 SMU_MSG_SetWorkloadMask, 1525 + 1 << workload_type, 1526 NULL); 1527 if (ret) { 1528 dev_err(smu->adev->dev, "Fail to set workload type %d\n", workload_type); 1529 return ret; 1530 } 1531 1532 + smu->power_profile_mode = profile_mode; 1533 1534 return 0; 1535 }
+1 -4
drivers/gpu/drm/amd/pm/swsmu/smu11/navi10_ppt.c
··· 2081 smu->power_profile_mode); 2082 if (workload_type < 0) 2083 return -EINVAL; 2084 - 2085 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetWorkloadMask, 2086 - smu->workload_mask, NULL); 2087 if (ret) 2088 dev_err(smu->adev->dev, "[%s] Failed to set work load mask!", __func__); 2089 - else 2090 - smu_cmn_assign_power_profile(smu); 2091 2092 return ret; 2093 }
··· 2081 smu->power_profile_mode); 2082 if (workload_type < 0) 2083 return -EINVAL; 2084 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetWorkloadMask, 2085 + 1 << workload_type, NULL); 2086 if (ret) 2087 dev_err(smu->adev->dev, "[%s] Failed to set work load mask!", __func__); 2088 2089 return ret; 2090 }
+1 -4
drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c
··· 1786 smu->power_profile_mode); 1787 if (workload_type < 0) 1788 return -EINVAL; 1789 - 1790 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetWorkloadMask, 1791 - smu->workload_mask, NULL); 1792 if (ret) 1793 dev_err(smu->adev->dev, "[%s] Failed to set work load mask!", __func__); 1794 - else 1795 - smu_cmn_assign_power_profile(smu); 1796 1797 return ret; 1798 }
··· 1786 smu->power_profile_mode); 1787 if (workload_type < 0) 1788 return -EINVAL; 1789 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetWorkloadMask, 1790 + 1 << workload_type, NULL); 1791 if (ret) 1792 dev_err(smu->adev->dev, "[%s] Failed to set work load mask!", __func__); 1793 1794 return ret; 1795 }
+2 -2
drivers/gpu/drm/amd/pm/swsmu/smu11/vangogh_ppt.c
··· 1079 } 1080 1081 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_ActiveProcessNotify, 1082 - smu->workload_mask, 1083 NULL); 1084 if (ret) { 1085 dev_err_once(smu->adev->dev, "Fail to set workload type %d\n", ··· 1087 return ret; 1088 } 1089 1090 - smu_cmn_assign_power_profile(smu); 1091 1092 return 0; 1093 }
··· 1079 } 1080 1081 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_ActiveProcessNotify, 1082 + 1 << workload_type, 1083 NULL); 1084 if (ret) { 1085 dev_err_once(smu->adev->dev, "Fail to set workload type %d\n", ··· 1087 return ret; 1088 } 1089 1090 + smu->power_profile_mode = profile_mode; 1091 1092 return 0; 1093 }
+2 -2
drivers/gpu/drm/amd/pm/swsmu/smu12/renoir_ppt.c
··· 890 } 891 892 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_ActiveProcessNotify, 893 - smu->workload_mask, 894 NULL); 895 if (ret) { 896 dev_err_once(smu->adev->dev, "Fail to set workload type %d\n", workload_type); 897 return ret; 898 } 899 900 - smu_cmn_assign_power_profile(smu); 901 902 return 0; 903 }
··· 890 } 891 892 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_ActiveProcessNotify, 893 + 1 << workload_type, 894 NULL); 895 if (ret) { 896 dev_err_once(smu->adev->dev, "Fail to set workload type %d\n", workload_type); 897 return ret; 898 } 899 900 + smu->power_profile_mode = profile_mode; 901 902 return 0; 903 }
+5 -15
drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c
··· 2485 DpmActivityMonitorCoeffInt_t *activity_monitor = 2486 &(activity_monitor_external.DpmActivityMonitorCoeffInt); 2487 int workload_type, ret = 0; 2488 - u32 workload_mask; 2489 2490 smu->power_profile_mode = input[size]; 2491 ··· 2552 if (workload_type < 0) 2553 return -EINVAL; 2554 2555 - workload_mask = 1 << workload_type; 2556 2557 /* Add optimizations for SMU13.0.0/10. Reuse the power saving profile */ 2558 if ((amdgpu_ip_version(smu->adev, MP1_HWIP, 0) == IP_VERSION(13, 0, 0) && ··· 2567 workload_mask |= 1 << workload_type; 2568 } 2569 2570 - smu->workload_mask |= workload_mask; 2571 ret = smu_cmn_send_smc_msg_with_param(smu, 2572 SMU_MSG_SetWorkloadMask, 2573 - smu->workload_mask, 2574 NULL); 2575 - if (!ret) { 2576 - smu_cmn_assign_power_profile(smu); 2577 - if (smu->power_profile_mode == PP_SMC_POWER_PROFILE_POWERSAVING) { 2578 - workload_type = smu_cmn_to_asic_specific_index(smu, 2579 - CMN2ASIC_MAPPING_WORKLOAD, 2580 - PP_SMC_POWER_PROFILE_FULLSCREEN3D); 2581 - smu->power_profile_mode = smu->workload_mask & (1 << workload_type) 2582 - ? PP_SMC_POWER_PROFILE_FULLSCREEN3D 2583 - : PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT; 2584 - } 2585 - } 2586 2587 return ret; 2588 }
··· 2485 DpmActivityMonitorCoeffInt_t *activity_monitor = 2486 &(activity_monitor_external.DpmActivityMonitorCoeffInt); 2487 int workload_type, ret = 0; 2488 + u32 workload_mask, selected_workload_mask; 2489 2490 smu->power_profile_mode = input[size]; 2491 ··· 2552 if (workload_type < 0) 2553 return -EINVAL; 2554 2555 + selected_workload_mask = workload_mask = 1 << workload_type; 2556 2557 /* Add optimizations for SMU13.0.0/10. Reuse the power saving profile */ 2558 if ((amdgpu_ip_version(smu->adev, MP1_HWIP, 0) == IP_VERSION(13, 0, 0) && ··· 2567 workload_mask |= 1 << workload_type; 2568 } 2569 2570 ret = smu_cmn_send_smc_msg_with_param(smu, 2571 SMU_MSG_SetWorkloadMask, 2572 + workload_mask, 2573 NULL); 2574 + if (!ret) 2575 + smu->workload_mask = selected_workload_mask; 2576 2577 return ret; 2578 }
+2 -3
drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c
··· 2499 smu->power_profile_mode); 2500 if (workload_type < 0) 2501 return -EINVAL; 2502 - 2503 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetWorkloadMask, 2504 - smu->workload_mask, NULL); 2505 2506 if (ret) 2507 dev_err(smu->adev->dev, "[%s] Failed to set work load mask!", __func__); 2508 else 2509 - smu_cmn_assign_power_profile(smu); 2510 2511 return ret; 2512 }
··· 2499 smu->power_profile_mode); 2500 if (workload_type < 0) 2501 return -EINVAL; 2502 ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetWorkloadMask, 2503 + 1 << workload_type, NULL); 2504 2505 if (ret) 2506 dev_err(smu->adev->dev, "[%s] Failed to set work load mask!", __func__); 2507 else 2508 + smu->workload_mask = (1 << workload_type); 2509 2510 return ret; 2511 }
+5 -4
drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0_2_ppt.c
··· 1807 if (workload_type < 0) 1808 return -EINVAL; 1809 1810 - ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetWorkloadMask, 1811 - smu->workload_mask, NULL); 1812 - 1813 if (!ret) 1814 - smu_cmn_assign_power_profile(smu); 1815 1816 return ret; 1817 }
··· 1807 if (workload_type < 0) 1808 return -EINVAL; 1809 1810 + ret = smu_cmn_send_smc_msg_with_param(smu, 1811 + SMU_MSG_SetWorkloadMask, 1812 + 1 << workload_type, 1813 + NULL); 1814 if (!ret) 1815 + smu->workload_mask = 1 << workload_type; 1816 1817 return ret; 1818 }
-8
drivers/gpu/drm/amd/pm/swsmu/smu_cmn.c
··· 1138 return ret; 1139 } 1140 1141 - void smu_cmn_assign_power_profile(struct smu_context *smu) 1142 - { 1143 - uint32_t index; 1144 - index = fls(smu->workload_mask); 1145 - index = index > 0 && index <= WORKLOAD_POLICY_MAX ? index - 1 : 0; 1146 - smu->power_profile_mode = smu->workload_setting[index]; 1147 - } 1148 - 1149 bool smu_cmn_is_audio_func_enabled(struct amdgpu_device *adev) 1150 { 1151 struct pci_dev *p = NULL;
··· 1138 return ret; 1139 } 1140 1141 bool smu_cmn_is_audio_func_enabled(struct amdgpu_device *adev) 1142 { 1143 struct pci_dev *p = NULL;
-2
drivers/gpu/drm/amd/pm/swsmu/smu_cmn.h
··· 130 int smu_cmn_set_mp1_state(struct smu_context *smu, 131 enum pp_mp1_state mp1_state); 132 133 - void smu_cmn_assign_power_profile(struct smu_context *smu); 134 - 135 /* 136 * Helper function to make sysfs_emit_at() happy. Align buf to 137 * the current page boundary and record the offset.
··· 130 int smu_cmn_set_mp1_state(struct smu_context *smu, 131 enum pp_mp1_state mp1_state); 132 133 /* 134 * Helper function to make sysfs_emit_at() happy. Align buf to 135 * the current page boundary and record the offset.