diff options
Diffstat (limited to 'common/recipes-kernel/linux/linux-yocto-4.14.71/0907-drm-amd-powerplay-delete-eventmgr-related-files.patch')
| -rw-r--r-- | common/recipes-kernel/linux/linux-yocto-4.14.71/0907-drm-amd-powerplay-delete-eventmgr-related-files.patch | 2548 |
1 files changed, 2548 insertions, 0 deletions
diff --git a/common/recipes-kernel/linux/linux-yocto-4.14.71/0907-drm-amd-powerplay-delete-eventmgr-related-files.patch b/common/recipes-kernel/linux/linux-yocto-4.14.71/0907-drm-amd-powerplay-delete-eventmgr-related-files.patch new file mode 100644 index 00000000..bafa67e6 --- /dev/null +++ b/common/recipes-kernel/linux/linux-yocto-4.14.71/0907-drm-amd-powerplay-delete-eventmgr-related-files.patch @@ -0,0 +1,2548 @@ +From 39723db4364b89bc96d409a154fe223cd86a9d11 Mon Sep 17 00:00:00 2001 +From: Rex Zhu <Rex.Zhu@amd.com> +Date: Fri, 1 Sep 2017 13:48:11 +0800 +Subject: [PATCH 0907/4131] drm/amd/powerplay: delete eventmgr related files. + +Change-Id: I6296a8cc697b51bf7d377c428ab02db64d3908fc +Reviewed-by: Alex Deucher <alexander.deucher@amd.com> +Signed-off-by: Rex Zhu <Rex.Zhu@amd.com> +--- + drivers/gpu/drm/amd/powerplay/eventmgr/Makefile | 11 - + .../drm/amd/powerplay/eventmgr/eventactionchains.c | 291 -------------- + .../drm/amd/powerplay/eventmgr/eventactionchains.h | 62 --- + drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.c | 195 --------- + 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 | 104 ----- + .../drm/amd/powerplay/eventmgr/eventsubchains.c | 410 ------------------- + .../drm/amd/powerplay/eventmgr/eventsubchains.h | 100 ----- + .../gpu/drm/amd/powerplay/eventmgr/eventtasks.c | 445 --------------------- + .../gpu/drm/amd/powerplay/eventmgr/eventtasks.h | 89 ----- + drivers/gpu/drm/amd/powerplay/eventmgr/psm.c | 119 ------ + drivers/gpu/drm/amd/powerplay/eventmgr/psm.h | 38 -- + drivers/gpu/drm/amd/powerplay/inc/eventmanager.h | 109 ----- + drivers/gpu/drm/amd/powerplay/inc/eventmgr.h | 124 ------ + 16 files changed, 2405 deletions(-) + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/Makefile + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.h + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.c + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.h + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.c + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.h + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventmgr.c + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.c + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.h + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.c + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.h + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/psm.c + delete mode 100644 drivers/gpu/drm/amd/powerplay/eventmgr/psm.h + delete mode 100644 drivers/gpu/drm/amd/powerplay/inc/eventmanager.h + delete mode 100644 drivers/gpu/drm/amd/powerplay/inc/eventmgr.h + +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/Makefile b/drivers/gpu/drm/amd/powerplay/eventmgr/Makefile +deleted file mode 100644 +index 7509e38..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/Makefile ++++ /dev/null +@@ -1,11 +0,0 @@ +-# +-# 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 +deleted file mode 100644 +index 8cee4e0..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c ++++ /dev/null +@@ -1,291 +0,0 @@ +-/* +- * 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 * const initialize_event[] = { +- block_adjust_power_state_tasks, +- power_budget_tasks, +- system_config_tasks, +- setup_asic_tasks, +- enable_dynamic_state_management_tasks, +- get_2d_performance_state_tasks, +- set_performance_state_tasks, +- initialize_thermal_controller_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 * const uninitialize_event[] = { +- ungate_all_display_phys_tasks, +- uninitialize_display_phy_access_tasks, +- disable_gfx_voltage_island_power_gating_tasks, +- disable_gfx_clock_gating_tasks, +- uninitialize_thermal_controller_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 * const 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 * const 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 * const 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 * const 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 * const 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, +- setup_asic_tasks, +- enable_stutter_mode_tasks, /*must do this in boot state and before SMC is started */ +- enable_dynamic_state_management_tasks, +- enable_disable_bapm_tasks, +- initialize_thermal_controller_tasks, +- get_2d_performance_state_tasks, +- set_performance_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 * const complete_init_event[] = { +- unblock_adjust_power_state_tasks, +- 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 * const 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 * const 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 * const 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 * const 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 * const 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 * const 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 * const 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 * const display_config_change_event[] = { +- /* countDisplayConfigurationChangeEventTasks, */ +- unblock_adjust_power_state_tasks, +- set_cpu_power_state, +- notify_hw_power_source_tasks, +- get_2d_performance_state_tasks, +- set_performance_state_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 * const 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 +deleted file mode 100644 +index f181e53..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.h ++++ /dev/null +@@ -1,62 +0,0 @@ +-/* +- * 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 +deleted file mode 100644 +index a3cd230..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.c ++++ /dev/null +@@ -1,195 +0,0 @@ +-/* +- * 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 "ppinterrupt.h" +-#include "hardwaremanager.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; +-} +- +-static int thermal_interrupt_callback(void *private_data, +- unsigned src_id, const uint32_t *iv_entry) +-{ +- /* TO DO hanle PEM_Event_ThermalNotification (struct pp_eventmgr *)private_data*/ +- pr_info("current thermal is out of range \n"); +- return 0; +-} +- +-int pem_register_interrupts(struct pp_eventmgr *eventmgr) +-{ +- int result = 0; +- struct pp_interrupt_registration_info info; +- +- info.call_back = thermal_interrupt_callback; +- info.context = eventmgr; +- +- result = phm_register_thermal_interrupt(eventmgr->hwmgr, &info); +- +- /* TODO: +- * 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 +deleted file mode 100644 +index 9ef96aa..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.h ++++ /dev/null +@@ -1,34 +0,0 @@ +-/* +- * 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 +deleted file mode 100644 +index cd1ca07..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.c ++++ /dev/null +@@ -1,215 +0,0 @@ +-/* +- * 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 * const *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 +deleted file mode 100644 +index 383d4b2..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.h ++++ /dev/null +@@ -1,59 +0,0 @@ +-/* +- * 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 +deleted file mode 100644 +index 3e3ca03..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventmgr.c ++++ /dev/null +@@ -1,104 +0,0 @@ +-/* +- * Copyright 2015 Advanced Micro Devices, Inc. +- * +- * Permission is hereby granted, free of charge, to any person obtaining a +- * copy of this software and associated documentation files (the "Software"), +- * to deal in the Software without restriction, including without limitation +- * the rights to use, copy, modify, merge, publish, distribute, sublicense, +- * and/or sell copies of the Software, and to permit persons to whom the +- * Software is furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice shall be included in +- * all copies or substantial portions of the Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR +- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +- * OTHER DEALINGS IN THE SOFTWARE. +- * +- */ +-#include <linux/types.h> +-#include <linux/kernel.h> +-#include <linux/slab.h> +-#include "eventmgr.h" +-#include "hwmgr.h" +-#include "eventinit.h" +-#include "eventmanagement.h" +- +-static int pem_init(struct pp_eventmgr *eventmgr) +-{ +- int result = 0; +- struct pem_event_data event_data = { {0} }; +- +- /* 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 = { {0} }; +- +- pem_uninit_featureInfo(eventmgr); +- pem_unregister_interrupts(eventmgr); +- +- pem_handle_event(eventmgr, AMD_PP_EVENT_UNINITIALIZE, &event_data); +-} +- +-int eventmgr_early_init(struct pp_instance *handle) +-{ +- 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 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 +deleted file mode 100644 +index b82c43a..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.c ++++ /dev/null +@@ -1,410 +0,0 @@ +-/* +- * 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_disable_smc_firmware_ctf, +- 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 +-}; +- +-const pem_event_action initialize_thermal_controller_tasks[] = { +- pem_task_initialize_thermal_controller, +- NULL +-}; +- +-const pem_event_action uninitialize_thermal_controller_tasks[] = { +- pem_task_uninitialize_thermal_controller, +- NULL +-}; +- +-const pem_event_action set_cpu_power_state[] = { +- pem_task_set_cpu_power_state, +- NULL +-}; +\ No newline at end of file +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.h b/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.h +deleted file mode 100644 +index 7714cb92..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.h ++++ /dev/null +@@ -1,100 +0,0 @@ +-/* +- * 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[]; +-extern const pem_event_action initialize_thermal_controller_tasks[]; +-extern const pem_event_action uninitialize_thermal_controller_tasks[]; +-extern const pem_event_action set_cpu_power_state[]; +-#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 +deleted file mode 100644 +index 8c4ebaa..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.c ++++ /dev/null +@@ -1,445 +0,0 @@ +-/* +- * 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" +- +-#define TEMP_RANGE_MIN (90 * 1000) +-#define TEMP_RANGE_MAX (120 * 1000) +- +-int pem_task_update_allowed_performance_levels(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) +-{ +- +- if (eventmgr == NULL || eventmgr->hwmgr == NULL) +- return -EINVAL; +- +- if (pem_is_hw_access_blocked(eventmgr)) +- return 0; +- +- phm_force_dpm_levels(eventmgr->hwmgr, eventmgr->hwmgr->dpm_level); +- +- 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) +-{ +- return phm_power_down_asic(eventmgr->hwmgr); +-} +- +-int pem_task_set_boot_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_states(eventmgr, &(event_data->requested_state_id)); +- +- 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) +-{ +- return phm_disable_dynamic_state_management(eventmgr->hwmgr); +-} +- +-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) +-{ +- phm_disable_clock_power_gatings(eventmgr->hwmgr); +- 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_disable_smc_firmware_ctf(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) +-{ +- return phm_disable_smc_firmware_ctf(eventmgr->hwmgr); +-} +- +-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) +-{ +- if (pem_is_hw_access_blocked(eventmgr)) +- return 0; +- +- return phm_display_configuration_changed(eventmgr->hwmgr); +-} +- +-int pem_task_notify_hw_mgr_pre_display_configuration_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) +-{ +- return 0; +-} +- +-int pem_task_notify_smc_display_config_after_power_state_adjustment(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) +-{ +- if (pem_is_hw_access_blocked(eventmgr)) +- return 0; +- +- return phm_notify_smc_display_config_after_ps_adjustment(eventmgr->hwmgr); +-} +- +-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) +-{ +- return phm_set_cpu_power_state(eventmgr->hwmgr); +-} +- +-/*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_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 *)((unsigned long)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; +-} +- +-int pem_task_initialize_thermal_controller(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) +-{ +- struct PP_TemperatureRange range; +- +- range.max = TEMP_RANGE_MAX; +- range.min = TEMP_RANGE_MIN; +- +- if (eventmgr == NULL || eventmgr->platform_descriptor == NULL) +- return -EINVAL; +- +- if (phm_cap_enabled(eventmgr->platform_descriptor->platformCaps, PHM_PlatformCaps_ThermalController)) +- return phm_start_thermal_controller(eventmgr->hwmgr, &range); +- +- return 0; +-} +- +-int pem_task_uninitialize_thermal_controller(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data) +-{ +- return phm_stop_thermal_controller(eventmgr->hwmgr); +-} +diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.h b/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.h +deleted file mode 100644 +index 37e7ca5..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.h ++++ /dev/null +@@ -1,89 +0,0 @@ +-/* +- * 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); +-int pem_task_notify_smc_display_config_after_power_state_adjustment(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); +-/*thermal */ +-int pem_task_initialize_thermal_controller(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); +-int pem_task_uninitialize_thermal_controller(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data); +-int pem_task_disable_smc_firmware_ctf(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 +deleted file mode 100644 +index 4899088..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/psm.c ++++ /dev/null +@@ -1,119 +0,0 @@ +-/* +- * 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 *)((unsigned long)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 *)((unsigned long)state + hwmgr->ps_size); +- } +- return -1; +-} +- +-int psm_set_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) { +- memcpy(hwmgr->request_ps, state, hwmgr->ps_size); +- return 0; +- } +- state = (struct pp_power_state *)((unsigned long)state + hwmgr->ps_size); +- } +- return -1; +-} +- +-int psm_adjust_power_state_dynamic(struct pp_eventmgr *eventmgr, bool skip) +-{ +- +- struct pp_power_state *pcurrent; +- struct pp_power_state *requested; +- struct pp_hwmgr *hwmgr; +- bool equal; +- +- if (skip) +- return 0; +- +- hwmgr = eventmgr->hwmgr; +- pcurrent = hwmgr->current_ps; +- requested = hwmgr->request_ps; +- +- if (requested == NULL) +- return 0; +- +- phm_apply_state_adjust_rules(hwmgr, requested, pcurrent); +- +- if (pcurrent == NULL || (0 != phm_check_states_equal(hwmgr, &pcurrent->hardware, &requested->hardware, &equal))) +- equal = false; +- +- if (!equal || phm_check_smc_update_required_for_display_configuration(hwmgr)) { +- phm_set_power_state(hwmgr, &pcurrent->hardware, &requested->hardware); +- memcpy(hwmgr->current_ps, hwmgr->request_ps, hwmgr->ps_size); +- } +- 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 +deleted file mode 100644 +index fbdff3e..0000000 +--- a/drivers/gpu/drm/amd/powerplay/eventmgr/psm.h ++++ /dev/null +@@ -1,38 +0,0 @@ +-/* +- * 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" +-#include "hardwaremanager.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_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 +deleted file mode 100644 +index b9d84de..0000000 +--- a/drivers/gpu/drm/amd/powerplay/inc/eventmanager.h ++++ /dev/null +@@ -1,109 +0,0 @@ +-/* +- * 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 +deleted file mode 100644 +index 7bd8a7e..0000000 +--- a/drivers/gpu/drm/amd/powerplay/inc/eventmgr.h ++++ /dev/null +@@ -1,124 +0,0 @@ +-/* +- * Copyright 2015 Advanced Micro Devices, Inc. +- * +- * Permission is hereby granted, free of charge, to any person obtaining a +- * copy of this software and associated documentation files (the "Software"), +- * to deal in the Software without restriction, including without limitation +- * the rights to use, copy, modify, merge, publish, distribute, sublicense, +- * and/or sell copies of the Software, and to permit persons to whom the +- * Software is furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice shall be included in +- * all copies or substantial portions of the Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR +- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +- * OTHER DEALINGS IN THE SOFTWARE. +- * +- */ +- +-#ifndef _EVENTMGR_H_ +-#define _EVENTMGR_H_ +- +-#include <linux/mutex.h> +-#include "pp_instance.h" +-#include "hardwaremanager.h" +-#include "eventmanager.h" +-#include "pp_feature.h" +-#include "pp_power_source.h" +-#include "power_state.h" +- +-typedef int (*pem_event_action)(struct pp_eventmgr *eventmgr, +- struct pem_event_data *event_data); +- +-struct action_chain { +- const char *description; /* action chain description for debugging purpose */ +- const pem_event_action * const *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_early_init(struct pp_instance *handle); +- +-#endif /* _EVENTMGR_H_ */ +-- +2.7.4 + |