[mirror_ubuntu-artful-kernel.git] / drivers / gpu / drm / amd / powerplay / smumgr / tonga_smumgr.c

/*
 * 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 "pp_debug.h"
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/gfp.h>

#include "smumgr.h"
#include "tonga_smumgr.h"
#include "smu_ucode_xfer_vi.h"
#include "tonga_ppsmc.h"
#include "smu/smu_7_1_2_d.h"
#include "smu/smu_7_1_2_sh_mask.h"
#include "cgs_common.h"
#include "tonga_smc.h"
#include "smu7_smumgr.h"


static int tonga_start_in_protection_mode(struct pp_smumgr *smumgr)
{
	int result;

	/* Assert reset */
	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
		SMC_SYSCON_RESET_CNTL, rst_reg, 1);

	result = smu7_upload_smu_firmware_image(smumgr);
	if (result)
		return result;

	/* Clear status */
	cgs_write_ind_register(smumgr->device, CGS_IND_REG__SMC,
		ixSMU_STATUS, 0);

	/* Enable clock */
	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
		SMC_SYSCON_CLOCK_CNTL_0, ck_disable, 0);

	/* De-assert reset */
	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
		SMC_SYSCON_RESET_CNTL, rst_reg, 0);

	/* Set SMU Auto Start */
	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
		SMU_INPUT_DATA, AUTO_START, 1);

	/* Clear firmware interrupt enable flag */
	cgs_write_ind_register(smumgr->device, CGS_IND_REG__SMC,
		ixFIRMWARE_FLAGS, 0);

	SMUM_WAIT_VFPF_INDIRECT_FIELD(smumgr, SMC_IND,
		RCU_UC_EVENTS, INTERRUPTS_ENABLED, 1);

	/**
	 * Call Test SMU message with 0x20000 offset to trigger SMU start
	 */
	smu7_send_msg_to_smc_offset(smumgr);

	/* Wait for done bit to be set */
	SMUM_WAIT_VFPF_INDIRECT_FIELD_UNEQUAL(smumgr, SMC_IND,
		SMU_STATUS, SMU_DONE, 0);

	/* Check pass/failed indicator */
	if (1 != SMUM_READ_VFPF_INDIRECT_FIELD(smumgr->device,
				CGS_IND_REG__SMC, SMU_STATUS, SMU_PASS)) {
		pr_err("SMU Firmware start failed\n");
		return -EINVAL;
	}

	/* Wait for firmware to initialize */
	SMUM_WAIT_VFPF_INDIRECT_FIELD(smumgr, SMC_IND,
		FIRMWARE_FLAGS, INTERRUPTS_ENABLED, 1);

	return 0;
}


static int tonga_start_in_non_protection_mode(struct pp_smumgr *smumgr)
{
	int result = 0;

	/* wait for smc boot up */
	SMUM_WAIT_VFPF_INDIRECT_FIELD_UNEQUAL(smumgr, SMC_IND,
		RCU_UC_EVENTS, boot_seq_done, 0);

	/*Clear firmware interrupt enable flag*/
	cgs_write_ind_register(smumgr->device, CGS_IND_REG__SMC,
		ixFIRMWARE_FLAGS, 0);


	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
		SMC_SYSCON_RESET_CNTL, rst_reg, 1);

	result = smu7_upload_smu_firmware_image(smumgr);

	if (result != 0)
		return result;

	/* Set smc instruct start point at 0x0 */
	smu7_program_jump_on_start(smumgr);


	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
		SMC_SYSCON_CLOCK_CNTL_0, ck_disable, 0);

	/*De-assert reset*/
	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
		SMC_SYSCON_RESET_CNTL, rst_reg, 0);

	/* Wait for firmware to initialize */
	SMUM_WAIT_VFPF_INDIRECT_FIELD(smumgr, SMC_IND,
		FIRMWARE_FLAGS, INTERRUPTS_ENABLED, 1);

	return result;
}

static int tonga_start_smu(struct pp_smumgr *smumgr)
{
	int result;

	/* Only start SMC if SMC RAM is not running */
	if (!(smu7_is_smc_ram_running(smumgr) ||
		cgs_is_virtualization_enabled(smumgr->device))) {
		/*Check if SMU is running in protected mode*/
		if (0 == SMUM_READ_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
					SMU_FIRMWARE, SMU_MODE)) {
			result = tonga_start_in_non_protection_mode(smumgr);
			if (result)
				return result;
		} else {
			result = tonga_start_in_protection_mode(smumgr);
			if (result)
				return result;
		}
	}

	result = smu7_request_smu_load_fw(smumgr);

	return result;
}

/**
 * Write a 32bit value to the SMC SRAM space.
 * ALL PARAMETERS ARE IN HOST BYTE ORDER.
 * @param    smumgr  the address of the powerplay hardware manager.
 * @param    smcAddress the address in the SMC RAM to access.
 * @param    value to write to the SMC SRAM.
 */
static int tonga_smu_init(struct pp_smumgr *smumgr)
{
	struct tonga_smumgr *tonga_priv = NULL;
	int  i;

	tonga_priv = kzalloc(sizeof(struct tonga_smumgr), GFP_KERNEL);
	if (tonga_priv == NULL)
		return -ENOMEM;

	smumgr->backend = tonga_priv;

	if (smu7_init(smumgr))
		return -EINVAL;

	for (i = 0; i < SMU72_MAX_LEVELS_GRAPHICS; i++)
		tonga_priv->activity_target[i] = 30;

	return 0;
}

const struct pp_smumgr_func tonga_smu_funcs = {
	.smu_init = &tonga_smu_init,
	.smu_fini = &smu7_smu_fini,
	.start_smu = &tonga_start_smu,
	.check_fw_load_finish = &smu7_check_fw_load_finish,
	.request_smu_load_fw = &smu7_request_smu_load_fw,
	.request_smu_load_specific_fw = NULL,
	.send_msg_to_smc = &smu7_send_msg_to_smc,
	.send_msg_to_smc_with_parameter = &smu7_send_msg_to_smc_with_parameter,
	.download_pptable_settings = NULL,
	.upload_pptable_settings = NULL,
	.update_smc_table = tonga_update_smc_table,
	.get_offsetof = tonga_get_offsetof,
	.process_firmware_header = tonga_process_firmware_header,
	.init_smc_table = tonga_init_smc_table,
	.update_sclk_threshold = tonga_update_sclk_threshold,
	.thermal_setup_fan_table = tonga_thermal_setup_fan_table,
	.populate_all_graphic_levels = tonga_populate_all_graphic_levels,
	.populate_all_memory_levels = tonga_populate_all_memory_levels,
	.get_mac_definition = tonga_get_mac_definition,
	.initialize_mc_reg_table = tonga_initialize_mc_reg_table,
	.is_dpm_running = tonga_is_dpm_running,
	.populate_requested_graphic_levels = tonga_populate_requested_graphic_levels,
};
Commit	Line	Data
1060029f JZ	1	/*
	2	* Copyright 2015 Advanced Micro Devices, Inc.
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	17	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
	18	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	19	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	20	* OTHER DEALINGS IN THE SOFTWARE.
	21	*
	22	*/
7bd55429	23	#include "pp_debug.h"
1060029f JZ	24	#include <linux/types.h>
	25	#include <linux/kernel.h>
	26	#include <linux/slab.h>
	27	#include <linux/gfp.h>
	28
	29	#include "smumgr.h"
	30	#include "tonga_smumgr.h"
1060029f JZ	31	#include "smu_ucode_xfer_vi.h"
	32	#include "tonga_ppsmc.h"
	33	#include "smu/smu_7_1_2_d.h"
	34	#include "smu/smu_7_1_2_sh_mask.h"
	35	#include "cgs_common.h"
14860220	36	#include "tonga_smc.h"
ac43f080	37	#include "smu7_smumgr.h"
1060029f	38
1060029f JZ	39
	40	static int tonga_start_in_protection_mode(struct pp_smumgr *smumgr)
	41	{
	42	int result;
	43
	44	/* Assert reset */
	45	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
	46	SMC_SYSCON_RESET_CNTL, rst_reg, 1);
	47
ac43f080	48	result = smu7_upload_smu_firmware_image(smumgr);
1060029f JZ	49	if (result)
	50	return result;
	51
	52	/* Clear status */
	53	cgs_write_ind_register(smumgr->device, CGS_IND_REG__SMC,
	54	ixSMU_STATUS, 0);
	55
	56	/* Enable clock */
	57	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
	58	SMC_SYSCON_CLOCK_CNTL_0, ck_disable, 0);
	59
	60	/* De-assert reset */
	61	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
	62	SMC_SYSCON_RESET_CNTL, rst_reg, 0);
	63
	64	/* Set SMU Auto Start */
	65	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
	66	SMU_INPUT_DATA, AUTO_START, 1);
	67
	68	/* Clear firmware interrupt enable flag */
	69	cgs_write_ind_register(smumgr->device, CGS_IND_REG__SMC,
	70	ixFIRMWARE_FLAGS, 0);
	71
	72	SMUM_WAIT_VFPF_INDIRECT_FIELD(smumgr, SMC_IND,
	73	RCU_UC_EVENTS, INTERRUPTS_ENABLED, 1);
	74
	75	/**
	76	* Call Test SMU message with 0x20000 offset to trigger SMU start
	77	*/
ac43f080	78	smu7_send_msg_to_smc_offset(smumgr);
1060029f JZ	79
	80	/* Wait for done bit to be set */
	81	SMUM_WAIT_VFPF_INDIRECT_FIELD_UNEQUAL(smumgr, SMC_IND,
	82	SMU_STATUS, SMU_DONE, 0);
	83
	84	/* Check pass/failed indicator */
	85	if (1 != SMUM_READ_VFPF_INDIRECT_FIELD(smumgr->device,
	86	CGS_IND_REG__SMC, SMU_STATUS, SMU_PASS)) {
634a24d8	87	pr_err("SMU Firmware start failed\n");
1060029f JZ	88	return -EINVAL;
	89	}
	90
	91	/* Wait for firmware to initialize */
	92	SMUM_WAIT_VFPF_INDIRECT_FIELD(smumgr, SMC_IND,
	93	FIRMWARE_FLAGS, INTERRUPTS_ENABLED, 1);
	94
	95	return 0;
	96	}
	97
	98
	99	static int tonga_start_in_non_protection_mode(struct pp_smumgr *smumgr)
	100	{
	101	int result = 0;
	102
	103	/* wait for smc boot up */
	104	SMUM_WAIT_VFPF_INDIRECT_FIELD_UNEQUAL(smumgr, SMC_IND,
	105	RCU_UC_EVENTS, boot_seq_done, 0);
	106
	107	/Clear firmware interrupt enable flag/
	108	cgs_write_ind_register(smumgr->device, CGS_IND_REG__SMC,
	109	ixFIRMWARE_FLAGS, 0);
	110
	111
	112	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
	113	SMC_SYSCON_RESET_CNTL, rst_reg, 1);
	114
ac43f080	115	result = smu7_upload_smu_firmware_image(smumgr);
1060029f JZ	116
	117	if (result != 0)
	118	return result;
	119
	120	/* Set smc instruct start point at 0x0 */
ac43f080	121	smu7_program_jump_on_start(smumgr);
1060029f JZ	122
	123
	124	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
	125	SMC_SYSCON_CLOCK_CNTL_0, ck_disable, 0);
	126
	127	/De-assert reset/
	128	SMUM_WRITE_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
	129	SMC_SYSCON_RESET_CNTL, rst_reg, 0);
	130
	131	/* Wait for firmware to initialize */
	132	SMUM_WAIT_VFPF_INDIRECT_FIELD(smumgr, SMC_IND,
	133	FIRMWARE_FLAGS, INTERRUPTS_ENABLED, 1);
	134
	135	return result;
	136	}
	137
	138	static int tonga_start_smu(struct pp_smumgr *smumgr)
	139	{
	140	int result;
	141
	142	/* Only start SMC if SMC RAM is not running */
06199554 TH	143	if (!(smu7_is_smc_ram_running(smumgr) \|\|
06199554 TH	144	cgs_is_virtualization_enabled(smumgr->device))) {
1060029f JZ	145	/Check if SMU is running in protected mode/
	146	if (0 == SMUM_READ_VFPF_INDIRECT_FIELD(smumgr->device, CGS_IND_REG__SMC,
	147	SMU_FIRMWARE, SMU_MODE)) {
	148	result = tonga_start_in_non_protection_mode(smumgr);
	149	if (result)
	150	return result;
	151	} else {
	152	result = tonga_start_in_protection_mode(smumgr);
	153	if (result)
	154	return result;
	155	}
	156	}
	157
ac43f080	158	result = smu7_request_smu_load_fw(smumgr);
1060029f JZ	159
	160	return result;
	161	}
	162
	163	/**
	164	* Write a 32bit value to the SMC SRAM space.
	165	* ALL PARAMETERS ARE IN HOST BYTE ORDER.
	166	* @param smumgr the address of the powerplay hardware manager.
	167	* @param smcAddress the address in the SMC RAM to access.
	168	* @param value to write to the SMC SRAM.
	169	*/
	170	static int tonga_smu_init(struct pp_smumgr *smumgr)
	171	{
63b55943 RZ	172	struct tonga_smumgr *tonga_priv = NULL;
63b55943 RZ	173	int i;
ac43f080	174
63b55943 RZ	175	tonga_priv = kzalloc(sizeof(struct tonga_smumgr), GFP_KERNEL);
	176	if (tonga_priv == NULL)
	177	return -ENOMEM;
	178
	179	smumgr->backend = tonga_priv;
14860220	180
ac43f080 RZ	181	if (smu7_init(smumgr))
ac43f080 RZ	182	return -EINVAL;
1060029f	183
14860220	184	for (i = 0; i < SMU72_MAX_LEVELS_GRAPHICS; i++)
63b55943	185	tonga_priv->activity_target[i] = 30;
14860220	186
1060029f JZ	187	return 0;
	188	}
	189
63b55943	190	const struct pp_smumgr_func tonga_smu_funcs = {
1060029f	191	.smu_init = &tonga_smu_init,
ac43f080	192	.smu_fini = &smu7_smu_fini,
1060029f	193	.start_smu = &tonga_start_smu,
ac43f080 RZ	194	.check_fw_load_finish = &smu7_check_fw_load_finish,
	195	.request_smu_load_fw = &smu7_request_smu_load_fw,
	196	.request_smu_load_specific_fw = NULL,
	197	.send_msg_to_smc = &smu7_send_msg_to_smc,
	198	.send_msg_to_smc_with_parameter = &smu7_send_msg_to_smc_with_parameter,
1060029f JZ	199	.download_pptable_settings = NULL,
1060029f JZ	200	.upload_pptable_settings = NULL,
14860220 RZ	201	.update_smc_table = tonga_update_smc_table,
	202	.get_offsetof = tonga_get_offsetof,
	203	.process_firmware_header = tonga_process_firmware_header,
	204	.init_smc_table = tonga_init_smc_table,
	205	.update_sclk_threshold = tonga_update_sclk_threshold,
	206	.thermal_setup_fan_table = tonga_thermal_setup_fan_table,
	207	.populate_all_graphic_levels = tonga_populate_all_graphic_levels,
	208	.populate_all_memory_levels = tonga_populate_all_memory_levels,
	209	.get_mac_definition = tonga_get_mac_definition,
	210	.initialize_mc_reg_table = tonga_initialize_mc_reg_table,
	211	.is_dpm_running = tonga_is_dpm_running,
3ed2584f	212	.populate_requested_graphic_levels = tonga_populate_requested_graphic_levels,
1060029f	213	};