2 * Copyright 2011 Advanced Micro Devices, Inc.
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
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.
22 * Authors: Alex Deucher
29 #include "rs780_dpm.h"
32 static struct igp_ps
*rs780_get_ps(struct radeon_ps
*rps
)
34 struct igp_ps
*ps
= rps
->ps_priv
;
39 static struct igp_power_info
*rs780_get_pi(struct radeon_device
*rdev
)
41 struct igp_power_info
*pi
= rdev
->pm
.dpm
.priv
;
46 static void rs780_get_pm_mode_parameters(struct radeon_device
*rdev
)
48 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
49 struct radeon_mode_info
*minfo
= &rdev
->mode_info
;
50 struct drm_crtc
*crtc
;
51 struct radeon_crtc
*radeon_crtc
;
56 pi
->refresh_rate
= 60;
58 for (i
= 0; i
< rdev
->num_crtc
; i
++) {
59 crtc
= (struct drm_crtc
*)minfo
->crtcs
[i
];
60 if (crtc
&& crtc
->enabled
) {
61 radeon_crtc
= to_radeon_crtc(crtc
);
62 pi
->crtc_id
= radeon_crtc
->crtc_id
;
63 if (crtc
->mode
.htotal
&& crtc
->mode
.vtotal
)
65 (crtc
->mode
.clock
* 1000) /
66 (crtc
->mode
.htotal
* crtc
->mode
.vtotal
);
72 static void rs780_voltage_scaling_enable(struct radeon_device
*rdev
, bool enable
);
74 static int rs780_initialize_dpm_power_state(struct radeon_device
*rdev
)
76 struct atom_clock_dividers dividers
;
77 struct igp_ps
*default_state
= rs780_get_ps(rdev
->pm
.dpm
.boot_ps
);
80 ret
= radeon_atom_get_clock_dividers(rdev
, COMPUTE_ENGINE_PLL_PARAM
,
81 default_state
->sclk_low
, false, ÷rs
);
85 r600_engine_clock_entry_set_reference_divider(rdev
, 0, dividers
.ref_div
);
86 r600_engine_clock_entry_set_feedback_divider(rdev
, 0, dividers
.fb_div
);
87 r600_engine_clock_entry_set_post_divider(rdev
, 0, dividers
.post_div
);
89 if (dividers
.enable_post_div
)
90 r600_engine_clock_entry_enable_post_divider(rdev
, 0, true);
92 r600_engine_clock_entry_enable_post_divider(rdev
, 0, false);
94 r600_engine_clock_entry_set_step_time(rdev
, 0, R600_SST_DFLT
);
95 r600_engine_clock_entry_enable_pulse_skipping(rdev
, 0, false);
97 r600_engine_clock_entry_enable(rdev
, 0, true);
98 for (i
= 1; i
< R600_PM_NUMBER_OF_SCLKS
; i
++)
99 r600_engine_clock_entry_enable(rdev
, i
, false);
101 r600_enable_mclk_control(rdev
, false);
102 r600_voltage_control_enable_pins(rdev
, 0);
107 static int rs780_initialize_dpm_parameters(struct radeon_device
*rdev
)
112 r600_set_bsp(rdev
, R600_BSU_DFLT
, R600_BSP_DFLT
);
114 r600_set_at(rdev
, 0, 0, 0, 0);
116 r600_set_git(rdev
, R600_GICST_DFLT
);
118 for (i
= 0; i
< R600_PM_NUMBER_OF_TC
; i
++)
119 r600_set_tc(rdev
, i
, 0, 0);
121 r600_select_td(rdev
, R600_TD_DFLT
);
122 r600_set_vrc(rdev
, 0);
124 r600_set_tpu(rdev
, R600_TPU_DFLT
);
125 r600_set_tpc(rdev
, R600_TPC_DFLT
);
127 r600_set_sstu(rdev
, R600_SSTU_DFLT
);
128 r600_set_sst(rdev
, R600_SST_DFLT
);
130 r600_set_fctu(rdev
, R600_FCTU_DFLT
);
131 r600_set_fct(rdev
, R600_FCT_DFLT
);
133 r600_set_vddc3d_oorsu(rdev
, R600_VDDC3DOORSU_DFLT
);
134 r600_set_vddc3d_oorphc(rdev
, R600_VDDC3DOORPHC_DFLT
);
135 r600_set_vddc3d_oorsdc(rdev
, R600_VDDC3DOORSDC_DFLT
);
136 r600_set_ctxcgtt3d_rphc(rdev
, R600_CTXCGTT3DRPHC_DFLT
);
137 r600_set_ctxcgtt3d_rsdc(rdev
, R600_CTXCGTT3DRSDC_DFLT
);
139 r600_vid_rt_set_vru(rdev
, R600_VRU_DFLT
);
140 r600_vid_rt_set_vrt(rdev
, R600_VOLTAGERESPONSETIME_DFLT
);
141 r600_vid_rt_set_ssu(rdev
, R600_SPLLSTEPUNIT_DFLT
);
143 ret
= rs780_initialize_dpm_power_state(rdev
);
145 r600_power_level_set_voltage_index(rdev
, R600_POWER_LEVEL_LOW
, 0);
146 r600_power_level_set_voltage_index(rdev
, R600_POWER_LEVEL_MEDIUM
, 0);
147 r600_power_level_set_voltage_index(rdev
, R600_POWER_LEVEL_HIGH
, 0);
149 r600_power_level_set_mem_clock_index(rdev
, R600_POWER_LEVEL_LOW
, 0);
150 r600_power_level_set_mem_clock_index(rdev
, R600_POWER_LEVEL_MEDIUM
, 0);
151 r600_power_level_set_mem_clock_index(rdev
, R600_POWER_LEVEL_HIGH
, 0);
153 r600_power_level_set_eng_clock_index(rdev
, R600_POWER_LEVEL_LOW
, 0);
154 r600_power_level_set_eng_clock_index(rdev
, R600_POWER_LEVEL_MEDIUM
, 0);
155 r600_power_level_set_eng_clock_index(rdev
, R600_POWER_LEVEL_HIGH
, 0);
157 r600_power_level_set_watermark_id(rdev
, R600_POWER_LEVEL_LOW
, R600_DISPLAY_WATERMARK_HIGH
);
158 r600_power_level_set_watermark_id(rdev
, R600_POWER_LEVEL_MEDIUM
, R600_DISPLAY_WATERMARK_HIGH
);
159 r600_power_level_set_watermark_id(rdev
, R600_POWER_LEVEL_HIGH
, R600_DISPLAY_WATERMARK_HIGH
);
161 r600_power_level_enable(rdev
, R600_POWER_LEVEL_CTXSW
, false);
162 r600_power_level_enable(rdev
, R600_POWER_LEVEL_HIGH
, false);
163 r600_power_level_enable(rdev
, R600_POWER_LEVEL_MEDIUM
, false);
164 r600_power_level_enable(rdev
, R600_POWER_LEVEL_LOW
, true);
166 r600_power_level_set_enter_index(rdev
, R600_POWER_LEVEL_LOW
);
168 r600_set_vrc(rdev
, RS780_CGFTV_DFLT
);
173 static void rs780_start_dpm(struct radeon_device
*rdev
)
175 r600_enable_sclk_control(rdev
, false);
176 r600_enable_mclk_control(rdev
, false);
178 r600_dynamicpm_enable(rdev
, true);
180 radeon_wait_for_vblank(rdev
, 0);
181 radeon_wait_for_vblank(rdev
, 1);
183 r600_enable_spll_bypass(rdev
, true);
184 r600_wait_for_spll_change(rdev
);
185 r600_enable_spll_bypass(rdev
, false);
186 r600_wait_for_spll_change(rdev
);
188 r600_enable_spll_bypass(rdev
, true);
189 r600_wait_for_spll_change(rdev
);
190 r600_enable_spll_bypass(rdev
, false);
191 r600_wait_for_spll_change(rdev
);
193 r600_enable_sclk_control(rdev
, true);
197 static void rs780_preset_ranges_slow_clk_fbdiv_en(struct radeon_device
*rdev
)
199 WREG32_P(FVTHROT_SLOW_CLK_FEEDBACK_DIV_REG1
, RANGE_SLOW_CLK_FEEDBACK_DIV_EN
,
200 ~RANGE_SLOW_CLK_FEEDBACK_DIV_EN
);
202 WREG32_P(FVTHROT_SLOW_CLK_FEEDBACK_DIV_REG1
,
203 RANGE0_SLOW_CLK_FEEDBACK_DIV(RS780_SLOWCLKFEEDBACKDIV_DFLT
),
204 ~RANGE0_SLOW_CLK_FEEDBACK_DIV_MASK
);
207 static void rs780_preset_starting_fbdiv(struct radeon_device
*rdev
)
209 u32 fbdiv
= (RREG32(CG_SPLL_FUNC_CNTL
) & SPLL_FB_DIV_MASK
) >> SPLL_FB_DIV_SHIFT
;
211 WREG32_P(FVTHROT_FBDIV_REG1
, STARTING_FEEDBACK_DIV(fbdiv
),
212 ~STARTING_FEEDBACK_DIV_MASK
);
214 WREG32_P(FVTHROT_FBDIV_REG2
, FORCED_FEEDBACK_DIV(fbdiv
),
215 ~FORCED_FEEDBACK_DIV_MASK
);
217 WREG32_P(FVTHROT_FBDIV_REG1
, FORCE_FEEDBACK_DIV
, ~FORCE_FEEDBACK_DIV
);
220 static void rs780_voltage_scaling_init(struct radeon_device
*rdev
)
222 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
223 struct drm_device
*dev
= rdev
->ddev
;
224 u32 fv_throt_pwm_fb_div_range
[3];
225 u32 fv_throt_pwm_range
[4];
227 if (dev
->pdev
->device
== 0x9614) {
228 fv_throt_pwm_fb_div_range
[0] = RS780D_FVTHROTPWMFBDIVRANGEREG0_DFLT
;
229 fv_throt_pwm_fb_div_range
[1] = RS780D_FVTHROTPWMFBDIVRANGEREG1_DFLT
;
230 fv_throt_pwm_fb_div_range
[2] = RS780D_FVTHROTPWMFBDIVRANGEREG2_DFLT
;
231 } else if ((dev
->pdev
->device
== 0x9714) ||
232 (dev
->pdev
->device
== 0x9715)) {
233 fv_throt_pwm_fb_div_range
[0] = RS880D_FVTHROTPWMFBDIVRANGEREG0_DFLT
;
234 fv_throt_pwm_fb_div_range
[1] = RS880D_FVTHROTPWMFBDIVRANGEREG1_DFLT
;
235 fv_throt_pwm_fb_div_range
[2] = RS880D_FVTHROTPWMFBDIVRANGEREG2_DFLT
;
237 fv_throt_pwm_fb_div_range
[0] = RS780_FVTHROTPWMFBDIVRANGEREG0_DFLT
;
238 fv_throt_pwm_fb_div_range
[1] = RS780_FVTHROTPWMFBDIVRANGEREG1_DFLT
;
239 fv_throt_pwm_fb_div_range
[2] = RS780_FVTHROTPWMFBDIVRANGEREG2_DFLT
;
242 if (pi
->pwm_voltage_control
) {
243 fv_throt_pwm_range
[0] = pi
->min_voltage
;
244 fv_throt_pwm_range
[1] = pi
->min_voltage
;
245 fv_throt_pwm_range
[2] = pi
->max_voltage
;
246 fv_throt_pwm_range
[3] = pi
->max_voltage
;
248 fv_throt_pwm_range
[0] = pi
->invert_pwm_required
?
249 RS780_FVTHROTPWMRANGE3_GPIO_DFLT
: RS780_FVTHROTPWMRANGE0_GPIO_DFLT
;
250 fv_throt_pwm_range
[1] = pi
->invert_pwm_required
?
251 RS780_FVTHROTPWMRANGE2_GPIO_DFLT
: RS780_FVTHROTPWMRANGE1_GPIO_DFLT
;
252 fv_throt_pwm_range
[2] = pi
->invert_pwm_required
?
253 RS780_FVTHROTPWMRANGE1_GPIO_DFLT
: RS780_FVTHROTPWMRANGE2_GPIO_DFLT
;
254 fv_throt_pwm_range
[3] = pi
->invert_pwm_required
?
255 RS780_FVTHROTPWMRANGE0_GPIO_DFLT
: RS780_FVTHROTPWMRANGE3_GPIO_DFLT
;
258 WREG32_P(FVTHROT_PWM_CTRL_REG0
,
259 STARTING_PWM_HIGHTIME(pi
->max_voltage
),
260 ~STARTING_PWM_HIGHTIME_MASK
);
262 WREG32_P(FVTHROT_PWM_CTRL_REG0
,
263 NUMBER_OF_CYCLES_IN_PERIOD(pi
->num_of_cycles_in_period
),
264 ~NUMBER_OF_CYCLES_IN_PERIOD_MASK
);
266 WREG32_P(FVTHROT_PWM_CTRL_REG0
, FORCE_STARTING_PWM_HIGHTIME
,
267 ~FORCE_STARTING_PWM_HIGHTIME
);
269 if (pi
->invert_pwm_required
)
270 WREG32_P(FVTHROT_PWM_CTRL_REG0
, INVERT_PWM_WAVEFORM
, ~INVERT_PWM_WAVEFORM
);
272 WREG32_P(FVTHROT_PWM_CTRL_REG0
, 0, ~INVERT_PWM_WAVEFORM
);
274 rs780_voltage_scaling_enable(rdev
, true);
276 WREG32(FVTHROT_PWM_CTRL_REG1
,
277 (MIN_PWM_HIGHTIME(pi
->min_voltage
) |
278 MAX_PWM_HIGHTIME(pi
->max_voltage
)));
280 WREG32(FVTHROT_PWM_US_REG0
, RS780_FVTHROTPWMUSREG0_DFLT
);
281 WREG32(FVTHROT_PWM_US_REG1
, RS780_FVTHROTPWMUSREG1_DFLT
);
282 WREG32(FVTHROT_PWM_DS_REG0
, RS780_FVTHROTPWMDSREG0_DFLT
);
283 WREG32(FVTHROT_PWM_DS_REG1
, RS780_FVTHROTPWMDSREG1_DFLT
);
285 WREG32_P(FVTHROT_PWM_FEEDBACK_DIV_REG1
,
286 RANGE0_PWM_FEEDBACK_DIV(fv_throt_pwm_fb_div_range
[0]),
287 ~RANGE0_PWM_FEEDBACK_DIV_MASK
);
289 WREG32(FVTHROT_PWM_FEEDBACK_DIV_REG2
,
290 (RANGE1_PWM_FEEDBACK_DIV(fv_throt_pwm_fb_div_range
[1]) |
291 RANGE2_PWM_FEEDBACK_DIV(fv_throt_pwm_fb_div_range
[2])));
293 WREG32(FVTHROT_PWM_FEEDBACK_DIV_REG3
,
294 (RANGE0_PWM(fv_throt_pwm_range
[1]) |
295 RANGE1_PWM(fv_throt_pwm_range
[2])));
296 WREG32(FVTHROT_PWM_FEEDBACK_DIV_REG4
,
297 (RANGE2_PWM(fv_throt_pwm_range
[1]) |
298 RANGE3_PWM(fv_throt_pwm_range
[2])));
301 static void rs780_clk_scaling_enable(struct radeon_device
*rdev
, bool enable
)
304 WREG32_P(FVTHROT_CNTRL_REG
, ENABLE_FV_THROT
| ENABLE_FV_UPDATE
,
305 ~(ENABLE_FV_THROT
| ENABLE_FV_UPDATE
));
307 WREG32_P(FVTHROT_CNTRL_REG
, 0,
308 ~(ENABLE_FV_THROT
| ENABLE_FV_UPDATE
));
311 static void rs780_voltage_scaling_enable(struct radeon_device
*rdev
, bool enable
)
314 WREG32_P(FVTHROT_CNTRL_REG
, ENABLE_FV_THROT_IO
, ~ENABLE_FV_THROT_IO
);
316 WREG32_P(FVTHROT_CNTRL_REG
, 0, ~ENABLE_FV_THROT_IO
);
319 static void rs780_set_engine_clock_wfc(struct radeon_device
*rdev
)
321 WREG32(FVTHROT_UTC0
, RS780_FVTHROTUTC0_DFLT
);
322 WREG32(FVTHROT_UTC1
, RS780_FVTHROTUTC1_DFLT
);
323 WREG32(FVTHROT_UTC2
, RS780_FVTHROTUTC2_DFLT
);
324 WREG32(FVTHROT_UTC3
, RS780_FVTHROTUTC3_DFLT
);
325 WREG32(FVTHROT_UTC4
, RS780_FVTHROTUTC4_DFLT
);
327 WREG32(FVTHROT_DTC0
, RS780_FVTHROTDTC0_DFLT
);
328 WREG32(FVTHROT_DTC1
, RS780_FVTHROTDTC1_DFLT
);
329 WREG32(FVTHROT_DTC2
, RS780_FVTHROTDTC2_DFLT
);
330 WREG32(FVTHROT_DTC3
, RS780_FVTHROTDTC3_DFLT
);
331 WREG32(FVTHROT_DTC4
, RS780_FVTHROTDTC4_DFLT
);
334 static void rs780_set_engine_clock_sc(struct radeon_device
*rdev
)
336 WREG32_P(FVTHROT_FBDIV_REG2
,
337 FB_DIV_TIMER_VAL(RS780_FBDIVTIMERVAL_DFLT
),
338 ~FB_DIV_TIMER_VAL_MASK
);
340 WREG32_P(FVTHROT_CNTRL_REG
,
341 REFRESH_RATE_DIVISOR(0) | MINIMUM_CIP(0xf),
342 ~(REFRESH_RATE_DIVISOR_MASK
| MINIMUM_CIP_MASK
));
345 static void rs780_set_engine_clock_tdc(struct radeon_device
*rdev
)
347 WREG32_P(FVTHROT_CNTRL_REG
, 0, ~(FORCE_TREND_SEL
| TREND_SEL_MODE
));
350 static void rs780_set_engine_clock_ssc(struct radeon_device
*rdev
)
352 WREG32(FVTHROT_FB_US_REG0
, RS780_FVTHROTFBUSREG0_DFLT
);
353 WREG32(FVTHROT_FB_US_REG1
, RS780_FVTHROTFBUSREG1_DFLT
);
354 WREG32(FVTHROT_FB_DS_REG0
, RS780_FVTHROTFBDSREG0_DFLT
);
355 WREG32(FVTHROT_FB_DS_REG1
, RS780_FVTHROTFBDSREG1_DFLT
);
357 WREG32_P(FVTHROT_FBDIV_REG1
, MAX_FEEDBACK_STEP(1), ~MAX_FEEDBACK_STEP_MASK
);
360 static void rs780_program_at(struct radeon_device
*rdev
)
362 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
364 WREG32(FVTHROT_TARGET_REG
, 30000000 / pi
->refresh_rate
);
365 WREG32(FVTHROT_CB1
, 1000000 * 5 / pi
->refresh_rate
);
366 WREG32(FVTHROT_CB2
, 1000000 * 10 / pi
->refresh_rate
);
367 WREG32(FVTHROT_CB3
, 1000000 * 30 / pi
->refresh_rate
);
368 WREG32(FVTHROT_CB4
, 1000000 * 50 / pi
->refresh_rate
);
371 static void rs780_disable_vbios_powersaving(struct radeon_device
*rdev
)
373 WREG32_P(CG_INTGFX_MISC
, 0, ~0xFFF00000);
376 static void rs780_force_voltage_to_high(struct radeon_device
*rdev
)
378 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
379 struct igp_ps
*current_state
= rs780_get_ps(rdev
->pm
.dpm
.current_ps
);
381 if ((current_state
->max_voltage
== RS780_VDDC_LEVEL_HIGH
) &&
382 (current_state
->min_voltage
== RS780_VDDC_LEVEL_HIGH
))
385 WREG32_P(GFX_MACRO_BYPASS_CNTL
, SPLL_BYPASS_CNTL
, ~SPLL_BYPASS_CNTL
);
389 WREG32_P(FVTHROT_PWM_CTRL_REG0
,
390 STARTING_PWM_HIGHTIME(pi
->max_voltage
),
391 ~STARTING_PWM_HIGHTIME_MASK
);
393 WREG32_P(FVTHROT_PWM_CTRL_REG0
,
394 FORCE_STARTING_PWM_HIGHTIME
, ~FORCE_STARTING_PWM_HIGHTIME
);
396 WREG32_P(FVTHROT_PWM_FEEDBACK_DIV_REG1
, 0,
397 ~RANGE_PWM_FEEDBACK_DIV_EN
);
401 WREG32_P(GFX_MACRO_BYPASS_CNTL
, 0, ~SPLL_BYPASS_CNTL
);
404 static int rs780_set_engine_clock_scaling(struct radeon_device
*rdev
)
406 struct atom_clock_dividers min_dividers
, max_dividers
, current_max_dividers
;
407 struct igp_ps
*new_state
= rs780_get_ps(rdev
->pm
.dpm
.requested_ps
);
408 struct igp_ps
*old_state
= rs780_get_ps(rdev
->pm
.dpm
.current_ps
);
411 if ((new_state
->sclk_high
== old_state
->sclk_high
) &&
412 (new_state
->sclk_low
== old_state
->sclk_low
))
415 ret
= radeon_atom_get_clock_dividers(rdev
, COMPUTE_ENGINE_PLL_PARAM
,
416 new_state
->sclk_low
, false, &min_dividers
);
420 ret
= radeon_atom_get_clock_dividers(rdev
, COMPUTE_ENGINE_PLL_PARAM
,
421 new_state
->sclk_high
, false, &max_dividers
);
425 ret
= radeon_atom_get_clock_dividers(rdev
, COMPUTE_ENGINE_PLL_PARAM
,
426 old_state
->sclk_high
, false, ¤t_max_dividers
);
430 WREG32_P(GFX_MACRO_BYPASS_CNTL
, SPLL_BYPASS_CNTL
, ~SPLL_BYPASS_CNTL
);
432 WREG32_P(FVTHROT_FBDIV_REG2
, FORCED_FEEDBACK_DIV(max_dividers
.fb_div
),
433 ~FORCED_FEEDBACK_DIV_MASK
);
434 WREG32_P(FVTHROT_FBDIV_REG1
, STARTING_FEEDBACK_DIV(max_dividers
.fb_div
),
435 ~STARTING_FEEDBACK_DIV_MASK
);
436 WREG32_P(FVTHROT_FBDIV_REG1
, FORCE_FEEDBACK_DIV
, ~FORCE_FEEDBACK_DIV
);
440 WREG32_P(GFX_MACRO_BYPASS_CNTL
, 0, ~SPLL_BYPASS_CNTL
);
442 if (max_dividers
.fb_div
> min_dividers
.fb_div
) {
443 WREG32_P(FVTHROT_FBDIV_REG0
,
444 MIN_FEEDBACK_DIV(min_dividers
.fb_div
) |
445 MAX_FEEDBACK_DIV(max_dividers
.fb_div
),
446 ~(MIN_FEEDBACK_DIV_MASK
| MAX_FEEDBACK_DIV_MASK
));
448 WREG32_P(FVTHROT_FBDIV_REG1
, 0, ~FORCE_FEEDBACK_DIV
);
454 static void rs780_set_engine_clock_spc(struct radeon_device
*rdev
)
456 struct igp_ps
*new_state
= rs780_get_ps(rdev
->pm
.dpm
.requested_ps
);
457 struct igp_ps
*old_state
= rs780_get_ps(rdev
->pm
.dpm
.current_ps
);
458 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
460 if ((new_state
->sclk_high
== old_state
->sclk_high
) &&
461 (new_state
->sclk_low
== old_state
->sclk_low
))
464 if (pi
->crtc_id
== 0)
465 WREG32_P(CG_INTGFX_MISC
, 0, ~FVTHROT_VBLANK_SEL
);
467 WREG32_P(CG_INTGFX_MISC
, FVTHROT_VBLANK_SEL
, ~FVTHROT_VBLANK_SEL
);
471 static void rs780_activate_engine_clk_scaling(struct radeon_device
*rdev
)
473 struct igp_ps
*new_state
= rs780_get_ps(rdev
->pm
.dpm
.requested_ps
);
474 struct igp_ps
*old_state
= rs780_get_ps(rdev
->pm
.dpm
.current_ps
);
476 if ((new_state
->sclk_high
== old_state
->sclk_high
) &&
477 (new_state
->sclk_low
== old_state
->sclk_low
))
480 rs780_clk_scaling_enable(rdev
, true);
483 static u32
rs780_get_voltage_for_vddc_level(struct radeon_device
*rdev
,
484 enum rs780_vddc_level vddc
)
486 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
488 if (vddc
== RS780_VDDC_LEVEL_HIGH
)
489 return pi
->max_voltage
;
490 else if (vddc
== RS780_VDDC_LEVEL_LOW
)
491 return pi
->min_voltage
;
493 return pi
->max_voltage
;
496 static void rs780_enable_voltage_scaling(struct radeon_device
*rdev
)
498 struct igp_ps
*new_state
= rs780_get_ps(rdev
->pm
.dpm
.requested_ps
);
499 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
500 enum rs780_vddc_level vddc_high
, vddc_low
;
504 if ((new_state
->max_voltage
== RS780_VDDC_LEVEL_HIGH
) &&
505 (new_state
->min_voltage
== RS780_VDDC_LEVEL_HIGH
))
508 vddc_high
= rs780_get_voltage_for_vddc_level(rdev
,
509 new_state
->max_voltage
);
510 vddc_low
= rs780_get_voltage_for_vddc_level(rdev
,
511 new_state
->min_voltage
);
513 WREG32_P(GFX_MACRO_BYPASS_CNTL
, SPLL_BYPASS_CNTL
, ~SPLL_BYPASS_CNTL
);
516 if (vddc_high
> vddc_low
) {
517 WREG32_P(FVTHROT_PWM_FEEDBACK_DIV_REG1
,
518 RANGE_PWM_FEEDBACK_DIV_EN
, ~RANGE_PWM_FEEDBACK_DIV_EN
);
520 WREG32_P(FVTHROT_PWM_CTRL_REG0
, 0, ~FORCE_STARTING_PWM_HIGHTIME
);
521 } else if (vddc_high
== vddc_low
) {
522 if (pi
->max_voltage
!= vddc_high
) {
523 WREG32_P(FVTHROT_PWM_CTRL_REG0
,
524 STARTING_PWM_HIGHTIME(vddc_high
),
525 ~STARTING_PWM_HIGHTIME_MASK
);
527 WREG32_P(FVTHROT_PWM_CTRL_REG0
,
528 FORCE_STARTING_PWM_HIGHTIME
,
529 ~FORCE_STARTING_PWM_HIGHTIME
);
533 WREG32_P(GFX_MACRO_BYPASS_CNTL
, 0, ~SPLL_BYPASS_CNTL
);
536 int rs780_dpm_enable(struct radeon_device
*rdev
)
538 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
540 rs780_get_pm_mode_parameters(rdev
);
541 rs780_disable_vbios_powersaving(rdev
);
543 if (r600_dynamicpm_enabled(rdev
))
545 if (rs780_initialize_dpm_parameters(rdev
))
547 rs780_start_dpm(rdev
);
549 rs780_preset_ranges_slow_clk_fbdiv_en(rdev
);
550 rs780_preset_starting_fbdiv(rdev
);
551 if (pi
->voltage_control
)
552 rs780_voltage_scaling_init(rdev
);
553 rs780_clk_scaling_enable(rdev
, true);
554 rs780_set_engine_clock_sc(rdev
);
555 rs780_set_engine_clock_wfc(rdev
);
556 rs780_program_at(rdev
);
557 rs780_set_engine_clock_tdc(rdev
);
558 rs780_set_engine_clock_ssc(rdev
);
560 if (pi
->gfx_clock_gating
)
561 r600_gfx_clockgating_enable(rdev
, true);
563 if (rdev
->irq
.installed
&& (rdev
->pm
.int_thermal_type
== THERMAL_TYPE_RV6XX
)) {
564 r600_set_thermal_temperature_range(rdev
, R600_TEMP_RANGE_MIN
, R600_TEMP_RANGE_MAX
);
565 rdev
->irq
.dpm_thermal
= true;
566 radeon_irq_set(rdev
);
572 void rs780_dpm_disable(struct radeon_device
*rdev
)
574 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
576 r600_dynamicpm_enable(rdev
, false);
578 rs780_clk_scaling_enable(rdev
, false);
579 rs780_voltage_scaling_enable(rdev
, false);
581 if (pi
->gfx_clock_gating
)
582 r600_gfx_clockgating_enable(rdev
, false);
584 if (rdev
->irq
.installed
&&
585 (rdev
->pm
.int_thermal_type
== THERMAL_TYPE_RV6XX
)) {
586 rdev
->irq
.dpm_thermal
= false;
587 radeon_irq_set(rdev
);
591 int rs780_dpm_set_power_state(struct radeon_device
*rdev
)
593 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
595 rs780_get_pm_mode_parameters(rdev
);
597 if (pi
->voltage_control
) {
598 rs780_force_voltage_to_high(rdev
);
602 rs780_set_engine_clock_scaling(rdev
);
603 rs780_set_engine_clock_spc(rdev
);
605 rs780_activate_engine_clk_scaling(rdev
);
607 if (pi
->voltage_control
)
608 rs780_enable_voltage_scaling(rdev
);
613 void rs780_dpm_setup_asic(struct radeon_device
*rdev
)
618 void rs780_dpm_display_configuration_changed(struct radeon_device
*rdev
)
620 rs780_get_pm_mode_parameters(rdev
);
621 rs780_program_at(rdev
);
625 struct _ATOM_INTEGRATED_SYSTEM_INFO info
;
626 struct _ATOM_INTEGRATED_SYSTEM_INFO_V2 info_2
;
630 struct _ATOM_POWERPLAY_INFO info
;
631 struct _ATOM_POWERPLAY_INFO_V2 info_2
;
632 struct _ATOM_POWERPLAY_INFO_V3 info_3
;
633 struct _ATOM_PPLIB_POWERPLAYTABLE pplib
;
634 struct _ATOM_PPLIB_POWERPLAYTABLE2 pplib2
;
635 struct _ATOM_PPLIB_POWERPLAYTABLE3 pplib3
;
638 union pplib_clock_info
{
639 struct _ATOM_PPLIB_R600_CLOCK_INFO r600
;
640 struct _ATOM_PPLIB_RS780_CLOCK_INFO rs780
;
641 struct _ATOM_PPLIB_EVERGREEN_CLOCK_INFO evergreen
;
642 struct _ATOM_PPLIB_SUMO_CLOCK_INFO sumo
;
645 union pplib_power_state
{
646 struct _ATOM_PPLIB_STATE v1
;
647 struct _ATOM_PPLIB_STATE_V2 v2
;
650 static void rs780_parse_pplib_non_clock_info(struct radeon_device
*rdev
,
651 struct radeon_ps
*rps
,
652 struct _ATOM_PPLIB_NONCLOCK_INFO
*non_clock_info
,
655 rps
->caps
= le32_to_cpu(non_clock_info
->ulCapsAndSettings
);
656 rps
->class = le16_to_cpu(non_clock_info
->usClassification
);
657 rps
->class2
= le16_to_cpu(non_clock_info
->usClassification2
);
659 if (ATOM_PPLIB_NONCLOCKINFO_VER1
< table_rev
) {
660 rps
->vclk
= le32_to_cpu(non_clock_info
->ulVCLK
);
661 rps
->dclk
= le32_to_cpu(non_clock_info
->ulDCLK
);
662 } else if (r600_is_uvd_state(rps
->class, rps
->class2
)) {
663 rps
->vclk
= RS780_DEFAULT_VCLK_FREQ
;
664 rps
->dclk
= RS780_DEFAULT_DCLK_FREQ
;
670 if (rps
->class & ATOM_PPLIB_CLASSIFICATION_BOOT
)
671 rdev
->pm
.dpm
.boot_ps
= rps
;
672 if (rps
->class & ATOM_PPLIB_CLASSIFICATION_UVDSTATE
)
673 rdev
->pm
.dpm
.uvd_ps
= rps
;
676 static void rs780_parse_pplib_clock_info(struct radeon_device
*rdev
,
677 struct radeon_ps
*rps
,
678 union pplib_clock_info
*clock_info
)
680 struct igp_ps
*ps
= rs780_get_ps(rps
);
683 sclk
= le16_to_cpu(clock_info
->rs780
.usLowEngineClockLow
);
684 sclk
|= clock_info
->rs780
.ucLowEngineClockHigh
<< 16;
686 sclk
= le16_to_cpu(clock_info
->rs780
.usHighEngineClockLow
);
687 sclk
|= clock_info
->rs780
.ucHighEngineClockHigh
<< 16;
688 ps
->sclk_high
= sclk
;
689 switch (le16_to_cpu(clock_info
->rs780
.usVDDC
)) {
690 case ATOM_PPLIB_RS780_VOLTAGE_NONE
:
692 ps
->min_voltage
= RS780_VDDC_LEVEL_UNKNOWN
;
693 ps
->max_voltage
= RS780_VDDC_LEVEL_UNKNOWN
;
695 case ATOM_PPLIB_RS780_VOLTAGE_LOW
:
696 ps
->min_voltage
= RS780_VDDC_LEVEL_LOW
;
697 ps
->max_voltage
= RS780_VDDC_LEVEL_LOW
;
699 case ATOM_PPLIB_RS780_VOLTAGE_HIGH
:
700 ps
->min_voltage
= RS780_VDDC_LEVEL_HIGH
;
701 ps
->max_voltage
= RS780_VDDC_LEVEL_HIGH
;
703 case ATOM_PPLIB_RS780_VOLTAGE_VARIABLE
:
704 ps
->min_voltage
= RS780_VDDC_LEVEL_LOW
;
705 ps
->max_voltage
= RS780_VDDC_LEVEL_HIGH
;
708 ps
->flags
= le32_to_cpu(clock_info
->rs780
.ulFlags
);
710 if (rps
->class & ATOM_PPLIB_CLASSIFICATION_BOOT
) {
711 ps
->sclk_low
= rdev
->clock
.default_sclk
;
712 ps
->sclk_high
= rdev
->clock
.default_sclk
;
713 ps
->min_voltage
= RS780_VDDC_LEVEL_HIGH
;
714 ps
->max_voltage
= RS780_VDDC_LEVEL_HIGH
;
718 static int rs780_parse_power_table(struct radeon_device
*rdev
)
720 struct radeon_mode_info
*mode_info
= &rdev
->mode_info
;
721 struct _ATOM_PPLIB_NONCLOCK_INFO
*non_clock_info
;
722 union pplib_power_state
*power_state
;
724 union pplib_clock_info
*clock_info
;
725 union power_info
*power_info
;
726 int index
= GetIndexIntoMasterTable(DATA
, PowerPlayInfo
);
731 if (!atom_parse_data_header(mode_info
->atom_context
, index
, NULL
,
732 &frev
, &crev
, &data_offset
))
734 power_info
= (union power_info
*)(mode_info
->atom_context
->bios
+ data_offset
);
736 rdev
->pm
.dpm
.ps
= kzalloc(sizeof(struct radeon_ps
) *
737 power_info
->pplib
.ucNumStates
, GFP_KERNEL
);
738 if (!rdev
->pm
.dpm
.ps
)
740 rdev
->pm
.dpm
.platform_caps
= le32_to_cpu(power_info
->pplib
.ulPlatformCaps
);
741 rdev
->pm
.dpm
.backbias_response_time
= le16_to_cpu(power_info
->pplib
.usBackbiasTime
);
742 rdev
->pm
.dpm
.voltage_response_time
= le16_to_cpu(power_info
->pplib
.usVoltageTime
);
744 for (i
= 0; i
< power_info
->pplib
.ucNumStates
; i
++) {
745 power_state
= (union pplib_power_state
*)
746 (mode_info
->atom_context
->bios
+ data_offset
+
747 le16_to_cpu(power_info
->pplib
.usStateArrayOffset
) +
748 i
* power_info
->pplib
.ucStateEntrySize
);
749 non_clock_info
= (struct _ATOM_PPLIB_NONCLOCK_INFO
*)
750 (mode_info
->atom_context
->bios
+ data_offset
+
751 le16_to_cpu(power_info
->pplib
.usNonClockInfoArrayOffset
) +
752 (power_state
->v1
.ucNonClockStateIndex
*
753 power_info
->pplib
.ucNonClockSize
));
754 if (power_info
->pplib
.ucStateEntrySize
- 1) {
755 clock_info
= (union pplib_clock_info
*)
756 (mode_info
->atom_context
->bios
+ data_offset
+
757 le16_to_cpu(power_info
->pplib
.usClockInfoArrayOffset
) +
758 (power_state
->v1
.ucClockStateIndices
[0] *
759 power_info
->pplib
.ucClockInfoSize
));
760 ps
= kzalloc(sizeof(struct igp_ps
), GFP_KERNEL
);
762 kfree(rdev
->pm
.dpm
.ps
);
765 rdev
->pm
.dpm
.ps
[i
].ps_priv
= ps
;
766 rs780_parse_pplib_non_clock_info(rdev
, &rdev
->pm
.dpm
.ps
[i
],
768 power_info
->pplib
.ucNonClockSize
);
769 rs780_parse_pplib_clock_info(rdev
,
774 rdev
->pm
.dpm
.num_ps
= power_info
->pplib
.ucNumStates
;
778 int rs780_dpm_init(struct radeon_device
*rdev
)
780 struct igp_power_info
*pi
;
781 int index
= GetIndexIntoMasterTable(DATA
, IntegratedSystemInfo
);
782 union igp_info
*info
;
787 pi
= kzalloc(sizeof(struct igp_power_info
), GFP_KERNEL
);
790 rdev
->pm
.dpm
.priv
= pi
;
792 ret
= rs780_parse_power_table(rdev
);
796 pi
->voltage_control
= false;
797 pi
->gfx_clock_gating
= true;
799 if (atom_parse_data_header(rdev
->mode_info
.atom_context
, index
, NULL
,
800 &frev
, &crev
, &data_offset
)) {
801 info
= (union igp_info
*)(rdev
->mode_info
.atom_context
->bios
+ data_offset
);
803 /* Get various system informations from bios */
806 pi
->num_of_cycles_in_period
=
807 info
->info
.ucNumberOfCyclesInPeriod
;
808 pi
->num_of_cycles_in_period
|=
809 info
->info
.ucNumberOfCyclesInPeriodHi
<< 8;
810 pi
->invert_pwm_required
=
811 (pi
->num_of_cycles_in_period
& 0x8000) ? true : false;
812 pi
->boot_voltage
= info
->info
.ucStartingPWM_HighTime
;
813 pi
->max_voltage
= info
->info
.ucMaxNBVoltage
;
814 pi
->max_voltage
|= info
->info
.ucMaxNBVoltageHigh
<< 8;
815 pi
->min_voltage
= info
->info
.ucMinNBVoltage
;
816 pi
->min_voltage
|= info
->info
.ucMinNBVoltageHigh
<< 8;
817 pi
->inter_voltage_low
=
818 le16_to_cpu(info
->info
.usInterNBVoltageLow
);
819 pi
->inter_voltage_high
=
820 le16_to_cpu(info
->info
.usInterNBVoltageHigh
);
821 pi
->voltage_control
= true;
822 pi
->bootup_uma_clk
= info
->info
.usK8MemoryClock
* 100;
825 pi
->num_of_cycles_in_period
=
826 le16_to_cpu(info
->info_2
.usNumberOfCyclesInPeriod
);
827 pi
->invert_pwm_required
=
828 (pi
->num_of_cycles_in_period
& 0x8000) ? true : false;
830 le16_to_cpu(info
->info_2
.usBootUpNBVoltage
);
832 le16_to_cpu(info
->info_2
.usMaxNBVoltage
);
834 le16_to_cpu(info
->info_2
.usMinNBVoltage
);
836 le32_to_cpu(info
->info_2
.ulSystemConfig
);
837 pi
->pwm_voltage_control
=
838 (pi
->system_config
& 0x4) ? true : false;
839 pi
->voltage_control
= true;
840 pi
->bootup_uma_clk
= le32_to_cpu(info
->info_2
.ulBootUpUMAClock
);
843 DRM_ERROR("No integrated system info for your GPU\n");
846 if (pi
->min_voltage
> pi
->max_voltage
)
847 pi
->voltage_control
= false;
848 if (pi
->pwm_voltage_control
) {
849 if ((pi
->num_of_cycles_in_period
== 0) ||
850 (pi
->max_voltage
== 0) ||
851 (pi
->min_voltage
== 0))
852 pi
->voltage_control
= false;
854 if ((pi
->num_of_cycles_in_period
== 0) ||
855 (pi
->max_voltage
== 0))
856 pi
->voltage_control
= false;
861 radeon_dpm_fini(rdev
);
865 void rs780_dpm_print_power_state(struct radeon_device
*rdev
,
866 struct radeon_ps
*rps
)
868 struct igp_ps
*ps
= rs780_get_ps(rps
);
870 r600_dpm_print_class_info(rps
->class, rps
->class2
);
871 r600_dpm_print_cap_info(rps
->caps
);
872 printk("\tuvd vclk: %d dclk: %d\n", rps
->vclk
, rps
->dclk
);
873 printk("\t\tpower level 0 sclk: %u vddc_index: %d\n",
874 ps
->sclk_low
, ps
->min_voltage
);
875 printk("\t\tpower level 1 sclk: %u vddc_index: %d\n",
876 ps
->sclk_high
, ps
->max_voltage
);
877 r600_dpm_print_ps_status(rdev
, rps
);
880 void rs780_dpm_fini(struct radeon_device
*rdev
)
884 for (i
= 0; i
< rdev
->pm
.dpm
.num_ps
; i
++) {
885 kfree(rdev
->pm
.dpm
.ps
[i
].ps_priv
);
887 kfree(rdev
->pm
.dpm
.ps
);
888 kfree(rdev
->pm
.dpm
.priv
);
891 u32
rs780_dpm_get_sclk(struct radeon_device
*rdev
, bool low
)
893 struct igp_ps
*requested_state
= rs780_get_ps(rdev
->pm
.dpm
.requested_ps
);
896 return requested_state
->sclk_low
;
898 return requested_state
->sclk_high
;
901 u32
rs780_dpm_get_mclk(struct radeon_device
*rdev
, bool low
)
903 struct igp_power_info
*pi
= rs780_get_pi(rdev
);
905 return pi
->bootup_uma_clk
;