drivers/gpu/drm/radeon/rv770_dpm.c

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