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