From 38aada7e86d4605b3edc269dfaa48637a16426b0 Mon Sep 17 00:00:00 2001 From: Rex Zhu 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 Reviewed-by: Jammy Zhou Reviewed-by: Alex Deucher --- 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 +#include +#include +#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 +#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