diff options
Diffstat (limited to 'common/recipes-kernel/linux/files/0048-drm-amd-powerplay-add-event-manager-sub-component.patch')
| -rw-r--r-- | common/recipes-kernel/linux/files/0048-drm-amd-powerplay-add-event-manager-sub-component.patch | 2664 |
1 files changed, 2664 insertions, 0 deletions
diff --git a/common/recipes-kernel/linux/files/0048-drm-amd-powerplay-add-event-manager-sub-component.patch b/common/recipes-kernel/linux/files/0048-drm-amd-powerplay-add-event-manager-sub-component.patch new file mode 100644 index 00000000..482edcb3 --- /dev/null +++ b/common/recipes-kernel/linux/files/0048-drm-amd-powerplay-add-event-manager-sub-component.patch @@ -0,0 +1,2664 @@ +From 38aada7e86d4605b3edc269dfaa48637a16426b0 Mon Sep 17 00:00:00 2001 +From: Rex Zhu <Rex.Zhu@amd.com> +Date: Wed, 23 Sep 2015 15:14:54 +0800 +Subject: [PATCH 0048/1110] drm/amd/powerplay: add event manager sub-component + +The event manager handles power related driver events. + +Signed-off-by: Rex Zhu <Rex.Zhu@amd.com> +Reviewed-by: Jammy Zhou <Jammy.Zhou@amd.com> +Reviewed-by: Alex Deucher <alexander.deucher@amd.com> +--- + drivers/gpu/drm/amd/powerplay/Makefile | 2 +- + drivers/gpu/drm/amd/powerplay/amd_powerplay.c | 23 ++ + drivers/gpu/drm/amd/powerplay/eventmgr/Makefile | 11 + + .../drm/amd/powerplay/eventmgr/eventactionchains.c | 287 +++++++++++++++ + .../drm/amd/powerplay/eventmgr/eventactionchains.h | 62 ++++ + drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.c | 180 +++++++++ + drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.h | 34 ++ + .../drm/amd/powerplay/eventmgr/eventmanagement.c | 215 +++++++++++ + .../drm/amd/powerplay/eventmgr/eventmanagement.h | 59 +++ + drivers/gpu/drm/amd/powerplay/eventmgr/eventmgr.c | 114 ++++++ + .../drm/amd/powerplay/eventmgr/eventsubchains.c | 395 ++++++++++++++++++++ + .../drm/amd/powerplay/eventmgr/eventsubchains.h | 98 +++++ + .../gpu/drm/amd/powerplay/eventmgr/eventtasks.c | 408 +++++++++++++++++++++ + .../gpu/drm/amd/powerplay/eventmgr/eventtasks.h | 85 +++++ + drivers/gpu/drm/amd/powerplay/eventmgr/psm.c | 111 ++++++ + drivers/gpu/drm/amd/powerplay/eventmgr/psm.h | 37 ++ + drivers/gpu/drm/amd/powerplay/inc/eventmanager.h | 109 ++++++ + drivers/gpu/drm/amd/powerplay/inc/eventmgr.h | 125 +++++++ + drivers/gpu/drm/amd/powerplay/inc/pp_feature.h | 67 ++++ + drivers/gpu/drm/amd/powerplay/inc/pp_instance.h | 2 + + 20 files changed, 2423 insertions(+), 1 deletion(-) + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/Makefile + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.h + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.c + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.h + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.c + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.h + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventmgr.c + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.c + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.h + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.c + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.h + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/psm.c + create mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/psm.h + create mode 100644 drivers/gpu/drm/amd/powerplay/inc/eventmanager.h + create mode 100644 drivers/gpu/drm/amd/powerplay/inc/eventmgr.h + create mode 100644 drivers/gpu/drm/amd/powerplay/inc/pp_feature.h + +diff --git a/drivers/gpu/drm/amd/powerplay/Makefile b/drivers/gpu/drm/amd/powerplay/Makefile +index 6359c67..0231021 100644 +--- a/drivers/gpu/drm/amd/powerplay/Makefile ++++ b/drivers/gpu/drm/amd/powerplay/Makefile +@@ -6,7 +6,7 @@ subdir-ccflags-y += -Iinclude/drm \ + + AMD_PP_PATH = ../powerplay + +-PP_LIBS = smumgr hwmgr ++PP_LIBS = smumgr hwmgr eventmgr + + AMD_POWERPLAY = $(addsuffix /Makefile,$(addprefix drivers/gpu/drm/amd/powerplay/,$(PP_LIBS))) + +diff --git a/drivers/gpu/drm/amd/powerplay/amd_powerplay.c b/drivers/gpu/drm/amd/powerplay/amd_powerplay.c +index 88fdb04..1964a2a 100644 +--- a/drivers/gpu/drm/amd/powerplay/amd_powerplay.c ++++ b/drivers/gpu/drm/amd/powerplay/amd_powerplay.c +@@ -52,6 +52,7 @@ static int pp_sw_init(void *handle) + return -EINVAL; + + ret = hwmgr->pptable_func->pptable_init(hwmgr); ++ + if (ret == 0) + ret = hwmgr->hwmgr_func->backend_init(hwmgr); + +@@ -81,6 +82,7 @@ static int pp_hw_init(void *handle) + { + struct pp_instance *pp_handle; + struct pp_smumgr *smumgr; ++ struct pp_eventmgr *eventmgr; + int ret = 0; + + if (handle == NULL) +@@ -106,8 +108,14 @@ static int pp_hw_init(void *handle) + smumgr->smumgr_funcs->smu_fini(smumgr); + return ret; + } ++ + hw_init_power_state_table(pp_handle->hwmgr); ++ eventmgr = pp_handle->eventmgr; + ++ if (eventmgr == NULL || eventmgr->pp_eventmgr_init == NULL) ++ return -EINVAL; ++ ++ ret = eventmgr->pp_eventmgr_init(eventmgr); + return 0; + } + +@@ -115,11 +123,17 @@ static int pp_hw_fini(void *handle) + { + struct pp_instance *pp_handle; + struct pp_smumgr *smumgr; ++ struct pp_eventmgr *eventmgr; + + if (handle == NULL) + return -EINVAL; + + pp_handle = (struct pp_instance *)handle; ++ eventmgr = pp_handle->eventmgr; ++ ++ if (eventmgr != NULL || eventmgr->pp_eventmgr_fini != NULL) ++ eventmgr->pp_eventmgr_fini(eventmgr); ++ + smumgr = pp_handle->smu_mgr; + + if (smumgr != NULL || smumgr->smumgr_funcs != NULL || +@@ -273,9 +287,15 @@ static int amd_pp_instance_init(struct amd_pp_init *pp_init, + if (ret) + goto fail_hwmgr; + ++ ret = eventmgr_init(handle); ++ if (ret) ++ goto fail_eventmgr; ++ + amd_pp->pp_handle = handle; + return 0; + ++fail_eventmgr: ++ hwmgr_fini(handle->hwmgr); + fail_hwmgr: + smum_fini(handle->smu_mgr); + fail_smum: +@@ -286,9 +306,12 @@ fail_smum: + static int amd_pp_instance_fini(void *handle) + { + struct pp_instance *instance = (struct pp_instance *)handle; ++ + if (instance == NULL) + return -EINVAL; + ++ eventmgr_fini(instance->eventmgr); ++ + hwmgr_fini(instance->hwmgr); + + smum_fini(instance->smu_mgr); +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/Makefile b/drivers/gpu/drm/amd/powerplay/eventmgr/Makefile +new file mode 100644 +index 0000000..7509e38 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/Makefile +@@ -0,0 +1,11 @@ ++# ++# Makefile for the 'event manager' sub-component of powerplay. ++# It provides the event management services for the driver. ++ ++EVENT_MGR = eventmgr.o eventinit.o eventmanagement.o \ ++ eventactionchains.o eventsubchains.o eventtasks.o psm.o ++ ++AMD_PP_EVENT = $(addprefix $(AMD_PP_PATH)/eventmgr/,$(EVENT_MGR)) ++ ++AMD_POWERPLAY_FILES += $(AMD_PP_EVENT) ++ +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c b/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c +new file mode 100644 +index 0000000..e9fe85f +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c +@@ -0,0 +1,287 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++#include "eventmgr.h" ++#include "eventactionchains.h" ++#include "eventsubchains.h" ++ ++static const pem_event_action *initialize_event[] = { ++ block_adjust_power_state_tasks, ++ power_budget_tasks, ++ system_config_tasks, ++ setup_asic_tasks, ++ enable_dynamic_state_management_tasks, ++ enable_clock_power_gatings_tasks, ++ get_2d_performance_state_tasks, ++ set_performance_state_tasks, ++ conditionally_force_3d_performance_state_tasks, ++ process_vbios_eventinfo_tasks, ++ broadcast_power_policy_tasks, ++ NULL ++}; ++ ++const struct action_chain initialize_action_chain = { ++ "Initialize", ++ initialize_event ++}; ++ ++static const pem_event_action *uninitialize_event[] = { ++ ungate_all_display_phys_tasks, ++ uninitialize_display_phy_access_tasks, ++ disable_gfx_voltage_island_power_gating_tasks, ++ disable_gfx_clock_gating_tasks, ++ set_boot_state_tasks, ++ adjust_power_state_tasks, ++ disable_dynamic_state_management_tasks, ++ disable_clock_power_gatings_tasks, ++ cleanup_asic_tasks, ++ prepare_for_pnp_stop_tasks, ++ NULL ++}; ++ ++const struct action_chain uninitialize_action_chain = { ++ "Uninitialize", ++ uninitialize_event ++}; ++ ++static const pem_event_action *power_source_change_event_pp_enabled[] = { ++ set_power_source_tasks, ++ set_power_saving_state_tasks, ++ adjust_power_state_tasks, ++ enable_disable_fps_tasks, ++ set_nbmcu_state_tasks, ++ broadcast_power_policy_tasks, ++ NULL ++}; ++ ++const struct action_chain power_source_change_action_chain_pp_enabled = { ++ "Power source change - PowerPlay enabled", ++ power_source_change_event_pp_enabled ++}; ++ ++static const pem_event_action *power_source_change_event_pp_disabled[] = { ++ set_power_source_tasks, ++ set_nbmcu_state_tasks, ++ NULL ++}; ++ ++const struct action_chain power_source_changes_action_chain_pp_disabled = { ++ "Power source change - PowerPlay disabled", ++ power_source_change_event_pp_disabled ++}; ++ ++static const pem_event_action *power_source_change_event_hardware_dc[] = { ++ set_power_source_tasks, ++ set_power_saving_state_tasks, ++ adjust_power_state_tasks, ++ enable_disable_fps_tasks, ++ reset_hardware_dc_notification_tasks, ++ set_nbmcu_state_tasks, ++ broadcast_power_policy_tasks, ++ NULL ++}; ++ ++const struct action_chain power_source_change_action_chain_hardware_dc = { ++ "Power source change - with Hardware DC switching", ++ power_source_change_event_hardware_dc ++}; ++ ++static const pem_event_action *suspend_event[] = { ++ reset_display_phy_access_tasks, ++ unregister_interrupt_tasks, ++ disable_gfx_voltage_island_power_gating_tasks, ++ disable_gfx_clock_gating_tasks, ++ notify_smu_suspend_tasks, ++ disable_smc_firmware_ctf_tasks, ++ set_boot_state_tasks, ++ adjust_power_state_tasks, ++ disable_fps_tasks, ++ vari_bright_suspend_tasks, ++ reset_fan_speed_to_default_tasks, ++ power_down_asic_tasks, ++ disable_stutter_mode_tasks, ++ set_connected_standby_tasks, ++ block_hw_access_tasks, ++ NULL ++}; ++ ++const struct action_chain suspend_action_chain = { ++ "Suspend", ++ suspend_event ++}; ++ ++static const pem_event_action *resume_event[] = { ++ unblock_hw_access_tasks, ++ resume_connected_standby_tasks, ++ notify_smu_resume_tasks, ++ reset_display_configCounter_tasks, ++ update_dal_configuration_tasks, ++ vari_bright_resume_tasks, ++ block_adjust_power_state_tasks, ++ setup_asic_tasks, ++ enable_stutter_mode_tasks, /*must do this in boot state and before SMC is started */ ++ enable_dynamic_state_management_tasks, ++ enable_clock_power_gatings_tasks, ++ enable_disable_bapm_tasks, ++ reset_boot_state_tasks, ++ adjust_power_state_tasks, ++ enable_disable_fps_tasks, ++ notify_hw_power_source_tasks, ++ process_vbios_event_info_tasks, ++ enable_gfx_clock_gating_tasks, ++ enable_gfx_voltage_island_power_gating_tasks, ++ reset_clock_gating_tasks, ++ notify_smu_vpu_recovery_end_tasks, ++ disable_vpu_cap_tasks, ++ execute_escape_sequence_tasks, ++ NULL ++}; ++ ++ ++const struct action_chain resume_action_chain = { ++ "resume", ++ resume_event ++}; ++ ++static const pem_event_action *complete_init_event[] = { ++ adjust_power_state_tasks, ++ enable_gfx_clock_gating_tasks, ++ enable_gfx_voltage_island_power_gating_tasks, ++ notify_power_state_change_tasks, ++ NULL ++}; ++ ++const struct action_chain complete_init_action_chain = { ++ "complete init", ++ complete_init_event ++}; ++ ++static const pem_event_action *enable_gfx_clock_gating_event[] = { ++ enable_gfx_clock_gating_tasks, ++ NULL ++}; ++ ++const struct action_chain enable_gfx_clock_gating_action_chain = { ++ "enable gfx clock gate", ++ enable_gfx_clock_gating_event ++}; ++ ++static const pem_event_action *disable_gfx_clock_gating_event[] = { ++ disable_gfx_clock_gating_tasks, ++ NULL ++}; ++ ++const struct action_chain disable_gfx_clock_gating_action_chain = { ++ "disable gfx clock gate", ++ disable_gfx_clock_gating_event ++}; ++ ++static const pem_event_action *enable_cgpg_event[] = { ++ enable_cgpg_tasks, ++ NULL ++}; ++ ++const struct action_chain enable_cgpg_action_chain = { ++ "eable cg pg", ++ enable_cgpg_event ++}; ++ ++static const pem_event_action *disable_cgpg_event[] = { ++ disable_cgpg_tasks, ++ NULL ++}; ++ ++const struct action_chain disable_cgpg_action_chain = { ++ "disable cg pg", ++ disable_cgpg_event ++}; ++ ++ ++/* Enable user _2d performance and activate */ ++ ++static const pem_event_action *enable_user_state_event[] = { ++ create_new_user_performance_state_tasks, ++ adjust_power_state_tasks, ++ NULL ++}; ++ ++const struct action_chain enable_user_state_action_chain = { ++ "Enable user state", ++ enable_user_state_event ++}; ++ ++static const pem_event_action *enable_user_2d_performance_event[] = { ++ enable_user_2d_performance_tasks, ++ add_user_2d_performance_state_tasks, ++ set_performance_state_tasks, ++ adjust_power_state_tasks, ++ delete_user_2d_performance_state_tasks, ++ NULL ++}; ++ ++const struct action_chain enable_user_2d_performance_action_chain = { ++ "enable_user_2d_performance_event_activate", ++ enable_user_2d_performance_event ++}; ++ ++ ++static const pem_event_action *disable_user_2d_performance_event[] = { ++ disable_user_2d_performance_tasks, ++ delete_user_2d_performance_state_tasks, ++ NULL ++}; ++ ++const struct action_chain disable_user_2d_performance_action_chain = { ++ "disable_user_2d_performance_event", ++ disable_user_2d_performance_event ++}; ++ ++ ++static const pem_event_action *display_config_change_event[] = { ++ /* countDisplayConfigurationChangeEventTasks, */ ++ unblock_adjust_power_state_tasks, ++ /* setCPUPowerState,*/ ++ notify_hw_power_source_tasks, ++ /* updateDALConfigurationTasks, ++ variBrightDisplayConfigurationChangeTasks, */ ++ adjust_power_state_tasks, ++ /*enableDisableFPSTasks, ++ setNBMCUStateTasks, ++ notifyPCIEDeviceReadyTasks,*/ ++ NULL ++}; ++ ++const struct action_chain display_config_change_action_chain = { ++ "Display configuration change", ++ display_config_change_event ++}; ++ ++static const pem_event_action *readjust_power_state_event[] = { ++ adjust_power_state_tasks, ++ NULL ++}; ++ ++const struct action_chain readjust_power_state_action_chain = { ++ "re-adjust power state", ++ readjust_power_state_event ++}; ++ +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.h b/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.h +new file mode 100644 +index 0000000..f181e53 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.h +@@ -0,0 +1,62 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++#ifndef _EVENT_ACTION_CHAINS_H_ ++#define _EVENT_ACTION_CHAINS_H_ ++#include "eventmgr.h" ++ ++extern const struct action_chain initialize_action_chain; ++ ++extern const struct action_chain uninitialize_action_chain; ++ ++extern const struct action_chain power_source_change_action_chain_pp_enabled; ++ ++extern const struct action_chain power_source_changes_action_chain_pp_disabled; ++ ++extern const struct action_chain power_source_change_action_chain_hardware_dc; ++ ++extern const struct action_chain suspend_action_chain; ++ ++extern const struct action_chain resume_action_chain; ++ ++extern const struct action_chain complete_init_action_chain; ++ ++extern const struct action_chain enable_gfx_clock_gating_action_chain; ++ ++extern const struct action_chain disable_gfx_clock_gating_action_chain; ++ ++extern const struct action_chain enable_cgpg_action_chain; ++ ++extern const struct action_chain disable_cgpg_action_chain; ++ ++extern const struct action_chain enable_user_2d_performance_action_chain; ++ ++extern const struct action_chain disable_user_2d_performance_action_chain; ++ ++extern const struct action_chain enable_user_state_action_chain; ++ ++extern const struct action_chain readjust_power_state_action_chain; ++ ++extern const struct action_chain display_config_change_action_chain; ++ ++#endif /*_EVENT_ACTION_CHAINS_H_*/ ++ +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.c b/drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.c +new file mode 100644 +index 0000000..0438442 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.c +@@ -0,0 +1,180 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++#include "eventmgr.h" ++#include "eventinit.h" ++ ++void pem_init_feature_info(struct pp_eventmgr *eventmgr) ++{ ++ ++ /* PowerPlay info */ ++ eventmgr->ui_state_info[PP_PowerSource_AC].default_ui_lable = ++ PP_StateUILabel_Performance; ++ ++ eventmgr->ui_state_info[PP_PowerSource_AC].current_ui_label = ++ PP_StateUILabel_Performance; ++ ++ eventmgr->ui_state_info[PP_PowerSource_DC].default_ui_lable = ++ PP_StateUILabel_Battery; ++ ++ eventmgr->ui_state_info[PP_PowerSource_DC].current_ui_label = ++ PP_StateUILabel_Battery; ++ ++ if (phm_cap_enabled(eventmgr->platform_descriptor->platformCaps, PHM_PlatformCaps_PowerPlaySupport)) { ++ eventmgr->features[PP_Feature_PowerPlay].supported = true; ++ eventmgr->features[PP_Feature_PowerPlay].version = PEM_CURRENT_POWERPLAY_FEATURE_VERSION; ++ eventmgr->features[PP_Feature_PowerPlay].enabled_default = true; ++ eventmgr->features[PP_Feature_PowerPlay].enabled = true; ++ } else { ++ eventmgr->features[PP_Feature_PowerPlay].supported = false; ++ eventmgr->features[PP_Feature_PowerPlay].enabled = false; ++ eventmgr->features[PP_Feature_PowerPlay].enabled_default = false; ++ } ++ ++ eventmgr->features[PP_Feature_Force3DClock].supported = true; ++ eventmgr->features[PP_Feature_Force3DClock].enabled = false; ++ eventmgr->features[PP_Feature_Force3DClock].enabled_default = false; ++ eventmgr->features[PP_Feature_Force3DClock].version = 1; ++ ++ /* over drive*/ ++ eventmgr->features[PP_Feature_User2DPerformance].version = 4; ++ eventmgr->features[PP_Feature_User3DPerformance].version = 4; ++ eventmgr->features[PP_Feature_OverdriveTest].version = 4; ++ ++ eventmgr->features[PP_Feature_OverDrive].version = 4; ++ eventmgr->features[PP_Feature_OverDrive].enabled = false; ++ eventmgr->features[PP_Feature_OverDrive].enabled_default = false; ++ ++ eventmgr->features[PP_Feature_User2DPerformance].supported = false; ++ eventmgr->features[PP_Feature_User2DPerformance].enabled = false; ++ eventmgr->features[PP_Feature_User2DPerformance].enabled_default = false; ++ ++ eventmgr->features[PP_Feature_User3DPerformance].supported = false; ++ eventmgr->features[PP_Feature_User3DPerformance].enabled = false; ++ eventmgr->features[PP_Feature_User3DPerformance].enabled_default = false; ++ ++ eventmgr->features[PP_Feature_OverdriveTest].supported = false; ++ eventmgr->features[PP_Feature_OverdriveTest].enabled = false; ++ eventmgr->features[PP_Feature_OverdriveTest].enabled_default = false; ++ ++ eventmgr->features[PP_Feature_OverDrive].supported = false; ++ ++ eventmgr->features[PP_Feature_PowerBudgetWaiver].enabled_default = false; ++ eventmgr->features[PP_Feature_PowerBudgetWaiver].version = 1; ++ eventmgr->features[PP_Feature_PowerBudgetWaiver].supported = false; ++ eventmgr->features[PP_Feature_PowerBudgetWaiver].enabled = false; ++ ++ /* Multi UVD States support */ ++ eventmgr->features[PP_Feature_MultiUVDState].supported = false; ++ eventmgr->features[PP_Feature_MultiUVDState].enabled = false; ++ eventmgr->features[PP_Feature_MultiUVDState].enabled_default = false; ++ ++ /* Dynamic UVD States support */ ++ eventmgr->features[PP_Feature_DynamicUVDState].supported = false; ++ eventmgr->features[PP_Feature_DynamicUVDState].enabled = false; ++ eventmgr->features[PP_Feature_DynamicUVDState].enabled_default = false; ++ ++ /* VCE DPM support */ ++ eventmgr->features[PP_Feature_VCEDPM].supported = false; ++ eventmgr->features[PP_Feature_VCEDPM].enabled = false; ++ eventmgr->features[PP_Feature_VCEDPM].enabled_default = false; ++ ++ /* ACP PowerGating support */ ++ eventmgr->features[PP_Feature_ACP_POWERGATING].supported = false; ++ eventmgr->features[PP_Feature_ACP_POWERGATING].enabled = false; ++ eventmgr->features[PP_Feature_ACP_POWERGATING].enabled_default = false; ++ ++ /* PPM support */ ++ eventmgr->features[PP_Feature_PPM].version = 1; ++ eventmgr->features[PP_Feature_PPM].supported = false; ++ eventmgr->features[PP_Feature_PPM].enabled = false; ++ ++ /* FFC support (enables fan and temp settings, Gemini needs temp settings) */ ++ if (phm_cap_enabled(eventmgr->platform_descriptor->platformCaps, PHM_PlatformCaps_ODFuzzyFanControlSupport) || ++ phm_cap_enabled(eventmgr->platform_descriptor->platformCaps, PHM_PlatformCaps_GeminiRegulatorFanControlSupport)) { ++ eventmgr->features[PP_Feature_FFC].version = 1; ++ eventmgr->features[PP_Feature_FFC].supported = true; ++ eventmgr->features[PP_Feature_FFC].enabled = true; ++ eventmgr->features[PP_Feature_FFC].enabled_default = true; ++ } else { ++ eventmgr->features[PP_Feature_FFC].supported = false; ++ eventmgr->features[PP_Feature_FFC].enabled = false; ++ eventmgr->features[PP_Feature_FFC].enabled_default = false; ++ } ++ ++ eventmgr->features[PP_Feature_VariBright].supported = false; ++ eventmgr->features[PP_Feature_VariBright].enabled = false; ++ eventmgr->features[PP_Feature_VariBright].enabled_default = false; ++ ++ eventmgr->features[PP_Feature_BACO].supported = false; ++ eventmgr->features[PP_Feature_BACO].supported = false; ++ eventmgr->features[PP_Feature_BACO].enabled_default = false; ++ ++ /* PowerDown feature support */ ++ eventmgr->features[PP_Feature_PowerDown].supported = false; ++ eventmgr->features[PP_Feature_PowerDown].enabled = false; ++ eventmgr->features[PP_Feature_PowerDown].enabled_default = false; ++ ++ eventmgr->features[PP_Feature_FPS].version = 1; ++ eventmgr->features[PP_Feature_FPS].supported = false; ++ eventmgr->features[PP_Feature_FPS].enabled_default = false; ++ eventmgr->features[PP_Feature_FPS].enabled = false; ++ ++ eventmgr->features[PP_Feature_ViPG].version = 1; ++ eventmgr->features[PP_Feature_ViPG].supported = false; ++ eventmgr->features[PP_Feature_ViPG].enabled_default = false; ++ eventmgr->features[PP_Feature_ViPG].enabled = false; ++} ++ ++int pem_register_interrupts(struct pp_eventmgr *eventmgr) ++{ ++ int result = 0; ++ ++ /* TODO: ++ * 1. Register thermal events interrupt ++ * 2. Register CTF event interrupt ++ * 3. Register for vbios events interrupt ++ * 4. Register External Throttle Interrupt ++ * 5. Register Smc To Host Interrupt ++ * */ ++ return result; ++} ++ ++ ++int pem_unregister_interrupts(struct pp_eventmgr *eventmgr) ++{ ++ return 0; ++} ++ ++ ++void pem_uninit_featureInfo(struct pp_eventmgr *eventmgr) ++{ ++ eventmgr->features[PP_Feature_MultiUVDState].supported = false; ++ eventmgr->features[PP_Feature_VariBright].supported = false; ++ eventmgr->features[PP_Feature_PowerBudgetWaiver].supported = false; ++ eventmgr->features[PP_Feature_OverDrive].supported = false; ++ eventmgr->features[PP_Feature_OverdriveTest].supported = false; ++ eventmgr->features[PP_Feature_User3DPerformance].supported = false; ++ eventmgr->features[PP_Feature_User2DPerformance].supported = false; ++ eventmgr->features[PP_Feature_PowerPlay].supported = false; ++ eventmgr->features[PP_Feature_Force3DClock].supported = false; ++} +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.h b/drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.h +new file mode 100644 +index 0000000..9ef96aa +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.h +@@ -0,0 +1,34 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++ ++#ifndef _EVENTINIT_H_ ++#define _EVENTINIT_H_ ++ ++#define PEM_CURRENT_POWERPLAY_FEATURE_VERSION 4 ++ ++void pem_init_feature_info(struct pp_eventmgr *eventmgr); ++void pem_uninit_featureInfo(struct pp_eventmgr *eventmgr); ++int pem_register_interrupts(struct pp_eventmgr *eventmgr); ++int pem_unregister_interrupts(struct pp_eventmgr *eventmgr); ++ ++#endif /* _EVENTINIT_H_ */ +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.c b/drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.c +new file mode 100644 +index 0000000..1e2ad56 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.c +@@ -0,0 +1,215 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++#include "eventmanagement.h" ++#include "eventmgr.h" ++#include "eventactionchains.h" ++ ++int pem_init_event_action_chains(struct pp_eventmgr *eventmgr) ++{ ++ int i; ++ ++ for (i = 0; i < AMD_PP_EVENT_MAX; i++) ++ eventmgr->event_chain[i] = NULL; ++ ++ eventmgr->event_chain[AMD_PP_EVENT_SUSPEND] = pem_get_suspend_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_INITIALIZE] = pem_get_initialize_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_UNINITIALIZE] = pem_get_uninitialize_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_POWER_SOURCE_CHANGE] = pem_get_power_source_change_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_HIBERNATE] = pem_get_hibernate_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_RESUME] = pem_get_resume_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_THERMAL_NOTIFICATION] = pem_get_thermal_notification_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_VBIOS_NOTIFICATION] = pem_get_vbios_notification_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_ENTER_THERMAL_STATE] = pem_get_enter_thermal_state_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_EXIT_THERMAL_STATE] = pem_get_exit_thermal_state_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_ENABLE_POWER_PLAY] = pem_get_enable_powerplay_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_DISABLE_POWER_PLAY] = pem_get_disable_powerplay_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_ENABLE_OVER_DRIVE_TEST] = pem_get_enable_overdrive_test_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_DISABLE_OVER_DRIVE_TEST] = pem_get_disable_overdrive_test_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_ENABLE_GFX_CLOCK_GATING] = pem_get_enable_gfx_clock_gating_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_DISABLE_GFX_CLOCK_GATING] = pem_get_disable_gfx_clock_gating_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_ENABLE_CGPG] = pem_get_enable_cgpg_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_DISABLE_CGPG] = pem_get_disable_cgpg_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_COMPLETE_INIT] = pem_get_complete_init_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_SCREEN_ON] = pem_get_screen_on_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_SCREEN_OFF] = pem_get_screen_off_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_PRE_SUSPEND] = pem_get_pre_suspend_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_PRE_RESUME] = pem_get_pre_resume_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_ENABLE_USER_STATE] = pem_enable_user_state_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_READJUST_POWER_STATE] = pem_readjust_power_state_action_chain(eventmgr); ++ eventmgr->event_chain[AMD_PP_EVENT_DISPLAY_CONFIG_CHANGE] = pem_display_config_change_action_chain(eventmgr); ++ return 0; ++} ++ ++int pem_excute_event_chain(struct pp_eventmgr *eventmgr, const struct action_chain *event_chain, struct pem_event_data *event_data) ++{ ++ const pem_event_action **paction_chain; ++ const pem_event_action *psub_chain; ++ int tmp_result = 0; ++ int result = 0; ++ ++ if (eventmgr == NULL || event_chain == NULL || event_data == NULL) ++ return -EINVAL; ++ ++ for (paction_chain = event_chain->action_chain; NULL != *paction_chain; paction_chain++) { ++ if (0 != result) ++ return result; ++ ++ for (psub_chain = *paction_chain; NULL != *psub_chain; psub_chain++) { ++ tmp_result = (*psub_chain)(eventmgr, event_data); ++ if (0 == result) ++ result = tmp_result; ++ } ++ } ++ ++ return result; ++} ++ ++const struct action_chain *pem_get_suspend_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &suspend_action_chain; ++} ++ ++const struct action_chain *pem_get_initialize_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &initialize_action_chain; ++} ++ ++const struct action_chain *pem_get_uninitialize_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &uninitialize_action_chain; ++} ++ ++const struct action_chain *pem_get_power_source_change_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &power_source_change_action_chain_pp_enabled; /* other case base on feature info*/ ++} ++ ++const struct action_chain *pem_get_resume_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &resume_action_chain; ++} ++ ++const struct action_chain *pem_get_hibernate_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_thermal_notification_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_vbios_notification_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_enter_thermal_state_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_exit_thermal_state_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_enable_powerplay_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_disable_powerplay_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_enable_overdrive_test_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_disable_overdrive_test_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_enable_gfx_clock_gating_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &enable_gfx_clock_gating_action_chain; ++} ++ ++const struct action_chain *pem_get_disable_gfx_clock_gating_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &disable_gfx_clock_gating_action_chain; ++} ++ ++const struct action_chain *pem_get_enable_cgpg_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &enable_cgpg_action_chain; ++} ++ ++const struct action_chain *pem_get_disable_cgpg_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &disable_cgpg_action_chain; ++} ++ ++const struct action_chain *pem_get_complete_init_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &complete_init_action_chain; ++} ++ ++const struct action_chain *pem_get_screen_on_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_screen_off_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_pre_suspend_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_get_pre_resume_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return NULL; ++} ++ ++const struct action_chain *pem_enable_user_state_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &enable_user_state_action_chain; ++} ++ ++const struct action_chain *pem_readjust_power_state_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &readjust_power_state_action_chain; ++} ++ ++const struct action_chain *pem_display_config_change_action_chain(struct pp_eventmgr *eventmgr) ++{ ++ return &display_config_change_action_chain; ++} +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.h b/drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.h +new file mode 100644 +index 0000000..383d4b2 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.h +@@ -0,0 +1,59 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++#ifndef _EVENT_MANAGEMENT_H_ ++#define _EVENT_MANAGEMENT_H_ ++ ++#include "eventmgr.h" ++ ++int pem_init_event_action_chains(struct pp_eventmgr *eventmgr); ++int pem_excute_event_chain(struct pp_eventmgr *eventmgr, const struct action_chain *event_chain, struct pem_event_data *event_data); ++const struct action_chain *pem_get_suspend_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_initialize_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_uninitialize_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_power_source_change_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_resume_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_hibernate_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_thermal_notification_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_vbios_notification_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_enter_thermal_state_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_exit_thermal_state_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_enable_powerplay_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_disable_powerplay_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_enable_overdrive_test_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_disable_overdrive_test_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_enable_gfx_clock_gating_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_disable_gfx_clock_gating_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_enable_cgpg_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_disable_cgpg_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_complete_init_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_screen_on_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_screen_off_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_pre_suspend_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_get_pre_resume_action_chain(struct pp_eventmgr *eventmgr); ++ ++extern const struct action_chain *pem_enable_user_state_action_chain(struct pp_eventmgr *eventmgr); ++extern const struct action_chain *pem_readjust_power_state_action_chain(struct pp_eventmgr *eventmgr); ++const struct action_chain *pem_display_config_change_action_chain(struct pp_eventmgr *eventmgr); ++ ++ ++#endif /* _EVENT_MANAGEMENT_H_ */ +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventmgr.c b/drivers/gpu/drm/amd/powerplay/eventmgr/eventmgr.c +new file mode 100644 +index 0000000..52a3efc +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventmgr.c +@@ -0,0 +1,114 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++#include <linux/types.h> ++#include <linux/kernel.h> ++#include <linux/slab.h> ++#include "eventmgr.h" ++#include "hwmgr.h" ++#include "eventinit.h" ++#include "eventmanagement.h" ++ ++static int pem_init(struct pp_eventmgr *eventmgr) ++{ ++ int result = 0; ++ struct pem_event_data event_data; ++ ++ /* Initialize PowerPlay feature info */ ++ pem_init_feature_info(eventmgr); ++ ++ /* Initialize event action chains */ ++ pem_init_event_action_chains(eventmgr); ++ ++ /* Call initialization event */ ++ result = pem_handle_event(eventmgr, AMD_PP_EVENT_INITIALIZE, &event_data); ++ ++ if (0 != result) ++ return result; ++ ++ /* Register interrupt callback functions */ ++ result = pem_register_interrupts(eventmgr); ++ return 0; ++} ++ ++static void pem_fini(struct pp_eventmgr *eventmgr) ++{ ++ struct pem_event_data event_data; ++ ++ pem_uninit_featureInfo(eventmgr); ++ pem_unregister_interrupts(eventmgr); ++ ++ pem_handle_event(eventmgr, AMD_PP_EVENT_UNINITIALIZE, &event_data); ++ ++ if (eventmgr != NULL) ++ kfree(eventmgr); ++} ++ ++int eventmgr_init(struct pp_instance *handle) ++{ ++ int result = 0; ++ struct pp_eventmgr *eventmgr; ++ ++ if (handle == NULL) ++ return -EINVAL; ++ ++ eventmgr = kzalloc(sizeof(struct pp_eventmgr), GFP_KERNEL); ++ if (eventmgr == NULL) ++ return -ENOMEM; ++ ++ eventmgr->hwmgr = handle->hwmgr; ++ handle->eventmgr = eventmgr; ++ ++ eventmgr->platform_descriptor = &(eventmgr->hwmgr->platform_descriptor); ++ eventmgr->pp_eventmgr_init = pem_init; ++ eventmgr->pp_eventmgr_fini = pem_fini; ++ ++ return result; ++} ++ ++int eventmgr_fini(struct pp_eventmgr *eventmgr) ++{ ++ kfree(eventmgr); ++ return 0; ++} ++ ++static int pem_handle_event_unlocked(struct pp_eventmgr *eventmgr, enum amd_pp_event event, struct pem_event_data *data) ++{ ++ if (eventmgr == NULL || event >= AMD_PP_EVENT_MAX || data == NULL) ++ return -EINVAL; ++ ++ return pem_excute_event_chain(eventmgr, eventmgr->event_chain[event], data); ++} ++ ++int pem_handle_event(struct pp_eventmgr *eventmgr, enum amd_pp_event event, struct pem_event_data *event_data) ++{ ++ int r = 0; ++ ++ r = pem_handle_event_unlocked(eventmgr, event, event_data); ++ ++ return r; ++} ++ ++bool pem_is_hw_access_blocked(struct pp_eventmgr *eventmgr) ++{ ++ return (eventmgr->block_adjust_power_state || phm_is_hw_access_blocked(eventmgr->hwmgr)); ++} +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.c b/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.c +new file mode 100644 +index 0000000..49d8a29 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.c +@@ -0,0 +1,395 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++ ++#include "eventmgr.h" ++#include "eventsubchains.h" ++#include "eventtasks.h" ++#include "hardwaremanager.h" ++ ++const pem_event_action reset_display_phy_access_tasks[] = { ++ pem_task_reset_display_phys_access, ++ NULL ++}; ++ ++const pem_event_action broadcast_power_policy_tasks[] = { ++ /* PEM_Task_BroadcastPowerPolicyChange, */ ++ NULL ++}; ++ ++const pem_event_action unregister_interrupt_tasks[] = { ++ pem_task_unregister_interrupts, ++ NULL ++}; ++ ++/* Disable GFX Voltage Islands Power Gating */ ++const pem_event_action disable_gfx_voltage_island_powergating_tasks[] = { ++ pem_task_disable_voltage_island_power_gating, ++ NULL ++}; ++ ++const pem_event_action disable_gfx_clockgating_tasks[] = { ++ pem_task_disable_gfx_clock_gating, ++ NULL ++}; ++ ++const pem_event_action block_adjust_power_state_tasks[] = { ++ pem_task_block_adjust_power_state, ++ NULL ++}; ++ ++ ++const pem_event_action unblock_adjust_power_state_tasks[] = { ++ pem_task_unblock_adjust_power_state, ++ NULL ++}; ++ ++const pem_event_action set_performance_state_tasks[] = { ++ pem_task_set_performance_state, ++ NULL ++}; ++ ++const pem_event_action get_2d_performance_state_tasks[] = { ++ pem_task_get_2D_performance_state_id, ++ NULL ++}; ++ ++const pem_event_action conditionally_force3D_performance_state_tasks[] = { ++ pem_task_conditionally_force_3d_performance_state, ++ NULL ++}; ++ ++const pem_event_action process_vbios_eventinfo_tasks[] = { ++ /* PEM_Task_ProcessVbiosEventInfo,*/ ++ NULL ++}; ++ ++const pem_event_action enable_dynamic_state_management_tasks[] = { ++ /* PEM_Task_ResetBAPMPolicyChangedFlag,*/ ++ pem_task_get_boot_state_id, ++ pem_task_enable_dynamic_state_management, ++ pem_task_register_interrupts, ++ NULL ++}; ++ ++const pem_event_action enable_clock_power_gatings_tasks[] = { ++ pem_task_enable_clock_power_gatings_tasks, ++ pem_task_powerdown_uvd_tasks, ++ pem_task_powerdown_vce_tasks, ++ NULL ++}; ++ ++const pem_event_action setup_asic_tasks[] = { ++ pem_task_setup_asic, ++ NULL ++}; ++ ++const pem_event_action power_budget_tasks[] = { ++ /* TODO ++ * PEM_Task_PowerBudgetWaiverAvailable, ++ * PEM_Task_PowerBudgetWarningMessage, ++ * PEM_Task_PruneStatesBasedOnPowerBudget, ++ */ ++ NULL ++}; ++ ++const pem_event_action system_config_tasks[] = { ++ /* PEM_Task_PruneStatesBasedOnSystemConfig,*/ ++ NULL ++}; ++ ++ ++const pem_event_action conditionally_force_3d_performance_state_tasks[] = { ++ pem_task_conditionally_force_3d_performance_state, ++ NULL ++}; ++ ++const pem_event_action ungate_all_display_phys_tasks[] = { ++ /* PEM_Task_GetDisplayPhyAccessInfo */ ++ NULL ++}; ++ ++const pem_event_action uninitialize_display_phy_access_tasks[] = { ++ /* PEM_Task_UninitializeDisplayPhysAccess, */ ++ NULL ++}; ++ ++const pem_event_action disable_gfx_voltage_island_power_gating_tasks[] = { ++ /* PEM_Task_DisableVoltageIslandPowerGating, */ ++ NULL ++}; ++ ++const pem_event_action disable_gfx_clock_gating_tasks[] = { ++ pem_task_disable_gfx_clock_gating, ++ NULL ++}; ++ ++const pem_event_action set_boot_state_tasks[] = { ++ pem_task_get_boot_state_id, ++ pem_task_set_boot_state, ++ NULL ++}; ++ ++const pem_event_action adjust_power_state_tasks[] = { ++ pem_task_notify_hw_mgr_display_configuration_change, ++ pem_task_adjust_power_state, ++ /*pem_task_notify_smc_display_config_after_power_state_adjustment,*/ ++ pem_task_update_allowed_performance_levels, ++ /* to do pem_task_Enable_disable_bapm, */ ++ NULL ++}; ++ ++const pem_event_action disable_dynamic_state_management_tasks[] = { ++ pem_task_unregister_interrupts, ++ pem_task_get_boot_state_id, ++ pem_task_disable_dynamic_state_management, ++ NULL ++}; ++ ++const pem_event_action disable_clock_power_gatings_tasks[] = { ++ pem_task_disable_clock_power_gatings_tasks, ++ NULL ++}; ++ ++const pem_event_action cleanup_asic_tasks[] = { ++ /* PEM_Task_DisableFPS,*/ ++ pem_task_cleanup_asic, ++ NULL ++}; ++ ++const pem_event_action prepare_for_pnp_stop_tasks[] = { ++ /* PEM_Task_PrepareForPnpStop,*/ ++ NULL ++}; ++ ++const pem_event_action set_power_source_tasks[] = { ++ pem_task_set_power_source, ++ pem_task_notify_hw_of_power_source, ++ NULL ++}; ++ ++const pem_event_action set_power_saving_state_tasks[] = { ++ pem_task_reset_power_saving_state, ++ pem_task_get_power_saving_state, ++ pem_task_set_power_saving_state, ++ /* PEM_Task_ResetODDCState, ++ * PEM_Task_GetODDCState, ++ * PEM_Task_SetODDCState,*/ ++ NULL ++}; ++ ++const pem_event_action enable_disable_fps_tasks[] = { ++ /* PEM_Task_EnableDisableFPS,*/ ++ NULL ++}; ++ ++const pem_event_action set_nbmcu_state_tasks[] = { ++ /* PEM_Task_NBMCUStateChange,*/ ++ NULL ++}; ++ ++const pem_event_action reset_hardware_dc_notification_tasks[] = { ++ /* PEM_Task_ResetHardwareDCNotification,*/ ++ NULL ++}; ++ ++ ++const pem_event_action notify_smu_suspend_tasks[] = { ++ /* PEM_Task_NotifySMUSuspend,*/ ++ NULL ++}; ++ ++const pem_event_action disable_smc_firmware_ctf_tasks[] = { ++ /* PEM_Task_DisableSMCFirmwareCTF,*/ ++ NULL ++}; ++ ++const pem_event_action disable_fps_tasks[] = { ++ /* PEM_Task_DisableFPS,*/ ++ NULL ++}; ++ ++const pem_event_action vari_bright_suspend_tasks[] = { ++ /* PEM_Task_VariBright_Suspend,*/ ++ NULL ++}; ++ ++const pem_event_action reset_fan_speed_to_default_tasks[] = { ++ /* PEM_Task_ResetFanSpeedToDefault,*/ ++ NULL ++}; ++ ++const pem_event_action power_down_asic_tasks[] = { ++ /* PEM_Task_DisableFPS,*/ ++ pem_task_power_down_asic, ++ NULL ++}; ++ ++const pem_event_action disable_stutter_mode_tasks[] = { ++ /* PEM_Task_DisableStutterMode,*/ ++ NULL ++}; ++ ++const pem_event_action set_connected_standby_tasks[] = { ++ /* PEM_Task_SetConnectedStandby,*/ ++ NULL ++}; ++ ++const pem_event_action block_hw_access_tasks[] = { ++ pem_task_block_hw_access, ++ NULL ++}; ++ ++const pem_event_action unblock_hw_access_tasks[] = { ++ pem_task_un_block_hw_access, ++ NULL ++}; ++ ++const pem_event_action resume_connected_standby_tasks[] = { ++ /* PEM_Task_ResumeConnectedStandby,*/ ++ NULL ++}; ++ ++const pem_event_action notify_smu_resume_tasks[] = { ++ /* PEM_Task_NotifySMUResume,*/ ++ NULL ++}; ++ ++const pem_event_action reset_display_configCounter_tasks[] = { ++ pem_task_reset_display_phys_access, ++ NULL ++}; ++ ++const pem_event_action update_dal_configuration_tasks[] = { ++ /* PEM_Task_CheckVBlankTime,*/ ++ NULL ++}; ++ ++const pem_event_action vari_bright_resume_tasks[] = { ++ /* PEM_Task_VariBright_Resume,*/ ++ NULL ++}; ++ ++const pem_event_action notify_hw_power_source_tasks[] = { ++ pem_task_notify_hw_of_power_source, ++ NULL ++}; ++ ++const pem_event_action process_vbios_event_info_tasks[] = { ++ /* PEM_Task_ProcessVbiosEventInfo,*/ ++ NULL ++}; ++ ++const pem_event_action enable_gfx_clock_gating_tasks[] = { ++ pem_task_enable_gfx_clock_gating, ++ NULL ++}; ++ ++const pem_event_action enable_gfx_voltage_island_power_gating_tasks[] = { ++ pem_task_enable_voltage_island_power_gating, ++ NULL ++}; ++ ++const pem_event_action reset_clock_gating_tasks[] = { ++ /* PEM_Task_ResetClockGating*/ ++ NULL ++}; ++ ++const pem_event_action notify_smu_vpu_recovery_end_tasks[] = { ++ /* PEM_Task_NotifySmuVPURecoveryEnd,*/ ++ NULL ++}; ++ ++const pem_event_action disable_vpu_cap_tasks[] = { ++ /* PEM_Task_DisableVPUCap,*/ ++ NULL ++}; ++ ++const pem_event_action execute_escape_sequence_tasks[] = { ++ /* PEM_Task_ExecuteEscapesequence,*/ ++ NULL ++}; ++ ++const pem_event_action notify_power_state_change_tasks[] = { ++ pem_task_notify_power_state_change, ++ NULL ++}; ++ ++const pem_event_action enable_cgpg_tasks[] = { ++ pem_task_enable_cgpg, ++ NULL ++}; ++ ++const pem_event_action disable_cgpg_tasks[] = { ++ pem_task_disable_cgpg, ++ NULL ++}; ++ ++const pem_event_action enable_user_2d_performance_tasks[] = { ++ /* PEM_Task_SetUser2DPerformanceFlag,*/ ++ /* PEM_Task_UpdateUser2DPerformanceEnableEvents,*/ ++ NULL ++}; ++ ++const pem_event_action add_user_2d_performance_state_tasks[] = { ++ /* PEM_Task_Get2DPerformanceTemplate,*/ ++ /* PEM_Task_AllocateNewPowerStateMemory,*/ ++ /* PEM_Task_CopyNewPowerStateInfo,*/ ++ /* PEM_Task_UpdateNewPowerStateClocks,*/ ++ /* PEM_Task_UpdateNewPowerStateUser2DPerformanceFlag,*/ ++ /* PEM_Task_AddPowerState,*/ ++ /* PEM_Task_ReleaseNewPowerStateMemory,*/ ++ NULL ++}; ++ ++const pem_event_action delete_user_2d_performance_state_tasks[] = { ++ /* PEM_Task_GetCurrentUser2DPerformanceStateID,*/ ++ /* PEM_Task_DeletePowerState,*/ ++ /* PEM_Task_SetCurrentUser2DPerformanceStateID,*/ ++ NULL ++}; ++ ++const pem_event_action disable_user_2d_performance_tasks[] = { ++ /* PEM_Task_ResetUser2DPerformanceFlag,*/ ++ /* PEM_Task_UpdateUser2DPerformanceDisableEvents,*/ ++ NULL ++}; ++ ++const pem_event_action enable_stutter_mode_tasks[] = { ++ pem_task_enable_stutter_mode, ++ NULL ++}; ++ ++const pem_event_action enable_disable_bapm_tasks[] = { ++ /*PEM_Task_EnableDisableBAPM,*/ ++ NULL ++}; ++ ++const pem_event_action reset_boot_state_tasks[] = { ++ pem_task_reset_boot_state, ++ NULL ++}; ++ ++const pem_event_action create_new_user_performance_state_tasks[] = { ++ pem_task_create_user_performance_state, ++ NULL ++}; +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.h b/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.h +new file mode 100644 +index 0000000..27e0e61 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.h +@@ -0,0 +1,98 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++ ++#ifndef _EVENT_SUB_CHAINS_H_ ++#define _EVENT_SUB_CHAINS_H_ ++ ++#include "eventmgr.h" ++ ++extern const pem_event_action reset_display_phy_access_tasks[]; ++extern const pem_event_action broadcast_power_policy_tasks[]; ++extern const pem_event_action unregister_interrupt_tasks[]; ++extern const pem_event_action disable_GFX_voltage_island_powergating_tasks[]; ++extern const pem_event_action disable_GFX_clockgating_tasks[]; ++extern const pem_event_action block_adjust_power_state_tasks[]; ++extern const pem_event_action unblock_adjust_power_state_tasks[]; ++extern const pem_event_action set_performance_state_tasks[]; ++extern const pem_event_action get_2D_performance_state_tasks[]; ++extern const pem_event_action conditionally_force3D_performance_state_tasks[]; ++extern const pem_event_action process_vbios_eventinfo_tasks[]; ++extern const pem_event_action enable_dynamic_state_management_tasks[]; ++extern const pem_event_action enable_clock_power_gatings_tasks[]; ++extern const pem_event_action conditionally_force3D_performance_state_tasks[]; ++extern const pem_event_action setup_asic_tasks[]; ++extern const pem_event_action power_budget_tasks[]; ++extern const pem_event_action system_config_tasks[]; ++extern const pem_event_action get_2d_performance_state_tasks[]; ++extern const pem_event_action conditionally_force_3d_performance_state_tasks[]; ++extern const pem_event_action ungate_all_display_phys_tasks[]; ++extern const pem_event_action uninitialize_display_phy_access_tasks[]; ++extern const pem_event_action disable_gfx_voltage_island_power_gating_tasks[]; ++extern const pem_event_action disable_gfx_clock_gating_tasks[]; ++extern const pem_event_action set_boot_state_tasks[]; ++extern const pem_event_action adjust_power_state_tasks[]; ++extern const pem_event_action disable_dynamic_state_management_tasks[]; ++extern const pem_event_action disable_clock_power_gatings_tasks[]; ++extern const pem_event_action cleanup_asic_tasks[]; ++extern const pem_event_action prepare_for_pnp_stop_tasks[]; ++extern const pem_event_action set_power_source_tasks[]; ++extern const pem_event_action set_power_saving_state_tasks[]; ++extern const pem_event_action enable_disable_fps_tasks[]; ++extern const pem_event_action set_nbmcu_state_tasks[]; ++extern const pem_event_action reset_hardware_dc_notification_tasks[]; ++extern const pem_event_action notify_smu_suspend_tasks[]; ++extern const pem_event_action disable_smc_firmware_ctf_tasks[]; ++extern const pem_event_action disable_fps_tasks[]; ++extern const pem_event_action vari_bright_suspend_tasks[]; ++extern const pem_event_action reset_fan_speed_to_default_tasks[]; ++extern const pem_event_action power_down_asic_tasks[]; ++extern const pem_event_action disable_stutter_mode_tasks[]; ++extern const pem_event_action set_connected_standby_tasks[]; ++extern const pem_event_action block_hw_access_tasks[]; ++extern const pem_event_action unblock_hw_access_tasks[]; ++extern const pem_event_action resume_connected_standby_tasks[]; ++extern const pem_event_action notify_smu_resume_tasks[]; ++extern const pem_event_action reset_display_configCounter_tasks[]; ++extern const pem_event_action update_dal_configuration_tasks[]; ++extern const pem_event_action vari_bright_resume_tasks[]; ++extern const pem_event_action notify_hw_power_source_tasks[]; ++extern const pem_event_action process_vbios_event_info_tasks[]; ++extern const pem_event_action enable_gfx_clock_gating_tasks[]; ++extern const pem_event_action enable_gfx_voltage_island_power_gating_tasks[]; ++extern const pem_event_action reset_clock_gating_tasks[]; ++extern const pem_event_action notify_smu_vpu_recovery_end_tasks[]; ++extern const pem_event_action disable_vpu_cap_tasks[]; ++extern const pem_event_action execute_escape_sequence_tasks[]; ++extern const pem_event_action notify_power_state_change_tasks[]; ++extern const pem_event_action enable_cgpg_tasks[]; ++extern const pem_event_action disable_cgpg_tasks[]; ++extern const pem_event_action enable_user_2d_performance_tasks[]; ++extern const pem_event_action add_user_2d_performance_state_tasks[]; ++extern const pem_event_action delete_user_2d_performance_state_tasks[]; ++extern const pem_event_action disable_user_2d_performance_tasks[]; ++extern const pem_event_action enable_stutter_mode_tasks[]; ++extern const pem_event_action enable_disable_bapm_tasks[]; ++extern const pem_event_action reset_boot_state_tasks[]; ++extern const pem_event_action create_new_user_performance_state_tasks[]; ++ ++#endif /* _EVENT_SUB_CHAINS_H_ */ +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.c b/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.c +new file mode 100644 +index 0000000..55d5490 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.c +@@ -0,0 +1,408 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++ ++#include "eventmgr.h" ++#include "eventinit.h" ++#include "eventmanagement.h" ++#include "eventmanager.h" ++#include "hardwaremanager.h" ++#include "eventtasks.h" ++#include "power_state.h" ++#include "hwmgr.h" ++#include "amd_powerplay.h" ++#include "psm.h" ++ ++int pem_task_update_allowed_performance_levels(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ ++ if (pem_is_hw_access_blocked(eventmgr)) ++ return 0; ++ ++ phm_force_dpm_levels(eventmgr->hwmgr, AMD_DPM_FORCED_LEVEL_AUTO); ++ ++ return 0; ++} ++ ++/* eventtasks_generic.c */ ++int pem_task_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ struct pp_hwmgr *hwmgr; ++ ++ if (pem_is_hw_access_blocked(eventmgr)) ++ return 0; ++ ++ hwmgr = eventmgr->hwmgr; ++ if (event_data->pnew_power_state != NULL) ++ hwmgr->request_ps = event_data->pnew_power_state; ++ ++ if (phm_cap_enabled(eventmgr->platform_descriptor->platformCaps, PHM_PlatformCaps_DynamicPatchPowerState)) ++ psm_adjust_power_state_dynamic(eventmgr, event_data->skip_state_adjust_rules); ++ else ++ psm_adjust_power_state_static(eventmgr, event_data->skip_state_adjust_rules); ++ ++ return 0; ++} ++ ++int pem_task_power_down_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_set_boot_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_reset_boot_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_update_new_power_state_clocks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_system_shutdown(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_register_interrupts(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_unregister_interrupts(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ return pem_unregister_interrupts(eventmgr); ++} ++ ++ ++ ++int pem_task_get_boot_state_id(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ int result; ++ ++ result = psm_get_state_by_classification(eventmgr, ++ PP_StateClassificationFlag_Boot, ++ &(event_data->requested_state_id) ++ ); ++ ++ if (0 == result) ++ pem_set_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID); ++ else ++ pem_unset_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID); ++ ++ return result; ++} ++ ++int pem_task_enable_dynamic_state_management(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ return phm_enable_dynamic_state_management(eventmgr->hwmgr); ++} ++ ++int pem_task_disable_dynamic_state_management(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_enable_clock_power_gatings_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ return phm_enable_clock_power_gatings(eventmgr->hwmgr); ++} ++ ++int pem_task_powerdown_uvd_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ return phm_powerdown_uvd(eventmgr->hwmgr); ++} ++ ++int pem_task_powerdown_vce_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ phm_powergate_uvd(eventmgr->hwmgr, true); ++ phm_powergate_vce(eventmgr->hwmgr, true); ++ return 0; ++} ++ ++int pem_task_disable_clock_power_gatings_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_start_asic_block_usage(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_stop_asic_block_usage(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_setup_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ return phm_setup_asic(eventmgr->hwmgr); ++} ++ ++int pem_task_cleanup_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_store_dal_configuration(struct pp_eventmgr *eventmgr, const struct amd_display_configuration *display_config) ++{ ++ /* TODO */ ++ return 0; ++ /*phm_store_dal_configuration_data(eventmgr->hwmgr, display_config) */ ++} ++ ++int pem_task_notify_hw_mgr_display_configuration_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_notify_hw_mgr_pre_display_configuration_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_block_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ eventmgr->block_adjust_power_state = true; ++ /* to do PHM_ResetIPSCounter(pEventMgr->pHwMgr);*/ ++ return 0; ++} ++ ++int pem_task_unblock_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ eventmgr->block_adjust_power_state = false; ++ return 0; ++} ++ ++int pem_task_notify_power_state_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_block_hw_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_un_block_hw_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_reset_display_phys_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_set_cpu_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++/*powersaving*/ ++ ++int pem_task_set_power_source(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_notify_hw_of_power_source(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_get_power_saving_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_reset_power_saving_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_set_power_saving_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_set_screen_state_on(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_set_screen_state_off(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_enable_voltage_island_power_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_disable_voltage_island_power_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_enable_cgpg(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_disable_cgpg(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_enable_clock_power_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++ ++int pem_task_enable_gfx_clock_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_disable_gfx_clock_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++ ++/* performance */ ++int pem_task_set_performance_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ if (pem_is_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID)) ++ return psm_set_performance_states(eventmgr, &(event_data->requested_state_id)); ++ ++ return 0; ++} ++ ++int pem_task_conditionally_force_3d_performance_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_enable_stutter_mode(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ /* TODO */ ++ return 0; ++} ++ ++int pem_task_get_2D_performance_state_id(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ int result; ++ ++ if (eventmgr->features[PP_Feature_PowerPlay].supported && ++ !(eventmgr->features[PP_Feature_PowerPlay].enabled)) ++ result = psm_get_state_by_classification(eventmgr, ++ PP_StateClassificationFlag_Boot, ++ &(event_data->requested_state_id)); ++ else if (eventmgr->features[PP_Feature_User2DPerformance].enabled) ++ result = psm_get_state_by_classification(eventmgr, ++ PP_StateClassificationFlag_User2DPerformance, ++ &(event_data->requested_state_id)); ++ else ++ result = psm_get_ui_state(eventmgr, PP_StateUILabel_Performance, ++ &(event_data->requested_state_id)); ++ ++ if (0 == result) ++ pem_set_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID); ++ else ++ pem_unset_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID); ++ ++ return result; ++} ++ ++int pem_task_create_user_performance_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) ++{ ++ struct pp_power_state *state; ++ int table_entries; ++ struct pp_hwmgr *hwmgr = eventmgr->hwmgr; ++ int i; ++ ++ table_entries = hwmgr->num_ps; ++ state = hwmgr->ps; ++ ++restart_search: ++ for (i = 0; i < table_entries; i++) { ++ if (state->classification.ui_label & event_data->requested_ui_label) { ++ event_data->pnew_power_state = state; ++ return 0; ++ } ++ state = (struct pp_power_state *)((uint64_t)state + hwmgr->ps_size); ++ } ++ ++ switch (event_data->requested_ui_label) { ++ case PP_StateUILabel_Battery: ++ case PP_StateUILabel_Balanced: ++ event_data->requested_ui_label = PP_StateUILabel_Performance; ++ goto restart_search; ++ default: ++ break; ++ } ++ return -1; ++} ++ +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.h b/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.h +new file mode 100644 +index 0000000..37d3cf1 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.h +@@ -0,0 +1,85 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++ ++#ifndef _EVENT_TASKS_H_ ++#define _EVENT_TASKS_H_ ++#include "eventmgr.h" ++ ++struct amd_display_configuration; ++ ++/* eventtasks_generic.c */ ++int pem_task_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_power_down_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_get_boot_state_id(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_set_boot_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_reset_boot_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_update_new_power_state_clocks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_system_shutdown(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_register_interrupts(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_unregister_interrupts(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_enable_dynamic_state_management(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_disable_dynamic_state_management(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_enable_clock_power_gatings_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_powerdown_uvd_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_powerdown_vce_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_disable_clock_power_gatings_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_start_asic_block_usage(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_stop_asic_block_usage(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_setup_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_cleanup_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_store_dal_configuration (struct pp_eventmgr *eventmgr, const struct amd_display_configuration *display_config); ++int pem_task_notify_hw_mgr_display_configuration_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_notify_hw_mgr_pre_display_configuration_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_block_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_unblock_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_notify_power_state_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_block_hw_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_un_block_hw_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_reset_display_phys_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_set_cpu_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++ ++/*powersaving*/ ++ ++int pem_task_set_power_source(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_notify_hw_of_power_source(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_get_power_saving_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_reset_power_saving_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_set_power_saving_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_set_screen_state_on(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_set_screen_state_off(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_enable_voltage_island_power_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_disable_voltage_island_power_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_enable_cgpg(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_disable_cgpg(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_enable_gfx_clock_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_disable_gfx_clock_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_enable_stutter_mode(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++ ++/* performance */ ++int pem_task_set_performance_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_conditionally_force_3d_performance_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_get_2D_performance_state_id(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_create_user_performance_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++int pem_task_update_allowed_performance_levels(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); ++ ++#endif /* _EVENT_TASKS_H_ */ +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/psm.c b/drivers/gpu/drm/amd/powerplay/eventmgr/psm.c +new file mode 100644 +index 0000000..7469c4c +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/psm.c +@@ -0,0 +1,111 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++#include "psm.h" ++ ++int psm_get_ui_state(struct pp_eventmgr *eventmgr, enum PP_StateUILabel ui_label, unsigned long *state_id) ++{ ++ struct pp_power_state *state; ++ int table_entries; ++ struct pp_hwmgr *hwmgr = eventmgr->hwmgr; ++ int i; ++ ++ table_entries = hwmgr->num_ps; ++ state = hwmgr->ps; ++ ++ for (i = 0; i < table_entries; i++) { ++ if (state->classification.ui_label & ui_label) { ++ *state_id = state->id; ++ return 0; ++ } ++ state = (struct pp_power_state *)((uint64_t)state + hwmgr->ps_size); ++ } ++ return -1; ++} ++ ++int psm_get_state_by_classification(struct pp_eventmgr *eventmgr, enum PP_StateClassificationFlag flag, unsigned long *state_id) ++{ ++ struct pp_power_state *state; ++ int table_entries; ++ struct pp_hwmgr *hwmgr = eventmgr->hwmgr; ++ int i; ++ ++ table_entries = hwmgr->num_ps; ++ state = hwmgr->ps; ++ ++ for (i = 0; i < table_entries; i++) { ++ if (state->classification.flags & flag) { ++ *state_id = state->id; ++ return 0; ++ } ++ state = (struct pp_power_state *)((uint64_t)state + hwmgr->ps_size); ++ } ++ return -1; ++} ++ ++int psm_set_performance_states(struct pp_eventmgr *eventmgr, unsigned long *state_id) ++{ ++ struct pp_power_state *state; ++ int table_entries; ++ struct pp_hwmgr *hwmgr = eventmgr->hwmgr; ++ int i; ++ ++ table_entries = hwmgr->num_ps; ++ state = hwmgr->ps; ++ ++ for (i = 0; i < table_entries; i++) { ++ if (state->id == *state_id) { ++ hwmgr->request_ps = state; ++ return 0; ++ } ++ state = (struct pp_power_state *)((uint64_t)state + hwmgr->ps_size); ++ } ++ return -1; ++} ++ ++ ++int psm_adjust_power_state_dynamic(struct pp_eventmgr *eventmgr, bool skip) ++{ ++ ++ const struct pp_power_state *pcurrent; ++ struct pp_power_state *requested; ++ struct pp_hwmgr *hwmgr; ++ ++ if (skip) ++ return 0; ++ ++ hwmgr = eventmgr->hwmgr; ++ pcurrent = hwmgr->current_ps; ++ requested = hwmgr->request_ps; ++ ++ if (pcurrent != NULL || requested != NULL) { ++ phm_apply_state_adjust_rules(hwmgr, requested, pcurrent); ++ phm_set_power_state(hwmgr, &pcurrent->hardware, &requested->hardware); ++ hwmgr->current_ps = requested; ++ } ++ return 0; ++} ++ ++int psm_adjust_power_state_static(struct pp_eventmgr *eventmgr, bool skip) ++{ ++ return 0; ++} +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/psm.h b/drivers/gpu/drm/amd/powerplay/eventmgr/psm.h +new file mode 100644 +index 0000000..15abfac +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/eventmgr/psm.h +@@ -0,0 +1,37 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++#include "eventmgr.h" ++#include "eventinit.h" ++#include "eventmanagement.h" ++#include "eventmanager.h" ++#include "power_state.h" ++ ++int psm_get_ui_state(struct pp_eventmgr *eventmgr, enum PP_StateUILabel ui_label, unsigned long *state_id); ++ ++int psm_get_state_by_classification(struct pp_eventmgr *eventmgr, enum PP_StateClassificationFlag flag, unsigned long *state_id); ++ ++int psm_set_performance_states(struct pp_eventmgr *eventmgr, unsigned long *state_id); ++ ++int psm_adjust_power_state_dynamic(struct pp_eventmgr *eventmgr, bool skip); ++ ++int psm_adjust_power_state_static(struct pp_eventmgr *eventmgr, bool skip); +diff --git a/drivers/gpu/drm/amd/powerplay/inc/eventmanager.h b/drivers/gpu/drm/amd/powerplay/inc/eventmanager.h +new file mode 100644 +index 0000000..b9d84de +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/inc/eventmanager.h +@@ -0,0 +1,109 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++#ifndef _EVENT_MANAGER_H_ ++#define _EVENT_MANAGER_H_ ++ ++#include "power_state.h" ++#include "pp_power_source.h" ++#include "hardwaremanager.h" ++#include "pp_asicblocks.h" ++ ++struct pp_eventmgr; ++enum amd_pp_event; ++ ++enum PEM_EventDataValid { ++ PEM_EventDataValid_RequestedStateID = 0, ++ PEM_EventDataValid_RequestedUILabel, ++ PEM_EventDataValid_NewPowerState, ++ PEM_EventDataValid_RequestedPowerSource, ++ PEM_EventDataValid_RequestedClocks, ++ PEM_EventDataValid_CurrentTemperature, ++ PEM_EventDataValid_AsicBlocks, ++ PEM_EventDataValid_ODParameters, ++ PEM_EventDataValid_PXAdapterPrefs, ++ PEM_EventDataValid_PXUserPrefs, ++ PEM_EventDataValid_PXSwitchReason, ++ PEM_EventDataValid_PXSwitchPhase, ++ PEM_EventDataValid_HdVideo, ++ PEM_EventDataValid_BacklightLevel, ++ PEM_EventDatavalid_VariBrightParams, ++ PEM_EventDataValid_VariBrightLevel, ++ PEM_EventDataValid_VariBrightImmediateChange, ++ PEM_EventDataValid_PercentWhite, ++ PEM_EventDataValid_SdVideo, ++ PEM_EventDataValid_HTLinkChangeReason, ++ PEM_EventDataValid_HWBlocks, ++ PEM_EventDataValid_RequestedThermalState, ++ PEM_EventDataValid_MvcVideo, ++ PEM_EventDataValid_Max ++}; ++ ++typedef enum PEM_EventDataValid PEM_EventDataValid; ++ ++/* Number of bits in ULONG variable */ ++#define PEM_MAX_NUM_EVENTDATAVALID_BITS_PER_FIELD (sizeof(unsigned long)*8) ++ ++/* Number of ULONG entries used by event data valid bits */ ++#define PEM_MAX_NUM_EVENTDATAVALID_ULONG_ENTRIES \ ++ ((PEM_EventDataValid_Max + PEM_MAX_NUM_EVENTDATAVALID_BITS_PER_FIELD - 1) / \ ++ PEM_MAX_NUM_EVENTDATAVALID_BITS_PER_FIELD) ++ ++static inline void pem_set_event_data_valid(unsigned long *fields, PEM_EventDataValid valid_field) ++{ ++ fields[valid_field / PEM_MAX_NUM_EVENTDATAVALID_BITS_PER_FIELD] |= ++ (1UL << (valid_field % PEM_MAX_NUM_EVENTDATAVALID_BITS_PER_FIELD)); ++} ++ ++static inline void pem_unset_event_data_valid(unsigned long *fields, PEM_EventDataValid valid_field) ++{ ++ fields[valid_field / PEM_MAX_NUM_EVENTDATAVALID_BITS_PER_FIELD] &= ++ ~(1UL << (valid_field % PEM_MAX_NUM_EVENTDATAVALID_BITS_PER_FIELD)); ++} ++ ++static inline unsigned long pem_is_event_data_valid(const unsigned long *fields, PEM_EventDataValid valid_field) ++{ ++ return fields[valid_field / PEM_MAX_NUM_EVENTDATAVALID_BITS_PER_FIELD] & ++ (1UL << (valid_field % PEM_MAX_NUM_EVENTDATAVALID_BITS_PER_FIELD)); ++} ++ ++struct pem_event_data { ++ unsigned long valid_fields[100]; ++ unsigned long requested_state_id; ++ enum PP_StateUILabel requested_ui_label; ++ struct pp_power_state *pnew_power_state; ++ enum pp_power_source requested_power_source; ++ struct PP_Clocks requested_clocks; ++ bool skip_state_adjust_rules; ++ struct phm_asic_blocks asic_blocks; ++ /* to doPP_ThermalState requestedThermalState; ++ enum ThermalStateRequestSrc requestThermalStateSrc; ++ PP_Temperature currentTemperature;*/ ++ ++}; ++ ++int pem_handle_event(struct pp_eventmgr *eventmgr, enum amd_pp_event event, ++ struct pem_event_data *event_data); ++ ++bool pem_is_hw_access_blocked(struct pp_eventmgr *eventmgr); ++ ++#endif /* _EVENT_MANAGER_H_ */ +diff --git a/drivers/gpu/drm/amd/powerplay/inc/eventmgr.h b/drivers/gpu/drm/amd/powerplay/inc/eventmgr.h +new file mode 100644 +index 0000000..10437dc +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/inc/eventmgr.h +@@ -0,0 +1,125 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++ ++#ifndef _EVENTMGR_H_ ++#define _EVENTMGR_H_ ++ ++#include <linux/mutex.h> ++#include "pp_instance.h" ++#include "hardwaremanager.h" ++#include "eventmanager.h" ++#include "pp_feature.h" ++#include "pp_power_source.h" ++#include "power_state.h" ++ ++typedef int (*pem_event_action)(struct pp_eventmgr *eventmgr, ++ struct pem_event_data *event_data); ++ ++struct action_chain { ++ const char *description; /* action chain description for debugging purpose */ ++ const pem_event_action **action_chain; /* pointer to chain of event actions */ ++}; ++ ++struct pem_power_source_ui_state_info { ++ enum PP_StateUILabel current_ui_label; ++ enum PP_StateUILabel default_ui_lable; ++ unsigned long configurable_ui_mapping; ++}; ++ ++struct pp_clock_range { ++ uint32_t min_sclk_khz; ++ uint32_t max_sclk_khz; ++ ++ uint32_t min_mclk_khz; ++ uint32_t max_mclk_khz; ++ ++ uint32_t min_vclk_khz; ++ uint32_t max_vclk_khz; ++ ++ uint32_t min_dclk_khz; ++ uint32_t max_dclk_khz; ++ ++ uint32_t min_aclk_khz; ++ uint32_t max_aclk_khz; ++ ++ uint32_t min_eclk_khz; ++ uint32_t max_eclk_khz; ++}; ++ ++enum pp_state { ++ UNINITIALIZED, ++ INACTIVE, ++ ACTIVE ++}; ++ ++enum pp_ring_index { ++ PP_RING_TYPE_GFX_INDEX = 0, ++ PP_RING_TYPE_DMA_INDEX, ++ PP_RING_TYPE_DMA1_INDEX, ++ PP_RING_TYPE_UVD_INDEX, ++ PP_RING_TYPE_VCE0_INDEX, ++ PP_RING_TYPE_VCE1_INDEX, ++ PP_RING_TYPE_CP1_INDEX, ++ PP_RING_TYPE_CP2_INDEX, ++ PP_NUM_RINGS, ++}; ++ ++struct pp_request { ++ uint32_t flags; ++ uint32_t sclk; ++ uint32_t sclk_throttle; ++ uint32_t mclk; ++ uint32_t vclk; ++ uint32_t dclk; ++ uint32_t eclk; ++ uint32_t aclk; ++ uint32_t iclk; ++ uint32_t vp8clk; ++ uint32_t rsv[32]; ++}; ++ ++struct pp_eventmgr { ++ struct pp_hwmgr *hwmgr; ++ struct pp_smumgr *smumgr; ++ ++ struct pp_feature_info features[PP_Feature_Max]; ++ const struct action_chain *event_chain[AMD_PP_EVENT_MAX]; ++ struct phm_platform_descriptor *platform_descriptor; ++ struct pp_clock_range clock_range; ++ enum pp_power_source current_power_source; ++ struct pem_power_source_ui_state_info ui_state_info[PP_PowerSource_Max]; ++ enum pp_state states[PP_NUM_RINGS]; ++ struct pp_request hi_req; ++ struct list_head context_list; ++ struct mutex lock; ++ bool block_adjust_power_state; ++ bool enable_cg; ++ bool enable_gfx_cgpg; ++ int (*pp_eventmgr_init)(struct pp_eventmgr *eventmgr); ++ void (*pp_eventmgr_fini)(struct pp_eventmgr *eventmgr); ++}; ++ ++int eventmgr_init(struct pp_instance *handle); ++int eventmgr_fini(struct pp_eventmgr *eventmgr); ++ ++#endif /* _EVENTMGR_H_ */ +diff --git a/drivers/gpu/drm/amd/powerplay/inc/pp_feature.h b/drivers/gpu/drm/amd/powerplay/inc/pp_feature.h +new file mode 100644 +index 0000000..0faf6a2 +--- /dev/null ++++ b/drivers/gpu/drm/amd/powerplay/inc/pp_feature.h +@@ -0,0 +1,67 @@ ++/* ++ * Copyright 2015 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++ ++#ifndef _PP_FEATURE_H_ ++#define _PP_FEATURE_H_ ++ ++/** ++ * PowerPlay feature ids. ++ */ ++enum pp_feature { ++ PP_Feature_PowerPlay = 0, ++ PP_Feature_User2DPerformance, ++ PP_Feature_User3DPerformance, ++ PP_Feature_VariBright, ++ PP_Feature_VariBrightOnPowerXpress, ++ PP_Feature_ReducedRefreshRate, ++ PP_Feature_GFXClockGating, ++ PP_Feature_OverdriveTest, ++ PP_Feature_OverDrive, ++ PP_Feature_PowerBudgetWaiver, ++ PP_Feature_PowerControl, ++ PP_Feature_PowerControl_2, ++ PP_Feature_MultiUVDState, ++ PP_Feature_Force3DClock, ++ PP_Feature_BACO, ++ PP_Feature_PowerDown, ++ PP_Feature_DynamicUVDState, ++ PP_Feature_VCEDPM, ++ PP_Feature_PPM, ++ PP_Feature_ACP_POWERGATING, ++ PP_Feature_FFC, ++ PP_Feature_FPS, ++ PP_Feature_ViPG, ++ PP_Feature_Max ++}; ++ ++/** ++ * Struct for PowerPlay feature info. ++ */ ++struct pp_feature_info { ++ bool supported; /* feature supported by PowerPlay */ ++ bool enabled; /* feature enabled in PowerPlay */ ++ bool enabled_default; /* default enable status of the feature */ ++ uint32_t version; /* feature version */ ++}; ++ ++#endif /* _PP_FEATURE_H_ */ +diff --git a/drivers/gpu/drm/amd/powerplay/inc/pp_instance.h b/drivers/gpu/drm/amd/powerplay/inc/pp_instance.h +index 35dfcd9..7b60b61 100644 +--- a/drivers/gpu/drm/amd/powerplay/inc/pp_instance.h ++++ b/drivers/gpu/drm/amd/powerplay/inc/pp_instance.h +@@ -25,10 +25,12 @@ + + #include "smumgr.h" + #include "hwmgr.h" ++#include "eventmgr.h" + + struct pp_instance { + struct pp_smumgr *smu_mgr; + struct pp_hwmgr *hwmgr; ++ struct pp_eventmgr *eventmgr; + }; + + #endif +-- +2.7.4 + |