Home | History | Annotate | Line # | Download | only in radeon
      1 /*	$NetBSD: radeon_cypress_dpm.c,v 1.3 2022/07/15 06:42:08 mrg Exp $	*/
      2 
      3 /*
      4  * Copyright 2011 Advanced Micro Devices, Inc.
      5  *
      6  * Permission is hereby granted, free of charge, to any person obtaining a
      7  * copy of this software and associated documentation files (the "Software"),
      8  * to deal in the Software without restriction, including without limitation
      9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
     10  * and/or sell copies of the Software, and to permit persons to whom the
     11  * Software is furnished to do so, subject to the following conditions:
     12  *
     13  * The above copyright notice and this permission notice shall be included in
     14  * all copies or substantial portions of the Software.
     15  *
     16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
     19  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
     20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
     21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
     22  * OTHER DEALINGS IN THE SOFTWARE.
     23  *
     24  * Authors: Alex Deucher
     25  */
     26 
     27 #include <sys/cdefs.h>
     28 __KERNEL_RCSID(0, "$NetBSD: radeon_cypress_dpm.c,v 1.3 2022/07/15 06:42:08 mrg Exp $");
     29 
     30 #include <linux/pci.h>
     31 
     32 #include "atom.h"
     33 #include "cypress_dpm.h"
     34 #include "evergreend.h"
     35 #include "r600_dpm.h"
     36 #include "radeon.h"
     37 #include "radeon_asic.h"
     38 
     39 #define SMC_RAM_END 0x8000
     40 
     41 #define MC_CG_ARB_FREQ_F0           0x0a
     42 #define MC_CG_ARB_FREQ_F1           0x0b
     43 #define MC_CG_ARB_FREQ_F2           0x0c
     44 #define MC_CG_ARB_FREQ_F3           0x0d
     45 
     46 #define MC_CG_SEQ_DRAMCONF_S0       0x05
     47 #define MC_CG_SEQ_DRAMCONF_S1       0x06
     48 #define MC_CG_SEQ_YCLK_SUSPEND      0x04
     49 #define MC_CG_SEQ_YCLK_RESUME       0x0a
     50 
     51 struct rv7xx_ps *rv770_get_ps(struct radeon_ps *rps);
     52 struct rv7xx_power_info *rv770_get_pi(struct radeon_device *rdev);
     53 struct evergreen_power_info *evergreen_get_pi(struct radeon_device *rdev);
     54 
     55 static void cypress_enable_bif_dynamic_pcie_gen2(struct radeon_device *rdev,
     56 						 bool enable)
     57 {
     58 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
     59 	u32 tmp, bif;
     60 
     61 	tmp = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
     62 	if (enable) {
     63 		if ((tmp & LC_OTHER_SIDE_EVER_SENT_GEN2) &&
     64 		    (tmp & LC_OTHER_SIDE_SUPPORTS_GEN2)) {
     65 			if (!pi->boot_in_gen2) {
     66 				bif = RREG32(CG_BIF_REQ_AND_RSP) & ~CG_CLIENT_REQ_MASK;
     67 				bif |= CG_CLIENT_REQ(0xd);
     68 				WREG32(CG_BIF_REQ_AND_RSP, bif);
     69 
     70 				tmp &= ~LC_HW_VOLTAGE_IF_CONTROL_MASK;
     71 				tmp |= LC_HW_VOLTAGE_IF_CONTROL(1);
     72 				tmp |= LC_GEN2_EN_STRAP;
     73 
     74 				tmp |= LC_CLR_FAILED_SPD_CHANGE_CNT;
     75 				WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, tmp);
     76 				udelay(10);
     77 				tmp &= ~LC_CLR_FAILED_SPD_CHANGE_CNT;
     78 				WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, tmp);
     79 			}
     80 		}
     81 	} else {
     82 		if (!pi->boot_in_gen2) {
     83 			tmp &= ~LC_HW_VOLTAGE_IF_CONTROL_MASK;
     84 			tmp &= ~LC_GEN2_EN_STRAP;
     85 		}
     86 		if ((tmp & LC_OTHER_SIDE_EVER_SENT_GEN2) ||
     87 		    (tmp & LC_OTHER_SIDE_SUPPORTS_GEN2))
     88 			WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, tmp);
     89 	}
     90 }
     91 
     92 static void cypress_enable_dynamic_pcie_gen2(struct radeon_device *rdev,
     93 					     bool enable)
     94 {
     95 	cypress_enable_bif_dynamic_pcie_gen2(rdev, enable);
     96 
     97 	if (enable)
     98 		WREG32_P(GENERAL_PWRMGT, ENABLE_GEN2PCIE, ~ENABLE_GEN2PCIE);
     99 	else
    100 		WREG32_P(GENERAL_PWRMGT, 0, ~ENABLE_GEN2PCIE);
    101 }
    102 
    103 #if 0
    104 static int cypress_enter_ulp_state(struct radeon_device *rdev)
    105 {
    106 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    107 
    108 	if (pi->gfx_clock_gating) {
    109 		WREG32_P(SCLK_PWRMGT_CNTL, 0, ~DYN_GFX_CLK_OFF_EN);
    110 		WREG32_P(SCLK_PWRMGT_CNTL, GFX_CLK_FORCE_ON, ~GFX_CLK_FORCE_ON);
    111 		WREG32_P(SCLK_PWRMGT_CNTL, 0, ~GFX_CLK_FORCE_ON);
    112 
    113 		RREG32(GB_ADDR_CONFIG);
    114 	}
    115 
    116 	WREG32_P(SMC_MSG, HOST_SMC_MSG(PPSMC_MSG_SwitchToMinimumPower),
    117 		 ~HOST_SMC_MSG_MASK);
    118 
    119 	udelay(7000);
    120 
    121 	return 0;
    122 }
    123 #endif
    124 
    125 static void cypress_gfx_clock_gating_enable(struct radeon_device *rdev,
    126 					    bool enable)
    127 {
    128 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    129 
    130 	if (enable) {
    131 		if (eg_pi->light_sleep) {
    132 			WREG32(GRBM_GFX_INDEX, 0xC0000000);
    133 
    134 			WREG32_CG(CG_CGLS_TILE_0, 0xFFFFFFFF);
    135 			WREG32_CG(CG_CGLS_TILE_1, 0xFFFFFFFF);
    136 			WREG32_CG(CG_CGLS_TILE_2, 0xFFFFFFFF);
    137 			WREG32_CG(CG_CGLS_TILE_3, 0xFFFFFFFF);
    138 			WREG32_CG(CG_CGLS_TILE_4, 0xFFFFFFFF);
    139 			WREG32_CG(CG_CGLS_TILE_5, 0xFFFFFFFF);
    140 			WREG32_CG(CG_CGLS_TILE_6, 0xFFFFFFFF);
    141 			WREG32_CG(CG_CGLS_TILE_7, 0xFFFFFFFF);
    142 			WREG32_CG(CG_CGLS_TILE_8, 0xFFFFFFFF);
    143 			WREG32_CG(CG_CGLS_TILE_9, 0xFFFFFFFF);
    144 			WREG32_CG(CG_CGLS_TILE_10, 0xFFFFFFFF);
    145 			WREG32_CG(CG_CGLS_TILE_11, 0xFFFFFFFF);
    146 
    147 			WREG32_P(SCLK_PWRMGT_CNTL, DYN_LIGHT_SLEEP_EN, ~DYN_LIGHT_SLEEP_EN);
    148 		}
    149 		WREG32_P(SCLK_PWRMGT_CNTL, DYN_GFX_CLK_OFF_EN, ~DYN_GFX_CLK_OFF_EN);
    150 	} else {
    151 		WREG32_P(SCLK_PWRMGT_CNTL, 0, ~DYN_GFX_CLK_OFF_EN);
    152 		WREG32_P(SCLK_PWRMGT_CNTL, GFX_CLK_FORCE_ON, ~GFX_CLK_FORCE_ON);
    153 		WREG32_P(SCLK_PWRMGT_CNTL, 0, ~GFX_CLK_FORCE_ON);
    154 		RREG32(GB_ADDR_CONFIG);
    155 
    156 		if (eg_pi->light_sleep) {
    157 			WREG32_P(SCLK_PWRMGT_CNTL, 0, ~DYN_LIGHT_SLEEP_EN);
    158 
    159 			WREG32(GRBM_GFX_INDEX, 0xC0000000);
    160 
    161 			WREG32_CG(CG_CGLS_TILE_0, 0);
    162 			WREG32_CG(CG_CGLS_TILE_1, 0);
    163 			WREG32_CG(CG_CGLS_TILE_2, 0);
    164 			WREG32_CG(CG_CGLS_TILE_3, 0);
    165 			WREG32_CG(CG_CGLS_TILE_4, 0);
    166 			WREG32_CG(CG_CGLS_TILE_5, 0);
    167 			WREG32_CG(CG_CGLS_TILE_6, 0);
    168 			WREG32_CG(CG_CGLS_TILE_7, 0);
    169 			WREG32_CG(CG_CGLS_TILE_8, 0);
    170 			WREG32_CG(CG_CGLS_TILE_9, 0);
    171 			WREG32_CG(CG_CGLS_TILE_10, 0);
    172 			WREG32_CG(CG_CGLS_TILE_11, 0);
    173 		}
    174 	}
    175 }
    176 
    177 static void cypress_mg_clock_gating_enable(struct radeon_device *rdev,
    178 					   bool enable)
    179 {
    180 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    181 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    182 
    183 	if (enable) {
    184 		u32 cgts_sm_ctrl_reg;
    185 
    186 		if (rdev->family == CHIP_CEDAR)
    187 			cgts_sm_ctrl_reg = CEDAR_MGCGCGTSSMCTRL_DFLT;
    188 		else if (rdev->family == CHIP_REDWOOD)
    189 			cgts_sm_ctrl_reg = REDWOOD_MGCGCGTSSMCTRL_DFLT;
    190 		else
    191 			cgts_sm_ctrl_reg = CYPRESS_MGCGCGTSSMCTRL_DFLT;
    192 
    193 		WREG32(GRBM_GFX_INDEX, 0xC0000000);
    194 
    195 		WREG32_CG(CG_CGTT_LOCAL_0, CYPRESS_MGCGTTLOCAL0_DFLT);
    196 		WREG32_CG(CG_CGTT_LOCAL_1, CYPRESS_MGCGTTLOCAL1_DFLT & 0xFFFFCFFF);
    197 		WREG32_CG(CG_CGTT_LOCAL_2, CYPRESS_MGCGTTLOCAL2_DFLT);
    198 		WREG32_CG(CG_CGTT_LOCAL_3, CYPRESS_MGCGTTLOCAL3_DFLT);
    199 
    200 		if (pi->mgcgtssm)
    201 			WREG32(CGTS_SM_CTRL_REG, cgts_sm_ctrl_reg);
    202 
    203 		if (eg_pi->mcls) {
    204 			WREG32_P(MC_CITF_MISC_RD_CG, MEM_LS_ENABLE, ~MEM_LS_ENABLE);
    205 			WREG32_P(MC_CITF_MISC_WR_CG, MEM_LS_ENABLE, ~MEM_LS_ENABLE);
    206 			WREG32_P(MC_CITF_MISC_VM_CG, MEM_LS_ENABLE, ~MEM_LS_ENABLE);
    207 			WREG32_P(MC_HUB_MISC_HUB_CG, MEM_LS_ENABLE, ~MEM_LS_ENABLE);
    208 			WREG32_P(MC_HUB_MISC_VM_CG, MEM_LS_ENABLE, ~MEM_LS_ENABLE);
    209 			WREG32_P(MC_HUB_MISC_SIP_CG, MEM_LS_ENABLE, ~MEM_LS_ENABLE);
    210 			WREG32_P(MC_XPB_CLK_GAT, MEM_LS_ENABLE, ~MEM_LS_ENABLE);
    211 			WREG32_P(VM_L2_CG, MEM_LS_ENABLE, ~MEM_LS_ENABLE);
    212 		}
    213 	} else {
    214 		WREG32(GRBM_GFX_INDEX, 0xC0000000);
    215 
    216 		WREG32_CG(CG_CGTT_LOCAL_0, 0xFFFFFFFF);
    217 		WREG32_CG(CG_CGTT_LOCAL_1, 0xFFFFFFFF);
    218 		WREG32_CG(CG_CGTT_LOCAL_2, 0xFFFFFFFF);
    219 		WREG32_CG(CG_CGTT_LOCAL_3, 0xFFFFFFFF);
    220 
    221 		if (pi->mgcgtssm)
    222 			WREG32(CGTS_SM_CTRL_REG, 0x81f44bc0);
    223 	}
    224 }
    225 
    226 void cypress_enable_spread_spectrum(struct radeon_device *rdev,
    227 				    bool enable)
    228 {
    229 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    230 
    231 	if (enable) {
    232 		if (pi->sclk_ss)
    233 			WREG32_P(GENERAL_PWRMGT, DYN_SPREAD_SPECTRUM_EN, ~DYN_SPREAD_SPECTRUM_EN);
    234 
    235 		if (pi->mclk_ss)
    236 			WREG32_P(MPLL_CNTL_MODE, SS_SSEN, ~SS_SSEN);
    237 	} else {
    238 		WREG32_P(CG_SPLL_SPREAD_SPECTRUM, 0, ~SSEN);
    239 		WREG32_P(GENERAL_PWRMGT, 0, ~DYN_SPREAD_SPECTRUM_EN);
    240 		WREG32_P(MPLL_CNTL_MODE, 0, ~SS_SSEN);
    241 		WREG32_P(MPLL_CNTL_MODE, 0, ~SS_DSMODE_EN);
    242 	}
    243 }
    244 
    245 void cypress_start_dpm(struct radeon_device *rdev)
    246 {
    247 	WREG32_P(GENERAL_PWRMGT, GLOBAL_PWRMGT_EN, ~GLOBAL_PWRMGT_EN);
    248 }
    249 
    250 void cypress_enable_sclk_control(struct radeon_device *rdev,
    251 				 bool enable)
    252 {
    253 	if (enable)
    254 		WREG32_P(SCLK_PWRMGT_CNTL, 0, ~SCLK_PWRMGT_OFF);
    255 	else
    256 		WREG32_P(SCLK_PWRMGT_CNTL, SCLK_PWRMGT_OFF, ~SCLK_PWRMGT_OFF);
    257 }
    258 
    259 void cypress_enable_mclk_control(struct radeon_device *rdev,
    260 				 bool enable)
    261 {
    262 	if (enable)
    263 		WREG32_P(MCLK_PWRMGT_CNTL, 0, ~MPLL_PWRMGT_OFF);
    264 	else
    265 		WREG32_P(MCLK_PWRMGT_CNTL, MPLL_PWRMGT_OFF, ~MPLL_PWRMGT_OFF);
    266 }
    267 
    268 int cypress_notify_smc_display_change(struct radeon_device *rdev,
    269 				      bool has_display)
    270 {
    271 	PPSMC_Msg msg = has_display ?
    272 		(PPSMC_Msg)PPSMC_MSG_HasDisplay : (PPSMC_Msg)PPSMC_MSG_NoDisplay;
    273 
    274 	if (rv770_send_msg_to_smc(rdev, msg) != PPSMC_Result_OK)
    275 		return -EINVAL;
    276 
    277 	return 0;
    278 }
    279 
    280 void cypress_program_response_times(struct radeon_device *rdev)
    281 {
    282 	u32 reference_clock;
    283 	u32 mclk_switch_limit;
    284 
    285 	reference_clock = radeon_get_xclk(rdev);
    286 	mclk_switch_limit = (460 * reference_clock) / 100;
    287 
    288 	rv770_write_smc_soft_register(rdev,
    289 				      RV770_SMC_SOFT_REGISTER_mclk_switch_lim,
    290 				      mclk_switch_limit);
    291 
    292 	rv770_write_smc_soft_register(rdev,
    293 				      RV770_SMC_SOFT_REGISTER_mvdd_chg_time, 1);
    294 
    295 	rv770_write_smc_soft_register(rdev,
    296 				      RV770_SMC_SOFT_REGISTER_mc_block_delay, 0xAA);
    297 
    298 	rv770_program_response_times(rdev);
    299 
    300 	if (ASIC_IS_LOMBOK(rdev))
    301 		rv770_write_smc_soft_register(rdev,
    302 					      RV770_SMC_SOFT_REGISTER_is_asic_lombok, 1);
    303 
    304 }
    305 
    306 static int cypress_pcie_performance_request(struct radeon_device *rdev,
    307 					    u8 perf_req, bool advertise)
    308 {
    309 #if defined(CONFIG_ACPI)
    310 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    311 #endif
    312 	u32 tmp;
    313 
    314 	udelay(10);
    315 	tmp = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
    316 	if ((perf_req == PCIE_PERF_REQ_PECI_GEN1) && (tmp & LC_CURRENT_DATA_RATE))
    317 		return 0;
    318 
    319 #if defined(CONFIG_ACPI)
    320 	if ((perf_req == PCIE_PERF_REQ_PECI_GEN1) ||
    321 	    (perf_req == PCIE_PERF_REQ_PECI_GEN2)) {
    322 		eg_pi->pcie_performance_request_registered = true;
    323 		return radeon_acpi_pcie_performance_request(rdev, perf_req, advertise);
    324 	} else if ((perf_req == PCIE_PERF_REQ_REMOVE_REGISTRY) &&
    325 		   eg_pi->pcie_performance_request_registered) {
    326 		eg_pi->pcie_performance_request_registered = false;
    327 		return radeon_acpi_pcie_performance_request(rdev, perf_req, advertise);
    328 	}
    329 #endif
    330 
    331 	return 0;
    332 }
    333 
    334 void cypress_advertise_gen2_capability(struct radeon_device *rdev)
    335 {
    336 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    337 	u32 tmp;
    338 
    339 #if defined(CONFIG_ACPI)
    340 	radeon_acpi_pcie_notify_device_ready(rdev);
    341 #endif
    342 
    343 	tmp = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
    344 
    345 	if ((tmp & LC_OTHER_SIDE_EVER_SENT_GEN2) &&
    346 	    (tmp & LC_OTHER_SIDE_SUPPORTS_GEN2))
    347 		pi->pcie_gen2 = true;
    348 	else
    349 		pi->pcie_gen2 = false;
    350 
    351 	if (!pi->pcie_gen2)
    352 		cypress_pcie_performance_request(rdev, PCIE_PERF_REQ_PECI_GEN2, true);
    353 
    354 }
    355 
    356 static enum radeon_pcie_gen cypress_get_maximum_link_speed(struct radeon_ps *radeon_state)
    357 {
    358 	struct rv7xx_ps *state = rv770_get_ps(radeon_state);
    359 
    360 	if (state->high.flags & ATOM_PPLIB_R600_FLAGS_PCIEGEN2)
    361 		return 1;
    362 	return 0;
    363 }
    364 
    365 void cypress_notify_link_speed_change_after_state_change(struct radeon_device *rdev,
    366 							 struct radeon_ps *radeon_new_state,
    367 							 struct radeon_ps *radeon_current_state)
    368 {
    369 	enum radeon_pcie_gen pcie_link_speed_target =
    370 		cypress_get_maximum_link_speed(radeon_new_state);
    371 	enum radeon_pcie_gen pcie_link_speed_current =
    372 		cypress_get_maximum_link_speed(radeon_current_state);
    373 	u8 request;
    374 
    375 	if (pcie_link_speed_target < pcie_link_speed_current) {
    376 		if (pcie_link_speed_target == RADEON_PCIE_GEN1)
    377 			request = PCIE_PERF_REQ_PECI_GEN1;
    378 		else if (pcie_link_speed_target == RADEON_PCIE_GEN2)
    379 			request = PCIE_PERF_REQ_PECI_GEN2;
    380 		else
    381 			request = PCIE_PERF_REQ_PECI_GEN3;
    382 
    383 		cypress_pcie_performance_request(rdev, request, false);
    384 	}
    385 }
    386 
    387 void cypress_notify_link_speed_change_before_state_change(struct radeon_device *rdev,
    388 							  struct radeon_ps *radeon_new_state,
    389 							  struct radeon_ps *radeon_current_state)
    390 {
    391 	enum radeon_pcie_gen pcie_link_speed_target =
    392 		cypress_get_maximum_link_speed(radeon_new_state);
    393 	enum radeon_pcie_gen pcie_link_speed_current =
    394 		cypress_get_maximum_link_speed(radeon_current_state);
    395 	u8 request;
    396 
    397 	if (pcie_link_speed_target > pcie_link_speed_current) {
    398 		if (pcie_link_speed_target == RADEON_PCIE_GEN1)
    399 			request = PCIE_PERF_REQ_PECI_GEN1;
    400 		else if (pcie_link_speed_target == RADEON_PCIE_GEN2)
    401 			request = PCIE_PERF_REQ_PECI_GEN2;
    402 		else
    403 			request = PCIE_PERF_REQ_PECI_GEN3;
    404 
    405 		cypress_pcie_performance_request(rdev, request, false);
    406 	}
    407 }
    408 
    409 static int cypress_populate_voltage_value(struct radeon_device *rdev,
    410 					  struct atom_voltage_table *table,
    411 					  u16 value, RV770_SMC_VOLTAGE_VALUE *voltage)
    412 {
    413 	unsigned int i;
    414 
    415 	for (i = 0; i < table->count; i++) {
    416 		if (value <= table->entries[i].value) {
    417 			voltage->index = (u8)i;
    418 			voltage->value = cpu_to_be16(table->entries[i].value);
    419 			break;
    420 		}
    421 	}
    422 
    423 	if (i == table->count)
    424 		return -EINVAL;
    425 
    426 	return 0;
    427 }
    428 
    429 u8 cypress_get_strobe_mode_settings(struct radeon_device *rdev, u32 mclk)
    430 {
    431 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    432 	u8 result = 0;
    433 	bool strobe_mode = false;
    434 
    435 	if (pi->mem_gddr5) {
    436 		if (mclk <= pi->mclk_strobe_mode_threshold)
    437 			strobe_mode = true;
    438 		result = cypress_get_mclk_frequency_ratio(rdev, mclk, strobe_mode);
    439 
    440 		if (strobe_mode)
    441 			result |= SMC_STROBE_ENABLE;
    442 	}
    443 
    444 	return result;
    445 }
    446 
    447 u32 cypress_map_clkf_to_ibias(struct radeon_device *rdev, u32 clkf)
    448 {
    449 	u32 ref_clk = rdev->clock.mpll.reference_freq;
    450 	u32 vco = clkf * ref_clk;
    451 
    452 	/* 100 Mhz ref clk */
    453 	if (ref_clk == 10000) {
    454 		if (vco > 500000)
    455 			return 0xC6;
    456 		if (vco > 400000)
    457 			return 0x9D;
    458 		if (vco > 330000)
    459 			return 0x6C;
    460 		if (vco > 250000)
    461 			return 0x2B;
    462 		if (vco >  160000)
    463 			return 0x5B;
    464 		if (vco > 120000)
    465 			return 0x0A;
    466 		return 0x4B;
    467 	}
    468 
    469 	/* 27 Mhz ref clk */
    470 	if (vco > 250000)
    471 		return 0x8B;
    472 	if (vco > 200000)
    473 		return 0xCC;
    474 	if (vco > 150000)
    475 		return 0x9B;
    476 	return 0x6B;
    477 }
    478 
    479 static int cypress_populate_mclk_value(struct radeon_device *rdev,
    480 				       u32 engine_clock, u32 memory_clock,
    481 				       RV7XX_SMC_MCLK_VALUE *mclk,
    482 				       bool strobe_mode, bool dll_state_on)
    483 {
    484 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    485 
    486 	u32 mpll_ad_func_cntl =
    487 		pi->clk_regs.rv770.mpll_ad_func_cntl;
    488 	u32 mpll_ad_func_cntl_2 =
    489 		pi->clk_regs.rv770.mpll_ad_func_cntl_2;
    490 	u32 mpll_dq_func_cntl =
    491 		pi->clk_regs.rv770.mpll_dq_func_cntl;
    492 	u32 mpll_dq_func_cntl_2 =
    493 		pi->clk_regs.rv770.mpll_dq_func_cntl_2;
    494 	u32 mclk_pwrmgt_cntl =
    495 		pi->clk_regs.rv770.mclk_pwrmgt_cntl;
    496 	u32 dll_cntl =
    497 		pi->clk_regs.rv770.dll_cntl;
    498 	u32 mpll_ss1 = pi->clk_regs.rv770.mpll_ss1;
    499 	u32 mpll_ss2 = pi->clk_regs.rv770.mpll_ss2;
    500 	struct atom_clock_dividers dividers;
    501 	u32 ibias;
    502 	u32 dll_speed;
    503 	int ret;
    504 	u32 mc_seq_misc7;
    505 
    506 	ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_MEMORY_PLL_PARAM,
    507 					     memory_clock, strobe_mode, &dividers);
    508 	if (ret)
    509 		return ret;
    510 
    511 	if (!strobe_mode) {
    512 		mc_seq_misc7 = RREG32(MC_SEQ_MISC7);
    513 
    514 		if(mc_seq_misc7 & 0x8000000)
    515 			dividers.post_div = 1;
    516 	}
    517 
    518 	ibias = cypress_map_clkf_to_ibias(rdev, dividers.whole_fb_div);
    519 
    520 	mpll_ad_func_cntl &= ~(CLKR_MASK |
    521 			       YCLK_POST_DIV_MASK |
    522 			       CLKF_MASK |
    523 			       CLKFRAC_MASK |
    524 			       IBIAS_MASK);
    525 	mpll_ad_func_cntl |= CLKR(dividers.ref_div);
    526 	mpll_ad_func_cntl |= YCLK_POST_DIV(dividers.post_div);
    527 	mpll_ad_func_cntl |= CLKF(dividers.whole_fb_div);
    528 	mpll_ad_func_cntl |= CLKFRAC(dividers.frac_fb_div);
    529 	mpll_ad_func_cntl |= IBIAS(ibias);
    530 
    531 	if (dividers.vco_mode)
    532 		mpll_ad_func_cntl_2 |= VCO_MODE;
    533 	else
    534 		mpll_ad_func_cntl_2 &= ~VCO_MODE;
    535 
    536 	if (pi->mem_gddr5) {
    537 		mpll_dq_func_cntl &= ~(CLKR_MASK |
    538 				       YCLK_POST_DIV_MASK |
    539 				       CLKF_MASK |
    540 				       CLKFRAC_MASK |
    541 				       IBIAS_MASK);
    542 		mpll_dq_func_cntl |= CLKR(dividers.ref_div);
    543 		mpll_dq_func_cntl |= YCLK_POST_DIV(dividers.post_div);
    544 		mpll_dq_func_cntl |= CLKF(dividers.whole_fb_div);
    545 		mpll_dq_func_cntl |= CLKFRAC(dividers.frac_fb_div);
    546 		mpll_dq_func_cntl |= IBIAS(ibias);
    547 
    548 		if (strobe_mode)
    549 			mpll_dq_func_cntl &= ~PDNB;
    550 		else
    551 			mpll_dq_func_cntl |= PDNB;
    552 
    553 		if (dividers.vco_mode)
    554 			mpll_dq_func_cntl_2 |= VCO_MODE;
    555 		else
    556 			mpll_dq_func_cntl_2 &= ~VCO_MODE;
    557 	}
    558 
    559 	if (pi->mclk_ss) {
    560 		struct radeon_atom_ss ss;
    561 		u32 vco_freq = memory_clock * dividers.post_div;
    562 
    563 		if (radeon_atombios_get_asic_ss_info(rdev, &ss,
    564 						     ASIC_INTERNAL_MEMORY_SS, vco_freq)) {
    565 			u32 reference_clock = rdev->clock.mpll.reference_freq;
    566 			u32 decoded_ref = rv740_get_decoded_reference_divider(dividers.ref_div);
    567 			u32 clk_s = reference_clock * 5 / (decoded_ref * ss.rate);
    568 			u32 clk_v = ss.percentage *
    569 				(0x4000 * dividers.whole_fb_div + 0x800 * dividers.frac_fb_div) / (clk_s * 625);
    570 
    571 			mpll_ss1 &= ~CLKV_MASK;
    572 			mpll_ss1 |= CLKV(clk_v);
    573 
    574 			mpll_ss2 &= ~CLKS_MASK;
    575 			mpll_ss2 |= CLKS(clk_s);
    576 		}
    577 	}
    578 
    579 	dll_speed = rv740_get_dll_speed(pi->mem_gddr5,
    580 					memory_clock);
    581 
    582 	mclk_pwrmgt_cntl &= ~DLL_SPEED_MASK;
    583 	mclk_pwrmgt_cntl |= DLL_SPEED(dll_speed);
    584 	if (dll_state_on)
    585 		mclk_pwrmgt_cntl |= (MRDCKA0_PDNB |
    586 				     MRDCKA1_PDNB |
    587 				     MRDCKB0_PDNB |
    588 				     MRDCKB1_PDNB |
    589 				     MRDCKC0_PDNB |
    590 				     MRDCKC1_PDNB |
    591 				     MRDCKD0_PDNB |
    592 				     MRDCKD1_PDNB);
    593 	else
    594 		mclk_pwrmgt_cntl &= ~(MRDCKA0_PDNB |
    595 				      MRDCKA1_PDNB |
    596 				      MRDCKB0_PDNB |
    597 				      MRDCKB1_PDNB |
    598 				      MRDCKC0_PDNB |
    599 				      MRDCKC1_PDNB |
    600 				      MRDCKD0_PDNB |
    601 				      MRDCKD1_PDNB);
    602 
    603 	mclk->mclk770.mclk_value = cpu_to_be32(memory_clock);
    604 	mclk->mclk770.vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl);
    605 	mclk->mclk770.vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2);
    606 	mclk->mclk770.vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl);
    607 	mclk->mclk770.vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2);
    608 	mclk->mclk770.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl);
    609 	mclk->mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl);
    610 	mclk->mclk770.vMPLL_SS = cpu_to_be32(mpll_ss1);
    611 	mclk->mclk770.vMPLL_SS2 = cpu_to_be32(mpll_ss2);
    612 
    613 	return 0;
    614 }
    615 
    616 u8 cypress_get_mclk_frequency_ratio(struct radeon_device *rdev,
    617 				    u32 memory_clock, bool strobe_mode)
    618 {
    619 	u8 mc_para_index;
    620 
    621 	if (rdev->family >= CHIP_BARTS) {
    622 		if (strobe_mode) {
    623 			if (memory_clock < 10000)
    624 				mc_para_index = 0x00;
    625 			else if (memory_clock > 47500)
    626 				mc_para_index = 0x0f;
    627 			else
    628 				mc_para_index = (u8)((memory_clock - 10000) / 2500);
    629 		} else {
    630 			if (memory_clock < 65000)
    631 				mc_para_index = 0x00;
    632 			else if (memory_clock > 135000)
    633 				mc_para_index = 0x0f;
    634 			else
    635 				mc_para_index = (u8)((memory_clock - 60000) / 5000);
    636 		}
    637 	} else {
    638 		if (strobe_mode) {
    639 			if (memory_clock < 10000)
    640 				mc_para_index = 0x00;
    641 			else if (memory_clock > 47500)
    642 				mc_para_index = 0x0f;
    643 			else
    644 				mc_para_index = (u8)((memory_clock - 10000) / 2500);
    645 		} else {
    646 			if (memory_clock < 40000)
    647 				mc_para_index = 0x00;
    648 			else if (memory_clock > 115000)
    649 				mc_para_index = 0x0f;
    650 			else
    651 				mc_para_index = (u8)((memory_clock - 40000) / 5000);
    652 		}
    653 	}
    654 	return mc_para_index;
    655 }
    656 
    657 static int cypress_populate_mvdd_value(struct radeon_device *rdev,
    658 				       u32 mclk,
    659 				       RV770_SMC_VOLTAGE_VALUE *voltage)
    660 {
    661 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    662 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    663 
    664 	if (!pi->mvdd_control) {
    665 		voltage->index = eg_pi->mvdd_high_index;
    666 		voltage->value = cpu_to_be16(MVDD_HIGH_VALUE);
    667 		return 0;
    668 	}
    669 
    670 	if (mclk <= pi->mvdd_split_frequency) {
    671 		voltage->index = eg_pi->mvdd_low_index;
    672 		voltage->value = cpu_to_be16(MVDD_LOW_VALUE);
    673 	} else {
    674 		voltage->index = eg_pi->mvdd_high_index;
    675 		voltage->value = cpu_to_be16(MVDD_HIGH_VALUE);
    676 	}
    677 
    678 	return 0;
    679 }
    680 
    681 int cypress_convert_power_level_to_smc(struct radeon_device *rdev,
    682 				       struct rv7xx_pl *pl,
    683 				       RV770_SMC_HW_PERFORMANCE_LEVEL *level,
    684 				       u8 watermark_level)
    685 {
    686 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    687 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    688 	int ret;
    689 	bool dll_state_on;
    690 
    691 	level->gen2PCIE = pi->pcie_gen2 ?
    692 		((pl->flags & ATOM_PPLIB_R600_FLAGS_PCIEGEN2) ? 1 : 0) : 0;
    693 	level->gen2XSP  = (pl->flags & ATOM_PPLIB_R600_FLAGS_PCIEGEN2) ? 1 : 0;
    694 	level->backbias = (pl->flags & ATOM_PPLIB_R600_FLAGS_BACKBIASENABLE) ? 1 : 0;
    695 	level->displayWatermark = watermark_level;
    696 
    697 	ret = rv740_populate_sclk_value(rdev, pl->sclk, &level->sclk);
    698 	if (ret)
    699 		return ret;
    700 
    701 	level->mcFlags =  0;
    702 	if (pi->mclk_stutter_mode_threshold &&
    703 	    (pl->mclk <= pi->mclk_stutter_mode_threshold) &&
    704 	    !eg_pi->uvd_enabled) {
    705 		level->mcFlags |= SMC_MC_STUTTER_EN;
    706 		if (eg_pi->sclk_deep_sleep)
    707 			level->stateFlags |= PPSMC_STATEFLAG_AUTO_PULSE_SKIP;
    708 		else
    709 			level->stateFlags &= ~PPSMC_STATEFLAG_AUTO_PULSE_SKIP;
    710 	}
    711 
    712 	if (pi->mem_gddr5) {
    713 		if (pl->mclk > pi->mclk_edc_enable_threshold)
    714 			level->mcFlags |= SMC_MC_EDC_RD_FLAG;
    715 
    716 		if (pl->mclk > eg_pi->mclk_edc_wr_enable_threshold)
    717 			level->mcFlags |= SMC_MC_EDC_WR_FLAG;
    718 
    719 		level->strobeMode = cypress_get_strobe_mode_settings(rdev, pl->mclk);
    720 
    721 		if (level->strobeMode & SMC_STROBE_ENABLE) {
    722 			if (cypress_get_mclk_frequency_ratio(rdev, pl->mclk, true) >=
    723 			    ((RREG32(MC_SEQ_MISC7) >> 16) & 0xf))
    724 				dll_state_on = ((RREG32(MC_SEQ_MISC5) >> 1) & 0x1) ? true : false;
    725 			else
    726 				dll_state_on = ((RREG32(MC_SEQ_MISC6) >> 1) & 0x1) ? true : false;
    727 		} else
    728 			dll_state_on = eg_pi->dll_default_on;
    729 
    730 		ret = cypress_populate_mclk_value(rdev,
    731 						  pl->sclk,
    732 						  pl->mclk,
    733 						  &level->mclk,
    734 						  (level->strobeMode & SMC_STROBE_ENABLE) != 0,
    735 						  dll_state_on);
    736 	} else {
    737 		ret = cypress_populate_mclk_value(rdev,
    738 						  pl->sclk,
    739 						  pl->mclk,
    740 						  &level->mclk,
    741 						  true,
    742 						  true);
    743 	}
    744 	if (ret)
    745 		return ret;
    746 
    747 	ret = cypress_populate_voltage_value(rdev,
    748 					     &eg_pi->vddc_voltage_table,
    749 					     pl->vddc,
    750 					     &level->vddc);
    751 	if (ret)
    752 		return ret;
    753 
    754 	if (eg_pi->vddci_control) {
    755 		ret = cypress_populate_voltage_value(rdev,
    756 						     &eg_pi->vddci_voltage_table,
    757 						     pl->vddci,
    758 						     &level->vddci);
    759 		if (ret)
    760 			return ret;
    761 	}
    762 
    763 	ret = cypress_populate_mvdd_value(rdev, pl->mclk, &level->mvdd);
    764 
    765 	return ret;
    766 }
    767 
    768 static int cypress_convert_power_state_to_smc(struct radeon_device *rdev,
    769 					      struct radeon_ps *radeon_state,
    770 					      RV770_SMC_SWSTATE *smc_state)
    771 {
    772 	struct rv7xx_ps *state = rv770_get_ps(radeon_state);
    773 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    774 	int ret;
    775 
    776 	if (!(radeon_state->caps & ATOM_PPLIB_DISALLOW_ON_DC))
    777 		smc_state->flags |= PPSMC_SWSTATE_FLAG_DC;
    778 
    779 	ret = cypress_convert_power_level_to_smc(rdev,
    780 						 &state->low,
    781 						 &smc_state->levels[0],
    782 						 PPSMC_DISPLAY_WATERMARK_LOW);
    783 	if (ret)
    784 		return ret;
    785 
    786 	ret = cypress_convert_power_level_to_smc(rdev,
    787 						 &state->medium,
    788 						 &smc_state->levels[1],
    789 						 PPSMC_DISPLAY_WATERMARK_LOW);
    790 	if (ret)
    791 		return ret;
    792 
    793 	ret = cypress_convert_power_level_to_smc(rdev,
    794 						 &state->high,
    795 						 &smc_state->levels[2],
    796 						 PPSMC_DISPLAY_WATERMARK_HIGH);
    797 	if (ret)
    798 		return ret;
    799 
    800 	smc_state->levels[0].arbValue = MC_CG_ARB_FREQ_F1;
    801 	smc_state->levels[1].arbValue = MC_CG_ARB_FREQ_F2;
    802 	smc_state->levels[2].arbValue = MC_CG_ARB_FREQ_F3;
    803 
    804 	if (eg_pi->dynamic_ac_timing) {
    805 		smc_state->levels[0].ACIndex = 2;
    806 		smc_state->levels[1].ACIndex = 3;
    807 		smc_state->levels[2].ACIndex = 4;
    808 	} else {
    809 		smc_state->levels[0].ACIndex = 0;
    810 		smc_state->levels[1].ACIndex = 0;
    811 		smc_state->levels[2].ACIndex = 0;
    812 	}
    813 
    814 	rv770_populate_smc_sp(rdev, radeon_state, smc_state);
    815 
    816 	return rv770_populate_smc_t(rdev, radeon_state, smc_state);
    817 }
    818 
    819 static void cypress_convert_mc_registers(struct evergreen_mc_reg_entry *entry,
    820 					 SMC_Evergreen_MCRegisterSet *data,
    821 					 u32 num_entries, u32 valid_flag)
    822 {
    823 	u32 i, j;
    824 
    825 	for (i = 0, j = 0; j < num_entries; j++) {
    826 		if (valid_flag & (1 << j)) {
    827 			data->value[i] = cpu_to_be32(entry->mc_data[j]);
    828 			i++;
    829 		}
    830 	}
    831 }
    832 
    833 static void cypress_convert_mc_reg_table_entry_to_smc(struct radeon_device *rdev,
    834 						      struct rv7xx_pl *pl,
    835 						      SMC_Evergreen_MCRegisterSet *mc_reg_table_data)
    836 {
    837 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    838 	u32 i = 0;
    839 
    840 	for (i = 0; i < eg_pi->mc_reg_table.num_entries; i++) {
    841 		if (pl->mclk <=
    842 		    eg_pi->mc_reg_table.mc_reg_table_entry[i].mclk_max)
    843 			break;
    844 	}
    845 
    846 	if ((i == eg_pi->mc_reg_table.num_entries) && (i > 0))
    847 		--i;
    848 
    849 	cypress_convert_mc_registers(&eg_pi->mc_reg_table.mc_reg_table_entry[i],
    850 				     mc_reg_table_data,
    851 				     eg_pi->mc_reg_table.last,
    852 				     eg_pi->mc_reg_table.valid_flag);
    853 }
    854 
    855 static void cypress_convert_mc_reg_table_to_smc(struct radeon_device *rdev,
    856 						struct radeon_ps *radeon_state,
    857 						SMC_Evergreen_MCRegisters *mc_reg_table)
    858 {
    859 	struct rv7xx_ps *state = rv770_get_ps(radeon_state);
    860 
    861 	cypress_convert_mc_reg_table_entry_to_smc(rdev,
    862 						  &state->low,
    863 						  &mc_reg_table->data[2]);
    864 	cypress_convert_mc_reg_table_entry_to_smc(rdev,
    865 						  &state->medium,
    866 						  &mc_reg_table->data[3]);
    867 	cypress_convert_mc_reg_table_entry_to_smc(rdev,
    868 						  &state->high,
    869 						  &mc_reg_table->data[4]);
    870 }
    871 
    872 int cypress_upload_sw_state(struct radeon_device *rdev,
    873 			    struct radeon_ps *radeon_new_state)
    874 {
    875 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    876 	u16 address = pi->state_table_start +
    877 		offsetof(RV770_SMC_STATETABLE, driverState);
    878 	RV770_SMC_SWSTATE state = { 0 };
    879 	int ret;
    880 
    881 	ret = cypress_convert_power_state_to_smc(rdev, radeon_new_state, &state);
    882 	if (ret)
    883 		return ret;
    884 
    885 	return rv770_copy_bytes_to_smc(rdev, address, (u8 *)&state,
    886 				    sizeof(RV770_SMC_SWSTATE),
    887 				    pi->sram_end);
    888 }
    889 
    890 int cypress_upload_mc_reg_table(struct radeon_device *rdev,
    891 				struct radeon_ps *radeon_new_state)
    892 {
    893 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    894 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    895 	SMC_Evergreen_MCRegisters mc_reg_table = { 0 };
    896 	u16 address;
    897 
    898 	cypress_convert_mc_reg_table_to_smc(rdev, radeon_new_state, &mc_reg_table);
    899 
    900 	address = eg_pi->mc_reg_table_start +
    901 		(u16)offsetof(SMC_Evergreen_MCRegisters, data[2]);
    902 
    903 	return rv770_copy_bytes_to_smc(rdev, address,
    904 				       (u8 *)&mc_reg_table.data[2],
    905 				       sizeof(SMC_Evergreen_MCRegisterSet) * 3,
    906 				       pi->sram_end);
    907 }
    908 
    909 u32 cypress_calculate_burst_time(struct radeon_device *rdev,
    910 				 u32 engine_clock, u32 memory_clock)
    911 {
    912 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
    913 	u32 multiplier = pi->mem_gddr5 ? 1 : 2;
    914 	u32 result = (4 * multiplier * engine_clock) / (memory_clock / 2);
    915 	u32 burst_time;
    916 
    917 	if (result <= 4)
    918 		burst_time = 0;
    919 	else if (result < 8)
    920 		burst_time = result - 4;
    921 	else {
    922 		burst_time = result / 2 ;
    923 		if (burst_time > 18)
    924 			burst_time = 18;
    925 	}
    926 
    927 	return burst_time;
    928 }
    929 
    930 void cypress_program_memory_timing_parameters(struct radeon_device *rdev,
    931 					      struct radeon_ps *radeon_new_state)
    932 {
    933 	struct rv7xx_ps *new_state = rv770_get_ps(radeon_new_state);
    934 	u32 mc_arb_burst_time = RREG32(MC_ARB_BURST_TIME);
    935 
    936 	mc_arb_burst_time &= ~(STATE1_MASK | STATE2_MASK | STATE3_MASK);
    937 
    938 	mc_arb_burst_time |= STATE1(cypress_calculate_burst_time(rdev,
    939 								 new_state->low.sclk,
    940 								 new_state->low.mclk));
    941 	mc_arb_burst_time |= STATE2(cypress_calculate_burst_time(rdev,
    942 								 new_state->medium.sclk,
    943 								 new_state->medium.mclk));
    944 	mc_arb_burst_time |= STATE3(cypress_calculate_burst_time(rdev,
    945 								 new_state->high.sclk,
    946 								 new_state->high.mclk));
    947 
    948 	rv730_program_memory_timing_parameters(rdev, radeon_new_state);
    949 
    950 	WREG32(MC_ARB_BURST_TIME, mc_arb_burst_time);
    951 }
    952 
    953 static void cypress_populate_mc_reg_addresses(struct radeon_device *rdev,
    954 					      SMC_Evergreen_MCRegisters *mc_reg_table)
    955 {
    956 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    957 	u32 i, j;
    958 
    959 	for (i = 0, j = 0; j < eg_pi->mc_reg_table.last; j++) {
    960 		if (eg_pi->mc_reg_table.valid_flag & (1 << j)) {
    961 			mc_reg_table->address[i].s0 =
    962 				cpu_to_be16(eg_pi->mc_reg_table.mc_reg_address[j].s0);
    963 			mc_reg_table->address[i].s1 =
    964 				cpu_to_be16(eg_pi->mc_reg_table.mc_reg_address[j].s1);
    965 			i++;
    966 		}
    967 	}
    968 
    969 	mc_reg_table->last = (u8)i;
    970 }
    971 
    972 static void cypress_set_mc_reg_address_table(struct radeon_device *rdev)
    973 {
    974 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
    975 	u32 i = 0;
    976 
    977 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_RAS_TIMING_LP >> 2;
    978 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_RAS_TIMING >> 2;
    979 	i++;
    980 
    981 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_CAS_TIMING_LP >> 2;
    982 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_CAS_TIMING >> 2;
    983 	i++;
    984 
    985 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_MISC_TIMING_LP >> 2;
    986 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_MISC_TIMING >> 2;
    987 	i++;
    988 
    989 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_MISC_TIMING2_LP >> 2;
    990 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_MISC_TIMING2 >> 2;
    991 	i++;
    992 
    993 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_RD_CTL_D0_LP >> 2;
    994 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_RD_CTL_D0 >> 2;
    995 	i++;
    996 
    997 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_RD_CTL_D1_LP >> 2;
    998 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_RD_CTL_D1 >> 2;
    999 	i++;
   1000 
   1001 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_WR_CTL_D0_LP >> 2;
   1002 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_WR_CTL_D0 >> 2;
   1003 	i++;
   1004 
   1005 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_WR_CTL_D1_LP >> 2;
   1006 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_WR_CTL_D1 >> 2;
   1007 	i++;
   1008 
   1009 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_PMG_CMD_EMRS_LP >> 2;
   1010 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_PMG_CMD_EMRS >> 2;
   1011 	i++;
   1012 
   1013 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_PMG_CMD_MRS_LP >> 2;
   1014 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_PMG_CMD_MRS >> 2;
   1015 	i++;
   1016 
   1017 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_PMG_CMD_MRS1_LP >> 2;
   1018 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_PMG_CMD_MRS1 >> 2;
   1019 	i++;
   1020 
   1021 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_MISC1 >> 2;
   1022 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_MISC1 >> 2;
   1023 	i++;
   1024 
   1025 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_RESERVE_M >> 2;
   1026 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_RESERVE_M >> 2;
   1027 	i++;
   1028 
   1029 	eg_pi->mc_reg_table.mc_reg_address[i].s0 = MC_SEQ_MISC3 >> 2;
   1030 	eg_pi->mc_reg_table.mc_reg_address[i].s1 = MC_SEQ_MISC3 >> 2;
   1031 	i++;
   1032 
   1033 	eg_pi->mc_reg_table.last = (u8)i;
   1034 }
   1035 
   1036 static void cypress_retrieve_ac_timing_for_one_entry(struct radeon_device *rdev,
   1037 						     struct evergreen_mc_reg_entry *entry)
   1038 {
   1039 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1040 	u32 i;
   1041 
   1042 	for (i = 0; i < eg_pi->mc_reg_table.last; i++)
   1043 		entry->mc_data[i] =
   1044 			RREG32(eg_pi->mc_reg_table.mc_reg_address[i].s1 << 2);
   1045 
   1046 }
   1047 
   1048 static void cypress_retrieve_ac_timing_for_all_ranges(struct radeon_device *rdev,
   1049 						      struct atom_memory_clock_range_table *range_table)
   1050 {
   1051 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1052 	u32 i, j;
   1053 
   1054 	for (i = 0; i < range_table->num_entries; i++) {
   1055 		eg_pi->mc_reg_table.mc_reg_table_entry[i].mclk_max =
   1056 			range_table->mclk[i];
   1057 		radeon_atom_set_ac_timing(rdev, range_table->mclk[i]);
   1058 		cypress_retrieve_ac_timing_for_one_entry(rdev,
   1059 							 &eg_pi->mc_reg_table.mc_reg_table_entry[i]);
   1060 	}
   1061 
   1062 	eg_pi->mc_reg_table.num_entries = range_table->num_entries;
   1063 	eg_pi->mc_reg_table.valid_flag = 0;
   1064 
   1065 	for (i = 0; i < eg_pi->mc_reg_table.last; i++) {
   1066 		for (j = 1; j < range_table->num_entries; j++) {
   1067 			if (eg_pi->mc_reg_table.mc_reg_table_entry[j-1].mc_data[i] !=
   1068 			    eg_pi->mc_reg_table.mc_reg_table_entry[j].mc_data[i]) {
   1069 				eg_pi->mc_reg_table.valid_flag |= (1 << i);
   1070 				break;
   1071 			}
   1072 		}
   1073 	}
   1074 }
   1075 
   1076 static int cypress_initialize_mc_reg_table(struct radeon_device *rdev)
   1077 {
   1078 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1079 	u8 module_index = rv770_get_memory_module_index(rdev);
   1080 	struct atom_memory_clock_range_table range_table = { 0 };
   1081 	int ret;
   1082 
   1083 	ret = radeon_atom_get_mclk_range_table(rdev,
   1084 					       pi->mem_gddr5,
   1085 					       module_index, &range_table);
   1086 	if (ret)
   1087 		return ret;
   1088 
   1089 	cypress_retrieve_ac_timing_for_all_ranges(rdev, &range_table);
   1090 
   1091 	return 0;
   1092 }
   1093 
   1094 static void cypress_wait_for_mc_sequencer(struct radeon_device *rdev, u8 value)
   1095 {
   1096 	u32 i, j;
   1097 	u32 channels = 2;
   1098 
   1099 	if ((rdev->family == CHIP_CYPRESS) ||
   1100 	    (rdev->family == CHIP_HEMLOCK))
   1101 		channels = 4;
   1102 	else if (rdev->family == CHIP_CEDAR)
   1103 		channels = 1;
   1104 
   1105 	for (i = 0; i < channels; i++) {
   1106 		if ((rdev->family == CHIP_CYPRESS) ||
   1107 		    (rdev->family == CHIP_HEMLOCK)) {
   1108 			WREG32_P(MC_CONFIG_MCD, MC_RD_ENABLE_MCD(i), ~MC_RD_ENABLE_MCD_MASK);
   1109 			WREG32_P(MC_CG_CONFIG_MCD, MC_RD_ENABLE_MCD(i), ~MC_RD_ENABLE_MCD_MASK);
   1110 		} else {
   1111 			WREG32_P(MC_CONFIG, MC_RD_ENABLE(i), ~MC_RD_ENABLE_MASK);
   1112 			WREG32_P(MC_CG_CONFIG, MC_RD_ENABLE(i), ~MC_RD_ENABLE_MASK);
   1113 		}
   1114 		for (j = 0; j < rdev->usec_timeout; j++) {
   1115 			if (((RREG32(MC_SEQ_CG) & CG_SEQ_RESP_MASK) >> CG_SEQ_RESP_SHIFT) == value)
   1116 				break;
   1117 			udelay(1);
   1118 		}
   1119 	}
   1120 }
   1121 
   1122 static void cypress_force_mc_use_s1(struct radeon_device *rdev,
   1123 				    struct radeon_ps *radeon_boot_state)
   1124 {
   1125 	struct rv7xx_ps *boot_state = rv770_get_ps(radeon_boot_state);
   1126 	u32 strobe_mode;
   1127 	u32 mc_seq_cg;
   1128 	int i;
   1129 
   1130 	if (RREG32(MC_SEQ_STATUS_M) & PMG_PWRSTATE)
   1131 		return;
   1132 
   1133 	radeon_atom_set_ac_timing(rdev, boot_state->low.mclk);
   1134 	radeon_mc_wait_for_idle(rdev);
   1135 
   1136 	if ((rdev->family == CHIP_CYPRESS) ||
   1137 	    (rdev->family == CHIP_HEMLOCK)) {
   1138 		WREG32(MC_CONFIG_MCD, 0xf);
   1139 		WREG32(MC_CG_CONFIG_MCD, 0xf);
   1140 	} else {
   1141 		WREG32(MC_CONFIG, 0xf);
   1142 		WREG32(MC_CG_CONFIG, 0xf);
   1143 	}
   1144 
   1145 	for (i = 0; i < rdev->num_crtc; i++)
   1146 		radeon_wait_for_vblank(rdev, i);
   1147 
   1148 	WREG32(MC_SEQ_CG, MC_CG_SEQ_YCLK_SUSPEND);
   1149 	cypress_wait_for_mc_sequencer(rdev, MC_CG_SEQ_YCLK_SUSPEND);
   1150 
   1151 	strobe_mode = cypress_get_strobe_mode_settings(rdev,
   1152 						       boot_state->low.mclk);
   1153 
   1154 	mc_seq_cg = CG_SEQ_REQ(MC_CG_SEQ_DRAMCONF_S1);
   1155 	mc_seq_cg |= SEQ_CG_RESP(strobe_mode);
   1156 	WREG32(MC_SEQ_CG, mc_seq_cg);
   1157 
   1158 	for (i = 0; i < rdev->usec_timeout; i++) {
   1159 		if (RREG32(MC_SEQ_STATUS_M) & PMG_PWRSTATE)
   1160 			break;
   1161 		udelay(1);
   1162 	}
   1163 
   1164 	mc_seq_cg &= ~CG_SEQ_REQ_MASK;
   1165 	mc_seq_cg |= CG_SEQ_REQ(MC_CG_SEQ_YCLK_RESUME);
   1166 	WREG32(MC_SEQ_CG, mc_seq_cg);
   1167 
   1168 	cypress_wait_for_mc_sequencer(rdev, MC_CG_SEQ_YCLK_RESUME);
   1169 }
   1170 
   1171 static void cypress_copy_ac_timing_from_s1_to_s0(struct radeon_device *rdev)
   1172 {
   1173 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1174 	u32 value;
   1175 	u32 i;
   1176 
   1177 	for (i = 0; i < eg_pi->mc_reg_table.last; i++) {
   1178 		value = RREG32(eg_pi->mc_reg_table.mc_reg_address[i].s1 << 2);
   1179 		WREG32(eg_pi->mc_reg_table.mc_reg_address[i].s0 << 2, value);
   1180 	}
   1181 }
   1182 
   1183 static void cypress_force_mc_use_s0(struct radeon_device *rdev,
   1184 				    struct radeon_ps *radeon_boot_state)
   1185 {
   1186 	struct rv7xx_ps *boot_state = rv770_get_ps(radeon_boot_state);
   1187 	u32 strobe_mode;
   1188 	u32 mc_seq_cg;
   1189 	int i;
   1190 
   1191 	cypress_copy_ac_timing_from_s1_to_s0(rdev);
   1192 	radeon_mc_wait_for_idle(rdev);
   1193 
   1194 	if ((rdev->family == CHIP_CYPRESS) ||
   1195 	    (rdev->family == CHIP_HEMLOCK)) {
   1196 		WREG32(MC_CONFIG_MCD, 0xf);
   1197 		WREG32(MC_CG_CONFIG_MCD, 0xf);
   1198 	} else {
   1199 		WREG32(MC_CONFIG, 0xf);
   1200 		WREG32(MC_CG_CONFIG, 0xf);
   1201 	}
   1202 
   1203 	for (i = 0; i < rdev->num_crtc; i++)
   1204 		radeon_wait_for_vblank(rdev, i);
   1205 
   1206 	WREG32(MC_SEQ_CG, MC_CG_SEQ_YCLK_SUSPEND);
   1207 	cypress_wait_for_mc_sequencer(rdev, MC_CG_SEQ_YCLK_SUSPEND);
   1208 
   1209 	strobe_mode = cypress_get_strobe_mode_settings(rdev,
   1210 						       boot_state->low.mclk);
   1211 
   1212 	mc_seq_cg = CG_SEQ_REQ(MC_CG_SEQ_DRAMCONF_S0);
   1213 	mc_seq_cg |= SEQ_CG_RESP(strobe_mode);
   1214 	WREG32(MC_SEQ_CG, mc_seq_cg);
   1215 
   1216 	for (i = 0; i < rdev->usec_timeout; i++) {
   1217 		if (!(RREG32(MC_SEQ_STATUS_M) & PMG_PWRSTATE))
   1218 			break;
   1219 		udelay(1);
   1220 	}
   1221 
   1222 	mc_seq_cg &= ~CG_SEQ_REQ_MASK;
   1223 	mc_seq_cg |= CG_SEQ_REQ(MC_CG_SEQ_YCLK_RESUME);
   1224 	WREG32(MC_SEQ_CG, mc_seq_cg);
   1225 
   1226 	cypress_wait_for_mc_sequencer(rdev, MC_CG_SEQ_YCLK_RESUME);
   1227 }
   1228 
   1229 static int cypress_populate_initial_mvdd_value(struct radeon_device *rdev,
   1230 					       RV770_SMC_VOLTAGE_VALUE *voltage)
   1231 {
   1232 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1233 
   1234 	voltage->index = eg_pi->mvdd_high_index;
   1235 	voltage->value = cpu_to_be16(MVDD_HIGH_VALUE);
   1236 
   1237 	return 0;
   1238 }
   1239 
   1240 int cypress_populate_smc_initial_state(struct radeon_device *rdev,
   1241 				       struct radeon_ps *radeon_initial_state,
   1242 				       RV770_SMC_STATETABLE *table)
   1243 {
   1244 	struct rv7xx_ps *initial_state = rv770_get_ps(radeon_initial_state);
   1245 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1246 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1247 	u32 a_t;
   1248 
   1249 	table->initialState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL =
   1250 		cpu_to_be32(pi->clk_regs.rv770.mpll_ad_func_cntl);
   1251 	table->initialState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL_2 =
   1252 		cpu_to_be32(pi->clk_regs.rv770.mpll_ad_func_cntl_2);
   1253 	table->initialState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL =
   1254 		cpu_to_be32(pi->clk_regs.rv770.mpll_dq_func_cntl);
   1255 	table->initialState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL_2 =
   1256 		cpu_to_be32(pi->clk_regs.rv770.mpll_dq_func_cntl_2);
   1257 	table->initialState.levels[0].mclk.mclk770.vMCLK_PWRMGT_CNTL =
   1258 		cpu_to_be32(pi->clk_regs.rv770.mclk_pwrmgt_cntl);
   1259 	table->initialState.levels[0].mclk.mclk770.vDLL_CNTL =
   1260 		cpu_to_be32(pi->clk_regs.rv770.dll_cntl);
   1261 
   1262 	table->initialState.levels[0].mclk.mclk770.vMPLL_SS =
   1263 		cpu_to_be32(pi->clk_regs.rv770.mpll_ss1);
   1264 	table->initialState.levels[0].mclk.mclk770.vMPLL_SS2 =
   1265 		cpu_to_be32(pi->clk_regs.rv770.mpll_ss2);
   1266 
   1267 	table->initialState.levels[0].mclk.mclk770.mclk_value =
   1268 		cpu_to_be32(initial_state->low.mclk);
   1269 
   1270 	table->initialState.levels[0].sclk.vCG_SPLL_FUNC_CNTL =
   1271 		cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl);
   1272 	table->initialState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_2 =
   1273 		cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl_2);
   1274 	table->initialState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_3 =
   1275 		cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl_3);
   1276 	table->initialState.levels[0].sclk.vCG_SPLL_SPREAD_SPECTRUM =
   1277 		cpu_to_be32(pi->clk_regs.rv770.cg_spll_spread_spectrum);
   1278 	table->initialState.levels[0].sclk.vCG_SPLL_SPREAD_SPECTRUM_2 =
   1279 		cpu_to_be32(pi->clk_regs.rv770.cg_spll_spread_spectrum_2);
   1280 
   1281 	table->initialState.levels[0].sclk.sclk_value =
   1282 		cpu_to_be32(initial_state->low.sclk);
   1283 
   1284 	table->initialState.levels[0].arbValue = MC_CG_ARB_FREQ_F0;
   1285 
   1286 	table->initialState.levels[0].ACIndex = 0;
   1287 
   1288 	cypress_populate_voltage_value(rdev,
   1289 				       &eg_pi->vddc_voltage_table,
   1290 				       initial_state->low.vddc,
   1291 				       &table->initialState.levels[0].vddc);
   1292 
   1293 	if (eg_pi->vddci_control)
   1294 		cypress_populate_voltage_value(rdev,
   1295 					       &eg_pi->vddci_voltage_table,
   1296 					       initial_state->low.vddci,
   1297 					       &table->initialState.levels[0].vddci);
   1298 
   1299 	cypress_populate_initial_mvdd_value(rdev,
   1300 					    &table->initialState.levels[0].mvdd);
   1301 
   1302 	a_t = CG_R(0xffff) | CG_L(0);
   1303 	table->initialState.levels[0].aT = cpu_to_be32(a_t);
   1304 
   1305 	table->initialState.levels[0].bSP = cpu_to_be32(pi->dsp);
   1306 
   1307 
   1308 	if (pi->boot_in_gen2)
   1309 		table->initialState.levels[0].gen2PCIE = 1;
   1310 	else
   1311 		table->initialState.levels[0].gen2PCIE = 0;
   1312 	if (initial_state->low.flags & ATOM_PPLIB_R600_FLAGS_PCIEGEN2)
   1313 		table->initialState.levels[0].gen2XSP = 1;
   1314 	else
   1315 		table->initialState.levels[0].gen2XSP = 0;
   1316 
   1317 	if (pi->mem_gddr5) {
   1318 		table->initialState.levels[0].strobeMode =
   1319 			cypress_get_strobe_mode_settings(rdev,
   1320 							 initial_state->low.mclk);
   1321 
   1322 		if (initial_state->low.mclk > pi->mclk_edc_enable_threshold)
   1323 			table->initialState.levels[0].mcFlags = SMC_MC_EDC_RD_FLAG | SMC_MC_EDC_WR_FLAG;
   1324 		else
   1325 			table->initialState.levels[0].mcFlags =  0;
   1326 	}
   1327 
   1328 	table->initialState.levels[1] = table->initialState.levels[0];
   1329 	table->initialState.levels[2] = table->initialState.levels[0];
   1330 
   1331 	table->initialState.flags |= PPSMC_SWSTATE_FLAG_DC;
   1332 
   1333 	return 0;
   1334 }
   1335 
   1336 int cypress_populate_smc_acpi_state(struct radeon_device *rdev,
   1337 				    RV770_SMC_STATETABLE *table)
   1338 {
   1339 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1340 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1341 	u32 mpll_ad_func_cntl =
   1342 		pi->clk_regs.rv770.mpll_ad_func_cntl;
   1343 	u32 mpll_ad_func_cntl_2 =
   1344 		pi->clk_regs.rv770.mpll_ad_func_cntl_2;
   1345 	u32 mpll_dq_func_cntl =
   1346 		pi->clk_regs.rv770.mpll_dq_func_cntl;
   1347 	u32 mpll_dq_func_cntl_2 =
   1348 		pi->clk_regs.rv770.mpll_dq_func_cntl_2;
   1349 	u32 spll_func_cntl =
   1350 		pi->clk_regs.rv770.cg_spll_func_cntl;
   1351 	u32 spll_func_cntl_2 =
   1352 		pi->clk_regs.rv770.cg_spll_func_cntl_2;
   1353 	u32 spll_func_cntl_3 =
   1354 		pi->clk_regs.rv770.cg_spll_func_cntl_3;
   1355 	u32 mclk_pwrmgt_cntl =
   1356 		pi->clk_regs.rv770.mclk_pwrmgt_cntl;
   1357 	u32 dll_cntl =
   1358 		pi->clk_regs.rv770.dll_cntl;
   1359 
   1360 	table->ACPIState = table->initialState;
   1361 
   1362 	table->ACPIState.flags &= ~PPSMC_SWSTATE_FLAG_DC;
   1363 
   1364 	if (pi->acpi_vddc) {
   1365 		cypress_populate_voltage_value(rdev,
   1366 					       &eg_pi->vddc_voltage_table,
   1367 					       pi->acpi_vddc,
   1368 					       &table->ACPIState.levels[0].vddc);
   1369 		if (pi->pcie_gen2) {
   1370 			if (pi->acpi_pcie_gen2)
   1371 				table->ACPIState.levels[0].gen2PCIE = 1;
   1372 			else
   1373 				table->ACPIState.levels[0].gen2PCIE = 0;
   1374 		} else
   1375 			table->ACPIState.levels[0].gen2PCIE = 0;
   1376 		if (pi->acpi_pcie_gen2)
   1377 			table->ACPIState.levels[0].gen2XSP = 1;
   1378 		else
   1379 			table->ACPIState.levels[0].gen2XSP = 0;
   1380 	} else {
   1381 		cypress_populate_voltage_value(rdev,
   1382 					       &eg_pi->vddc_voltage_table,
   1383 					       pi->min_vddc_in_table,
   1384 					       &table->ACPIState.levels[0].vddc);
   1385 		table->ACPIState.levels[0].gen2PCIE = 0;
   1386 	}
   1387 
   1388 	if (eg_pi->acpi_vddci) {
   1389 		if (eg_pi->vddci_control) {
   1390 			cypress_populate_voltage_value(rdev,
   1391 						       &eg_pi->vddci_voltage_table,
   1392 						       eg_pi->acpi_vddci,
   1393 						       &table->ACPIState.levels[0].vddci);
   1394 		}
   1395 	}
   1396 
   1397 	mpll_ad_func_cntl &= ~PDNB;
   1398 
   1399 	mpll_ad_func_cntl_2 |= BIAS_GEN_PDNB | RESET_EN;
   1400 
   1401 	if (pi->mem_gddr5)
   1402 		mpll_dq_func_cntl &= ~PDNB;
   1403 	mpll_dq_func_cntl_2 |= BIAS_GEN_PDNB | RESET_EN | BYPASS;
   1404 
   1405 	mclk_pwrmgt_cntl |= (MRDCKA0_RESET |
   1406 			     MRDCKA1_RESET |
   1407 			     MRDCKB0_RESET |
   1408 			     MRDCKB1_RESET |
   1409 			     MRDCKC0_RESET |
   1410 			     MRDCKC1_RESET |
   1411 			     MRDCKD0_RESET |
   1412 			     MRDCKD1_RESET);
   1413 
   1414 	mclk_pwrmgt_cntl &= ~(MRDCKA0_PDNB |
   1415 			      MRDCKA1_PDNB |
   1416 			      MRDCKB0_PDNB |
   1417 			      MRDCKB1_PDNB |
   1418 			      MRDCKC0_PDNB |
   1419 			      MRDCKC1_PDNB |
   1420 			      MRDCKD0_PDNB |
   1421 			      MRDCKD1_PDNB);
   1422 
   1423 	dll_cntl |= (MRDCKA0_BYPASS |
   1424 		     MRDCKA1_BYPASS |
   1425 		     MRDCKB0_BYPASS |
   1426 		     MRDCKB1_BYPASS |
   1427 		     MRDCKC0_BYPASS |
   1428 		     MRDCKC1_BYPASS |
   1429 		     MRDCKD0_BYPASS |
   1430 		     MRDCKD1_BYPASS);
   1431 
   1432 	/* evergreen only */
   1433 	if (rdev->family <= CHIP_HEMLOCK)
   1434 		spll_func_cntl |= SPLL_RESET | SPLL_SLEEP | SPLL_BYPASS_EN;
   1435 
   1436 	spll_func_cntl_2 &= ~SCLK_MUX_SEL_MASK;
   1437 	spll_func_cntl_2 |= SCLK_MUX_SEL(4);
   1438 
   1439 	table->ACPIState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL =
   1440 		cpu_to_be32(mpll_ad_func_cntl);
   1441 	table->ACPIState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL_2 =
   1442 		cpu_to_be32(mpll_ad_func_cntl_2);
   1443 	table->ACPIState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL =
   1444 		cpu_to_be32(mpll_dq_func_cntl);
   1445 	table->ACPIState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL_2 =
   1446 		cpu_to_be32(mpll_dq_func_cntl_2);
   1447 	table->ACPIState.levels[0].mclk.mclk770.vMCLK_PWRMGT_CNTL =
   1448 		cpu_to_be32(mclk_pwrmgt_cntl);
   1449 	table->ACPIState.levels[0].mclk.mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl);
   1450 
   1451 	table->ACPIState.levels[0].mclk.mclk770.mclk_value = 0;
   1452 
   1453 	table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL =
   1454 		cpu_to_be32(spll_func_cntl);
   1455 	table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_2 =
   1456 		cpu_to_be32(spll_func_cntl_2);
   1457 	table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_3 =
   1458 		cpu_to_be32(spll_func_cntl_3);
   1459 
   1460 	table->ACPIState.levels[0].sclk.sclk_value = 0;
   1461 
   1462 	cypress_populate_mvdd_value(rdev, 0, &table->ACPIState.levels[0].mvdd);
   1463 
   1464 	if (eg_pi->dynamic_ac_timing)
   1465 		table->ACPIState.levels[0].ACIndex = 1;
   1466 
   1467 	table->ACPIState.levels[1] = table->ACPIState.levels[0];
   1468 	table->ACPIState.levels[2] = table->ACPIState.levels[0];
   1469 
   1470 	return 0;
   1471 }
   1472 
   1473 static void cypress_trim_voltage_table_to_fit_state_table(struct radeon_device *rdev,
   1474 							  struct atom_voltage_table *voltage_table)
   1475 {
   1476 	unsigned int i, diff;
   1477 
   1478 	if (voltage_table->count <= MAX_NO_VREG_STEPS)
   1479 		return;
   1480 
   1481 	diff = voltage_table->count - MAX_NO_VREG_STEPS;
   1482 
   1483 	for (i= 0; i < MAX_NO_VREG_STEPS; i++)
   1484 		voltage_table->entries[i] = voltage_table->entries[i + diff];
   1485 
   1486 	voltage_table->count = MAX_NO_VREG_STEPS;
   1487 }
   1488 
   1489 int cypress_construct_voltage_tables(struct radeon_device *rdev)
   1490 {
   1491 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1492 	int ret;
   1493 
   1494 	ret = radeon_atom_get_voltage_table(rdev, SET_VOLTAGE_TYPE_ASIC_VDDC, 0,
   1495 					    &eg_pi->vddc_voltage_table);
   1496 	if (ret)
   1497 		return ret;
   1498 
   1499 	if (eg_pi->vddc_voltage_table.count > MAX_NO_VREG_STEPS)
   1500 		cypress_trim_voltage_table_to_fit_state_table(rdev,
   1501 							      &eg_pi->vddc_voltage_table);
   1502 
   1503 	if (eg_pi->vddci_control) {
   1504 		ret = radeon_atom_get_voltage_table(rdev, SET_VOLTAGE_TYPE_ASIC_VDDCI, 0,
   1505 						    &eg_pi->vddci_voltage_table);
   1506 		if (ret)
   1507 			return ret;
   1508 
   1509 		if (eg_pi->vddci_voltage_table.count > MAX_NO_VREG_STEPS)
   1510 			cypress_trim_voltage_table_to_fit_state_table(rdev,
   1511 								      &eg_pi->vddci_voltage_table);
   1512 	}
   1513 
   1514 	return 0;
   1515 }
   1516 
   1517 static void cypress_populate_smc_voltage_table(struct radeon_device *rdev,
   1518 					       struct atom_voltage_table *voltage_table,
   1519 					       RV770_SMC_STATETABLE *table)
   1520 {
   1521 	unsigned int i;
   1522 
   1523 	for (i = 0; i < voltage_table->count; i++) {
   1524 		table->highSMIO[i] = 0;
   1525 		table->lowSMIO[i] |= cpu_to_be32(voltage_table->entries[i].smio_low);
   1526 	}
   1527 }
   1528 
   1529 int cypress_populate_smc_voltage_tables(struct radeon_device *rdev,
   1530 					RV770_SMC_STATETABLE *table)
   1531 {
   1532 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1533 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1534 	unsigned char i;
   1535 
   1536 	if (eg_pi->vddc_voltage_table.count) {
   1537 		cypress_populate_smc_voltage_table(rdev,
   1538 						   &eg_pi->vddc_voltage_table,
   1539 						   table);
   1540 
   1541 		table->voltageMaskTable.highMask[RV770_SMC_VOLTAGEMASK_VDDC] = 0;
   1542 		table->voltageMaskTable.lowMask[RV770_SMC_VOLTAGEMASK_VDDC] =
   1543 			cpu_to_be32(eg_pi->vddc_voltage_table.mask_low);
   1544 
   1545 		for (i = 0; i < eg_pi->vddc_voltage_table.count; i++) {
   1546 			if (pi->max_vddc_in_table <=
   1547 			    eg_pi->vddc_voltage_table.entries[i].value) {
   1548 				table->maxVDDCIndexInPPTable = i;
   1549 				break;
   1550 			}
   1551 		}
   1552 	}
   1553 
   1554 	if (eg_pi->vddci_voltage_table.count) {
   1555 		cypress_populate_smc_voltage_table(rdev,
   1556 						   &eg_pi->vddci_voltage_table,
   1557 						   table);
   1558 
   1559 		table->voltageMaskTable.highMask[RV770_SMC_VOLTAGEMASK_VDDCI] = 0;
   1560 		table->voltageMaskTable.lowMask[RV770_SMC_VOLTAGEMASK_VDDCI] =
   1561 			cpu_to_be32(eg_pi->vddci_voltage_table.mask_low);
   1562 	}
   1563 
   1564 	return 0;
   1565 }
   1566 
   1567 static u32 cypress_get_mclk_split_point(struct atom_memory_info *memory_info)
   1568 {
   1569 	if ((memory_info->mem_type == MEM_TYPE_GDDR3) ||
   1570 	    (memory_info->mem_type == MEM_TYPE_DDR3))
   1571 		return 30000;
   1572 
   1573 	return 0;
   1574 }
   1575 
   1576 int cypress_get_mvdd_configuration(struct radeon_device *rdev)
   1577 {
   1578 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1579 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1580 	u8 module_index;
   1581 	struct atom_memory_info memory_info;
   1582 	u32 tmp = RREG32(GENERAL_PWRMGT);
   1583 
   1584 	if (!(tmp & BACKBIAS_PAD_EN)) {
   1585 		eg_pi->mvdd_high_index = 0;
   1586 		eg_pi->mvdd_low_index = 1;
   1587 		pi->mvdd_control = false;
   1588 		return 0;
   1589 	}
   1590 
   1591 	if (tmp & BACKBIAS_VALUE)
   1592 		eg_pi->mvdd_high_index = 1;
   1593 	else
   1594 		eg_pi->mvdd_high_index = 0;
   1595 
   1596 	eg_pi->mvdd_low_index =
   1597 		(eg_pi->mvdd_high_index == 0) ? 1 : 0;
   1598 
   1599 	module_index = rv770_get_memory_module_index(rdev);
   1600 
   1601 	if (radeon_atom_get_memory_info(rdev, module_index, &memory_info)) {
   1602 		pi->mvdd_control = false;
   1603 		return 0;
   1604 	}
   1605 
   1606 	pi->mvdd_split_frequency =
   1607 		cypress_get_mclk_split_point(&memory_info);
   1608 
   1609 	if (pi->mvdd_split_frequency == 0) {
   1610 		pi->mvdd_control = false;
   1611 		return 0;
   1612 	}
   1613 
   1614 	return 0;
   1615 }
   1616 
   1617 static int cypress_init_smc_table(struct radeon_device *rdev,
   1618 				  struct radeon_ps *radeon_boot_state)
   1619 {
   1620 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1621 	RV770_SMC_STATETABLE *table = &pi->smc_statetable;
   1622 	int ret;
   1623 
   1624 	memset(table, 0, sizeof(RV770_SMC_STATETABLE));
   1625 
   1626 	cypress_populate_smc_voltage_tables(rdev, table);
   1627 
   1628 	switch (rdev->pm.int_thermal_type) {
   1629 	case THERMAL_TYPE_EVERGREEN:
   1630 	case THERMAL_TYPE_EMC2103_WITH_INTERNAL:
   1631 		table->thermalProtectType = PPSMC_THERMAL_PROTECT_TYPE_INTERNAL;
   1632 		break;
   1633 	case THERMAL_TYPE_NONE:
   1634 		table->thermalProtectType = PPSMC_THERMAL_PROTECT_TYPE_NONE;
   1635 		break;
   1636 	default:
   1637 		table->thermalProtectType = PPSMC_THERMAL_PROTECT_TYPE_EXTERNAL;
   1638 		break;
   1639 	}
   1640 
   1641 	if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_HARDWAREDC)
   1642 		table->systemFlags |= PPSMC_SYSTEMFLAG_GPIO_DC;
   1643 
   1644 	if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_REGULATOR_HOT)
   1645 		table->systemFlags |= PPSMC_SYSTEMFLAG_REGULATOR_HOT;
   1646 
   1647 	if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_STEPVDDC)
   1648 		table->systemFlags |= PPSMC_SYSTEMFLAG_STEPVDDC;
   1649 
   1650 	if (pi->mem_gddr5)
   1651 		table->systemFlags |= PPSMC_SYSTEMFLAG_GDDR5;
   1652 
   1653 	ret = cypress_populate_smc_initial_state(rdev, radeon_boot_state, table);
   1654 	if (ret)
   1655 		return ret;
   1656 
   1657 	ret = cypress_populate_smc_acpi_state(rdev, table);
   1658 	if (ret)
   1659 		return ret;
   1660 
   1661 	table->driverState = table->initialState;
   1662 
   1663 	return rv770_copy_bytes_to_smc(rdev,
   1664 				       pi->state_table_start,
   1665 				       (u8 *)table, sizeof(RV770_SMC_STATETABLE),
   1666 				       pi->sram_end);
   1667 }
   1668 
   1669 int cypress_populate_mc_reg_table(struct radeon_device *rdev,
   1670 				  struct radeon_ps *radeon_boot_state)
   1671 {
   1672 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1673 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1674 	struct rv7xx_ps *boot_state = rv770_get_ps(radeon_boot_state);
   1675 	SMC_Evergreen_MCRegisters mc_reg_table = { 0 };
   1676 
   1677 	rv770_write_smc_soft_register(rdev,
   1678 				      RV770_SMC_SOFT_REGISTER_seq_index, 1);
   1679 
   1680 	cypress_populate_mc_reg_addresses(rdev, &mc_reg_table);
   1681 
   1682 	cypress_convert_mc_reg_table_entry_to_smc(rdev,
   1683 						  &boot_state->low,
   1684 						  &mc_reg_table.data[0]);
   1685 
   1686 	cypress_convert_mc_registers(&eg_pi->mc_reg_table.mc_reg_table_entry[0],
   1687 				     &mc_reg_table.data[1], eg_pi->mc_reg_table.last,
   1688 				     eg_pi->mc_reg_table.valid_flag);
   1689 
   1690 	cypress_convert_mc_reg_table_to_smc(rdev, radeon_boot_state, &mc_reg_table);
   1691 
   1692 	return rv770_copy_bytes_to_smc(rdev, eg_pi->mc_reg_table_start,
   1693 				       (u8 *)&mc_reg_table, sizeof(SMC_Evergreen_MCRegisters),
   1694 				       pi->sram_end);
   1695 }
   1696 
   1697 int cypress_get_table_locations(struct radeon_device *rdev)
   1698 {
   1699 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1700 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1701 	u32 tmp;
   1702 	int ret;
   1703 
   1704 	ret = rv770_read_smc_sram_dword(rdev,
   1705 					EVERGREEN_SMC_FIRMWARE_HEADER_LOCATION +
   1706 					EVERGREEN_SMC_FIRMWARE_HEADER_stateTable,
   1707 					&tmp, pi->sram_end);
   1708 	if (ret)
   1709 		return ret;
   1710 
   1711 	pi->state_table_start = (u16)tmp;
   1712 
   1713 	ret = rv770_read_smc_sram_dword(rdev,
   1714 					EVERGREEN_SMC_FIRMWARE_HEADER_LOCATION +
   1715 					EVERGREEN_SMC_FIRMWARE_HEADER_softRegisters,
   1716 					&tmp, pi->sram_end);
   1717 	if (ret)
   1718 		return ret;
   1719 
   1720 	pi->soft_regs_start = (u16)tmp;
   1721 
   1722 	ret = rv770_read_smc_sram_dword(rdev,
   1723 					EVERGREEN_SMC_FIRMWARE_HEADER_LOCATION +
   1724 					EVERGREEN_SMC_FIRMWARE_HEADER_mcRegisterTable,
   1725 					&tmp, pi->sram_end);
   1726 	if (ret)
   1727 		return ret;
   1728 
   1729 	eg_pi->mc_reg_table_start = (u16)tmp;
   1730 
   1731 	return 0;
   1732 }
   1733 
   1734 void cypress_enable_display_gap(struct radeon_device *rdev)
   1735 {
   1736 	u32 tmp = RREG32(CG_DISPLAY_GAP_CNTL);
   1737 
   1738 	tmp &= ~(DISP1_GAP_MASK | DISP2_GAP_MASK);
   1739 	tmp |= (DISP1_GAP(R600_PM_DISPLAY_GAP_IGNORE) |
   1740 		DISP2_GAP(R600_PM_DISPLAY_GAP_IGNORE));
   1741 
   1742 	tmp &= ~(DISP1_GAP_MCHG_MASK | DISP2_GAP_MCHG_MASK);
   1743 	tmp |= (DISP1_GAP_MCHG(R600_PM_DISPLAY_GAP_VBLANK) |
   1744 		DISP2_GAP_MCHG(R600_PM_DISPLAY_GAP_IGNORE));
   1745 	WREG32(CG_DISPLAY_GAP_CNTL, tmp);
   1746 }
   1747 
   1748 static void cypress_program_display_gap(struct radeon_device *rdev)
   1749 {
   1750 	u32 tmp, pipe;
   1751 	int i;
   1752 
   1753 	tmp = RREG32(CG_DISPLAY_GAP_CNTL) & ~(DISP1_GAP_MASK | DISP2_GAP_MASK);
   1754 	if (rdev->pm.dpm.new_active_crtc_count > 0)
   1755 		tmp |= DISP1_GAP(R600_PM_DISPLAY_GAP_VBLANK_OR_WM);
   1756 	else
   1757 		tmp |= DISP1_GAP(R600_PM_DISPLAY_GAP_IGNORE);
   1758 
   1759 	if (rdev->pm.dpm.new_active_crtc_count > 1)
   1760 		tmp |= DISP2_GAP(R600_PM_DISPLAY_GAP_VBLANK_OR_WM);
   1761 	else
   1762 		tmp |= DISP2_GAP(R600_PM_DISPLAY_GAP_IGNORE);
   1763 
   1764 	WREG32(CG_DISPLAY_GAP_CNTL, tmp);
   1765 
   1766 	tmp = RREG32(DCCG_DISP_SLOW_SELECT_REG);
   1767 	pipe = (tmp & DCCG_DISP1_SLOW_SELECT_MASK) >> DCCG_DISP1_SLOW_SELECT_SHIFT;
   1768 
   1769 	if ((rdev->pm.dpm.new_active_crtc_count > 0) &&
   1770 	    (!(rdev->pm.dpm.new_active_crtcs & (1 << pipe)))) {
   1771 		/* find the first active crtc */
   1772 		for (i = 0; i < rdev->num_crtc; i++) {
   1773 			if (rdev->pm.dpm.new_active_crtcs & (1 << i))
   1774 				break;
   1775 		}
   1776 		if (i == rdev->num_crtc)
   1777 			pipe = 0;
   1778 		else
   1779 			pipe = i;
   1780 
   1781 		tmp &= ~DCCG_DISP1_SLOW_SELECT_MASK;
   1782 		tmp |= DCCG_DISP1_SLOW_SELECT(pipe);
   1783 		WREG32(DCCG_DISP_SLOW_SELECT_REG, tmp);
   1784 	}
   1785 
   1786 	cypress_notify_smc_display_change(rdev, rdev->pm.dpm.new_active_crtc_count > 0);
   1787 }
   1788 
   1789 void cypress_dpm_setup_asic(struct radeon_device *rdev)
   1790 {
   1791 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1792 
   1793 	rv740_read_clock_registers(rdev);
   1794 	rv770_read_voltage_smio_registers(rdev);
   1795 	rv770_get_max_vddc(rdev);
   1796 	rv770_get_memory_type(rdev);
   1797 
   1798 	if (eg_pi->pcie_performance_request)
   1799 		eg_pi->pcie_performance_request_registered = false;
   1800 
   1801 	if (eg_pi->pcie_performance_request)
   1802 		cypress_advertise_gen2_capability(rdev);
   1803 
   1804 	rv770_get_pcie_gen2_status(rdev);
   1805 
   1806 	rv770_enable_acpi_pm(rdev);
   1807 }
   1808 
   1809 int cypress_dpm_enable(struct radeon_device *rdev)
   1810 {
   1811 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1812 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1813 	struct radeon_ps *boot_ps = rdev->pm.dpm.boot_ps;
   1814 	int ret;
   1815 
   1816 	if (pi->gfx_clock_gating)
   1817 		rv770_restore_cgcg(rdev);
   1818 
   1819 	if (rv770_dpm_enabled(rdev))
   1820 		return -EINVAL;
   1821 
   1822 	if (pi->voltage_control) {
   1823 		rv770_enable_voltage_control(rdev, true);
   1824 		ret = cypress_construct_voltage_tables(rdev);
   1825 		if (ret) {
   1826 			DRM_ERROR("cypress_construct_voltage_tables failed\n");
   1827 			return ret;
   1828 		}
   1829 	}
   1830 
   1831 	if (pi->mvdd_control) {
   1832 		ret = cypress_get_mvdd_configuration(rdev);
   1833 		if (ret) {
   1834 			DRM_ERROR("cypress_get_mvdd_configuration failed\n");
   1835 			return ret;
   1836 		}
   1837 	}
   1838 
   1839 	if (eg_pi->dynamic_ac_timing) {
   1840 		cypress_set_mc_reg_address_table(rdev);
   1841 		cypress_force_mc_use_s0(rdev, boot_ps);
   1842 		ret = cypress_initialize_mc_reg_table(rdev);
   1843 		if (ret)
   1844 			eg_pi->dynamic_ac_timing = false;
   1845 		cypress_force_mc_use_s1(rdev, boot_ps);
   1846 	}
   1847 
   1848 	if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_BACKBIAS)
   1849 		rv770_enable_backbias(rdev, true);
   1850 
   1851 	if (pi->dynamic_ss)
   1852 		cypress_enable_spread_spectrum(rdev, true);
   1853 
   1854 	if (pi->thermal_protection)
   1855 		rv770_enable_thermal_protection(rdev, true);
   1856 
   1857 	rv770_setup_bsp(rdev);
   1858 	rv770_program_git(rdev);
   1859 	rv770_program_tp(rdev);
   1860 	rv770_program_tpp(rdev);
   1861 	rv770_program_sstp(rdev);
   1862 	rv770_program_engine_speed_parameters(rdev);
   1863 	cypress_enable_display_gap(rdev);
   1864 	rv770_program_vc(rdev);
   1865 
   1866 	if (pi->dynamic_pcie_gen2)
   1867 		cypress_enable_dynamic_pcie_gen2(rdev, true);
   1868 
   1869 	ret = rv770_upload_firmware(rdev);
   1870 	if (ret) {
   1871 		DRM_ERROR("rv770_upload_firmware failed\n");
   1872 		return ret;
   1873 	}
   1874 
   1875 	ret = cypress_get_table_locations(rdev);
   1876 	if (ret) {
   1877 		DRM_ERROR("cypress_get_table_locations failed\n");
   1878 		return ret;
   1879 	}
   1880 	ret = cypress_init_smc_table(rdev, boot_ps);
   1881 	if (ret) {
   1882 		DRM_ERROR("cypress_init_smc_table failed\n");
   1883 		return ret;
   1884 	}
   1885 	if (eg_pi->dynamic_ac_timing) {
   1886 		ret = cypress_populate_mc_reg_table(rdev, boot_ps);
   1887 		if (ret) {
   1888 			DRM_ERROR("cypress_populate_mc_reg_table failed\n");
   1889 			return ret;
   1890 		}
   1891 	}
   1892 
   1893 	cypress_program_response_times(rdev);
   1894 
   1895 	r7xx_start_smc(rdev);
   1896 
   1897 	ret = cypress_notify_smc_display_change(rdev, false);
   1898 	if (ret) {
   1899 		DRM_ERROR("cypress_notify_smc_display_change failed\n");
   1900 		return ret;
   1901 	}
   1902 	cypress_enable_sclk_control(rdev, true);
   1903 
   1904 	if (eg_pi->memory_transition)
   1905 		cypress_enable_mclk_control(rdev, true);
   1906 
   1907 	cypress_start_dpm(rdev);
   1908 
   1909 	if (pi->gfx_clock_gating)
   1910 		cypress_gfx_clock_gating_enable(rdev, true);
   1911 
   1912 	if (pi->mg_clock_gating)
   1913 		cypress_mg_clock_gating_enable(rdev, true);
   1914 
   1915 	rv770_enable_auto_throttle_source(rdev, RADEON_DPM_AUTO_THROTTLE_SRC_THERMAL, true);
   1916 
   1917 	return 0;
   1918 }
   1919 
   1920 void cypress_dpm_disable(struct radeon_device *rdev)
   1921 {
   1922 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   1923 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1924 	struct radeon_ps *boot_ps = rdev->pm.dpm.boot_ps;
   1925 
   1926 	if (!rv770_dpm_enabled(rdev))
   1927 		return;
   1928 
   1929 	rv770_clear_vc(rdev);
   1930 
   1931 	if (pi->thermal_protection)
   1932 		rv770_enable_thermal_protection(rdev, false);
   1933 
   1934 	if (pi->dynamic_pcie_gen2)
   1935 		cypress_enable_dynamic_pcie_gen2(rdev, false);
   1936 
   1937 	if (rdev->irq.installed &&
   1938 	    r600_is_internal_thermal_sensor(rdev->pm.int_thermal_type)) {
   1939 		rdev->irq.dpm_thermal = false;
   1940 		radeon_irq_set(rdev);
   1941 	}
   1942 
   1943 	if (pi->gfx_clock_gating)
   1944 		cypress_gfx_clock_gating_enable(rdev, false);
   1945 
   1946 	if (pi->mg_clock_gating)
   1947 		cypress_mg_clock_gating_enable(rdev, false);
   1948 
   1949 	rv770_stop_dpm(rdev);
   1950 	r7xx_stop_smc(rdev);
   1951 
   1952 	cypress_enable_spread_spectrum(rdev, false);
   1953 
   1954 	if (eg_pi->dynamic_ac_timing)
   1955 		cypress_force_mc_use_s1(rdev, boot_ps);
   1956 
   1957 	rv770_reset_smio_status(rdev);
   1958 }
   1959 
   1960 int cypress_dpm_set_power_state(struct radeon_device *rdev)
   1961 {
   1962 	struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev);
   1963 	struct radeon_ps *new_ps = rdev->pm.dpm.requested_ps;
   1964 	struct radeon_ps *old_ps = rdev->pm.dpm.current_ps;
   1965 	int ret;
   1966 
   1967 	ret = rv770_restrict_performance_levels_before_switch(rdev);
   1968 	if (ret) {
   1969 		DRM_ERROR("rv770_restrict_performance_levels_before_switch failed: %d\n", ret);
   1970 		return ret;
   1971 	}
   1972 	if (eg_pi->pcie_performance_request)
   1973 		cypress_notify_link_speed_change_before_state_change(rdev, new_ps, old_ps);
   1974 
   1975 	rv770_set_uvd_clock_before_set_eng_clock(rdev, new_ps, old_ps);
   1976 	ret = rv770_halt_smc(rdev);
   1977 	if (ret) {
   1978 		DRM_ERROR("rv770_halt_smc failed\n");
   1979 		return ret;
   1980 	}
   1981 	ret = cypress_upload_sw_state(rdev, new_ps);
   1982 	if (ret) {
   1983 		DRM_ERROR("cypress_upload_sw_state failed\n");
   1984 		return ret;
   1985 	}
   1986 	if (eg_pi->dynamic_ac_timing) {
   1987 		ret = cypress_upload_mc_reg_table(rdev, new_ps);
   1988 		if (ret) {
   1989 			DRM_ERROR("cypress_upload_mc_reg_table failed\n");
   1990 			return ret;
   1991 		}
   1992 	}
   1993 
   1994 	cypress_program_memory_timing_parameters(rdev, new_ps);
   1995 
   1996 	ret = rv770_resume_smc(rdev);
   1997 	if (ret) {
   1998 		DRM_ERROR("rv770_resume_smc failed\n");
   1999 		return ret;
   2000 	}
   2001 	ret = rv770_set_sw_state(rdev);
   2002 	if (ret) {
   2003 		DRM_ERROR("rv770_set_sw_state failed\n");
   2004 		return ret;
   2005 	}
   2006 	rv770_set_uvd_clock_after_set_eng_clock(rdev, new_ps, old_ps);
   2007 
   2008 	if (eg_pi->pcie_performance_request)
   2009 		cypress_notify_link_speed_change_after_state_change(rdev, new_ps, old_ps);
   2010 
   2011 	return 0;
   2012 }
   2013 
   2014 #if 0
   2015 void cypress_dpm_reset_asic(struct radeon_device *rdev)
   2016 {
   2017 	rv770_restrict_performance_levels_before_switch(rdev);
   2018 	rv770_set_boot_state(rdev);
   2019 }
   2020 #endif
   2021 
   2022 void cypress_dpm_display_configuration_changed(struct radeon_device *rdev)
   2023 {
   2024 	cypress_program_display_gap(rdev);
   2025 }
   2026 
   2027 int cypress_dpm_init(struct radeon_device *rdev)
   2028 {
   2029 	struct rv7xx_power_info *pi;
   2030 	struct evergreen_power_info *eg_pi;
   2031 	struct atom_clock_dividers dividers;
   2032 	int ret;
   2033 
   2034 	eg_pi = kzalloc(sizeof(struct evergreen_power_info), GFP_KERNEL);
   2035 	if (eg_pi == NULL)
   2036 		return -ENOMEM;
   2037 	rdev->pm.dpm.priv = eg_pi;
   2038 	pi = &eg_pi->rv7xx;
   2039 
   2040 	rv770_get_max_vddc(rdev);
   2041 
   2042 	eg_pi->ulv.supported = false;
   2043 	pi->acpi_vddc = 0;
   2044 	eg_pi->acpi_vddci = 0;
   2045 	pi->min_vddc_in_table = 0;
   2046 	pi->max_vddc_in_table = 0;
   2047 
   2048 	ret = r600_get_platform_caps(rdev);
   2049 	if (ret)
   2050 		return ret;
   2051 
   2052 	ret = rv7xx_parse_power_table(rdev);
   2053 	if (ret)
   2054 		return ret;
   2055 
   2056 	if (rdev->pm.dpm.voltage_response_time == 0)
   2057 		rdev->pm.dpm.voltage_response_time = R600_VOLTAGERESPONSETIME_DFLT;
   2058 	if (rdev->pm.dpm.backbias_response_time == 0)
   2059 		rdev->pm.dpm.backbias_response_time = R600_BACKBIASRESPONSETIME_DFLT;
   2060 
   2061 	ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM,
   2062 					     0, false, &dividers);
   2063 	if (ret)
   2064 		pi->ref_div = dividers.ref_div + 1;
   2065 	else
   2066 		pi->ref_div = R600_REFERENCEDIVIDER_DFLT;
   2067 
   2068 	pi->mclk_strobe_mode_threshold = 40000;
   2069 	pi->mclk_edc_enable_threshold = 40000;
   2070 	eg_pi->mclk_edc_wr_enable_threshold = 40000;
   2071 
   2072 	pi->rlp = RV770_RLP_DFLT;
   2073 	pi->rmp = RV770_RMP_DFLT;
   2074 	pi->lhp = RV770_LHP_DFLT;
   2075 	pi->lmp = RV770_LMP_DFLT;
   2076 
   2077 	pi->voltage_control =
   2078 		radeon_atom_is_voltage_gpio(rdev, SET_VOLTAGE_TYPE_ASIC_VDDC, 0);
   2079 
   2080 	pi->mvdd_control =
   2081 		radeon_atom_is_voltage_gpio(rdev, SET_VOLTAGE_TYPE_ASIC_MVDDC, 0);
   2082 
   2083 	eg_pi->vddci_control =
   2084 		radeon_atom_is_voltage_gpio(rdev, SET_VOLTAGE_TYPE_ASIC_VDDCI, 0);
   2085 
   2086 	rv770_get_engine_memory_ss(rdev);
   2087 
   2088 	pi->asi = RV770_ASI_DFLT;
   2089 	pi->pasi = CYPRESS_HASI_DFLT;
   2090 	pi->vrc = CYPRESS_VRC_DFLT;
   2091 
   2092 	pi->power_gating = false;
   2093 
   2094 	if ((rdev->family == CHIP_CYPRESS) ||
   2095 	    (rdev->family == CHIP_HEMLOCK))
   2096 		pi->gfx_clock_gating = false;
   2097 	else
   2098 		pi->gfx_clock_gating = true;
   2099 
   2100 	pi->mg_clock_gating = true;
   2101 	pi->mgcgtssm = true;
   2102 	eg_pi->ls_clock_gating = false;
   2103 	eg_pi->sclk_deep_sleep = false;
   2104 
   2105 	pi->dynamic_pcie_gen2 = true;
   2106 
   2107 	if (rdev->pm.int_thermal_type != THERMAL_TYPE_NONE)
   2108 		pi->thermal_protection = true;
   2109 	else
   2110 		pi->thermal_protection = false;
   2111 
   2112 	pi->display_gap = true;
   2113 
   2114 	if (rdev->flags & RADEON_IS_MOBILITY)
   2115 		pi->dcodt = true;
   2116 	else
   2117 		pi->dcodt = false;
   2118 
   2119 	pi->ulps = true;
   2120 
   2121 	eg_pi->dynamic_ac_timing = true;
   2122 	eg_pi->abm = true;
   2123 	eg_pi->mcls = true;
   2124 	eg_pi->light_sleep = true;
   2125 	eg_pi->memory_transition = true;
   2126 #if defined(CONFIG_ACPI)
   2127 	eg_pi->pcie_performance_request =
   2128 		radeon_acpi_is_pcie_performance_request_supported(rdev);
   2129 #else
   2130 	eg_pi->pcie_performance_request = false;
   2131 #endif
   2132 
   2133 	if ((rdev->family == CHIP_CYPRESS) ||
   2134 	    (rdev->family == CHIP_HEMLOCK) ||
   2135 	    (rdev->family == CHIP_JUNIPER))
   2136 		eg_pi->dll_default_on = true;
   2137 	else
   2138 		eg_pi->dll_default_on = false;
   2139 
   2140 	eg_pi->sclk_deep_sleep = false;
   2141 	pi->mclk_stutter_mode_threshold = 0;
   2142 
   2143 	pi->sram_end = SMC_RAM_END;
   2144 
   2145 	return 0;
   2146 }
   2147 
   2148 void cypress_dpm_fini(struct radeon_device *rdev)
   2149 {
   2150 	int i;
   2151 
   2152 	for (i = 0; i < rdev->pm.dpm.num_ps; i++) {
   2153 		kfree(rdev->pm.dpm.ps[i].ps_priv);
   2154 	}
   2155 	kfree(rdev->pm.dpm.ps);
   2156 	kfree(rdev->pm.dpm.priv);
   2157 }
   2158 
   2159 bool cypress_dpm_vblank_too_short(struct radeon_device *rdev)
   2160 {
   2161 	struct rv7xx_power_info *pi = rv770_get_pi(rdev);
   2162 	u32 vblank_time = r600_dpm_get_vblank_time(rdev);
   2163 	/* we never hit the non-gddr5 limit so disable it */
   2164 	u32 switch_limit = pi->mem_gddr5 ? 450 : 0;
   2165 
   2166 	if (vblank_time < switch_limit)
   2167 		return true;
   2168 	else
   2169 		return false;
   2170 
   2171 }
   2172