Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3bace359 authored by Jammy Zhou's avatar Jammy Zhou Committed by Alex Deucher
Browse files

drm/amd/powerplay: add hardware manager sub-component 



The hwmgr handles all hardware related calls, including clock/power
gating control, DPM, read and parse PPTable, etc.

v5: squash in fixes
v4: implement acpi's atcs function use cgs interface
v3: fix code style error and add big-endian mode support.
v2: use cgs interface directly in hwmgr sub-module

Signed-off-by: default avatarRex Zhu <Rex.Zhu@amd.com>
Signed-off-by: default avatarJammy Zhou <Jammy.Zhou@amd.com>
Reviewed-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent ac885b3a

drivers/gpu/drm/amd/powerplay/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -6,7 +6,7 @@ subdir-ccflags-y += -Iinclude/drm \ 


AMD_PP_PATH = ../powerplay



PP_LIBS = smumgr

PP_LIBS = smumgr hwmgr



AMD_POWERPLAY = $(addsuffix /Makefile,$(addprefix drivers/gpu/drm/amd/powerplay/,$(PP_LIBS)))

drivers/gpu/drm/amd/powerplay/amd_powerplay.c

+52 −3
Original line number Diff line number Diff line
@@ -35,12 +35,46 @@ static int pp_early_init(void *handle) 


static int pp_sw_init(void *handle)

{

	return 0;

	struct pp_instance *pp_handle;

	struct pp_hwmgr  *hwmgr;

	int ret = 0;



	if (handle == NULL)

		return -EINVAL;



	pp_handle = (struct pp_instance *)handle;

	hwmgr = pp_handle->hwmgr;



	if (hwmgr == NULL || hwmgr->pptable_func == NULL ||

	    hwmgr->hwmgr_func == NULL ||

	    hwmgr->pptable_func->pptable_init == NULL ||

	    hwmgr->hwmgr_func->backend_init == NULL)

		return -EINVAL;



	ret = hwmgr->pptable_func->pptable_init(hwmgr);

	if (ret == 0)

		ret = hwmgr->hwmgr_func->backend_init(hwmgr);



	return ret;

}



static int pp_sw_fini(void *handle)

{

	return 0;

	struct pp_instance *pp_handle;

	struct pp_hwmgr  *hwmgr;

	int ret = 0;



	if (handle == NULL)

		return -EINVAL;



	pp_handle = (struct pp_instance *)handle;

	hwmgr = pp_handle->hwmgr;



	if (hwmgr != NULL || hwmgr->hwmgr_func != NULL ||

	    hwmgr->hwmgr_func->backend_fini != NULL)

		ret = hwmgr->hwmgr_func->backend_fini(hwmgr);



	return ret;

}



static int pp_hw_init(void *handle)
@@ -72,6 +106,8 @@ static int pp_hw_init(void *handle) 
		smumgr->smumgr_funcs->smu_fini(smumgr);

		return ret;

	}

	hw_init_power_state_table(pp_handle->hwmgr);



	return 0;

}
@@ -203,6 +239,7 @@ pp_debugfs_print_current_performance_level(void *handle, 
{

	return;

}



const struct amd_powerplay_funcs pp_dpm_funcs = {

	.get_temperature = NULL,

	.load_firmware = pp_dpm_load_fw,
@@ -230,10 +267,20 @@ static int amd_pp_instance_init(struct amd_pp_init *pp_init, 


	ret = smum_init(pp_init, handle);

	if (ret)

		return ret;

		goto fail_smum;



	ret = hwmgr_init(pp_init, handle);

	if (ret)

		goto fail_hwmgr;



	amd_pp->pp_handle = handle;

	return 0;



fail_hwmgr:

	smum_fini(handle->smu_mgr);

fail_smum:

	kfree(handle);

	return ret;

}



static int amd_pp_instance_fini(void *handle)
@@ -242,6 +289,8 @@ static int amd_pp_instance_fini(void *handle) 
	if (instance == NULL)

		return -EINVAL;



	hwmgr_fini(instance->hwmgr);



	smum_fini(instance->smu_mgr);



	kfree(handle);

drivers/gpu/drm/amd/powerplay/hwmgr/Makefile

0 → 100644
+10 −0
Original line number Diff line number Diff line 
#

# Makefile for the 'hw manager' sub-component of powerplay.

# It provides the hardware management services for the driver.



HARDWARE_MGR = hwmgr.o processpptables.o functiontables.o \

	       hardwaremanager.o pp_acpi.o



AMD_PP_HWMGR = $(addprefix $(AMD_PP_PATH)/hwmgr/,$(HARDWARE_MGR))



AMD_POWERPLAY_FILES += $(AMD_PP_HWMGR)

drivers/gpu/drm/amd/powerplay/hwmgr/functiontables.c

0 → 100644
+154 −0
Original line number Diff line number Diff line 
/*

 * 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 "hwmgr.h"



static int phm_run_table(struct pp_hwmgr *hwmgr,

			 struct phm_runtime_table_header *rt_table,

			 void *input,

			 void *output,

			 void *temp_storage)

{

	int result = 0;

	phm_table_function *function;



	for (function = rt_table->function_list; NULL != *function; function++) {

		int tmp = (*function)(hwmgr, input, output, temp_storage, result);



		if (tmp == PP_Result_TableImmediateExit)

			break;

		if (tmp) {

			if (0 == result)

				result = tmp;

			if (rt_table->exit_error)

				break;

		}

	}



	return result;

}



int phm_dispatch_table(struct pp_hwmgr *hwmgr,

		       struct phm_runtime_table_header *rt_table,

		       void *input, void *output)

{

	int result = 0;

	void *temp_storage = NULL;



	if (hwmgr == NULL || rt_table == NULL || rt_table->function_list == NULL) {

		printk(KERN_ERR "[ powerplay ] Invalid Parameter!\n");

		return 0; /*temp return ture because some function not implement on some asic */

	}



	if (0 != rt_table->storage_size) {

		temp_storage = kzalloc(rt_table->storage_size, GFP_KERNEL);

		if (temp_storage == NULL) {

			printk(KERN_ERR "[ powerplay ] Could not allocate table temporary storage\n");

			return -1;

		}

	}



	result = phm_run_table(hwmgr, rt_table, input, output, temp_storage);



	if (NULL != temp_storage)

		kfree(temp_storage);



	return result;

}



int phm_construct_table(struct pp_hwmgr *hwmgr,

			struct phm_master_table_header *master_table,

			struct phm_runtime_table_header *rt_table)

{

	uint32_t function_count = 0;

	const struct phm_master_table_item *table_item;

	uint32_t size;

	phm_table_function *run_time_list;

	phm_table_function *rtf;



	if (hwmgr == NULL || master_table == NULL || rt_table == NULL) {

		printk(KERN_ERR "[ powerplay ] Invalid Parameter!\n");

		return -1;

	}



	for (table_item = master_table->master_list;

		NULL != table_item->tableFunction; table_item++) {

		if ((NULL == table_item->isFunctionNeededInRuntimeTable) ||

		    (table_item->isFunctionNeededInRuntimeTable(hwmgr)))

			function_count++;

	}



	size = (function_count + 1) * sizeof(phm_table_function);

	run_time_list = kzalloc(size, GFP_KERNEL);

	if (NULL == run_time_list)

		return -1;



	rtf = run_time_list;

	for (table_item = master_table->master_list;

		NULL != table_item->tableFunction; table_item++) {

		if ((rtf - run_time_list) > function_count) {

			printk(KERN_ERR "[ powerplay ] Check function results have changed\n");

			kfree(run_time_list);

			return -1;

		}



		if ((NULL == table_item->isFunctionNeededInRuntimeTable) ||

		     (table_item->isFunctionNeededInRuntimeTable(hwmgr))) {

			*(rtf++) = table_item->tableFunction;

		}

	}



	if ((rtf - run_time_list) > function_count) {

		printk(KERN_ERR "[ powerplay ] Check function results have changed\n");

		kfree(run_time_list);

		return -1;

	}



	*rtf = NULL;

	rt_table->function_list = run_time_list;

	rt_table->exit_error = (0 != (master_table->flags & PHM_MasterTableFlag_ExitOnError));

	rt_table->storage_size = master_table->storage_size;

	return 0;

}



int phm_destroy_table(struct pp_hwmgr *hwmgr,

		      struct phm_runtime_table_header *rt_table)

{

	if (hwmgr == NULL || rt_table == NULL) {

		printk(KERN_ERR "[ powerplay ] Invalid Parameter\n");

		return -1;

	}



	if (NULL == rt_table->function_list)

		return 0;



	kfree(rt_table->function_list);



	rt_table->function_list = NULL;

	rt_table->storage_size = 0;

	rt_table->exit_error = false;



	return 0;

}

drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c

0 → 100644
+84 −0
Original line number Diff line number Diff line 
/*

 * 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/errno.h>

#include "hwmgr.h"

#include "hardwaremanager.h"

#include "pp_acpi.h"

#include "amd_acpi.h"



void phm_init_dynamic_caps(struct pp_hwmgr *hwmgr)

{

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableVoltageTransition);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableEngineTransition);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableMemoryTransition);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableMGClockGating);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableMGCGTSSM);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableLSClockGating);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_Force3DClockSupport);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableLightSleep);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableMCLS);

	phm_cap_set(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisablePowerGating);



	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableDPM);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_DisableSMUUVDHandshake);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_ThermalAutoThrottling);



	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_PCIEPerformanceRequest);



	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_NoOD5Support);

	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_UserMaxClockForMultiDisplays);



	phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_VpuRecoveryInProgress);



	if (acpi_atcs_functions_supported(hwmgr->device, ATCS_FUNCTION_PCIE_PERFORMANCE_REQUEST) &&

		acpi_atcs_functions_supported(hwmgr->device, ATCS_FUNCTION_PCIE_DEVICE_READY_NOTIFICATION))

		phm_cap_set(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_PCIEPerformanceRequest);

}



int phm_setup_asic(struct pp_hwmgr *hwmgr)

{

	if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,

		PHM_PlatformCaps_TablelessHardwareInterface)) {

		if (NULL != hwmgr->hwmgr_func->asic_setup)

			return hwmgr->hwmgr_func->asic_setup(hwmgr);

	} else {

		return phm_dispatch_table (hwmgr, &(hwmgr->setup_asic),

					  NULL, NULL);

	}



	return 0;

}



int phm_enable_dynamic_state_management(struct pp_hwmgr *hwmgr)

{

	if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,

		PHM_PlatformCaps_TablelessHardwareInterface)) {

		if (NULL != hwmgr->hwmgr_func->dynamic_state_management_enable)

			return hwmgr->hwmgr_func->dynamic_state_management_enable(hwmgr);

	} else {

		return phm_dispatch_table (hwmgr,

				&(hwmgr->enable_dynamic_state_management),

				NULL, NULL);

	}

	return 0;

}