drm/amd/powerplay: add event manager sub-component
authorRex Zhu <Rex.Zhu@amd.com>
Wed, 23 Sep 2015 07:14:54 +0000 (15:14 +0800)
committerAlex Deucher <alexander.deucher@amd.com>
Mon, 21 Dec 2015 21:42:11 +0000 (16:42 -0500)
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>
20 files changed:
drivers/gpu/drm/amd/powerplay/Makefile
drivers/gpu/drm/amd/powerplay/amd_powerplay.c
drivers/gpu/drm/amd/powerplay/eventmgr/Makefile [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.h [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.c [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventinit.h [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.c [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventmanagement.h [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventmgr.c [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.c [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventsubchains.h [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.c [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.h [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/psm.c [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/eventmgr/psm.h [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/inc/eventmanager.h [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/inc/eventmgr.h [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/inc/pp_feature.h [new file with mode: 0644]
drivers/gpu/drm/amd/powerplay/inc/pp_instance.h

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