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