1 /* 2 * Copyright 2011 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 * Authors: Alex Deucher 23 */ 24 25 #include "radeon.h" 26 #include "radeon_asic.h" 27 #include "rv770.h" 28 #include "rv770d.h" 29 #include "r600_dpm.h" 30 #include "rv770_dpm.h" 31 #include "cypress_dpm.h" 32 #include "atom.h" 33 #include "evergreen.h" 34 #include <linux/seq_file.h> 35 36 #define MC_CG_ARB_FREQ_F0 0x0a 37 #define MC_CG_ARB_FREQ_F1 0x0b 38 #define MC_CG_ARB_FREQ_F2 0x0c 39 #define MC_CG_ARB_FREQ_F3 0x0d 40 41 #define MC_CG_SEQ_DRAMCONF_S0 0x05 42 #define MC_CG_SEQ_DRAMCONF_S1 0x06 43 44 #define PCIE_BUS_CLK 10000 45 #define TCLK (PCIE_BUS_CLK / 10) 46 47 #define SMC_RAM_END 0xC000 48 49 struct rv7xx_ps *rv770_get_ps(struct radeon_ps *rps) 50 { 51 struct rv7xx_ps *ps = rps->ps_priv; 52 53 return ps; 54 } 55 56 struct rv7xx_power_info *rv770_get_pi(struct radeon_device *rdev) 57 { 58 struct rv7xx_power_info *pi = rdev->pm.dpm.priv; 59 60 return pi; 61 } 62 63 struct evergreen_power_info *evergreen_get_pi(struct radeon_device *rdev) 64 { 65 struct evergreen_power_info *pi = rdev->pm.dpm.priv; 66 67 return pi; 68 } 69 70 static void rv770_enable_bif_dynamic_pcie_gen2(struct radeon_device *rdev, 71 bool enable) 72 { 73 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 74 u32 tmp; 75 76 tmp = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL); 77 if (enable) { 78 tmp &= ~LC_HW_VOLTAGE_IF_CONTROL_MASK; 79 tmp |= LC_HW_VOLTAGE_IF_CONTROL(1); 80 tmp |= LC_GEN2_EN_STRAP; 81 } else { 82 if (!pi->boot_in_gen2) { 83 tmp &= ~LC_HW_VOLTAGE_IF_CONTROL_MASK; 84 tmp &= ~LC_GEN2_EN_STRAP; 85 } 86 } 87 if ((tmp & LC_OTHER_SIDE_EVER_SENT_GEN2) || 88 (tmp & LC_OTHER_SIDE_SUPPORTS_GEN2)) 89 WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, tmp); 90 91 } 92 93 static void rv770_enable_l0s(struct radeon_device *rdev) 94 { 95 u32 tmp; 96 97 tmp = RREG32_PCIE_PORT(PCIE_LC_CNTL) & ~LC_L0S_INACTIVITY_MASK; 98 tmp |= LC_L0S_INACTIVITY(3); 99 WREG32_PCIE_PORT(PCIE_LC_CNTL, tmp); 100 } 101 102 static void rv770_enable_l1(struct radeon_device *rdev) 103 { 104 u32 tmp; 105 106 tmp = RREG32_PCIE_PORT(PCIE_LC_CNTL); 107 tmp &= ~LC_L1_INACTIVITY_MASK; 108 tmp |= LC_L1_INACTIVITY(4); 109 tmp &= ~LC_PMI_TO_L1_DIS; 110 tmp &= ~LC_ASPM_TO_L1_DIS; 111 WREG32_PCIE_PORT(PCIE_LC_CNTL, tmp); 112 } 113 114 static void rv770_enable_pll_sleep_in_l1(struct radeon_device *rdev) 115 { 116 u32 tmp; 117 118 tmp = RREG32_PCIE_PORT(PCIE_LC_CNTL) & ~LC_L1_INACTIVITY_MASK; 119 tmp |= LC_L1_INACTIVITY(8); 120 WREG32_PCIE_PORT(PCIE_LC_CNTL, tmp); 121 122 /* NOTE, this is a PCIE indirect reg, not PCIE PORT */ 123 tmp = RREG32_PCIE(PCIE_P_CNTL); 124 tmp |= P_PLL_PWRDN_IN_L1L23; 125 tmp &= ~P_PLL_BUF_PDNB; 126 tmp &= ~P_PLL_PDNB; 127 tmp |= P_ALLOW_PRX_FRONTEND_SHUTOFF; 128 WREG32_PCIE(PCIE_P_CNTL, tmp); 129 } 130 131 static void rv770_gfx_clock_gating_enable(struct radeon_device *rdev, 132 bool enable) 133 { 134 if (enable) 135 WREG32_P(SCLK_PWRMGT_CNTL, DYN_GFX_CLK_OFF_EN, ~DYN_GFX_CLK_OFF_EN); 136 else { 137 WREG32_P(SCLK_PWRMGT_CNTL, 0, ~DYN_GFX_CLK_OFF_EN); 138 WREG32_P(SCLK_PWRMGT_CNTL, GFX_CLK_FORCE_ON, ~GFX_CLK_FORCE_ON); 139 WREG32_P(SCLK_PWRMGT_CNTL, 0, ~GFX_CLK_FORCE_ON); 140 RREG32(GB_TILING_CONFIG); 141 } 142 } 143 144 static void rv770_mg_clock_gating_enable(struct radeon_device *rdev, 145 bool enable) 146 { 147 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 148 149 if (enable) { 150 u32 mgcg_cgtt_local0; 151 152 if (rdev->family == CHIP_RV770) 153 mgcg_cgtt_local0 = RV770_MGCGTTLOCAL0_DFLT; 154 else 155 mgcg_cgtt_local0 = RV7XX_MGCGTTLOCAL0_DFLT; 156 157 WREG32(CG_CGTT_LOCAL_0, mgcg_cgtt_local0); 158 WREG32(CG_CGTT_LOCAL_1, (RV770_MGCGTTLOCAL1_DFLT & 0xFFFFCFFF)); 159 160 if (pi->mgcgtssm) 161 WREG32(CGTS_SM_CTRL_REG, RV770_MGCGCGTSSMCTRL_DFLT); 162 } else { 163 WREG32(CG_CGTT_LOCAL_0, 0xFFFFFFFF); 164 WREG32(CG_CGTT_LOCAL_1, 0xFFFFCFFF); 165 } 166 } 167 168 void rv770_restore_cgcg(struct radeon_device *rdev) 169 { 170 bool dpm_en = false, cg_en = false; 171 172 if (RREG32(GENERAL_PWRMGT) & GLOBAL_PWRMGT_EN) 173 dpm_en = true; 174 if (RREG32(SCLK_PWRMGT_CNTL) & DYN_GFX_CLK_OFF_EN) 175 cg_en = true; 176 177 if (dpm_en && !cg_en) 178 WREG32_P(SCLK_PWRMGT_CNTL, DYN_GFX_CLK_OFF_EN, ~DYN_GFX_CLK_OFF_EN); 179 } 180 181 static void rv770_start_dpm(struct radeon_device *rdev) 182 { 183 WREG32_P(SCLK_PWRMGT_CNTL, 0, ~SCLK_PWRMGT_OFF); 184 185 WREG32_P(MCLK_PWRMGT_CNTL, 0, ~MPLL_PWRMGT_OFF); 186 187 WREG32_P(GENERAL_PWRMGT, GLOBAL_PWRMGT_EN, ~GLOBAL_PWRMGT_EN); 188 } 189 190 void rv770_stop_dpm(struct radeon_device *rdev) 191 { 192 PPSMC_Result result; 193 194 result = rv770_send_msg_to_smc(rdev, PPSMC_MSG_TwoLevelsDisabled); 195 196 if (result != PPSMC_Result_OK) 197 DRM_DEBUG("Could not force DPM to low.\n"); 198 199 WREG32_P(GENERAL_PWRMGT, 0, ~GLOBAL_PWRMGT_EN); 200 201 WREG32_P(SCLK_PWRMGT_CNTL, SCLK_PWRMGT_OFF, ~SCLK_PWRMGT_OFF); 202 203 WREG32_P(MCLK_PWRMGT_CNTL, MPLL_PWRMGT_OFF, ~MPLL_PWRMGT_OFF); 204 } 205 206 bool rv770_dpm_enabled(struct radeon_device *rdev) 207 { 208 if (RREG32(GENERAL_PWRMGT) & GLOBAL_PWRMGT_EN) 209 return true; 210 else 211 return false; 212 } 213 214 void rv770_enable_thermal_protection(struct radeon_device *rdev, 215 bool enable) 216 { 217 if (enable) 218 WREG32_P(GENERAL_PWRMGT, 0, ~THERMAL_PROTECTION_DIS); 219 else 220 WREG32_P(GENERAL_PWRMGT, THERMAL_PROTECTION_DIS, ~THERMAL_PROTECTION_DIS); 221 } 222 223 void rv770_enable_acpi_pm(struct radeon_device *rdev) 224 { 225 WREG32_P(GENERAL_PWRMGT, STATIC_PM_EN, ~STATIC_PM_EN); 226 } 227 228 u8 rv770_get_seq_value(struct radeon_device *rdev, 229 struct rv7xx_pl *pl) 230 { 231 return (pl->flags & ATOM_PPLIB_R600_FLAGS_LOWPOWER) ? 232 MC_CG_SEQ_DRAMCONF_S0 : MC_CG_SEQ_DRAMCONF_S1; 233 } 234 235 #if 0 236 int rv770_read_smc_soft_register(struct radeon_device *rdev, 237 u16 reg_offset, u32 *value) 238 { 239 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 240 241 return rv770_read_smc_sram_dword(rdev, 242 pi->soft_regs_start + reg_offset, 243 value, pi->sram_end); 244 } 245 #endif 246 247 int rv770_write_smc_soft_register(struct radeon_device *rdev, 248 u16 reg_offset, u32 value) 249 { 250 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 251 252 return rv770_write_smc_sram_dword(rdev, 253 pi->soft_regs_start + reg_offset, 254 value, pi->sram_end); 255 } 256 257 int rv770_populate_smc_t(struct radeon_device *rdev, 258 struct radeon_ps *radeon_state, 259 RV770_SMC_SWSTATE *smc_state) 260 { 261 struct rv7xx_ps *state = rv770_get_ps(radeon_state); 262 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 263 int i; 264 int a_n; 265 int a_d; 266 u8 l[RV770_SMC_PERFORMANCE_LEVELS_PER_SWSTATE]; 267 u8 r[RV770_SMC_PERFORMANCE_LEVELS_PER_SWSTATE]; 268 u32 a_t; 269 270 l[0] = 0; 271 r[2] = 100; 272 273 a_n = (int)state->medium.sclk * pi->lmp + 274 (int)state->low.sclk * (R600_AH_DFLT - pi->rlp); 275 a_d = (int)state->low.sclk * (100 - (int)pi->rlp) + 276 (int)state->medium.sclk * pi->lmp; 277 278 l[1] = (u8)(pi->lmp - (int)pi->lmp * a_n / a_d); 279 r[0] = (u8)(pi->rlp + (100 - (int)pi->rlp) * a_n / a_d); 280 281 a_n = (int)state->high.sclk * pi->lhp + (int)state->medium.sclk * 282 (R600_AH_DFLT - pi->rmp); 283 a_d = (int)state->medium.sclk * (100 - (int)pi->rmp) + 284 (int)state->high.sclk * pi->lhp; 285 286 l[2] = (u8)(pi->lhp - (int)pi->lhp * a_n / a_d); 287 r[1] = (u8)(pi->rmp + (100 - (int)pi->rmp) * a_n / a_d); 288 289 for (i = 0; i < (RV770_SMC_PERFORMANCE_LEVELS_PER_SWSTATE - 1); i++) { 290 a_t = CG_R(r[i] * pi->bsp / 200) | CG_L(l[i] * pi->bsp / 200); 291 smc_state->levels[i].aT = cpu_to_be32(a_t); 292 } 293 294 a_t = CG_R(r[RV770_SMC_PERFORMANCE_LEVELS_PER_SWSTATE - 1] * pi->pbsp / 200) | 295 CG_L(l[RV770_SMC_PERFORMANCE_LEVELS_PER_SWSTATE - 1] * pi->pbsp / 200); 296 297 smc_state->levels[RV770_SMC_PERFORMANCE_LEVELS_PER_SWSTATE - 1].aT = 298 cpu_to_be32(a_t); 299 300 return 0; 301 } 302 303 int rv770_populate_smc_sp(struct radeon_device *rdev, 304 struct radeon_ps *radeon_state, 305 RV770_SMC_SWSTATE *smc_state) 306 { 307 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 308 int i; 309 310 for (i = 0; i < (RV770_SMC_PERFORMANCE_LEVELS_PER_SWSTATE - 1); i++) 311 smc_state->levels[i].bSP = cpu_to_be32(pi->dsp); 312 313 smc_state->levels[RV770_SMC_PERFORMANCE_LEVELS_PER_SWSTATE - 1].bSP = 314 cpu_to_be32(pi->psp); 315 316 return 0; 317 } 318 319 static void rv770_calculate_fractional_mpll_feedback_divider(u32 memory_clock, 320 u32 reference_clock, 321 bool gddr5, 322 struct atom_clock_dividers *dividers, 323 u32 *clkf, 324 u32 *clkfrac) 325 { 326 u32 post_divider, reference_divider, feedback_divider8; 327 u32 fyclk; 328 329 if (gddr5) 330 fyclk = (memory_clock * 8) / 2; 331 else 332 fyclk = (memory_clock * 4) / 2; 333 334 post_divider = dividers->post_div; 335 reference_divider = dividers->ref_div; 336 337 feedback_divider8 = 338 (8 * fyclk * reference_divider * post_divider) / reference_clock; 339 340 *clkf = feedback_divider8 / 8; 341 *clkfrac = feedback_divider8 % 8; 342 } 343 344 static int rv770_encode_yclk_post_div(u32 postdiv, u32 *encoded_postdiv) 345 { 346 int ret = 0; 347 348 switch (postdiv) { 349 case 1: 350 *encoded_postdiv = 0; 351 break; 352 case 2: 353 *encoded_postdiv = 1; 354 break; 355 case 4: 356 *encoded_postdiv = 2; 357 break; 358 case 8: 359 *encoded_postdiv = 3; 360 break; 361 case 16: 362 *encoded_postdiv = 4; 363 break; 364 default: 365 ret = -EINVAL; 366 break; 367 } 368 369 return ret; 370 } 371 372 u32 rv770_map_clkf_to_ibias(struct radeon_device *rdev, u32 clkf) 373 { 374 if (clkf <= 0x10) 375 return 0x4B; 376 if (clkf <= 0x19) 377 return 0x5B; 378 if (clkf <= 0x21) 379 return 0x2B; 380 if (clkf <= 0x27) 381 return 0x6C; 382 if (clkf <= 0x31) 383 return 0x9D; 384 return 0xC6; 385 } 386 387 static int rv770_populate_mclk_value(struct radeon_device *rdev, 388 u32 engine_clock, u32 memory_clock, 389 RV7XX_SMC_MCLK_VALUE *mclk) 390 { 391 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 392 u8 encoded_reference_dividers[] = { 0, 16, 17, 20, 21 }; 393 u32 mpll_ad_func_cntl = 394 pi->clk_regs.rv770.mpll_ad_func_cntl; 395 u32 mpll_ad_func_cntl_2 = 396 pi->clk_regs.rv770.mpll_ad_func_cntl_2; 397 u32 mpll_dq_func_cntl = 398 pi->clk_regs.rv770.mpll_dq_func_cntl; 399 u32 mpll_dq_func_cntl_2 = 400 pi->clk_regs.rv770.mpll_dq_func_cntl_2; 401 u32 mclk_pwrmgt_cntl = 402 pi->clk_regs.rv770.mclk_pwrmgt_cntl; 403 u32 dll_cntl = pi->clk_regs.rv770.dll_cntl; 404 struct atom_clock_dividers dividers; 405 u32 reference_clock = rdev->clock.mpll.reference_freq; 406 u32 clkf, clkfrac; 407 u32 postdiv_yclk; 408 u32 ibias; 409 int ret; 410 411 ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_MEMORY_PLL_PARAM, 412 memory_clock, false, ÷rs); 413 if (ret) 414 return ret; 415 416 if ((dividers.ref_div < 1) || (dividers.ref_div > 5)) 417 return -EINVAL; 418 419 rv770_calculate_fractional_mpll_feedback_divider(memory_clock, reference_clock, 420 pi->mem_gddr5, 421 ÷rs, &clkf, &clkfrac); 422 423 ret = rv770_encode_yclk_post_div(dividers.post_div, &postdiv_yclk); 424 if (ret) 425 return ret; 426 427 ibias = rv770_map_clkf_to_ibias(rdev, clkf); 428 429 mpll_ad_func_cntl &= ~(CLKR_MASK | 430 YCLK_POST_DIV_MASK | 431 CLKF_MASK | 432 CLKFRAC_MASK | 433 IBIAS_MASK); 434 mpll_ad_func_cntl |= CLKR(encoded_reference_dividers[dividers.ref_div - 1]); 435 mpll_ad_func_cntl |= YCLK_POST_DIV(postdiv_yclk); 436 mpll_ad_func_cntl |= CLKF(clkf); 437 mpll_ad_func_cntl |= CLKFRAC(clkfrac); 438 mpll_ad_func_cntl |= IBIAS(ibias); 439 440 if (dividers.vco_mode) 441 mpll_ad_func_cntl_2 |= VCO_MODE; 442 else 443 mpll_ad_func_cntl_2 &= ~VCO_MODE; 444 445 if (pi->mem_gddr5) { 446 rv770_calculate_fractional_mpll_feedback_divider(memory_clock, 447 reference_clock, 448 pi->mem_gddr5, 449 ÷rs, &clkf, &clkfrac); 450 451 ibias = rv770_map_clkf_to_ibias(rdev, clkf); 452 453 ret = rv770_encode_yclk_post_div(dividers.post_div, &postdiv_yclk); 454 if (ret) 455 return ret; 456 457 mpll_dq_func_cntl &= ~(CLKR_MASK | 458 YCLK_POST_DIV_MASK | 459 CLKF_MASK | 460 CLKFRAC_MASK | 461 IBIAS_MASK); 462 mpll_dq_func_cntl |= CLKR(encoded_reference_dividers[dividers.ref_div - 1]); 463 mpll_dq_func_cntl |= YCLK_POST_DIV(postdiv_yclk); 464 mpll_dq_func_cntl |= CLKF(clkf); 465 mpll_dq_func_cntl |= CLKFRAC(clkfrac); 466 mpll_dq_func_cntl |= IBIAS(ibias); 467 468 if (dividers.vco_mode) 469 mpll_dq_func_cntl_2 |= VCO_MODE; 470 else 471 mpll_dq_func_cntl_2 &= ~VCO_MODE; 472 } 473 474 mclk->mclk770.mclk_value = cpu_to_be32(memory_clock); 475 mclk->mclk770.vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); 476 mclk->mclk770.vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2); 477 mclk->mclk770.vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); 478 mclk->mclk770.vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2); 479 mclk->mclk770.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); 480 mclk->mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl); 481 482 return 0; 483 } 484 485 static int rv770_populate_sclk_value(struct radeon_device *rdev, 486 u32 engine_clock, 487 RV770_SMC_SCLK_VALUE *sclk) 488 { 489 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 490 struct atom_clock_dividers dividers; 491 u32 spll_func_cntl = 492 pi->clk_regs.rv770.cg_spll_func_cntl; 493 u32 spll_func_cntl_2 = 494 pi->clk_regs.rv770.cg_spll_func_cntl_2; 495 u32 spll_func_cntl_3 = 496 pi->clk_regs.rv770.cg_spll_func_cntl_3; 497 u32 cg_spll_spread_spectrum = 498 pi->clk_regs.rv770.cg_spll_spread_spectrum; 499 u32 cg_spll_spread_spectrum_2 = 500 pi->clk_regs.rv770.cg_spll_spread_spectrum_2; 501 u64 tmp; 502 u32 reference_clock = rdev->clock.spll.reference_freq; 503 u32 reference_divider, post_divider; 504 u32 fbdiv; 505 int ret; 506 507 ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM, 508 engine_clock, false, ÷rs); 509 if (ret) 510 return ret; 511 512 reference_divider = 1 + dividers.ref_div; 513 514 if (dividers.enable_post_div) 515 post_divider = (0x0f & (dividers.post_div >> 4)) + (0x0f & dividers.post_div) + 2; 516 else 517 post_divider = 1; 518 519 tmp = (u64) engine_clock * reference_divider * post_divider * 16384; 520 do_div(tmp, reference_clock); 521 fbdiv = (u32) tmp; 522 523 if (dividers.enable_post_div) 524 spll_func_cntl |= SPLL_DIVEN; 525 else 526 spll_func_cntl &= ~SPLL_DIVEN; 527 spll_func_cntl &= ~(SPLL_HILEN_MASK | SPLL_LOLEN_MASK | SPLL_REF_DIV_MASK); 528 spll_func_cntl |= SPLL_REF_DIV(dividers.ref_div); 529 spll_func_cntl |= SPLL_HILEN((dividers.post_div >> 4) & 0xf); 530 spll_func_cntl |= SPLL_LOLEN(dividers.post_div & 0xf); 531 532 spll_func_cntl_2 &= ~SCLK_MUX_SEL_MASK; 533 spll_func_cntl_2 |= SCLK_MUX_SEL(2); 534 535 spll_func_cntl_3 &= ~SPLL_FB_DIV_MASK; 536 spll_func_cntl_3 |= SPLL_FB_DIV(fbdiv); 537 spll_func_cntl_3 |= SPLL_DITHEN; 538 539 if (pi->sclk_ss) { 540 struct radeon_atom_ss ss; 541 u32 vco_freq = engine_clock * post_divider; 542 543 if (radeon_atombios_get_asic_ss_info(rdev, &ss, 544 ASIC_INTERNAL_ENGINE_SS, vco_freq)) { 545 u32 clk_s = reference_clock * 5 / (reference_divider * ss.rate); 546 u32 clk_v = ss.percentage * fbdiv / (clk_s * 10000); 547 548 cg_spll_spread_spectrum &= ~CLKS_MASK; 549 cg_spll_spread_spectrum |= CLKS(clk_s); 550 cg_spll_spread_spectrum |= SSEN; 551 552 cg_spll_spread_spectrum_2 &= ~CLKV_MASK; 553 cg_spll_spread_spectrum_2 |= CLKV(clk_v); 554 } 555 } 556 557 sclk->sclk_value = cpu_to_be32(engine_clock); 558 sclk->vCG_SPLL_FUNC_CNTL = cpu_to_be32(spll_func_cntl); 559 sclk->vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(spll_func_cntl_2); 560 sclk->vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(spll_func_cntl_3); 561 sclk->vCG_SPLL_SPREAD_SPECTRUM = cpu_to_be32(cg_spll_spread_spectrum); 562 sclk->vCG_SPLL_SPREAD_SPECTRUM_2 = cpu_to_be32(cg_spll_spread_spectrum_2); 563 564 return 0; 565 } 566 567 int rv770_populate_vddc_value(struct radeon_device *rdev, u16 vddc, 568 RV770_SMC_VOLTAGE_VALUE *voltage) 569 { 570 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 571 int i; 572 573 if (!pi->voltage_control) { 574 voltage->index = 0; 575 voltage->value = 0; 576 return 0; 577 } 578 579 for (i = 0; i < pi->valid_vddc_entries; i++) { 580 if (vddc <= pi->vddc_table[i].vddc) { 581 voltage->index = pi->vddc_table[i].vddc_index; 582 voltage->value = cpu_to_be16(vddc); 583 break; 584 } 585 } 586 587 if (i == pi->valid_vddc_entries) 588 return -EINVAL; 589 590 return 0; 591 } 592 593 int rv770_populate_mvdd_value(struct radeon_device *rdev, u32 mclk, 594 RV770_SMC_VOLTAGE_VALUE *voltage) 595 { 596 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 597 598 if (!pi->mvdd_control) { 599 voltage->index = MVDD_HIGH_INDEX; 600 voltage->value = cpu_to_be16(MVDD_HIGH_VALUE); 601 return 0; 602 } 603 604 if (mclk <= pi->mvdd_split_frequency) { 605 voltage->index = MVDD_LOW_INDEX; 606 voltage->value = cpu_to_be16(MVDD_LOW_VALUE); 607 } else { 608 voltage->index = MVDD_HIGH_INDEX; 609 voltage->value = cpu_to_be16(MVDD_HIGH_VALUE); 610 } 611 612 return 0; 613 } 614 615 static int rv770_convert_power_level_to_smc(struct radeon_device *rdev, 616 struct rv7xx_pl *pl, 617 RV770_SMC_HW_PERFORMANCE_LEVEL *level, 618 u8 watermark_level) 619 { 620 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 621 int ret; 622 623 level->gen2PCIE = pi->pcie_gen2 ? 624 ((pl->flags & ATOM_PPLIB_R600_FLAGS_PCIEGEN2) ? 1 : 0) : 0; 625 level->gen2XSP = (pl->flags & ATOM_PPLIB_R600_FLAGS_PCIEGEN2) ? 1 : 0; 626 level->backbias = (pl->flags & ATOM_PPLIB_R600_FLAGS_BACKBIASENABLE) ? 1 : 0; 627 level->displayWatermark = watermark_level; 628 629 if (rdev->family == CHIP_RV740) 630 ret = rv740_populate_sclk_value(rdev, pl->sclk, 631 &level->sclk); 632 else if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 633 ret = rv730_populate_sclk_value(rdev, pl->sclk, 634 &level->sclk); 635 else 636 ret = rv770_populate_sclk_value(rdev, pl->sclk, 637 &level->sclk); 638 if (ret) 639 return ret; 640 641 if (rdev->family == CHIP_RV740) { 642 if (pi->mem_gddr5) { 643 if (pl->mclk <= pi->mclk_strobe_mode_threshold) 644 level->strobeMode = 645 rv740_get_mclk_frequency_ratio(pl->mclk) | 0x10; 646 else 647 level->strobeMode = 0; 648 649 if (pl->mclk > pi->mclk_edc_enable_threshold) 650 level->mcFlags = SMC_MC_EDC_RD_FLAG | SMC_MC_EDC_WR_FLAG; 651 else 652 level->mcFlags = 0; 653 } 654 ret = rv740_populate_mclk_value(rdev, pl->sclk, 655 pl->mclk, &level->mclk); 656 } else if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 657 ret = rv730_populate_mclk_value(rdev, pl->sclk, 658 pl->mclk, &level->mclk); 659 else 660 ret = rv770_populate_mclk_value(rdev, pl->sclk, 661 pl->mclk, &level->mclk); 662 if (ret) 663 return ret; 664 665 ret = rv770_populate_vddc_value(rdev, pl->vddc, 666 &level->vddc); 667 if (ret) 668 return ret; 669 670 ret = rv770_populate_mvdd_value(rdev, pl->mclk, &level->mvdd); 671 672 return ret; 673 } 674 675 static int rv770_convert_power_state_to_smc(struct radeon_device *rdev, 676 struct radeon_ps *radeon_state, 677 RV770_SMC_SWSTATE *smc_state) 678 { 679 struct rv7xx_ps *state = rv770_get_ps(radeon_state); 680 int ret; 681 682 if (!(radeon_state->caps & ATOM_PPLIB_DISALLOW_ON_DC)) 683 smc_state->flags |= PPSMC_SWSTATE_FLAG_DC; 684 685 ret = rv770_convert_power_level_to_smc(rdev, 686 &state->low, 687 &smc_state->levels[0], 688 PPSMC_DISPLAY_WATERMARK_LOW); 689 if (ret) 690 return ret; 691 692 ret = rv770_convert_power_level_to_smc(rdev, 693 &state->medium, 694 &smc_state->levels[1], 695 PPSMC_DISPLAY_WATERMARK_LOW); 696 if (ret) 697 return ret; 698 699 ret = rv770_convert_power_level_to_smc(rdev, 700 &state->high, 701 &smc_state->levels[2], 702 PPSMC_DISPLAY_WATERMARK_HIGH); 703 if (ret) 704 return ret; 705 706 smc_state->levels[0].arbValue = MC_CG_ARB_FREQ_F1; 707 smc_state->levels[1].arbValue = MC_CG_ARB_FREQ_F2; 708 smc_state->levels[2].arbValue = MC_CG_ARB_FREQ_F3; 709 710 smc_state->levels[0].seqValue = rv770_get_seq_value(rdev, 711 &state->low); 712 smc_state->levels[1].seqValue = rv770_get_seq_value(rdev, 713 &state->medium); 714 smc_state->levels[2].seqValue = rv770_get_seq_value(rdev, 715 &state->high); 716 717 rv770_populate_smc_sp(rdev, radeon_state, smc_state); 718 719 return rv770_populate_smc_t(rdev, radeon_state, smc_state); 720 721 } 722 723 u32 rv770_calculate_memory_refresh_rate(struct radeon_device *rdev, 724 u32 engine_clock) 725 { 726 u32 dram_rows; 727 u32 dram_refresh_rate; 728 u32 mc_arb_rfsh_rate; 729 u32 tmp; 730 731 tmp = (RREG32(MC_ARB_RAMCFG) & NOOFROWS_MASK) >> NOOFROWS_SHIFT; 732 dram_rows = 1 << (tmp + 10); 733 tmp = RREG32(MC_SEQ_MISC0) & 3; 734 dram_refresh_rate = 1 << (tmp + 3); 735 mc_arb_rfsh_rate = ((engine_clock * 10) * dram_refresh_rate / dram_rows - 32) / 64; 736 737 return mc_arb_rfsh_rate; 738 } 739 740 static void rv770_program_memory_timing_parameters(struct radeon_device *rdev, 741 struct radeon_ps *radeon_state) 742 { 743 struct rv7xx_ps *state = rv770_get_ps(radeon_state); 744 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 745 u32 sqm_ratio; 746 u32 arb_refresh_rate; 747 u32 high_clock; 748 749 if (state->high.sclk < (state->low.sclk * 0xFF / 0x40)) 750 high_clock = state->high.sclk; 751 else 752 high_clock = (state->low.sclk * 0xFF / 0x40); 753 754 radeon_atom_set_engine_dram_timings(rdev, high_clock, 755 state->high.mclk); 756 757 sqm_ratio = 758 STATE0(64 * high_clock / pi->boot_sclk) | 759 STATE1(64 * high_clock / state->low.sclk) | 760 STATE2(64 * high_clock / state->medium.sclk) | 761 STATE3(64 * high_clock / state->high.sclk); 762 WREG32(MC_ARB_SQM_RATIO, sqm_ratio); 763 764 arb_refresh_rate = 765 POWERMODE0(rv770_calculate_memory_refresh_rate(rdev, pi->boot_sclk)) | 766 POWERMODE1(rv770_calculate_memory_refresh_rate(rdev, state->low.sclk)) | 767 POWERMODE2(rv770_calculate_memory_refresh_rate(rdev, state->medium.sclk)) | 768 POWERMODE3(rv770_calculate_memory_refresh_rate(rdev, state->high.sclk)); 769 WREG32(MC_ARB_RFSH_RATE, arb_refresh_rate); 770 } 771 772 void rv770_enable_backbias(struct radeon_device *rdev, 773 bool enable) 774 { 775 if (enable) 776 WREG32_P(GENERAL_PWRMGT, BACKBIAS_PAD_EN, ~BACKBIAS_PAD_EN); 777 else 778 WREG32_P(GENERAL_PWRMGT, 0, ~(BACKBIAS_VALUE | BACKBIAS_PAD_EN)); 779 } 780 781 static void rv770_enable_spread_spectrum(struct radeon_device *rdev, 782 bool enable) 783 { 784 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 785 786 if (enable) { 787 if (pi->sclk_ss) 788 WREG32_P(GENERAL_PWRMGT, DYN_SPREAD_SPECTRUM_EN, ~DYN_SPREAD_SPECTRUM_EN); 789 790 if (pi->mclk_ss) { 791 if (rdev->family == CHIP_RV740) 792 rv740_enable_mclk_spread_spectrum(rdev, true); 793 } 794 } else { 795 WREG32_P(CG_SPLL_SPREAD_SPECTRUM, 0, ~SSEN); 796 797 WREG32_P(GENERAL_PWRMGT, 0, ~DYN_SPREAD_SPECTRUM_EN); 798 799 WREG32_P(CG_MPLL_SPREAD_SPECTRUM, 0, ~SSEN); 800 801 if (rdev->family == CHIP_RV740) 802 rv740_enable_mclk_spread_spectrum(rdev, false); 803 } 804 } 805 806 static void rv770_program_mpll_timing_parameters(struct radeon_device *rdev) 807 { 808 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 809 810 if ((rdev->family == CHIP_RV770) && !pi->mem_gddr5) { 811 WREG32(MPLL_TIME, 812 (MPLL_LOCK_TIME(R600_MPLLLOCKTIME_DFLT * pi->ref_div) | 813 MPLL_RESET_TIME(R600_MPLLRESETTIME_DFLT))); 814 } 815 } 816 817 void rv770_setup_bsp(struct radeon_device *rdev) 818 { 819 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 820 u32 xclk = radeon_get_xclk(rdev); 821 822 r600_calculate_u_and_p(pi->asi, 823 xclk, 824 16, 825 &pi->bsp, 826 &pi->bsu); 827 828 r600_calculate_u_and_p(pi->pasi, 829 xclk, 830 16, 831 &pi->pbsp, 832 &pi->pbsu); 833 834 pi->dsp = BSP(pi->bsp) | BSU(pi->bsu); 835 pi->psp = BSP(pi->pbsp) | BSU(pi->pbsu); 836 837 WREG32(CG_BSP, pi->dsp); 838 839 } 840 841 void rv770_program_git(struct radeon_device *rdev) 842 { 843 WREG32_P(CG_GIT, CG_GICST(R600_GICST_DFLT), ~CG_GICST_MASK); 844 } 845 846 void rv770_program_tp(struct radeon_device *rdev) 847 { 848 int i; 849 enum r600_td td = R600_TD_DFLT; 850 851 for (i = 0; i < R600_PM_NUMBER_OF_TC; i++) 852 WREG32(CG_FFCT_0 + (i * 4), (UTC_0(r600_utc[i]) | DTC_0(r600_dtc[i]))); 853 854 if (td == R600_TD_AUTO) 855 WREG32_P(SCLK_PWRMGT_CNTL, 0, ~FIR_FORCE_TREND_SEL); 856 else 857 WREG32_P(SCLK_PWRMGT_CNTL, FIR_FORCE_TREND_SEL, ~FIR_FORCE_TREND_SEL); 858 if (td == R600_TD_UP) 859 WREG32_P(SCLK_PWRMGT_CNTL, 0, ~FIR_TREND_MODE); 860 if (td == R600_TD_DOWN) 861 WREG32_P(SCLK_PWRMGT_CNTL, FIR_TREND_MODE, ~FIR_TREND_MODE); 862 } 863 864 void rv770_program_tpp(struct radeon_device *rdev) 865 { 866 WREG32(CG_TPC, R600_TPC_DFLT); 867 } 868 869 void rv770_program_sstp(struct radeon_device *rdev) 870 { 871 WREG32(CG_SSP, (SSTU(R600_SSTU_DFLT) | SST(R600_SST_DFLT))); 872 } 873 874 void rv770_program_engine_speed_parameters(struct radeon_device *rdev) 875 { 876 WREG32_P(SPLL_CNTL_MODE, SPLL_DIV_SYNC, ~SPLL_DIV_SYNC); 877 } 878 879 static void rv770_enable_display_gap(struct radeon_device *rdev) 880 { 881 u32 tmp = RREG32(CG_DISPLAY_GAP_CNTL); 882 883 tmp &= ~(DISP1_GAP_MCHG_MASK | DISP2_GAP_MCHG_MASK); 884 tmp |= (DISP1_GAP_MCHG(R600_PM_DISPLAY_GAP_IGNORE) | 885 DISP2_GAP_MCHG(R600_PM_DISPLAY_GAP_IGNORE)); 886 WREG32(CG_DISPLAY_GAP_CNTL, tmp); 887 } 888 889 void rv770_program_vc(struct radeon_device *rdev) 890 { 891 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 892 893 WREG32(CG_FTV, pi->vrc); 894 } 895 896 void rv770_clear_vc(struct radeon_device *rdev) 897 { 898 WREG32(CG_FTV, 0); 899 } 900 901 int rv770_upload_firmware(struct radeon_device *rdev) 902 { 903 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 904 int ret; 905 906 rv770_reset_smc(rdev); 907 rv770_stop_smc_clock(rdev); 908 909 ret = rv770_load_smc_ucode(rdev, pi->sram_end); 910 if (ret) 911 return ret; 912 913 return 0; 914 } 915 916 static int rv770_populate_smc_acpi_state(struct radeon_device *rdev, 917 RV770_SMC_STATETABLE *table) 918 { 919 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 920 921 u32 mpll_ad_func_cntl = 922 pi->clk_regs.rv770.mpll_ad_func_cntl; 923 u32 mpll_ad_func_cntl_2 = 924 pi->clk_regs.rv770.mpll_ad_func_cntl_2; 925 u32 mpll_dq_func_cntl = 926 pi->clk_regs.rv770.mpll_dq_func_cntl; 927 u32 mpll_dq_func_cntl_2 = 928 pi->clk_regs.rv770.mpll_dq_func_cntl_2; 929 u32 spll_func_cntl = 930 pi->clk_regs.rv770.cg_spll_func_cntl; 931 u32 spll_func_cntl_2 = 932 pi->clk_regs.rv770.cg_spll_func_cntl_2; 933 u32 spll_func_cntl_3 = 934 pi->clk_regs.rv770.cg_spll_func_cntl_3; 935 u32 mclk_pwrmgt_cntl; 936 u32 dll_cntl; 937 938 table->ACPIState = table->initialState; 939 940 table->ACPIState.flags &= ~PPSMC_SWSTATE_FLAG_DC; 941 942 if (pi->acpi_vddc) { 943 rv770_populate_vddc_value(rdev, pi->acpi_vddc, 944 &table->ACPIState.levels[0].vddc); 945 if (pi->pcie_gen2) { 946 if (pi->acpi_pcie_gen2) 947 table->ACPIState.levels[0].gen2PCIE = 1; 948 else 949 table->ACPIState.levels[0].gen2PCIE = 0; 950 } else 951 table->ACPIState.levels[0].gen2PCIE = 0; 952 if (pi->acpi_pcie_gen2) 953 table->ACPIState.levels[0].gen2XSP = 1; 954 else 955 table->ACPIState.levels[0].gen2XSP = 0; 956 } else { 957 rv770_populate_vddc_value(rdev, pi->min_vddc_in_table, 958 &table->ACPIState.levels[0].vddc); 959 table->ACPIState.levels[0].gen2PCIE = 0; 960 } 961 962 963 mpll_ad_func_cntl_2 |= BIAS_GEN_PDNB | RESET_EN; 964 965 mpll_dq_func_cntl_2 |= BIAS_GEN_PDNB | RESET_EN; 966 967 mclk_pwrmgt_cntl = (MRDCKA0_RESET | 968 MRDCKA1_RESET | 969 MRDCKB0_RESET | 970 MRDCKB1_RESET | 971 MRDCKC0_RESET | 972 MRDCKC1_RESET | 973 MRDCKD0_RESET | 974 MRDCKD1_RESET); 975 976 dll_cntl = 0xff000000; 977 978 spll_func_cntl |= SPLL_RESET | SPLL_SLEEP | SPLL_BYPASS_EN; 979 980 spll_func_cntl_2 &= ~SCLK_MUX_SEL_MASK; 981 spll_func_cntl_2 |= SCLK_MUX_SEL(4); 982 983 table->ACPIState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL = cpu_to_be32(mpll_ad_func_cntl); 984 table->ACPIState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL_2 = cpu_to_be32(mpll_ad_func_cntl_2); 985 table->ACPIState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL = cpu_to_be32(mpll_dq_func_cntl); 986 table->ACPIState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL_2 = cpu_to_be32(mpll_dq_func_cntl_2); 987 988 table->ACPIState.levels[0].mclk.mclk770.vMCLK_PWRMGT_CNTL = cpu_to_be32(mclk_pwrmgt_cntl); 989 table->ACPIState.levels[0].mclk.mclk770.vDLL_CNTL = cpu_to_be32(dll_cntl); 990 991 table->ACPIState.levels[0].mclk.mclk770.mclk_value = 0; 992 993 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL = cpu_to_be32(spll_func_cntl); 994 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_2 = cpu_to_be32(spll_func_cntl_2); 995 table->ACPIState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_3 = cpu_to_be32(spll_func_cntl_3); 996 997 table->ACPIState.levels[0].sclk.sclk_value = 0; 998 999 rv770_populate_mvdd_value(rdev, 0, &table->ACPIState.levels[0].mvdd); 1000 1001 table->ACPIState.levels[1] = table->ACPIState.levels[0]; 1002 table->ACPIState.levels[2] = table->ACPIState.levels[0]; 1003 1004 return 0; 1005 } 1006 1007 int rv770_populate_initial_mvdd_value(struct radeon_device *rdev, 1008 RV770_SMC_VOLTAGE_VALUE *voltage) 1009 { 1010 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1011 1012 if ((pi->s0_vid_lower_smio_cntl & pi->mvdd_mask_low) == 1013 (pi->mvdd_low_smio[MVDD_LOW_INDEX] & pi->mvdd_mask_low)) { 1014 voltage->index = MVDD_LOW_INDEX; 1015 voltage->value = cpu_to_be16(MVDD_LOW_VALUE); 1016 } else { 1017 voltage->index = MVDD_HIGH_INDEX; 1018 voltage->value = cpu_to_be16(MVDD_HIGH_VALUE); 1019 } 1020 1021 return 0; 1022 } 1023 1024 static int rv770_populate_smc_initial_state(struct radeon_device *rdev, 1025 struct radeon_ps *radeon_state, 1026 RV770_SMC_STATETABLE *table) 1027 { 1028 struct rv7xx_ps *initial_state = rv770_get_ps(radeon_state); 1029 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1030 u32 a_t; 1031 1032 table->initialState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL = 1033 cpu_to_be32(pi->clk_regs.rv770.mpll_ad_func_cntl); 1034 table->initialState.levels[0].mclk.mclk770.vMPLL_AD_FUNC_CNTL_2 = 1035 cpu_to_be32(pi->clk_regs.rv770.mpll_ad_func_cntl_2); 1036 table->initialState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL = 1037 cpu_to_be32(pi->clk_regs.rv770.mpll_dq_func_cntl); 1038 table->initialState.levels[0].mclk.mclk770.vMPLL_DQ_FUNC_CNTL_2 = 1039 cpu_to_be32(pi->clk_regs.rv770.mpll_dq_func_cntl_2); 1040 table->initialState.levels[0].mclk.mclk770.vMCLK_PWRMGT_CNTL = 1041 cpu_to_be32(pi->clk_regs.rv770.mclk_pwrmgt_cntl); 1042 table->initialState.levels[0].mclk.mclk770.vDLL_CNTL = 1043 cpu_to_be32(pi->clk_regs.rv770.dll_cntl); 1044 1045 table->initialState.levels[0].mclk.mclk770.vMPLL_SS = 1046 cpu_to_be32(pi->clk_regs.rv770.mpll_ss1); 1047 table->initialState.levels[0].mclk.mclk770.vMPLL_SS2 = 1048 cpu_to_be32(pi->clk_regs.rv770.mpll_ss2); 1049 1050 table->initialState.levels[0].mclk.mclk770.mclk_value = 1051 cpu_to_be32(initial_state->low.mclk); 1052 1053 table->initialState.levels[0].sclk.vCG_SPLL_FUNC_CNTL = 1054 cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl); 1055 table->initialState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_2 = 1056 cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl_2); 1057 table->initialState.levels[0].sclk.vCG_SPLL_FUNC_CNTL_3 = 1058 cpu_to_be32(pi->clk_regs.rv770.cg_spll_func_cntl_3); 1059 table->initialState.levels[0].sclk.vCG_SPLL_SPREAD_SPECTRUM = 1060 cpu_to_be32(pi->clk_regs.rv770.cg_spll_spread_spectrum); 1061 table->initialState.levels[0].sclk.vCG_SPLL_SPREAD_SPECTRUM_2 = 1062 cpu_to_be32(pi->clk_regs.rv770.cg_spll_spread_spectrum_2); 1063 1064 table->initialState.levels[0].sclk.sclk_value = 1065 cpu_to_be32(initial_state->low.sclk); 1066 1067 table->initialState.levels[0].arbValue = MC_CG_ARB_FREQ_F0; 1068 1069 table->initialState.levels[0].seqValue = 1070 rv770_get_seq_value(rdev, &initial_state->low); 1071 1072 rv770_populate_vddc_value(rdev, 1073 initial_state->low.vddc, 1074 &table->initialState.levels[0].vddc); 1075 rv770_populate_initial_mvdd_value(rdev, 1076 &table->initialState.levels[0].mvdd); 1077 1078 a_t = CG_R(0xffff) | CG_L(0); 1079 table->initialState.levels[0].aT = cpu_to_be32(a_t); 1080 1081 table->initialState.levels[0].bSP = cpu_to_be32(pi->dsp); 1082 1083 if (pi->boot_in_gen2) 1084 table->initialState.levels[0].gen2PCIE = 1; 1085 else 1086 table->initialState.levels[0].gen2PCIE = 0; 1087 if (initial_state->low.flags & ATOM_PPLIB_R600_FLAGS_PCIEGEN2) 1088 table->initialState.levels[0].gen2XSP = 1; 1089 else 1090 table->initialState.levels[0].gen2XSP = 0; 1091 1092 if (rdev->family == CHIP_RV740) { 1093 if (pi->mem_gddr5) { 1094 if (initial_state->low.mclk <= pi->mclk_strobe_mode_threshold) 1095 table->initialState.levels[0].strobeMode = 1096 rv740_get_mclk_frequency_ratio(initial_state->low.mclk) | 0x10; 1097 else 1098 table->initialState.levels[0].strobeMode = 0; 1099 1100 if (initial_state->low.mclk >= pi->mclk_edc_enable_threshold) 1101 table->initialState.levels[0].mcFlags = SMC_MC_EDC_RD_FLAG | SMC_MC_EDC_WR_FLAG; 1102 else 1103 table->initialState.levels[0].mcFlags = 0; 1104 } 1105 } 1106 1107 table->initialState.levels[1] = table->initialState.levels[0]; 1108 table->initialState.levels[2] = table->initialState.levels[0]; 1109 1110 table->initialState.flags |= PPSMC_SWSTATE_FLAG_DC; 1111 1112 return 0; 1113 } 1114 1115 static int rv770_populate_smc_vddc_table(struct radeon_device *rdev, 1116 RV770_SMC_STATETABLE *table) 1117 { 1118 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1119 int i; 1120 1121 for (i = 0; i < pi->valid_vddc_entries; i++) { 1122 table->highSMIO[pi->vddc_table[i].vddc_index] = 1123 pi->vddc_table[i].high_smio; 1124 table->lowSMIO[pi->vddc_table[i].vddc_index] = 1125 cpu_to_be32(pi->vddc_table[i].low_smio); 1126 } 1127 1128 table->voltageMaskTable.highMask[RV770_SMC_VOLTAGEMASK_VDDC] = 0; 1129 table->voltageMaskTable.lowMask[RV770_SMC_VOLTAGEMASK_VDDC] = 1130 cpu_to_be32(pi->vddc_mask_low); 1131 1132 for (i = 0; 1133 ((i < pi->valid_vddc_entries) && 1134 (pi->max_vddc_in_table > 1135 pi->vddc_table[i].vddc)); 1136 i++); 1137 1138 table->maxVDDCIndexInPPTable = 1139 pi->vddc_table[i].vddc_index; 1140 1141 return 0; 1142 } 1143 1144 static int rv770_populate_smc_mvdd_table(struct radeon_device *rdev, 1145 RV770_SMC_STATETABLE *table) 1146 { 1147 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1148 1149 if (pi->mvdd_control) { 1150 table->lowSMIO[MVDD_HIGH_INDEX] |= 1151 cpu_to_be32(pi->mvdd_low_smio[MVDD_HIGH_INDEX]); 1152 table->lowSMIO[MVDD_LOW_INDEX] |= 1153 cpu_to_be32(pi->mvdd_low_smio[MVDD_LOW_INDEX]); 1154 1155 table->voltageMaskTable.highMask[RV770_SMC_VOLTAGEMASK_MVDD] = 0; 1156 table->voltageMaskTable.lowMask[RV770_SMC_VOLTAGEMASK_MVDD] = 1157 cpu_to_be32(pi->mvdd_mask_low); 1158 } 1159 1160 return 0; 1161 } 1162 1163 static int rv770_init_smc_table(struct radeon_device *rdev, 1164 struct radeon_ps *radeon_boot_state) 1165 { 1166 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1167 struct rv7xx_ps *boot_state = rv770_get_ps(radeon_boot_state); 1168 RV770_SMC_STATETABLE *table = &pi->smc_statetable; 1169 int ret; 1170 1171 memset(table, 0, sizeof(RV770_SMC_STATETABLE)); 1172 1173 pi->boot_sclk = boot_state->low.sclk; 1174 1175 rv770_populate_smc_vddc_table(rdev, table); 1176 rv770_populate_smc_mvdd_table(rdev, table); 1177 1178 switch (rdev->pm.int_thermal_type) { 1179 case THERMAL_TYPE_RV770: 1180 case THERMAL_TYPE_ADT7473_WITH_INTERNAL: 1181 table->thermalProtectType = PPSMC_THERMAL_PROTECT_TYPE_INTERNAL; 1182 break; 1183 case THERMAL_TYPE_NONE: 1184 table->thermalProtectType = PPSMC_THERMAL_PROTECT_TYPE_NONE; 1185 break; 1186 case THERMAL_TYPE_EXTERNAL_GPIO: 1187 default: 1188 table->thermalProtectType = PPSMC_THERMAL_PROTECT_TYPE_EXTERNAL; 1189 break; 1190 } 1191 1192 if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_HARDWAREDC) { 1193 table->systemFlags |= PPSMC_SYSTEMFLAG_GPIO_DC; 1194 1195 if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_DONT_WAIT_FOR_VBLANK_ON_ALERT) 1196 table->extraFlags |= PPSMC_EXTRAFLAGS_AC2DC_DONT_WAIT_FOR_VBLANK; 1197 1198 if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_GOTO_BOOT_ON_ALERT) 1199 table->extraFlags |= PPSMC_EXTRAFLAGS_AC2DC_ACTION_GOTOINITIALSTATE; 1200 } 1201 1202 if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_STEPVDDC) 1203 table->systemFlags |= PPSMC_SYSTEMFLAG_STEPVDDC; 1204 1205 if (pi->mem_gddr5) 1206 table->systemFlags |= PPSMC_SYSTEMFLAG_GDDR5; 1207 1208 if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 1209 ret = rv730_populate_smc_initial_state(rdev, radeon_boot_state, table); 1210 else 1211 ret = rv770_populate_smc_initial_state(rdev, radeon_boot_state, table); 1212 if (ret) 1213 return ret; 1214 1215 if (rdev->family == CHIP_RV740) 1216 ret = rv740_populate_smc_acpi_state(rdev, table); 1217 else if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 1218 ret = rv730_populate_smc_acpi_state(rdev, table); 1219 else 1220 ret = rv770_populate_smc_acpi_state(rdev, table); 1221 if (ret) 1222 return ret; 1223 1224 table->driverState = table->initialState; 1225 1226 return rv770_copy_bytes_to_smc(rdev, 1227 pi->state_table_start, 1228 (const u8 *)table, 1229 sizeof(RV770_SMC_STATETABLE), 1230 pi->sram_end); 1231 } 1232 1233 static int rv770_construct_vddc_table(struct radeon_device *rdev) 1234 { 1235 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1236 u16 min, max, step; 1237 u32 steps = 0; 1238 u8 vddc_index = 0; 1239 u32 i; 1240 1241 radeon_atom_get_min_voltage(rdev, SET_VOLTAGE_TYPE_ASIC_VDDC, &min); 1242 radeon_atom_get_max_voltage(rdev, SET_VOLTAGE_TYPE_ASIC_VDDC, &max); 1243 radeon_atom_get_voltage_step(rdev, SET_VOLTAGE_TYPE_ASIC_VDDC, &step); 1244 1245 steps = (max - min) / step + 1; 1246 1247 if (steps > MAX_NO_VREG_STEPS) 1248 return -EINVAL; 1249 1250 for (i = 0; i < steps; i++) { 1251 u32 gpio_pins, gpio_mask; 1252 1253 pi->vddc_table[i].vddc = (u16)(min + i * step); 1254 radeon_atom_get_voltage_gpio_settings(rdev, 1255 pi->vddc_table[i].vddc, 1256 SET_VOLTAGE_TYPE_ASIC_VDDC, 1257 &gpio_pins, &gpio_mask); 1258 pi->vddc_table[i].low_smio = gpio_pins & gpio_mask; 1259 pi->vddc_table[i].high_smio = 0; 1260 pi->vddc_mask_low = gpio_mask; 1261 if (i > 0) { 1262 if ((pi->vddc_table[i].low_smio != 1263 pi->vddc_table[i - 1].low_smio) || 1264 (pi->vddc_table[i].high_smio != 1265 pi->vddc_table[i - 1].high_smio)) 1266 vddc_index++; 1267 } 1268 pi->vddc_table[i].vddc_index = vddc_index; 1269 } 1270 1271 pi->valid_vddc_entries = (u8)steps; 1272 1273 return 0; 1274 } 1275 1276 static u32 rv770_get_mclk_split_point(struct atom_memory_info *memory_info) 1277 { 1278 if (memory_info->mem_type == MEM_TYPE_GDDR3) 1279 return 30000; 1280 1281 return 0; 1282 } 1283 1284 static int rv770_get_mvdd_pin_configuration(struct radeon_device *rdev) 1285 { 1286 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1287 u32 gpio_pins, gpio_mask; 1288 1289 radeon_atom_get_voltage_gpio_settings(rdev, 1290 MVDD_HIGH_VALUE, SET_VOLTAGE_TYPE_ASIC_MVDDC, 1291 &gpio_pins, &gpio_mask); 1292 pi->mvdd_mask_low = gpio_mask; 1293 pi->mvdd_low_smio[MVDD_HIGH_INDEX] = 1294 gpio_pins & gpio_mask; 1295 1296 radeon_atom_get_voltage_gpio_settings(rdev, 1297 MVDD_LOW_VALUE, SET_VOLTAGE_TYPE_ASIC_MVDDC, 1298 &gpio_pins, &gpio_mask); 1299 pi->mvdd_low_smio[MVDD_LOW_INDEX] = 1300 gpio_pins & gpio_mask; 1301 1302 return 0; 1303 } 1304 1305 u8 rv770_get_memory_module_index(struct radeon_device *rdev) 1306 { 1307 return (u8) ((RREG32(BIOS_SCRATCH_4) >> 16) & 0xff); 1308 } 1309 1310 static int rv770_get_mvdd_configuration(struct radeon_device *rdev) 1311 { 1312 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1313 u8 memory_module_index; 1314 struct atom_memory_info memory_info; 1315 1316 memory_module_index = rv770_get_memory_module_index(rdev); 1317 1318 if (radeon_atom_get_memory_info(rdev, memory_module_index, &memory_info)) { 1319 pi->mvdd_control = false; 1320 return 0; 1321 } 1322 1323 pi->mvdd_split_frequency = 1324 rv770_get_mclk_split_point(&memory_info); 1325 1326 if (pi->mvdd_split_frequency == 0) { 1327 pi->mvdd_control = false; 1328 return 0; 1329 } 1330 1331 return rv770_get_mvdd_pin_configuration(rdev); 1332 } 1333 1334 void rv770_enable_voltage_control(struct radeon_device *rdev, 1335 bool enable) 1336 { 1337 if (enable) 1338 WREG32_P(GENERAL_PWRMGT, VOLT_PWRMGT_EN, ~VOLT_PWRMGT_EN); 1339 else 1340 WREG32_P(GENERAL_PWRMGT, 0, ~VOLT_PWRMGT_EN); 1341 } 1342 1343 static void rv770_program_display_gap(struct radeon_device *rdev) 1344 { 1345 u32 tmp = RREG32(CG_DISPLAY_GAP_CNTL); 1346 1347 tmp &= ~(DISP1_GAP_MCHG_MASK | DISP2_GAP_MCHG_MASK); 1348 if (rdev->pm.dpm.new_active_crtcs & 1) { 1349 tmp |= DISP1_GAP_MCHG(R600_PM_DISPLAY_GAP_VBLANK); 1350 tmp |= DISP2_GAP_MCHG(R600_PM_DISPLAY_GAP_IGNORE); 1351 } else if (rdev->pm.dpm.new_active_crtcs & 2) { 1352 tmp |= DISP1_GAP_MCHG(R600_PM_DISPLAY_GAP_IGNORE); 1353 tmp |= DISP2_GAP_MCHG(R600_PM_DISPLAY_GAP_VBLANK); 1354 } else { 1355 tmp |= DISP1_GAP_MCHG(R600_PM_DISPLAY_GAP_IGNORE); 1356 tmp |= DISP2_GAP_MCHG(R600_PM_DISPLAY_GAP_IGNORE); 1357 } 1358 WREG32(CG_DISPLAY_GAP_CNTL, tmp); 1359 } 1360 1361 static void rv770_enable_dynamic_pcie_gen2(struct radeon_device *rdev, 1362 bool enable) 1363 { 1364 rv770_enable_bif_dynamic_pcie_gen2(rdev, enable); 1365 1366 if (enable) 1367 WREG32_P(GENERAL_PWRMGT, ENABLE_GEN2PCIE, ~ENABLE_GEN2PCIE); 1368 else 1369 WREG32_P(GENERAL_PWRMGT, 0, ~ENABLE_GEN2PCIE); 1370 } 1371 1372 static void r7xx_program_memory_timing_parameters(struct radeon_device *rdev, 1373 struct radeon_ps *radeon_new_state) 1374 { 1375 if ((rdev->family == CHIP_RV730) || 1376 (rdev->family == CHIP_RV710) || 1377 (rdev->family == CHIP_RV740)) 1378 rv730_program_memory_timing_parameters(rdev, radeon_new_state); 1379 else 1380 rv770_program_memory_timing_parameters(rdev, radeon_new_state); 1381 } 1382 1383 static int rv770_upload_sw_state(struct radeon_device *rdev, 1384 struct radeon_ps *radeon_new_state) 1385 { 1386 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1387 u16 address = pi->state_table_start + 1388 offsetof(RV770_SMC_STATETABLE, driverState); 1389 RV770_SMC_SWSTATE state = { 0 }; 1390 int ret; 1391 1392 ret = rv770_convert_power_state_to_smc(rdev, radeon_new_state, &state); 1393 if (ret) 1394 return ret; 1395 1396 return rv770_copy_bytes_to_smc(rdev, address, (const u8 *)&state, 1397 sizeof(RV770_SMC_SWSTATE), 1398 pi->sram_end); 1399 } 1400 1401 int rv770_halt_smc(struct radeon_device *rdev) 1402 { 1403 if (rv770_send_msg_to_smc(rdev, PPSMC_MSG_Halt) != PPSMC_Result_OK) 1404 return -EINVAL; 1405 1406 if (rv770_wait_for_smc_inactive(rdev) != PPSMC_Result_OK) 1407 return -EINVAL; 1408 1409 return 0; 1410 } 1411 1412 int rv770_resume_smc(struct radeon_device *rdev) 1413 { 1414 if (rv770_send_msg_to_smc(rdev, PPSMC_MSG_Resume) != PPSMC_Result_OK) 1415 return -EINVAL; 1416 return 0; 1417 } 1418 1419 int rv770_set_sw_state(struct radeon_device *rdev) 1420 { 1421 if (rv770_send_msg_to_smc(rdev, PPSMC_MSG_SwitchToSwState) != PPSMC_Result_OK) 1422 DRM_DEBUG("rv770_set_sw_state failed\n"); 1423 return 0; 1424 } 1425 1426 int rv770_set_boot_state(struct radeon_device *rdev) 1427 { 1428 if (rv770_send_msg_to_smc(rdev, PPSMC_MSG_SwitchToInitialState) != PPSMC_Result_OK) 1429 return -EINVAL; 1430 return 0; 1431 } 1432 1433 void rv770_set_uvd_clock_before_set_eng_clock(struct radeon_device *rdev, 1434 struct radeon_ps *new_ps, 1435 struct radeon_ps *old_ps) 1436 { 1437 struct rv7xx_ps *new_state = rv770_get_ps(new_ps); 1438 struct rv7xx_ps *current_state = rv770_get_ps(old_ps); 1439 1440 if ((new_ps->vclk == old_ps->vclk) && 1441 (new_ps->dclk == old_ps->dclk)) 1442 return; 1443 1444 if (new_state->high.sclk >= current_state->high.sclk) 1445 return; 1446 1447 radeon_set_uvd_clocks(rdev, new_ps->vclk, new_ps->dclk); 1448 } 1449 1450 void rv770_set_uvd_clock_after_set_eng_clock(struct radeon_device *rdev, 1451 struct radeon_ps *new_ps, 1452 struct radeon_ps *old_ps) 1453 { 1454 struct rv7xx_ps *new_state = rv770_get_ps(new_ps); 1455 struct rv7xx_ps *current_state = rv770_get_ps(old_ps); 1456 1457 if ((new_ps->vclk == old_ps->vclk) && 1458 (new_ps->dclk == old_ps->dclk)) 1459 return; 1460 1461 if (new_state->high.sclk < current_state->high.sclk) 1462 return; 1463 1464 radeon_set_uvd_clocks(rdev, new_ps->vclk, new_ps->dclk); 1465 } 1466 1467 int rv770_restrict_performance_levels_before_switch(struct radeon_device *rdev) 1468 { 1469 if (rv770_send_msg_to_smc(rdev, (PPSMC_Msg)(PPSMC_MSG_NoForcedLevel)) != PPSMC_Result_OK) 1470 return -EINVAL; 1471 1472 if (rv770_send_msg_to_smc(rdev, (PPSMC_Msg)(PPSMC_MSG_TwoLevelsDisabled)) != PPSMC_Result_OK) 1473 return -EINVAL; 1474 1475 return 0; 1476 } 1477 1478 int rv770_dpm_force_performance_level(struct radeon_device *rdev, 1479 enum radeon_dpm_forced_level level) 1480 { 1481 PPSMC_Msg msg; 1482 1483 if (level == RADEON_DPM_FORCED_LEVEL_HIGH) { 1484 if (rv770_send_msg_to_smc(rdev, PPSMC_MSG_ZeroLevelsDisabled) != PPSMC_Result_OK) 1485 return -EINVAL; 1486 msg = PPSMC_MSG_ForceHigh; 1487 } else if (level == RADEON_DPM_FORCED_LEVEL_LOW) { 1488 if (rv770_send_msg_to_smc(rdev, PPSMC_MSG_NoForcedLevel) != PPSMC_Result_OK) 1489 return -EINVAL; 1490 msg = (PPSMC_Msg)(PPSMC_MSG_TwoLevelsDisabled); 1491 } else { 1492 if (rv770_send_msg_to_smc(rdev, PPSMC_MSG_NoForcedLevel) != PPSMC_Result_OK) 1493 return -EINVAL; 1494 msg = (PPSMC_Msg)(PPSMC_MSG_ZeroLevelsDisabled); 1495 } 1496 1497 if (rv770_send_msg_to_smc(rdev, msg) != PPSMC_Result_OK) 1498 return -EINVAL; 1499 1500 rdev->pm.dpm.forced_level = level; 1501 1502 return 0; 1503 } 1504 1505 void r7xx_start_smc(struct radeon_device *rdev) 1506 { 1507 rv770_start_smc(rdev); 1508 rv770_start_smc_clock(rdev); 1509 } 1510 1511 1512 void r7xx_stop_smc(struct radeon_device *rdev) 1513 { 1514 rv770_reset_smc(rdev); 1515 rv770_stop_smc_clock(rdev); 1516 } 1517 1518 static void rv770_read_clock_registers(struct radeon_device *rdev) 1519 { 1520 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1521 1522 pi->clk_regs.rv770.cg_spll_func_cntl = 1523 RREG32(CG_SPLL_FUNC_CNTL); 1524 pi->clk_regs.rv770.cg_spll_func_cntl_2 = 1525 RREG32(CG_SPLL_FUNC_CNTL_2); 1526 pi->clk_regs.rv770.cg_spll_func_cntl_3 = 1527 RREG32(CG_SPLL_FUNC_CNTL_3); 1528 pi->clk_regs.rv770.cg_spll_spread_spectrum = 1529 RREG32(CG_SPLL_SPREAD_SPECTRUM); 1530 pi->clk_regs.rv770.cg_spll_spread_spectrum_2 = 1531 RREG32(CG_SPLL_SPREAD_SPECTRUM_2); 1532 pi->clk_regs.rv770.mpll_ad_func_cntl = 1533 RREG32(MPLL_AD_FUNC_CNTL); 1534 pi->clk_regs.rv770.mpll_ad_func_cntl_2 = 1535 RREG32(MPLL_AD_FUNC_CNTL_2); 1536 pi->clk_regs.rv770.mpll_dq_func_cntl = 1537 RREG32(MPLL_DQ_FUNC_CNTL); 1538 pi->clk_regs.rv770.mpll_dq_func_cntl_2 = 1539 RREG32(MPLL_DQ_FUNC_CNTL_2); 1540 pi->clk_regs.rv770.mclk_pwrmgt_cntl = 1541 RREG32(MCLK_PWRMGT_CNTL); 1542 pi->clk_regs.rv770.dll_cntl = RREG32(DLL_CNTL); 1543 } 1544 1545 static void r7xx_read_clock_registers(struct radeon_device *rdev) 1546 { 1547 if (rdev->family == CHIP_RV740) 1548 rv740_read_clock_registers(rdev); 1549 else if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 1550 rv730_read_clock_registers(rdev); 1551 else 1552 rv770_read_clock_registers(rdev); 1553 } 1554 1555 void rv770_read_voltage_smio_registers(struct radeon_device *rdev) 1556 { 1557 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1558 1559 pi->s0_vid_lower_smio_cntl = 1560 RREG32(S0_VID_LOWER_SMIO_CNTL); 1561 } 1562 1563 void rv770_reset_smio_status(struct radeon_device *rdev) 1564 { 1565 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1566 u32 sw_smio_index, vid_smio_cntl; 1567 1568 sw_smio_index = 1569 (RREG32(GENERAL_PWRMGT) & SW_SMIO_INDEX_MASK) >> SW_SMIO_INDEX_SHIFT; 1570 switch (sw_smio_index) { 1571 case 3: 1572 vid_smio_cntl = RREG32(S3_VID_LOWER_SMIO_CNTL); 1573 break; 1574 case 2: 1575 vid_smio_cntl = RREG32(S2_VID_LOWER_SMIO_CNTL); 1576 break; 1577 case 1: 1578 vid_smio_cntl = RREG32(S1_VID_LOWER_SMIO_CNTL); 1579 break; 1580 case 0: 1581 return; 1582 default: 1583 vid_smio_cntl = pi->s0_vid_lower_smio_cntl; 1584 break; 1585 } 1586 1587 WREG32(S0_VID_LOWER_SMIO_CNTL, vid_smio_cntl); 1588 WREG32_P(GENERAL_PWRMGT, SW_SMIO_INDEX(0), ~SW_SMIO_INDEX_MASK); 1589 } 1590 1591 void rv770_get_memory_type(struct radeon_device *rdev) 1592 { 1593 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1594 u32 tmp; 1595 1596 tmp = RREG32(MC_SEQ_MISC0); 1597 1598 if (((tmp & MC_SEQ_MISC0_GDDR5_MASK) >> MC_SEQ_MISC0_GDDR5_SHIFT) == 1599 MC_SEQ_MISC0_GDDR5_VALUE) 1600 pi->mem_gddr5 = true; 1601 else 1602 pi->mem_gddr5 = false; 1603 1604 } 1605 1606 void rv770_get_pcie_gen2_status(struct radeon_device *rdev) 1607 { 1608 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1609 u32 tmp; 1610 1611 tmp = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL); 1612 1613 if ((tmp & LC_OTHER_SIDE_EVER_SENT_GEN2) && 1614 (tmp & LC_OTHER_SIDE_SUPPORTS_GEN2)) 1615 pi->pcie_gen2 = true; 1616 else 1617 pi->pcie_gen2 = false; 1618 1619 if (pi->pcie_gen2) { 1620 if (tmp & LC_CURRENT_DATA_RATE) 1621 pi->boot_in_gen2 = true; 1622 else 1623 pi->boot_in_gen2 = false; 1624 } else 1625 pi->boot_in_gen2 = false; 1626 } 1627 1628 #if 0 1629 static int rv770_enter_ulp_state(struct radeon_device *rdev) 1630 { 1631 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1632 1633 if (pi->gfx_clock_gating) { 1634 WREG32_P(SCLK_PWRMGT_CNTL, 0, ~DYN_GFX_CLK_OFF_EN); 1635 WREG32_P(SCLK_PWRMGT_CNTL, GFX_CLK_FORCE_ON, ~GFX_CLK_FORCE_ON); 1636 WREG32_P(SCLK_PWRMGT_CNTL, 0, ~GFX_CLK_FORCE_ON); 1637 RREG32(GB_TILING_CONFIG); 1638 } 1639 1640 WREG32_P(SMC_MSG, HOST_SMC_MSG(PPSMC_MSG_SwitchToMinimumPower), 1641 ~HOST_SMC_MSG_MASK); 1642 1643 udelay(7000); 1644 1645 return 0; 1646 } 1647 1648 static int rv770_exit_ulp_state(struct radeon_device *rdev) 1649 { 1650 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1651 int i; 1652 1653 WREG32_P(SMC_MSG, HOST_SMC_MSG(PPSMC_MSG_ResumeFromMinimumPower), 1654 ~HOST_SMC_MSG_MASK); 1655 1656 udelay(7000); 1657 1658 for (i = 0; i < rdev->usec_timeout; i++) { 1659 if (((RREG32(SMC_MSG) & HOST_SMC_RESP_MASK) >> HOST_SMC_RESP_SHIFT) == 1) 1660 break; 1661 udelay(1000); 1662 } 1663 1664 if (pi->gfx_clock_gating) 1665 WREG32_P(SCLK_PWRMGT_CNTL, DYN_GFX_CLK_OFF_EN, ~DYN_GFX_CLK_OFF_EN); 1666 1667 return 0; 1668 } 1669 #endif 1670 1671 static void rv770_get_mclk_odt_threshold(struct radeon_device *rdev) 1672 { 1673 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1674 u8 memory_module_index; 1675 struct atom_memory_info memory_info; 1676 1677 pi->mclk_odt_threshold = 0; 1678 1679 if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) { 1680 memory_module_index = rv770_get_memory_module_index(rdev); 1681 1682 if (radeon_atom_get_memory_info(rdev, memory_module_index, &memory_info)) 1683 return; 1684 1685 if (memory_info.mem_type == MEM_TYPE_DDR2 || 1686 memory_info.mem_type == MEM_TYPE_DDR3) 1687 pi->mclk_odt_threshold = 30000; 1688 } 1689 } 1690 1691 void rv770_get_max_vddc(struct radeon_device *rdev) 1692 { 1693 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1694 u16 vddc; 1695 1696 if (radeon_atom_get_max_vddc(rdev, 0, 0, &vddc)) 1697 pi->max_vddc = 0; 1698 else 1699 pi->max_vddc = vddc; 1700 } 1701 1702 void rv770_program_response_times(struct radeon_device *rdev) 1703 { 1704 u32 voltage_response_time, backbias_response_time; 1705 u32 acpi_delay_time, vbi_time_out; 1706 u32 vddc_dly, bb_dly, acpi_dly, vbi_dly; 1707 u32 reference_clock; 1708 1709 voltage_response_time = (u32)rdev->pm.dpm.voltage_response_time; 1710 backbias_response_time = (u32)rdev->pm.dpm.backbias_response_time; 1711 1712 if (voltage_response_time == 0) 1713 voltage_response_time = 1000; 1714 1715 if (backbias_response_time == 0) 1716 backbias_response_time = 1000; 1717 1718 acpi_delay_time = 15000; 1719 vbi_time_out = 100000; 1720 1721 reference_clock = radeon_get_xclk(rdev); 1722 1723 vddc_dly = (voltage_response_time * reference_clock) / 1600; 1724 bb_dly = (backbias_response_time * reference_clock) / 1600; 1725 acpi_dly = (acpi_delay_time * reference_clock) / 1600; 1726 vbi_dly = (vbi_time_out * reference_clock) / 1600; 1727 1728 rv770_write_smc_soft_register(rdev, 1729 RV770_SMC_SOFT_REGISTER_delay_vreg, vddc_dly); 1730 rv770_write_smc_soft_register(rdev, 1731 RV770_SMC_SOFT_REGISTER_delay_bbias, bb_dly); 1732 rv770_write_smc_soft_register(rdev, 1733 RV770_SMC_SOFT_REGISTER_delay_acpi, acpi_dly); 1734 rv770_write_smc_soft_register(rdev, 1735 RV770_SMC_SOFT_REGISTER_mclk_chg_timeout, vbi_dly); 1736 #if 0 1737 /* XXX look up hw revision */ 1738 if (WEKIVA_A21) 1739 rv770_write_smc_soft_register(rdev, 1740 RV770_SMC_SOFT_REGISTER_baby_step_timer, 1741 0x10); 1742 #endif 1743 } 1744 1745 static void rv770_program_dcodt_before_state_switch(struct radeon_device *rdev, 1746 struct radeon_ps *radeon_new_state, 1747 struct radeon_ps *radeon_current_state) 1748 { 1749 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1750 struct rv7xx_ps *new_state = rv770_get_ps(radeon_new_state); 1751 struct rv7xx_ps *current_state = rv770_get_ps(radeon_current_state); 1752 bool current_use_dc = false; 1753 bool new_use_dc = false; 1754 1755 if (pi->mclk_odt_threshold == 0) 1756 return; 1757 1758 if (current_state->high.mclk <= pi->mclk_odt_threshold) 1759 current_use_dc = true; 1760 1761 if (new_state->high.mclk <= pi->mclk_odt_threshold) 1762 new_use_dc = true; 1763 1764 if (current_use_dc == new_use_dc) 1765 return; 1766 1767 if (!current_use_dc && new_use_dc) 1768 return; 1769 1770 if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 1771 rv730_program_dcodt(rdev, new_use_dc); 1772 } 1773 1774 static void rv770_program_dcodt_after_state_switch(struct radeon_device *rdev, 1775 struct radeon_ps *radeon_new_state, 1776 struct radeon_ps *radeon_current_state) 1777 { 1778 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1779 struct rv7xx_ps *new_state = rv770_get_ps(radeon_new_state); 1780 struct rv7xx_ps *current_state = rv770_get_ps(radeon_current_state); 1781 bool current_use_dc = false; 1782 bool new_use_dc = false; 1783 1784 if (pi->mclk_odt_threshold == 0) 1785 return; 1786 1787 if (current_state->high.mclk <= pi->mclk_odt_threshold) 1788 current_use_dc = true; 1789 1790 if (new_state->high.mclk <= pi->mclk_odt_threshold) 1791 new_use_dc = true; 1792 1793 if (current_use_dc == new_use_dc) 1794 return; 1795 1796 if (current_use_dc && !new_use_dc) 1797 return; 1798 1799 if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 1800 rv730_program_dcodt(rdev, new_use_dc); 1801 } 1802 1803 static void rv770_retrieve_odt_values(struct radeon_device *rdev) 1804 { 1805 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1806 1807 if (pi->mclk_odt_threshold == 0) 1808 return; 1809 1810 if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 1811 rv730_get_odt_values(rdev); 1812 } 1813 1814 static void rv770_set_dpm_event_sources(struct radeon_device *rdev, u32 sources) 1815 { 1816 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1817 bool want_thermal_protection; 1818 enum radeon_dpm_event_src dpm_event_src; 1819 1820 switch (sources) { 1821 case 0: 1822 default: 1823 want_thermal_protection = false; 1824 break; 1825 case (1 << RADEON_DPM_AUTO_THROTTLE_SRC_THERMAL): 1826 want_thermal_protection = true; 1827 dpm_event_src = RADEON_DPM_EVENT_SRC_DIGITAL; 1828 break; 1829 1830 case (1 << RADEON_DPM_AUTO_THROTTLE_SRC_EXTERNAL): 1831 want_thermal_protection = true; 1832 dpm_event_src = RADEON_DPM_EVENT_SRC_EXTERNAL; 1833 break; 1834 1835 case ((1 << RADEON_DPM_AUTO_THROTTLE_SRC_EXTERNAL) | 1836 (1 << RADEON_DPM_AUTO_THROTTLE_SRC_THERMAL)): 1837 want_thermal_protection = true; 1838 dpm_event_src = RADEON_DPM_EVENT_SRC_DIGIAL_OR_EXTERNAL; 1839 break; 1840 } 1841 1842 if (want_thermal_protection) { 1843 WREG32_P(CG_THERMAL_CTRL, DPM_EVENT_SRC(dpm_event_src), ~DPM_EVENT_SRC_MASK); 1844 if (pi->thermal_protection) 1845 WREG32_P(GENERAL_PWRMGT, 0, ~THERMAL_PROTECTION_DIS); 1846 } else { 1847 WREG32_P(GENERAL_PWRMGT, THERMAL_PROTECTION_DIS, ~THERMAL_PROTECTION_DIS); 1848 } 1849 } 1850 1851 void rv770_enable_auto_throttle_source(struct radeon_device *rdev, 1852 enum radeon_dpm_auto_throttle_src source, 1853 bool enable) 1854 { 1855 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1856 1857 if (enable) { 1858 if (!(pi->active_auto_throttle_sources & (1 << source))) { 1859 pi->active_auto_throttle_sources |= 1 << source; 1860 rv770_set_dpm_event_sources(rdev, pi->active_auto_throttle_sources); 1861 } 1862 } else { 1863 if (pi->active_auto_throttle_sources & (1 << source)) { 1864 pi->active_auto_throttle_sources &= ~(1 << source); 1865 rv770_set_dpm_event_sources(rdev, pi->active_auto_throttle_sources); 1866 } 1867 } 1868 } 1869 1870 static int rv770_set_thermal_temperature_range(struct radeon_device *rdev, 1871 int min_temp, int max_temp) 1872 { 1873 int low_temp = 0 * 1000; 1874 int high_temp = 255 * 1000; 1875 1876 if (low_temp < min_temp) 1877 low_temp = min_temp; 1878 if (high_temp > max_temp) 1879 high_temp = max_temp; 1880 if (high_temp < low_temp) { 1881 DRM_ERROR("invalid thermal range: %d - %d\n", low_temp, high_temp); 1882 return -EINVAL; 1883 } 1884 1885 WREG32_P(CG_THERMAL_INT, DIG_THERM_INTH(high_temp / 1000), ~DIG_THERM_INTH_MASK); 1886 WREG32_P(CG_THERMAL_INT, DIG_THERM_INTL(low_temp / 1000), ~DIG_THERM_INTL_MASK); 1887 WREG32_P(CG_THERMAL_CTRL, DIG_THERM_DPM(high_temp / 1000), ~DIG_THERM_DPM_MASK); 1888 1889 rdev->pm.dpm.thermal.min_temp = low_temp; 1890 rdev->pm.dpm.thermal.max_temp = high_temp; 1891 1892 return 0; 1893 } 1894 1895 int rv770_dpm_enable(struct radeon_device *rdev) 1896 { 1897 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 1898 struct radeon_ps *boot_ps = rdev->pm.dpm.boot_ps; 1899 int ret; 1900 1901 if (pi->gfx_clock_gating) 1902 rv770_restore_cgcg(rdev); 1903 1904 if (rv770_dpm_enabled(rdev)) 1905 return -EINVAL; 1906 1907 if (pi->voltage_control) { 1908 rv770_enable_voltage_control(rdev, true); 1909 ret = rv770_construct_vddc_table(rdev); 1910 if (ret) { 1911 DRM_ERROR("rv770_construct_vddc_table failed\n"); 1912 return ret; 1913 } 1914 } 1915 1916 if (pi->dcodt) 1917 rv770_retrieve_odt_values(rdev); 1918 1919 if (pi->mvdd_control) { 1920 ret = rv770_get_mvdd_configuration(rdev); 1921 if (ret) { 1922 DRM_ERROR("rv770_get_mvdd_configuration failed\n"); 1923 return ret; 1924 } 1925 } 1926 1927 if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_BACKBIAS) 1928 rv770_enable_backbias(rdev, true); 1929 1930 rv770_enable_spread_spectrum(rdev, true); 1931 1932 if (pi->thermal_protection) 1933 rv770_enable_thermal_protection(rdev, true); 1934 1935 rv770_program_mpll_timing_parameters(rdev); 1936 rv770_setup_bsp(rdev); 1937 rv770_program_git(rdev); 1938 rv770_program_tp(rdev); 1939 rv770_program_tpp(rdev); 1940 rv770_program_sstp(rdev); 1941 rv770_program_engine_speed_parameters(rdev); 1942 rv770_enable_display_gap(rdev); 1943 rv770_program_vc(rdev); 1944 1945 if (pi->dynamic_pcie_gen2) 1946 rv770_enable_dynamic_pcie_gen2(rdev, true); 1947 1948 ret = rv770_upload_firmware(rdev); 1949 if (ret) { 1950 DRM_ERROR("rv770_upload_firmware failed\n"); 1951 return ret; 1952 } 1953 ret = rv770_init_smc_table(rdev, boot_ps); 1954 if (ret) { 1955 DRM_ERROR("rv770_init_smc_table failed\n"); 1956 return ret; 1957 } 1958 1959 rv770_program_response_times(rdev); 1960 r7xx_start_smc(rdev); 1961 1962 if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 1963 rv730_start_dpm(rdev); 1964 else 1965 rv770_start_dpm(rdev); 1966 1967 if (pi->gfx_clock_gating) 1968 rv770_gfx_clock_gating_enable(rdev, true); 1969 1970 if (pi->mg_clock_gating) 1971 rv770_mg_clock_gating_enable(rdev, true); 1972 1973 rv770_enable_auto_throttle_source(rdev, RADEON_DPM_AUTO_THROTTLE_SRC_THERMAL, true); 1974 1975 return 0; 1976 } 1977 1978 int rv770_dpm_late_enable(struct radeon_device *rdev) 1979 { 1980 int ret; 1981 1982 if (rdev->irq.installed && 1983 r600_is_internal_thermal_sensor(rdev->pm.int_thermal_type)) { 1984 PPSMC_Result result; 1985 1986 ret = rv770_set_thermal_temperature_range(rdev, R600_TEMP_RANGE_MIN, R600_TEMP_RANGE_MAX); 1987 if (ret) 1988 return ret; 1989 rdev->irq.dpm_thermal = true; 1990 radeon_irq_set(rdev); 1991 result = rv770_send_msg_to_smc(rdev, PPSMC_MSG_EnableThermalInterrupt); 1992 1993 if (result != PPSMC_Result_OK) 1994 DRM_DEBUG_KMS("Could not enable thermal interrupts.\n"); 1995 } 1996 1997 return 0; 1998 } 1999 2000 void rv770_dpm_disable(struct radeon_device *rdev) 2001 { 2002 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 2003 2004 if (!rv770_dpm_enabled(rdev)) 2005 return; 2006 2007 rv770_clear_vc(rdev); 2008 2009 if (pi->thermal_protection) 2010 rv770_enable_thermal_protection(rdev, false); 2011 2012 rv770_enable_spread_spectrum(rdev, false); 2013 2014 if (pi->dynamic_pcie_gen2) 2015 rv770_enable_dynamic_pcie_gen2(rdev, false); 2016 2017 if (rdev->irq.installed && 2018 r600_is_internal_thermal_sensor(rdev->pm.int_thermal_type)) { 2019 rdev->irq.dpm_thermal = false; 2020 radeon_irq_set(rdev); 2021 } 2022 2023 if (pi->gfx_clock_gating) 2024 rv770_gfx_clock_gating_enable(rdev, false); 2025 2026 if (pi->mg_clock_gating) 2027 rv770_mg_clock_gating_enable(rdev, false); 2028 2029 if ((rdev->family == CHIP_RV730) || (rdev->family == CHIP_RV710)) 2030 rv730_stop_dpm(rdev); 2031 else 2032 rv770_stop_dpm(rdev); 2033 2034 r7xx_stop_smc(rdev); 2035 rv770_reset_smio_status(rdev); 2036 } 2037 2038 int rv770_dpm_set_power_state(struct radeon_device *rdev) 2039 { 2040 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 2041 struct radeon_ps *new_ps = rdev->pm.dpm.requested_ps; 2042 struct radeon_ps *old_ps = rdev->pm.dpm.current_ps; 2043 int ret; 2044 2045 ret = rv770_restrict_performance_levels_before_switch(rdev); 2046 if (ret) { 2047 DRM_ERROR("rv770_restrict_performance_levels_before_switch failed\n"); 2048 return ret; 2049 } 2050 rv770_set_uvd_clock_before_set_eng_clock(rdev, new_ps, old_ps); 2051 ret = rv770_halt_smc(rdev); 2052 if (ret) { 2053 DRM_ERROR("rv770_halt_smc failed\n"); 2054 return ret; 2055 } 2056 ret = rv770_upload_sw_state(rdev, new_ps); 2057 if (ret) { 2058 DRM_ERROR("rv770_upload_sw_state failed\n"); 2059 return ret; 2060 } 2061 r7xx_program_memory_timing_parameters(rdev, new_ps); 2062 if (pi->dcodt) 2063 rv770_program_dcodt_before_state_switch(rdev, new_ps, old_ps); 2064 ret = rv770_resume_smc(rdev); 2065 if (ret) { 2066 DRM_ERROR("rv770_resume_smc failed\n"); 2067 return ret; 2068 } 2069 ret = rv770_set_sw_state(rdev); 2070 if (ret) { 2071 DRM_ERROR("rv770_set_sw_state failed\n"); 2072 return ret; 2073 } 2074 if (pi->dcodt) 2075 rv770_program_dcodt_after_state_switch(rdev, new_ps, old_ps); 2076 rv770_set_uvd_clock_after_set_eng_clock(rdev, new_ps, old_ps); 2077 2078 return 0; 2079 } 2080 2081 #if 0 2082 void rv770_dpm_reset_asic(struct radeon_device *rdev) 2083 { 2084 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 2085 struct radeon_ps *boot_ps = rdev->pm.dpm.boot_ps; 2086 2087 rv770_restrict_performance_levels_before_switch(rdev); 2088 if (pi->dcodt) 2089 rv770_program_dcodt_before_state_switch(rdev, boot_ps, boot_ps); 2090 rv770_set_boot_state(rdev); 2091 if (pi->dcodt) 2092 rv770_program_dcodt_after_state_switch(rdev, boot_ps, boot_ps); 2093 } 2094 #endif 2095 2096 void rv770_dpm_setup_asic(struct radeon_device *rdev) 2097 { 2098 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 2099 2100 r7xx_read_clock_registers(rdev); 2101 rv770_read_voltage_smio_registers(rdev); 2102 rv770_get_memory_type(rdev); 2103 if (pi->dcodt) 2104 rv770_get_mclk_odt_threshold(rdev); 2105 rv770_get_pcie_gen2_status(rdev); 2106 2107 rv770_enable_acpi_pm(rdev); 2108 2109 if (radeon_aspm != 0) { 2110 if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_ASPM_L0s) 2111 rv770_enable_l0s(rdev); 2112 if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_ASPM_L1) 2113 rv770_enable_l1(rdev); 2114 if (rdev->pm.dpm.platform_caps & ATOM_PP_PLATFORM_CAP_TURNOFFPLL_ASPML1) 2115 rv770_enable_pll_sleep_in_l1(rdev); 2116 } 2117 } 2118 2119 void rv770_dpm_display_configuration_changed(struct radeon_device *rdev) 2120 { 2121 rv770_program_display_gap(rdev); 2122 } 2123 2124 union power_info { 2125 struct _ATOM_POWERPLAY_INFO info; 2126 struct _ATOM_POWERPLAY_INFO_V2 info_2; 2127 struct _ATOM_POWERPLAY_INFO_V3 info_3; 2128 struct _ATOM_PPLIB_POWERPLAYTABLE pplib; 2129 struct _ATOM_PPLIB_POWERPLAYTABLE2 pplib2; 2130 struct _ATOM_PPLIB_POWERPLAYTABLE3 pplib3; 2131 }; 2132 2133 union pplib_clock_info { 2134 struct _ATOM_PPLIB_R600_CLOCK_INFO r600; 2135 struct _ATOM_PPLIB_RS780_CLOCK_INFO rs780; 2136 struct _ATOM_PPLIB_EVERGREEN_CLOCK_INFO evergreen; 2137 struct _ATOM_PPLIB_SUMO_CLOCK_INFO sumo; 2138 }; 2139 2140 union pplib_power_state { 2141 struct _ATOM_PPLIB_STATE v1; 2142 struct _ATOM_PPLIB_STATE_V2 v2; 2143 }; 2144 2145 static void rv7xx_parse_pplib_non_clock_info(struct radeon_device *rdev, 2146 struct radeon_ps *rps, 2147 struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info, 2148 u8 table_rev) 2149 { 2150 rps->caps = le32_to_cpu(non_clock_info->ulCapsAndSettings); 2151 rps->class = le16_to_cpu(non_clock_info->usClassification); 2152 rps->class2 = le16_to_cpu(non_clock_info->usClassification2); 2153 2154 if (ATOM_PPLIB_NONCLOCKINFO_VER1 < table_rev) { 2155 rps->vclk = le32_to_cpu(non_clock_info->ulVCLK); 2156 rps->dclk = le32_to_cpu(non_clock_info->ulDCLK); 2157 } else { 2158 rps->vclk = 0; 2159 rps->dclk = 0; 2160 } 2161 2162 if (r600_is_uvd_state(rps->class, rps->class2)) { 2163 if ((rps->vclk == 0) || (rps->dclk == 0)) { 2164 rps->vclk = RV770_DEFAULT_VCLK_FREQ; 2165 rps->dclk = RV770_DEFAULT_DCLK_FREQ; 2166 } 2167 } 2168 2169 if (rps->class & ATOM_PPLIB_CLASSIFICATION_BOOT) 2170 rdev->pm.dpm.boot_ps = rps; 2171 if (rps->class & ATOM_PPLIB_CLASSIFICATION_UVDSTATE) 2172 rdev->pm.dpm.uvd_ps = rps; 2173 } 2174 2175 static void rv7xx_parse_pplib_clock_info(struct radeon_device *rdev, 2176 struct radeon_ps *rps, int index, 2177 union pplib_clock_info *clock_info) 2178 { 2179 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 2180 struct evergreen_power_info *eg_pi = evergreen_get_pi(rdev); 2181 struct rv7xx_ps *ps = rv770_get_ps(rps); 2182 u32 sclk, mclk; 2183 struct rv7xx_pl *pl; 2184 2185 switch (index) { 2186 case 0: 2187 pl = &ps->low; 2188 break; 2189 case 1: 2190 pl = &ps->medium; 2191 break; 2192 case 2: 2193 default: 2194 pl = &ps->high; 2195 break; 2196 } 2197 2198 if (rdev->family >= CHIP_CEDAR) { 2199 sclk = le16_to_cpu(clock_info->evergreen.usEngineClockLow); 2200 sclk |= clock_info->evergreen.ucEngineClockHigh << 16; 2201 mclk = le16_to_cpu(clock_info->evergreen.usMemoryClockLow); 2202 mclk |= clock_info->evergreen.ucMemoryClockHigh << 16; 2203 2204 pl->vddc = le16_to_cpu(clock_info->evergreen.usVDDC); 2205 pl->vddci = le16_to_cpu(clock_info->evergreen.usVDDCI); 2206 pl->flags = le32_to_cpu(clock_info->evergreen.ulFlags); 2207 } else { 2208 sclk = le16_to_cpu(clock_info->r600.usEngineClockLow); 2209 sclk |= clock_info->r600.ucEngineClockHigh << 16; 2210 mclk = le16_to_cpu(clock_info->r600.usMemoryClockLow); 2211 mclk |= clock_info->r600.ucMemoryClockHigh << 16; 2212 2213 pl->vddc = le16_to_cpu(clock_info->r600.usVDDC); 2214 pl->flags = le32_to_cpu(clock_info->r600.ulFlags); 2215 } 2216 2217 pl->mclk = mclk; 2218 pl->sclk = sclk; 2219 2220 /* patch up vddc if necessary */ 2221 if (pl->vddc == 0xff01) { 2222 if (pi->max_vddc) 2223 pl->vddc = pi->max_vddc; 2224 } 2225 2226 if (rps->class & ATOM_PPLIB_CLASSIFICATION_ACPI) { 2227 pi->acpi_vddc = pl->vddc; 2228 if (rdev->family >= CHIP_CEDAR) 2229 eg_pi->acpi_vddci = pl->vddci; 2230 if (ps->low.flags & ATOM_PPLIB_R600_FLAGS_PCIEGEN2) 2231 pi->acpi_pcie_gen2 = true; 2232 else 2233 pi->acpi_pcie_gen2 = false; 2234 } 2235 2236 if (rps->class2 & ATOM_PPLIB_CLASSIFICATION2_ULV) { 2237 if (rdev->family >= CHIP_BARTS) { 2238 eg_pi->ulv.supported = true; 2239 eg_pi->ulv.pl = pl; 2240 } 2241 } 2242 2243 if (pi->min_vddc_in_table > pl->vddc) 2244 pi->min_vddc_in_table = pl->vddc; 2245 2246 if (pi->max_vddc_in_table < pl->vddc) 2247 pi->max_vddc_in_table = pl->vddc; 2248 2249 /* patch up boot state */ 2250 if (rps->class & ATOM_PPLIB_CLASSIFICATION_BOOT) { 2251 u16 vddc, vddci, mvdd; 2252 radeon_atombios_get_default_voltages(rdev, &vddc, &vddci, &mvdd); 2253 pl->mclk = rdev->clock.default_mclk; 2254 pl->sclk = rdev->clock.default_sclk; 2255 pl->vddc = vddc; 2256 pl->vddci = vddci; 2257 } 2258 2259 if ((rps->class & ATOM_PPLIB_CLASSIFICATION_UI_MASK) == 2260 ATOM_PPLIB_CLASSIFICATION_UI_PERFORMANCE) { 2261 rdev->pm.dpm.dyn_state.max_clock_voltage_on_ac.sclk = pl->sclk; 2262 rdev->pm.dpm.dyn_state.max_clock_voltage_on_ac.mclk = pl->mclk; 2263 rdev->pm.dpm.dyn_state.max_clock_voltage_on_ac.vddc = pl->vddc; 2264 rdev->pm.dpm.dyn_state.max_clock_voltage_on_ac.vddci = pl->vddci; 2265 } 2266 } 2267 2268 int rv7xx_parse_power_table(struct radeon_device *rdev) 2269 { 2270 struct radeon_mode_info *mode_info = &rdev->mode_info; 2271 struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info; 2272 union pplib_power_state *power_state; 2273 int i, j; 2274 union pplib_clock_info *clock_info; 2275 union power_info *power_info; 2276 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo); 2277 u16 data_offset; 2278 u8 frev, crev; 2279 struct rv7xx_ps *ps; 2280 2281 if (!atom_parse_data_header(mode_info->atom_context, index, NULL, 2282 &frev, &crev, &data_offset)) 2283 return -EINVAL; 2284 power_info = (union power_info *)(mode_info->atom_context->bios + data_offset); 2285 2286 rdev->pm.dpm.ps = kcalloc(power_info->pplib.ucNumStates, 2287 sizeof(struct radeon_ps), 2288 GFP_KERNEL); 2289 if (!rdev->pm.dpm.ps) 2290 return -ENOMEM; 2291 2292 for (i = 0; i < power_info->pplib.ucNumStates; i++) { 2293 power_state = (union pplib_power_state *) 2294 (mode_info->atom_context->bios + data_offset + 2295 le16_to_cpu(power_info->pplib.usStateArrayOffset) + 2296 i * power_info->pplib.ucStateEntrySize); 2297 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *) 2298 (mode_info->atom_context->bios + data_offset + 2299 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset) + 2300 (power_state->v1.ucNonClockStateIndex * 2301 power_info->pplib.ucNonClockSize)); 2302 if (power_info->pplib.ucStateEntrySize - 1) { 2303 u8 *idx; 2304 ps = kzalloc(sizeof(struct rv7xx_ps), GFP_KERNEL); 2305 if (ps == NULL) { 2306 kfree(rdev->pm.dpm.ps); 2307 return -ENOMEM; 2308 } 2309 rdev->pm.dpm.ps[i].ps_priv = ps; 2310 rv7xx_parse_pplib_non_clock_info(rdev, &rdev->pm.dpm.ps[i], 2311 non_clock_info, 2312 power_info->pplib.ucNonClockSize); 2313 idx = (u8 *)&power_state->v1.ucClockStateIndices[0]; 2314 for (j = 0; j < (power_info->pplib.ucStateEntrySize - 1); j++) { 2315 clock_info = (union pplib_clock_info *) 2316 (mode_info->atom_context->bios + data_offset + 2317 le16_to_cpu(power_info->pplib.usClockInfoArrayOffset) + 2318 (idx[j] * power_info->pplib.ucClockInfoSize)); 2319 rv7xx_parse_pplib_clock_info(rdev, 2320 &rdev->pm.dpm.ps[i], j, 2321 clock_info); 2322 } 2323 } 2324 } 2325 rdev->pm.dpm.num_ps = power_info->pplib.ucNumStates; 2326 return 0; 2327 } 2328 2329 void rv770_get_engine_memory_ss(struct radeon_device *rdev) 2330 { 2331 struct rv7xx_power_info *pi = rv770_get_pi(rdev); 2332 struct radeon_atom_ss ss; 2333 2334 pi->sclk_ss = radeon_atombios_get_asic_ss_info(rdev, &ss, 2335 ASIC_INTERNAL_ENGINE_SS, 0); 2336 pi->mclk_ss = radeon_atombios_get_asic_ss_info(rdev, &ss, 2337 ASIC_INTERNAL_MEMORY_SS, 0); 2338 2339 if (pi->sclk_ss || pi->mclk_ss) 2340 pi->dynamic_ss = true; 2341 else 2342 pi->dynamic_ss = false; 2343 } 2344 2345 int rv770_dpm_init(struct radeon_device *rdev) 2346 { 2347 struct rv7xx_power_info *pi; 2348 struct atom_clock_dividers dividers; 2349 int ret; 2350 2351 pi = kzalloc(sizeof(struct rv7xx_power_info), GFP_KERNEL); 2352 if (pi == NULL) 2353 return -ENOMEM; 2354 rdev->pm.dpm.priv = pi; 2355 2356 rv770_get_max_vddc(rdev); 2357 2358 pi->acpi_vddc = 0; 2359 pi->min_vddc_in_table = 0; 2360 pi->max_vddc_in_table = 0; 2361 2362 ret = r600_get_platform_caps(rdev); 2363 if (ret) 2364 return ret; 2365 2366 ret = rv7xx_parse_power_table(rdev); 2367 if (ret) 2368 return ret; 2369 2370 if (rdev->pm.dpm.voltage_response_time == 0) 2371 rdev->pm.dpm.voltage_response_time = R600_VOLTAGERESPONSETIME_DFLT; 2372 if (rdev->pm.dpm.backbias_response_time == 0) 2373 rdev->pm.dpm.backbias_response_time = R600_BACKBIASRESPONSETIME_DFLT; 2374 2375 ret = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM, 2376 0, false, ÷rs); 2377 if (ret) 2378 pi->ref_div = dividers.ref_div + 1; 2379 else 2380 pi->ref_div = R600_REFERENCEDIVIDER_DFLT; 2381 2382 pi->mclk_strobe_mode_threshold = 30000; 2383 pi->mclk_edc_enable_threshold = 30000; 2384 2385 pi->rlp = RV770_RLP_DFLT; 2386 pi->rmp = RV770_RMP_DFLT; 2387 pi->lhp = RV770_LHP_DFLT; 2388 pi->lmp = RV770_LMP_DFLT; 2389 2390 pi->voltage_control = 2391 radeon_atom_is_voltage_gpio(rdev, SET_VOLTAGE_TYPE_ASIC_VDDC, 0); 2392 2393 pi->mvdd_control = 2394 radeon_atom_is_voltage_gpio(rdev, SET_VOLTAGE_TYPE_ASIC_MVDDC, 0); 2395 2396 rv770_get_engine_memory_ss(rdev); 2397 2398 pi->asi = RV770_ASI_DFLT; 2399 pi->pasi = RV770_HASI_DFLT; 2400 pi->vrc = RV770_VRC_DFLT; 2401 2402 pi->power_gating = false; 2403 2404 pi->gfx_clock_gating = true; 2405 2406 pi->mg_clock_gating = true; 2407 pi->mgcgtssm = true; 2408 2409 pi->dynamic_pcie_gen2 = true; 2410 2411 if (rdev->pm.int_thermal_type != THERMAL_TYPE_NONE) 2412 pi->thermal_protection = true; 2413 else 2414 pi->thermal_protection = false; 2415 2416 pi->display_gap = true; 2417 2418 if (rdev->flags & RADEON_IS_MOBILITY) 2419 pi->dcodt = true; 2420 else 2421 pi->dcodt = false; 2422 2423 pi->ulps = true; 2424 2425 pi->mclk_stutter_mode_threshold = 0; 2426 2427 pi->sram_end = SMC_RAM_END; 2428 pi->state_table_start = RV770_SMC_TABLE_ADDRESS; 2429 pi->soft_regs_start = RV770_SMC_SOFT_REGISTERS_START; 2430 2431 return 0; 2432 } 2433 2434 void rv770_dpm_print_power_state(struct radeon_device *rdev, 2435 struct radeon_ps *rps) 2436 { 2437 struct rv7xx_ps *ps = rv770_get_ps(rps); 2438 struct rv7xx_pl *pl; 2439 2440 r600_dpm_print_class_info(rps->class, rps->class2); 2441 r600_dpm_print_cap_info(rps->caps); 2442 printk("\tuvd vclk: %d dclk: %d\n", rps->vclk, rps->dclk); 2443 if (rdev->family >= CHIP_CEDAR) { 2444 pl = &ps->low; 2445 printk("\t\tpower level 0 sclk: %u mclk: %u vddc: %u vddci: %u\n", 2446 pl->sclk, pl->mclk, pl->vddc, pl->vddci); 2447 pl = &ps->medium; 2448 printk("\t\tpower level 1 sclk: %u mclk: %u vddc: %u vddci: %u\n", 2449 pl->sclk, pl->mclk, pl->vddc, pl->vddci); 2450 pl = &ps->high; 2451 printk("\t\tpower level 2 sclk: %u mclk: %u vddc: %u vddci: %u\n", 2452 pl->sclk, pl->mclk, pl->vddc, pl->vddci); 2453 } else { 2454 pl = &ps->low; 2455 printk("\t\tpower level 0 sclk: %u mclk: %u vddc: %u\n", 2456 pl->sclk, pl->mclk, pl->vddc); 2457 pl = &ps->medium; 2458 printk("\t\tpower level 1 sclk: %u mclk: %u vddc: %u\n", 2459 pl->sclk, pl->mclk, pl->vddc); 2460 pl = &ps->high; 2461 printk("\t\tpower level 2 sclk: %u mclk: %u vddc: %u\n", 2462 pl->sclk, pl->mclk, pl->vddc); 2463 } 2464 r600_dpm_print_ps_status(rdev, rps); 2465 } 2466 2467 void rv770_dpm_debugfs_print_current_performance_level(struct radeon_device *rdev, 2468 struct seq_file *m) 2469 { 2470 struct radeon_ps *rps = rdev->pm.dpm.current_ps; 2471 struct rv7xx_ps *ps = rv770_get_ps(rps); 2472 struct rv7xx_pl *pl; 2473 u32 current_index = 2474 (RREG32(TARGET_AND_CURRENT_PROFILE_INDEX) & CURRENT_PROFILE_INDEX_MASK) >> 2475 CURRENT_PROFILE_INDEX_SHIFT; 2476 2477 if (current_index > 2) { 2478 seq_printf(m, "invalid dpm profile %d\n", current_index); 2479 } else { 2480 if (current_index == 0) 2481 pl = &ps->low; 2482 else if (current_index == 1) 2483 pl = &ps->medium; 2484 else /* current_index == 2 */ 2485 pl = &ps->high; 2486 seq_printf(m, "uvd vclk: %d dclk: %d\n", rps->vclk, rps->dclk); 2487 if (rdev->family >= CHIP_CEDAR) { 2488 seq_printf(m, "power level %d sclk: %u mclk: %u vddc: %u vddci: %u\n", 2489 current_index, pl->sclk, pl->mclk, pl->vddc, pl->vddci); 2490 } else { 2491 seq_printf(m, "power level %d sclk: %u mclk: %u vddc: %u\n", 2492 current_index, pl->sclk, pl->mclk, pl->vddc); 2493 } 2494 } 2495 } 2496 2497 u32 rv770_dpm_get_current_sclk(struct radeon_device *rdev) 2498 { 2499 struct radeon_ps *rps = rdev->pm.dpm.current_ps; 2500 struct rv7xx_ps *ps = rv770_get_ps(rps); 2501 struct rv7xx_pl *pl; 2502 u32 current_index = 2503 (RREG32(TARGET_AND_CURRENT_PROFILE_INDEX) & CURRENT_PROFILE_INDEX_MASK) >> 2504 CURRENT_PROFILE_INDEX_SHIFT; 2505 2506 if (current_index > 2) { 2507 return 0; 2508 } else { 2509 if (current_index == 0) 2510 pl = &ps->low; 2511 else if (current_index == 1) 2512 pl = &ps->medium; 2513 else /* current_index == 2 */ 2514 pl = &ps->high; 2515 return pl->sclk; 2516 } 2517 } 2518 2519 u32 rv770_dpm_get_current_mclk(struct radeon_device *rdev) 2520 { 2521 struct radeon_ps *rps = rdev->pm.dpm.current_ps; 2522 struct rv7xx_ps *ps = rv770_get_ps(rps); 2523 struct rv7xx_pl *pl; 2524 u32 current_index = 2525 (RREG32(TARGET_AND_CURRENT_PROFILE_INDEX) & CURRENT_PROFILE_INDEX_MASK) >> 2526 CURRENT_PROFILE_INDEX_SHIFT; 2527 2528 if (current_index > 2) { 2529 return 0; 2530 } else { 2531 if (current_index == 0) 2532 pl = &ps->low; 2533 else if (current_index == 1) 2534 pl = &ps->medium; 2535 else /* current_index == 2 */ 2536 pl = &ps->high; 2537 return pl->mclk; 2538 } 2539 } 2540 2541 void rv770_dpm_fini(struct radeon_device *rdev) 2542 { 2543 int i; 2544 2545 for (i = 0; i < rdev->pm.dpm.num_ps; i++) { 2546 kfree(rdev->pm.dpm.ps[i].ps_priv); 2547 } 2548 kfree(rdev->pm.dpm.ps); 2549 kfree(rdev->pm.dpm.priv); 2550 } 2551 2552 u32 rv770_dpm_get_sclk(struct radeon_device *rdev, bool low) 2553 { 2554 struct rv7xx_ps *requested_state = rv770_get_ps(rdev->pm.dpm.requested_ps); 2555 2556 if (low) 2557 return requested_state->low.sclk; 2558 else 2559 return requested_state->high.sclk; 2560 } 2561 2562 u32 rv770_dpm_get_mclk(struct radeon_device *rdev, bool low) 2563 { 2564 struct rv7xx_ps *requested_state = rv770_get_ps(rdev->pm.dpm.requested_ps); 2565 2566 if (low) 2567 return requested_state->low.mclk; 2568 else 2569 return requested_state->high.mclk; 2570 } 2571 2572 bool rv770_dpm_vblank_too_short(struct radeon_device *rdev) 2573 { 2574 u32 vblank_time = r600_dpm_get_vblank_time(rdev); 2575 u32 switch_limit = 200; /* 300 */ 2576 2577 /* RV770 */ 2578 /* mclk switching doesn't seem to work reliably on desktop RV770s */ 2579 if ((rdev->family == CHIP_RV770) && 2580 !(rdev->flags & RADEON_IS_MOBILITY)) 2581 switch_limit = 0xffffffff; /* disable mclk switching */ 2582 2583 if (vblank_time < switch_limit) 2584 return true; 2585 else 2586 return false; 2587 2588 } 2589