2 * Copyright 2016 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.
24 #include <linux/delay.h>
26 #include <linux/module.h>
27 #include <linux/slab.h>
30 #include "amd_powerplay.h"
31 #include "vega10_smumgr.h"
32 #include "hardwaremanager.h"
33 #include "ppatomfwctrl.h"
34 #include "atomfirmware.h"
35 #include "cgs_common.h"
36 #include "vega10_powertune.h"
38 #include "smu9_driver_if.h"
39 #include "vega10_inc.h"
41 #include "pppcielanes.h"
42 #include "vega10_hwmgr.h"
43 #include "vega10_processpptables.h"
44 #include "vega10_pptable.h"
45 #include "vega10_thermal.h"
48 #include "amd_pcie_helpers.h"
49 #include "cgs_linux.h"
50 #include "ppinterrupt.h"
51 #include "pp_overdriver.h"
53 #define VOLTAGE_SCALE 4
54 #define VOLTAGE_VID_OFFSET_SCALE1 625
55 #define VOLTAGE_VID_OFFSET_SCALE2 100
57 #define HBM_MEMORY_CHANNEL_WIDTH 128
59 uint32_t channel_number[] = {1, 2, 0, 4, 0, 8, 0, 16, 2};
61 #define MEM_FREQ_LOW_LATENCY 25000
62 #define MEM_FREQ_HIGH_LATENCY 80000
63 #define MEM_LATENCY_HIGH 245
64 #define MEM_LATENCY_LOW 35
65 #define MEM_LATENCY_ERR 0xFFFF
67 #define mmDF_CS_AON0_DramBaseAddress0 0x0044
68 #define mmDF_CS_AON0_DramBaseAddress0_BASE_IDX 0
70 //DF_CS_AON0_DramBaseAddress0
71 #define DF_CS_AON0_DramBaseAddress0__AddrRngVal__SHIFT 0x0
72 #define DF_CS_AON0_DramBaseAddress0__LgcyMmioHoleEn__SHIFT 0x1
73 #define DF_CS_AON0_DramBaseAddress0__IntLvNumChan__SHIFT 0x4
74 #define DF_CS_AON0_DramBaseAddress0__IntLvAddrSel__SHIFT 0x8
75 #define DF_CS_AON0_DramBaseAddress0__DramBaseAddr__SHIFT 0xc
76 #define DF_CS_AON0_DramBaseAddress0__AddrRngVal_MASK 0x00000001L
77 #define DF_CS_AON0_DramBaseAddress0__LgcyMmioHoleEn_MASK 0x00000002L
78 #define DF_CS_AON0_DramBaseAddress0__IntLvNumChan_MASK 0x000000F0L
79 #define DF_CS_AON0_DramBaseAddress0__IntLvAddrSel_MASK 0x00000700L
80 #define DF_CS_AON0_DramBaseAddress0__DramBaseAddr_MASK 0xFFFFF000L
82 const ULONG PhwVega10_Magic = (ULONG)(PHM_VIslands_Magic);
84 struct vega10_power_state *cast_phw_vega10_power_state(
85 struct pp_hw_power_state *hw_ps)
87 PP_ASSERT_WITH_CODE((PhwVega10_Magic == hw_ps->magic),
88 "Invalid Powerstate Type!",
91 return (struct vega10_power_state *)hw_ps;
94 const struct vega10_power_state *cast_const_phw_vega10_power_state(
95 const struct pp_hw_power_state *hw_ps)
97 PP_ASSERT_WITH_CODE((PhwVega10_Magic == hw_ps->magic),
98 "Invalid Powerstate Type!",
101 return (const struct vega10_power_state *)hw_ps;
104 static void vega10_set_default_registry_data(struct pp_hwmgr *hwmgr)
106 struct vega10_hwmgr *data =
107 (struct vega10_hwmgr *)(hwmgr->backend);
109 data->registry_data.sclk_dpm_key_disabled =
110 hwmgr->feature_mask & PP_SCLK_DPM_MASK ? false : true;
111 data->registry_data.socclk_dpm_key_disabled =
112 hwmgr->feature_mask & PP_SOCCLK_DPM_MASK ? false : true;
113 data->registry_data.mclk_dpm_key_disabled =
114 hwmgr->feature_mask & PP_MCLK_DPM_MASK ? false : true;
115 data->registry_data.pcie_dpm_key_disabled =
116 hwmgr->feature_mask & PP_PCIE_DPM_MASK ? false : true;
118 data->registry_data.dcefclk_dpm_key_disabled =
119 hwmgr->feature_mask & PP_DCEFCLK_DPM_MASK ? false : true;
121 if (hwmgr->feature_mask & PP_POWER_CONTAINMENT_MASK) {
122 data->registry_data.power_containment_support = 1;
123 data->registry_data.enable_pkg_pwr_tracking_feature = 1;
124 data->registry_data.enable_tdc_limit_feature = 1;
127 data->registry_data.clock_stretcher_support =
128 hwmgr->feature_mask & PP_CLOCK_STRETCH_MASK ? true : false;
130 data->registry_data.ulv_support =
131 hwmgr->feature_mask & PP_ULV_MASK ? true : false;
133 data->registry_data.sclk_deep_sleep_support =
134 hwmgr->feature_mask & PP_SCLK_DEEP_SLEEP_MASK ? true : false;
136 data->registry_data.disable_water_mark = 0;
138 data->registry_data.fan_control_support = 1;
139 data->registry_data.thermal_support = 1;
140 data->registry_data.fw_ctf_enabled = 1;
142 data->registry_data.avfs_support = 1;
143 data->registry_data.led_dpm_enabled = 1;
145 data->registry_data.vr0hot_enabled = 1;
146 data->registry_data.vr1hot_enabled = 1;
147 data->registry_data.regulator_hot_gpio_support = 1;
149 data->display_voltage_mode = PPVEGA10_VEGA10DISPLAYVOLTAGEMODE_DFLT;
150 data->dcef_clk_quad_eqn_a = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
151 data->dcef_clk_quad_eqn_b = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
152 data->dcef_clk_quad_eqn_c = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
153 data->disp_clk_quad_eqn_a = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
154 data->disp_clk_quad_eqn_b = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
155 data->disp_clk_quad_eqn_c = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
156 data->pixel_clk_quad_eqn_a = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
157 data->pixel_clk_quad_eqn_b = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
158 data->pixel_clk_quad_eqn_c = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
159 data->phy_clk_quad_eqn_a = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
160 data->phy_clk_quad_eqn_b = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
161 data->phy_clk_quad_eqn_c = PPREGKEY_VEGA10QUADRATICEQUATION_DFLT;
163 data->gfxclk_average_alpha = PPVEGA10_VEGA10GFXCLKAVERAGEALPHA_DFLT;
164 data->socclk_average_alpha = PPVEGA10_VEGA10SOCCLKAVERAGEALPHA_DFLT;
165 data->uclk_average_alpha = PPVEGA10_VEGA10UCLKCLKAVERAGEALPHA_DFLT;
166 data->gfx_activity_average_alpha = PPVEGA10_VEGA10GFXACTIVITYAVERAGEALPHA_DFLT;
169 static int vega10_set_features_platform_caps(struct pp_hwmgr *hwmgr)
171 struct vega10_hwmgr *data =
172 (struct vega10_hwmgr *)(hwmgr->backend);
173 struct phm_ppt_v2_information *table_info =
174 (struct phm_ppt_v2_information *)hwmgr->pptable;
175 struct cgs_system_info sys_info = {0};
178 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
179 PHM_PlatformCaps_SclkDeepSleep);
181 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
182 PHM_PlatformCaps_DynamicPatchPowerState);
184 if (data->vddci_control == VEGA10_VOLTAGE_CONTROL_NONE)
185 phm_cap_unset(hwmgr->platform_descriptor.platformCaps,
186 PHM_PlatformCaps_ControlVDDCI);
188 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
189 PHM_PlatformCaps_TablelessHardwareInterface);
191 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
192 PHM_PlatformCaps_EnableSMU7ThermalManagement);
194 sys_info.size = sizeof(struct cgs_system_info);
195 sys_info.info_id = CGS_SYSTEM_INFO_PG_FLAGS;
196 result = cgs_query_system_info(hwmgr->device, &sys_info);
198 if (!result && (sys_info.value & AMD_PG_SUPPORT_UVD))
199 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
200 PHM_PlatformCaps_UVDPowerGating);
202 if (!result && (sys_info.value & AMD_PG_SUPPORT_VCE))
203 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
204 PHM_PlatformCaps_VCEPowerGating);
206 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
207 PHM_PlatformCaps_UnTabledHardwareInterface);
209 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
210 PHM_PlatformCaps_FanSpeedInTableIsRPM);
212 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
213 PHM_PlatformCaps_ODFuzzyFanControlSupport);
215 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
216 PHM_PlatformCaps_DynamicPowerManagement);
218 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
219 PHM_PlatformCaps_SMC);
221 /* power tune caps */
222 /* assume disabled */
223 phm_cap_unset(hwmgr->platform_descriptor.platformCaps,
224 PHM_PlatformCaps_PowerContainment);
225 phm_cap_unset(hwmgr->platform_descriptor.platformCaps,
226 PHM_PlatformCaps_SQRamping);
227 phm_cap_unset(hwmgr->platform_descriptor.platformCaps,
228 PHM_PlatformCaps_DBRamping);
229 phm_cap_unset(hwmgr->platform_descriptor.platformCaps,
230 PHM_PlatformCaps_TDRamping);
231 phm_cap_unset(hwmgr->platform_descriptor.platformCaps,
232 PHM_PlatformCaps_TCPRamping);
234 if (data->registry_data.power_containment_support)
235 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
236 PHM_PlatformCaps_PowerContainment);
237 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
238 PHM_PlatformCaps_CAC);
240 if (table_info->tdp_table->usClockStretchAmount &&
241 data->registry_data.clock_stretcher_support)
242 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
243 PHM_PlatformCaps_ClockStretcher);
245 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
246 PHM_PlatformCaps_RegulatorHot);
247 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
248 PHM_PlatformCaps_AutomaticDCTransition);
250 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
251 PHM_PlatformCaps_UVDDPM);
252 phm_cap_set(hwmgr->platform_descriptor.platformCaps,
253 PHM_PlatformCaps_VCEDPM);
258 static void vega10_init_dpm_defaults(struct pp_hwmgr *hwmgr)
260 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
263 vega10_initialize_power_tune_defaults(hwmgr);
265 for (i = 0; i < GNLD_FEATURES_MAX; i++) {
266 data->smu_features[i].smu_feature_id = 0xffff;
267 data->smu_features[i].smu_feature_bitmap = 1 << i;
268 data->smu_features[i].enabled = false;
269 data->smu_features[i].supported = false;
272 data->smu_features[GNLD_DPM_PREFETCHER].smu_feature_id =
273 FEATURE_DPM_PREFETCHER_BIT;
274 data->smu_features[GNLD_DPM_GFXCLK].smu_feature_id =
275 FEATURE_DPM_GFXCLK_BIT;
276 data->smu_features[GNLD_DPM_UCLK].smu_feature_id =
277 FEATURE_DPM_UCLK_BIT;
278 data->smu_features[GNLD_DPM_SOCCLK].smu_feature_id =
279 FEATURE_DPM_SOCCLK_BIT;
280 data->smu_features[GNLD_DPM_UVD].smu_feature_id =
282 data->smu_features[GNLD_DPM_VCE].smu_feature_id =
284 data->smu_features[GNLD_DPM_MP0CLK].smu_feature_id =
285 FEATURE_DPM_MP0CLK_BIT;
286 data->smu_features[GNLD_DPM_LINK].smu_feature_id =
287 FEATURE_DPM_LINK_BIT;
288 data->smu_features[GNLD_DPM_DCEFCLK].smu_feature_id =
289 FEATURE_DPM_DCEFCLK_BIT;
290 data->smu_features[GNLD_ULV].smu_feature_id =
292 data->smu_features[GNLD_AVFS].smu_feature_id =
294 data->smu_features[GNLD_DS_GFXCLK].smu_feature_id =
295 FEATURE_DS_GFXCLK_BIT;
296 data->smu_features[GNLD_DS_SOCCLK].smu_feature_id =
297 FEATURE_DS_SOCCLK_BIT;
298 data->smu_features[GNLD_DS_LCLK].smu_feature_id =
300 data->smu_features[GNLD_PPT].smu_feature_id =
302 data->smu_features[GNLD_TDC].smu_feature_id =
304 data->smu_features[GNLD_THERMAL].smu_feature_id =
306 data->smu_features[GNLD_GFX_PER_CU_CG].smu_feature_id =
307 FEATURE_GFX_PER_CU_CG_BIT;
308 data->smu_features[GNLD_RM].smu_feature_id =
310 data->smu_features[GNLD_DS_DCEFCLK].smu_feature_id =
311 FEATURE_DS_DCEFCLK_BIT;
312 data->smu_features[GNLD_ACDC].smu_feature_id =
314 data->smu_features[GNLD_VR0HOT].smu_feature_id =
316 data->smu_features[GNLD_VR1HOT].smu_feature_id =
318 data->smu_features[GNLD_FW_CTF].smu_feature_id =
320 data->smu_features[GNLD_LED_DISPLAY].smu_feature_id =
321 FEATURE_LED_DISPLAY_BIT;
322 data->smu_features[GNLD_FAN_CONTROL].smu_feature_id =
323 FEATURE_FAN_CONTROL_BIT;
324 data->smu_features[GNLD_VOLTAGE_CONTROLLER].smu_feature_id =
325 FEATURE_VOLTAGE_CONTROLLER_BIT;
327 if (!data->registry_data.prefetcher_dpm_key_disabled)
328 data->smu_features[GNLD_DPM_PREFETCHER].supported = true;
330 if (!data->registry_data.sclk_dpm_key_disabled)
331 data->smu_features[GNLD_DPM_GFXCLK].supported = true;
333 if (!data->registry_data.mclk_dpm_key_disabled)
334 data->smu_features[GNLD_DPM_UCLK].supported = true;
336 if (!data->registry_data.socclk_dpm_key_disabled)
337 data->smu_features[GNLD_DPM_SOCCLK].supported = true;
339 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
340 PHM_PlatformCaps_UVDDPM))
341 data->smu_features[GNLD_DPM_UVD].supported = true;
343 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
344 PHM_PlatformCaps_VCEDPM))
345 data->smu_features[GNLD_DPM_VCE].supported = true;
347 if (!data->registry_data.pcie_dpm_key_disabled)
348 data->smu_features[GNLD_DPM_LINK].supported = true;
350 if (!data->registry_data.dcefclk_dpm_key_disabled)
351 data->smu_features[GNLD_DPM_DCEFCLK].supported = true;
353 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
354 PHM_PlatformCaps_SclkDeepSleep) &&
355 data->registry_data.sclk_deep_sleep_support) {
356 data->smu_features[GNLD_DS_GFXCLK].supported = true;
357 data->smu_features[GNLD_DS_SOCCLK].supported = true;
358 data->smu_features[GNLD_DS_LCLK].supported = true;
359 data->smu_features[GNLD_DS_DCEFCLK].supported = true;
362 if (data->registry_data.enable_pkg_pwr_tracking_feature)
363 data->smu_features[GNLD_PPT].supported = true;
365 if (data->registry_data.enable_tdc_limit_feature)
366 data->smu_features[GNLD_TDC].supported = true;
368 if (data->registry_data.thermal_support)
369 data->smu_features[GNLD_THERMAL].supported = true;
371 if (data->registry_data.fan_control_support)
372 data->smu_features[GNLD_FAN_CONTROL].supported = true;
374 if (data->registry_data.fw_ctf_enabled)
375 data->smu_features[GNLD_FW_CTF].supported = true;
377 if (data->registry_data.avfs_support)
378 data->smu_features[GNLD_AVFS].supported = true;
380 if (data->registry_data.led_dpm_enabled)
381 data->smu_features[GNLD_LED_DISPLAY].supported = true;
383 if (data->registry_data.vr1hot_enabled)
384 data->smu_features[GNLD_VR1HOT].supported = true;
386 if (data->registry_data.vr0hot_enabled)
387 data->smu_features[GNLD_VR0HOT].supported = true;
391 #ifdef PPLIB_VEGA10_EVV_SUPPORT
392 static int vega10_get_socclk_for_voltage_evv(struct pp_hwmgr *hwmgr,
393 phm_ppt_v1_voltage_lookup_table *lookup_table,
394 uint16_t virtual_voltage_id, int32_t *socclk)
398 struct phm_ppt_v2_information *table_info =
399 (struct phm_ppt_v2_information *)(hwmgr->pptable);
401 PP_ASSERT_WITH_CODE(lookup_table->count != 0,
402 "Lookup table is empty",
405 /* search for leakage voltage ID 0xff01 ~ 0xff08 and sclk */
406 for (entry_id = 0; entry_id < table_info->vdd_dep_on_sclk->count; entry_id++) {
407 voltage_id = table_info->vdd_dep_on_socclk->entries[entry_id].vddInd;
408 if (lookup_table->entries[voltage_id].us_vdd == virtual_voltage_id)
412 PP_ASSERT_WITH_CODE(entry_id < table_info->vdd_dep_on_socclk->count,
413 "Can't find requested voltage id in vdd_dep_on_socclk table!",
416 *socclk = table_info->vdd_dep_on_socclk->entries[entry_id].clk;
421 #define ATOM_VIRTUAL_VOLTAGE_ID0 0xff01
423 * Get Leakage VDDC based on leakage ID.
425 * @param hwmgr the address of the powerplay hardware manager.
428 static int vega10_get_evv_voltages(struct pp_hwmgr *hwmgr)
430 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
435 struct phm_ppt_v2_information *table_info =
436 (struct phm_ppt_v2_information *)hwmgr->pptable;
437 struct phm_ppt_v1_clock_voltage_dependency_table *socclk_table =
438 table_info->vdd_dep_on_socclk;
441 for (i = 0; i < VEGA10_MAX_LEAKAGE_COUNT; i++) {
442 vv_id = ATOM_VIRTUAL_VOLTAGE_ID0 + i;
444 if (!vega10_get_socclk_for_voltage_evv(hwmgr,
445 table_info->vddc_lookup_table, vv_id, &sclk)) {
446 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
447 PHM_PlatformCaps_ClockStretcher)) {
448 for (j = 1; j < socclk_table->count; j++) {
449 if (socclk_table->entries[j].clk == sclk &&
450 socclk_table->entries[j].cks_enable == 0) {
457 PP_ASSERT_WITH_CODE(!atomctrl_get_voltage_evv_on_sclk_ai(hwmgr,
458 VOLTAGE_TYPE_VDDC, sclk, vv_id, &vddc),
459 "Error retrieving EVV voltage value!",
463 /* need to make sure vddc is less than 2v or else, it could burn the ASIC. */
464 PP_ASSERT_WITH_CODE((vddc < 2000 && vddc != 0),
465 "Invalid VDDC value", result = -EINVAL;);
467 /* the voltage should not be zero nor equal to leakage ID */
468 if (vddc != 0 && vddc != vv_id) {
469 data->vddc_leakage.actual_voltage[data->vddc_leakage.count] = (uint16_t)(vddc/100);
470 data->vddc_leakage.leakage_id[data->vddc_leakage.count] = vv_id;
471 data->vddc_leakage.count++;
480 * Change virtual leakage voltage to actual value.
482 * @param hwmgr the address of the powerplay hardware manager.
483 * @param pointer to changing voltage
484 * @param pointer to leakage table
486 static void vega10_patch_with_vdd_leakage(struct pp_hwmgr *hwmgr,
487 uint16_t *voltage, struct vega10_leakage_voltage *leakage_table)
491 /* search for leakage voltage ID 0xff01 ~ 0xff08 */
492 for (index = 0; index < leakage_table->count; index++) {
493 /* if this voltage matches a leakage voltage ID */
494 /* patch with actual leakage voltage */
495 if (leakage_table->leakage_id[index] == *voltage) {
496 *voltage = leakage_table->actual_voltage[index];
501 if (*voltage > ATOM_VIRTUAL_VOLTAGE_ID0)
502 pr_info("Voltage value looks like a Leakage ID \
503 but it's not patched\n");
507 * Patch voltage lookup table by EVV leakages.
509 * @param hwmgr the address of the powerplay hardware manager.
510 * @param pointer to voltage lookup table
511 * @param pointer to leakage table
514 static int vega10_patch_lookup_table_with_leakage(struct pp_hwmgr *hwmgr,
515 phm_ppt_v1_voltage_lookup_table *lookup_table,
516 struct vega10_leakage_voltage *leakage_table)
520 for (i = 0; i < lookup_table->count; i++)
521 vega10_patch_with_vdd_leakage(hwmgr,
522 &lookup_table->entries[i].us_vdd, leakage_table);
527 static int vega10_patch_clock_voltage_limits_with_vddc_leakage(
528 struct pp_hwmgr *hwmgr, struct vega10_leakage_voltage *leakage_table,
531 vega10_patch_with_vdd_leakage(hwmgr, (uint16_t *)vddc, leakage_table);
537 static int vega10_patch_voltage_dependency_tables_with_lookup_table(
538 struct pp_hwmgr *hwmgr)
542 struct phm_ppt_v2_information *table_info =
543 (struct phm_ppt_v2_information *)(hwmgr->pptable);
544 struct phm_ppt_v1_clock_voltage_dependency_table *socclk_table =
545 table_info->vdd_dep_on_socclk;
546 struct phm_ppt_v1_clock_voltage_dependency_table *gfxclk_table =
547 table_info->vdd_dep_on_sclk;
548 struct phm_ppt_v1_clock_voltage_dependency_table *dcefclk_table =
549 table_info->vdd_dep_on_dcefclk;
550 struct phm_ppt_v1_clock_voltage_dependency_table *pixclk_table =
551 table_info->vdd_dep_on_pixclk;
552 struct phm_ppt_v1_clock_voltage_dependency_table *dspclk_table =
553 table_info->vdd_dep_on_dispclk;
554 struct phm_ppt_v1_clock_voltage_dependency_table *phyclk_table =
555 table_info->vdd_dep_on_phyclk;
556 struct phm_ppt_v1_clock_voltage_dependency_table *mclk_table =
557 table_info->vdd_dep_on_mclk;
558 struct phm_ppt_v1_mm_clock_voltage_dependency_table *mm_table =
559 table_info->mm_dep_table;
561 for (entry_id = 0; entry_id < socclk_table->count; entry_id++) {
562 voltage_id = socclk_table->entries[entry_id].vddInd;
563 socclk_table->entries[entry_id].vddc =
564 table_info->vddc_lookup_table->entries[voltage_id].us_vdd;
567 for (entry_id = 0; entry_id < gfxclk_table->count; entry_id++) {
568 voltage_id = gfxclk_table->entries[entry_id].vddInd;
569 gfxclk_table->entries[entry_id].vddc =
570 table_info->vddc_lookup_table->entries[voltage_id].us_vdd;
573 for (entry_id = 0; entry_id < dcefclk_table->count; entry_id++) {
574 voltage_id = dcefclk_table->entries[entry_id].vddInd;
575 dcefclk_table->entries[entry_id].vddc =
576 table_info->vddc_lookup_table->entries[voltage_id].us_vdd;
579 for (entry_id = 0; entry_id < pixclk_table->count; entry_id++) {
580 voltage_id = pixclk_table->entries[entry_id].vddInd;
581 pixclk_table->entries[entry_id].vddc =
582 table_info->vddc_lookup_table->entries[voltage_id].us_vdd;
585 for (entry_id = 0; entry_id < dspclk_table->count; entry_id++) {
586 voltage_id = dspclk_table->entries[entry_id].vddInd;
587 dspclk_table->entries[entry_id].vddc =
588 table_info->vddc_lookup_table->entries[voltage_id].us_vdd;
591 for (entry_id = 0; entry_id < phyclk_table->count; entry_id++) {
592 voltage_id = phyclk_table->entries[entry_id].vddInd;
593 phyclk_table->entries[entry_id].vddc =
594 table_info->vddc_lookup_table->entries[voltage_id].us_vdd;
597 for (entry_id = 0; entry_id < mclk_table->count; ++entry_id) {
598 voltage_id = mclk_table->entries[entry_id].vddInd;
599 mclk_table->entries[entry_id].vddc =
600 table_info->vddc_lookup_table->entries[voltage_id].us_vdd;
601 voltage_id = mclk_table->entries[entry_id].vddciInd;
602 mclk_table->entries[entry_id].vddci =
603 table_info->vddci_lookup_table->entries[voltage_id].us_vdd;
604 voltage_id = mclk_table->entries[entry_id].mvddInd;
605 mclk_table->entries[entry_id].mvdd =
606 table_info->vddmem_lookup_table->entries[voltage_id].us_vdd;
609 for (entry_id = 0; entry_id < mm_table->count; ++entry_id) {
610 voltage_id = mm_table->entries[entry_id].vddcInd;
611 mm_table->entries[entry_id].vddc =
612 table_info->vddc_lookup_table->entries[voltage_id].us_vdd;
619 static int vega10_sort_lookup_table(struct pp_hwmgr *hwmgr,
620 struct phm_ppt_v1_voltage_lookup_table *lookup_table)
622 uint32_t table_size, i, j;
623 struct phm_ppt_v1_voltage_lookup_record tmp_voltage_lookup_record;
625 PP_ASSERT_WITH_CODE(lookup_table && lookup_table->count,
626 "Lookup table is empty", return -EINVAL);
628 table_size = lookup_table->count;
630 /* Sorting voltages */
631 for (i = 0; i < table_size - 1; i++) {
632 for (j = i + 1; j > 0; j--) {
633 if (lookup_table->entries[j].us_vdd <
634 lookup_table->entries[j - 1].us_vdd) {
635 tmp_voltage_lookup_record = lookup_table->entries[j - 1];
636 lookup_table->entries[j - 1] = lookup_table->entries[j];
637 lookup_table->entries[j] = tmp_voltage_lookup_record;
645 static int vega10_complete_dependency_tables(struct pp_hwmgr *hwmgr)
649 struct phm_ppt_v2_information *table_info =
650 (struct phm_ppt_v2_information *)(hwmgr->pptable);
651 #ifdef PPLIB_VEGA10_EVV_SUPPORT
652 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
654 tmp_result = vega10_patch_lookup_table_with_leakage(hwmgr,
655 table_info->vddc_lookup_table, &(data->vddc_leakage));
659 tmp_result = vega10_patch_clock_voltage_limits_with_vddc_leakage(hwmgr,
660 &(data->vddc_leakage), &table_info->max_clock_voltage_on_dc.vddc);
665 tmp_result = vega10_patch_voltage_dependency_tables_with_lookup_table(hwmgr);
669 tmp_result = vega10_sort_lookup_table(hwmgr, table_info->vddc_lookup_table);
676 static int vega10_set_private_data_based_on_pptable(struct pp_hwmgr *hwmgr)
678 struct phm_ppt_v2_information *table_info =
679 (struct phm_ppt_v2_information *)(hwmgr->pptable);
680 struct phm_ppt_v1_clock_voltage_dependency_table *allowed_sclk_vdd_table =
681 table_info->vdd_dep_on_socclk;
682 struct phm_ppt_v1_clock_voltage_dependency_table *allowed_mclk_vdd_table =
683 table_info->vdd_dep_on_mclk;
685 PP_ASSERT_WITH_CODE(allowed_sclk_vdd_table,
686 "VDD dependency on SCLK table is missing. \
687 This table is mandatory", return -EINVAL);
688 PP_ASSERT_WITH_CODE(allowed_sclk_vdd_table->count >= 1,
689 "VDD dependency on SCLK table is empty. \
690 This table is mandatory", return -EINVAL);
692 PP_ASSERT_WITH_CODE(allowed_mclk_vdd_table,
693 "VDD dependency on MCLK table is missing. \
694 This table is mandatory", return -EINVAL);
695 PP_ASSERT_WITH_CODE(allowed_mclk_vdd_table->count >= 1,
696 "VDD dependency on MCLK table is empty. \
697 This table is mandatory", return -EINVAL);
699 table_info->max_clock_voltage_on_ac.sclk =
700 allowed_sclk_vdd_table->entries[allowed_sclk_vdd_table->count - 1].clk;
701 table_info->max_clock_voltage_on_ac.mclk =
702 allowed_mclk_vdd_table->entries[allowed_mclk_vdd_table->count - 1].clk;
703 table_info->max_clock_voltage_on_ac.vddc =
704 allowed_sclk_vdd_table->entries[allowed_sclk_vdd_table->count - 1].vddc;
705 table_info->max_clock_voltage_on_ac.vddci =
706 allowed_mclk_vdd_table->entries[allowed_mclk_vdd_table->count - 1].vddci;
708 hwmgr->dyn_state.max_clock_voltage_on_ac.sclk =
709 table_info->max_clock_voltage_on_ac.sclk;
710 hwmgr->dyn_state.max_clock_voltage_on_ac.mclk =
711 table_info->max_clock_voltage_on_ac.mclk;
712 hwmgr->dyn_state.max_clock_voltage_on_ac.vddc =
713 table_info->max_clock_voltage_on_ac.vddc;
714 hwmgr->dyn_state.max_clock_voltage_on_ac.vddci =
715 table_info->max_clock_voltage_on_ac.vddci;
720 static int vega10_hwmgr_backend_fini(struct pp_hwmgr *hwmgr)
722 kfree(hwmgr->dyn_state.vddc_dep_on_dal_pwrl);
723 hwmgr->dyn_state.vddc_dep_on_dal_pwrl = NULL;
725 kfree(hwmgr->backend);
726 hwmgr->backend = NULL;
731 static int vega10_hwmgr_backend_init(struct pp_hwmgr *hwmgr)
734 struct vega10_hwmgr *data;
735 uint32_t config_telemetry = 0;
736 struct pp_atomfwctrl_voltage_table vol_table;
737 struct cgs_system_info sys_info = {0};
739 data = kzalloc(sizeof(struct vega10_hwmgr), GFP_KERNEL);
743 hwmgr->backend = data;
745 vega10_set_default_registry_data(hwmgr);
747 data->disable_dpm_mask = 0xff;
748 data->workload_mask = 0xff;
750 /* need to set voltage control types before EVV patching */
751 data->vddc_control = VEGA10_VOLTAGE_CONTROL_NONE;
752 data->mvdd_control = VEGA10_VOLTAGE_CONTROL_NONE;
753 data->vddci_control = VEGA10_VOLTAGE_CONTROL_NONE;
756 if (pp_atomfwctrl_is_voltage_controlled_by_gpio_v4(hwmgr,
757 VOLTAGE_TYPE_VDDC, VOLTAGE_OBJ_SVID2)) {
758 if (!pp_atomfwctrl_get_voltage_table_v4(hwmgr,
759 VOLTAGE_TYPE_VDDC, VOLTAGE_OBJ_SVID2,
761 config_telemetry = ((vol_table.telemetry_slope << 8) & 0xff00) |
762 (vol_table.telemetry_offset & 0xff);
763 data->vddc_control = VEGA10_VOLTAGE_CONTROL_BY_SVID2;
766 kfree(hwmgr->backend);
767 hwmgr->backend = NULL;
768 PP_ASSERT_WITH_CODE(false,
769 "VDDCR_SOC is not SVID2!",
774 if (pp_atomfwctrl_is_voltage_controlled_by_gpio_v4(hwmgr,
775 VOLTAGE_TYPE_MVDDC, VOLTAGE_OBJ_SVID2)) {
776 if (!pp_atomfwctrl_get_voltage_table_v4(hwmgr,
777 VOLTAGE_TYPE_MVDDC, VOLTAGE_OBJ_SVID2,
780 ((vol_table.telemetry_slope << 24) & 0xff000000) |
781 ((vol_table.telemetry_offset << 16) & 0xff0000);
782 data->mvdd_control = VEGA10_VOLTAGE_CONTROL_BY_SVID2;
787 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
788 PHM_PlatformCaps_ControlVDDCI)) {
789 if (pp_atomfwctrl_is_voltage_controlled_by_gpio_v4(hwmgr,
790 VOLTAGE_TYPE_VDDCI, VOLTAGE_OBJ_GPIO_LUT))
791 data->vddci_control = VEGA10_VOLTAGE_CONTROL_BY_GPIO;
794 data->config_telemetry = config_telemetry;
796 vega10_set_features_platform_caps(hwmgr);
798 vega10_init_dpm_defaults(hwmgr);
800 #ifdef PPLIB_VEGA10_EVV_SUPPORT
801 /* Get leakage voltage based on leakage ID. */
802 PP_ASSERT_WITH_CODE(!vega10_get_evv_voltages(hwmgr),
803 "Get EVV Voltage Failed. Abort Driver loading!",
807 /* Patch our voltage dependency table with actual leakage voltage
808 * We need to perform leakage translation before it's used by other functions
810 vega10_complete_dependency_tables(hwmgr);
812 /* Parse pptable data read from VBIOS */
813 vega10_set_private_data_based_on_pptable(hwmgr);
815 data->is_tlu_enabled = false;
817 hwmgr->platform_descriptor.hardwareActivityPerformanceLevels =
818 VEGA10_MAX_HARDWARE_POWERLEVELS;
819 hwmgr->platform_descriptor.hardwarePerformanceLevels = 2;
820 hwmgr->platform_descriptor.minimumClocksReductionPercentage = 50;
822 hwmgr->platform_descriptor.vbiosInterruptId = 0x20000400; /* IRQ_SOURCE1_SW_INT */
823 /* The true clock step depends on the frequency, typically 4.5 or 9 MHz. Here we use 5. */
824 hwmgr->platform_descriptor.clockStep.engineClock = 500;
825 hwmgr->platform_descriptor.clockStep.memoryClock = 500;
827 sys_info.size = sizeof(struct cgs_system_info);
828 sys_info.info_id = CGS_SYSTEM_INFO_GFX_CU_INFO;
829 result = cgs_query_system_info(hwmgr->device, &sys_info);
830 data->total_active_cus = sys_info.value;
831 /* Setup default Overdrive Fan control settings */
832 data->odn_fan_table.target_fan_speed =
833 hwmgr->thermal_controller.advanceFanControlParameters.usMaxFanRPM;
834 data->odn_fan_table.target_temperature =
835 hwmgr->thermal_controller.
836 advanceFanControlParameters.ucTargetTemperature;
837 data->odn_fan_table.min_performance_clock =
838 hwmgr->thermal_controller.advanceFanControlParameters.
839 ulMinFanSCLKAcousticLimit;
840 data->odn_fan_table.min_fan_limit =
841 hwmgr->thermal_controller.
842 advanceFanControlParameters.usFanPWMMinLimit *
843 hwmgr->thermal_controller.fanInfo.ulMaxRPM / 100;
848 static int vega10_init_sclk_threshold(struct pp_hwmgr *hwmgr)
850 struct vega10_hwmgr *data =
851 (struct vega10_hwmgr *)(hwmgr->backend);
853 data->low_sclk_interrupt_threshold = 0;
858 static int vega10_setup_dpm_led_config(struct pp_hwmgr *hwmgr)
860 struct vega10_hwmgr *data =
861 (struct vega10_hwmgr *)(hwmgr->backend);
862 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
864 struct pp_atomfwctrl_voltage_table table;
870 ret = pp_atomfwctrl_get_voltage_table_v4(hwmgr, VOLTAGE_TYPE_LEDDPM,
871 VOLTAGE_OBJ_GPIO_LUT, &table);
874 tmp = table.mask_low;
875 for (i = 0, j = 0; i < 32; i++) {
877 mask |= (uint32_t)(i << (8 * j));
885 pp_table->LedPin0 = (uint8_t)(mask & 0xff);
886 pp_table->LedPin1 = (uint8_t)((mask >> 8) & 0xff);
887 pp_table->LedPin2 = (uint8_t)((mask >> 16) & 0xff);
891 static int vega10_setup_asic_task(struct pp_hwmgr *hwmgr)
893 PP_ASSERT_WITH_CODE(!vega10_init_sclk_threshold(hwmgr),
894 "Failed to init sclk threshold!",
897 PP_ASSERT_WITH_CODE(!vega10_setup_dpm_led_config(hwmgr),
898 "Failed to set up led dpm config!",
904 static bool vega10_is_dpm_running(struct pp_hwmgr *hwmgr)
906 uint32_t features_enabled;
908 if (!vega10_get_smc_features(hwmgr->smumgr, &features_enabled)) {
909 if (features_enabled & SMC_DPM_FEATURES)
916 * Remove repeated voltage values and create table with unique values.
918 * @param hwmgr the address of the powerplay hardware manager.
919 * @param vol_table the pointer to changing voltage table
920 * @return 0 in success
923 static int vega10_trim_voltage_table(struct pp_hwmgr *hwmgr,
924 struct pp_atomfwctrl_voltage_table *vol_table)
929 struct pp_atomfwctrl_voltage_table *table;
931 PP_ASSERT_WITH_CODE(vol_table,
932 "Voltage Table empty.", return -EINVAL);
933 table = kzalloc(sizeof(struct pp_atomfwctrl_voltage_table),
939 table->mask_low = vol_table->mask_low;
940 table->phase_delay = vol_table->phase_delay;
942 for (i = 0; i < vol_table->count; i++) {
943 vvalue = vol_table->entries[i].value;
946 for (j = 0; j < table->count; j++) {
947 if (vvalue == table->entries[j].value) {
954 table->entries[table->count].value = vvalue;
955 table->entries[table->count].smio_low =
956 vol_table->entries[i].smio_low;
961 memcpy(vol_table, table, sizeof(struct pp_atomfwctrl_voltage_table));
967 static int vega10_get_mvdd_voltage_table(struct pp_hwmgr *hwmgr,
968 phm_ppt_v1_clock_voltage_dependency_table *dep_table,
969 struct pp_atomfwctrl_voltage_table *vol_table)
973 PP_ASSERT_WITH_CODE(dep_table->count,
974 "Voltage Dependency Table empty.",
977 vol_table->mask_low = 0;
978 vol_table->phase_delay = 0;
979 vol_table->count = dep_table->count;
981 for (i = 0; i < vol_table->count; i++) {
982 vol_table->entries[i].value = dep_table->entries[i].mvdd;
983 vol_table->entries[i].smio_low = 0;
986 PP_ASSERT_WITH_CODE(!vega10_trim_voltage_table(hwmgr,
988 "Failed to trim MVDD Table!",
994 static int vega10_get_vddci_voltage_table(struct pp_hwmgr *hwmgr,
995 phm_ppt_v1_clock_voltage_dependency_table *dep_table,
996 struct pp_atomfwctrl_voltage_table *vol_table)
1000 PP_ASSERT_WITH_CODE(dep_table->count,
1001 "Voltage Dependency Table empty.",
1004 vol_table->mask_low = 0;
1005 vol_table->phase_delay = 0;
1006 vol_table->count = dep_table->count;
1008 for (i = 0; i < dep_table->count; i++) {
1009 vol_table->entries[i].value = dep_table->entries[i].vddci;
1010 vol_table->entries[i].smio_low = 0;
1013 PP_ASSERT_WITH_CODE(!vega10_trim_voltage_table(hwmgr, vol_table),
1014 "Failed to trim VDDCI table.",
1020 static int vega10_get_vdd_voltage_table(struct pp_hwmgr *hwmgr,
1021 phm_ppt_v1_clock_voltage_dependency_table *dep_table,
1022 struct pp_atomfwctrl_voltage_table *vol_table)
1026 PP_ASSERT_WITH_CODE(dep_table->count,
1027 "Voltage Dependency Table empty.",
1030 vol_table->mask_low = 0;
1031 vol_table->phase_delay = 0;
1032 vol_table->count = dep_table->count;
1034 for (i = 0; i < vol_table->count; i++) {
1035 vol_table->entries[i].value = dep_table->entries[i].vddc;
1036 vol_table->entries[i].smio_low = 0;
1042 /* ---- Voltage Tables ----
1043 * If the voltage table would be bigger than
1044 * what will fit into the state table on
1045 * the SMC keep only the higher entries.
1047 static void vega10_trim_voltage_table_to_fit_state_table(
1048 struct pp_hwmgr *hwmgr,
1049 uint32_t max_vol_steps,
1050 struct pp_atomfwctrl_voltage_table *vol_table)
1052 unsigned int i, diff;
1054 if (vol_table->count <= max_vol_steps)
1057 diff = vol_table->count - max_vol_steps;
1059 for (i = 0; i < max_vol_steps; i++)
1060 vol_table->entries[i] = vol_table->entries[i + diff];
1062 vol_table->count = max_vol_steps;
1066 * Create Voltage Tables.
1068 * @param hwmgr the address of the powerplay hardware manager.
1071 static int vega10_construct_voltage_tables(struct pp_hwmgr *hwmgr)
1073 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
1074 struct phm_ppt_v2_information *table_info =
1075 (struct phm_ppt_v2_information *)hwmgr->pptable;
1078 if (data->mvdd_control == VEGA10_VOLTAGE_CONTROL_BY_SVID2 ||
1079 data->mvdd_control == VEGA10_VOLTAGE_CONTROL_NONE) {
1080 result = vega10_get_mvdd_voltage_table(hwmgr,
1081 table_info->vdd_dep_on_mclk,
1082 &(data->mvdd_voltage_table));
1083 PP_ASSERT_WITH_CODE(!result,
1084 "Failed to retrieve MVDDC table!",
1088 if (data->vddci_control == VEGA10_VOLTAGE_CONTROL_NONE) {
1089 result = vega10_get_vddci_voltage_table(hwmgr,
1090 table_info->vdd_dep_on_mclk,
1091 &(data->vddci_voltage_table));
1092 PP_ASSERT_WITH_CODE(!result,
1093 "Failed to retrieve VDDCI_MEM table!",
1097 if (data->vddc_control == VEGA10_VOLTAGE_CONTROL_BY_SVID2 ||
1098 data->vddc_control == VEGA10_VOLTAGE_CONTROL_NONE) {
1099 result = vega10_get_vdd_voltage_table(hwmgr,
1100 table_info->vdd_dep_on_sclk,
1101 &(data->vddc_voltage_table));
1102 PP_ASSERT_WITH_CODE(!result,
1103 "Failed to retrieve VDDCR_SOC table!",
1107 PP_ASSERT_WITH_CODE(data->vddc_voltage_table.count <= 16,
1108 "Too many voltage values for VDDC. Trimming to fit state table.",
1109 vega10_trim_voltage_table_to_fit_state_table(hwmgr,
1110 16, &(data->vddc_voltage_table)));
1112 PP_ASSERT_WITH_CODE(data->vddci_voltage_table.count <= 16,
1113 "Too many voltage values for VDDCI. Trimming to fit state table.",
1114 vega10_trim_voltage_table_to_fit_state_table(hwmgr,
1115 16, &(data->vddci_voltage_table)));
1117 PP_ASSERT_WITH_CODE(data->mvdd_voltage_table.count <= 16,
1118 "Too many voltage values for MVDD. Trimming to fit state table.",
1119 vega10_trim_voltage_table_to_fit_state_table(hwmgr,
1120 16, &(data->mvdd_voltage_table)));
1127 * @fn vega10_init_dpm_state
1128 * @brief Function to initialize all Soft Min/Max and Hard Min/Max to 0xff.
1130 * @param dpm_state - the address of the DPM Table to initiailize.
1133 static void vega10_init_dpm_state(struct vega10_dpm_state *dpm_state)
1135 dpm_state->soft_min_level = 0xff;
1136 dpm_state->soft_max_level = 0xff;
1137 dpm_state->hard_min_level = 0xff;
1138 dpm_state->hard_max_level = 0xff;
1141 static void vega10_setup_default_single_dpm_table(struct pp_hwmgr *hwmgr,
1142 struct vega10_single_dpm_table *dpm_table,
1143 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table)
1147 for (i = 0; i < dep_table->count; i++) {
1148 if (i == 0 || dpm_table->dpm_levels[dpm_table->count - 1].value <=
1149 dep_table->entries[i].clk) {
1150 dpm_table->dpm_levels[dpm_table->count].value =
1151 dep_table->entries[i].clk;
1152 dpm_table->dpm_levels[dpm_table->count].enabled = true;
1157 static int vega10_setup_default_pcie_table(struct pp_hwmgr *hwmgr)
1159 struct vega10_hwmgr *data =
1160 (struct vega10_hwmgr *)(hwmgr->backend);
1161 struct vega10_pcie_table *pcie_table = &(data->dpm_table.pcie_table);
1162 struct phm_ppt_v2_information *table_info =
1163 (struct phm_ppt_v2_information *)(hwmgr->pptable);
1164 struct phm_ppt_v1_pcie_table *bios_pcie_table =
1165 table_info->pcie_table;
1168 PP_ASSERT_WITH_CODE(bios_pcie_table->count,
1169 "Incorrect number of PCIE States from VBIOS!",
1172 for (i = 0; i < NUM_LINK_LEVELS; i++) {
1173 if (data->registry_data.pcieSpeedOverride)
1174 pcie_table->pcie_gen[i] =
1175 data->registry_data.pcieSpeedOverride;
1177 pcie_table->pcie_gen[i] =
1178 bios_pcie_table->entries[i].gen_speed;
1180 if (data->registry_data.pcieLaneOverride)
1181 pcie_table->pcie_lane[i] = (uint8_t)encode_pcie_lane_width(
1182 data->registry_data.pcieLaneOverride);
1184 pcie_table->pcie_lane[i] = (uint8_t)encode_pcie_lane_width(
1185 bios_pcie_table->entries[i].lane_width);
1186 if (data->registry_data.pcieClockOverride)
1187 pcie_table->lclk[i] =
1188 data->registry_data.pcieClockOverride;
1190 pcie_table->lclk[i] =
1191 bios_pcie_table->entries[i].pcie_sclk;
1194 pcie_table->count = NUM_LINK_LEVELS;
1200 * This function is to initialize all DPM state tables
1201 * for SMU based on the dependency table.
1202 * Dynamic state patching function will then trim these
1203 * state tables to the allowed range based
1204 * on the power policy or external client requests,
1205 * such as UVD request, etc.
1207 static int vega10_setup_default_dpm_tables(struct pp_hwmgr *hwmgr)
1209 struct vega10_hwmgr *data =
1210 (struct vega10_hwmgr *)(hwmgr->backend);
1211 struct phm_ppt_v2_information *table_info =
1212 (struct phm_ppt_v2_information *)(hwmgr->pptable);
1213 struct vega10_single_dpm_table *dpm_table;
1216 struct phm_ppt_v1_clock_voltage_dependency_table *dep_soc_table =
1217 table_info->vdd_dep_on_socclk;
1218 struct phm_ppt_v1_clock_voltage_dependency_table *dep_gfx_table =
1219 table_info->vdd_dep_on_sclk;
1220 struct phm_ppt_v1_clock_voltage_dependency_table *dep_mclk_table =
1221 table_info->vdd_dep_on_mclk;
1222 struct phm_ppt_v1_mm_clock_voltage_dependency_table *dep_mm_table =
1223 table_info->mm_dep_table;
1224 struct phm_ppt_v1_clock_voltage_dependency_table *dep_dcef_table =
1225 table_info->vdd_dep_on_dcefclk;
1226 struct phm_ppt_v1_clock_voltage_dependency_table *dep_pix_table =
1227 table_info->vdd_dep_on_pixclk;
1228 struct phm_ppt_v1_clock_voltage_dependency_table *dep_disp_table =
1229 table_info->vdd_dep_on_dispclk;
1230 struct phm_ppt_v1_clock_voltage_dependency_table *dep_phy_table =
1231 table_info->vdd_dep_on_phyclk;
1233 PP_ASSERT_WITH_CODE(dep_soc_table,
1234 "SOCCLK dependency table is missing. This table is mandatory",
1236 PP_ASSERT_WITH_CODE(dep_soc_table->count >= 1,
1237 "SOCCLK dependency table is empty. This table is mandatory",
1240 PP_ASSERT_WITH_CODE(dep_gfx_table,
1241 "GFXCLK dependency table is missing. This table is mandatory",
1243 PP_ASSERT_WITH_CODE(dep_gfx_table->count >= 1,
1244 "GFXCLK dependency table is empty. This table is mandatory",
1247 PP_ASSERT_WITH_CODE(dep_mclk_table,
1248 "MCLK dependency table is missing. This table is mandatory",
1250 PP_ASSERT_WITH_CODE(dep_mclk_table->count >= 1,
1251 "MCLK dependency table has to have is missing. This table is mandatory",
1254 /* Initialize Sclk DPM table based on allow Sclk values */
1255 data->dpm_table.soc_table.count = 0;
1256 data->dpm_table.gfx_table.count = 0;
1257 data->dpm_table.dcef_table.count = 0;
1259 dpm_table = &(data->dpm_table.soc_table);
1260 vega10_setup_default_single_dpm_table(hwmgr,
1264 vega10_init_dpm_state(&(dpm_table->dpm_state));
1266 dpm_table = &(data->dpm_table.gfx_table);
1267 vega10_setup_default_single_dpm_table(hwmgr,
1270 vega10_init_dpm_state(&(dpm_table->dpm_state));
1272 /* Initialize Mclk DPM table based on allow Mclk values */
1273 data->dpm_table.mem_table.count = 0;
1274 dpm_table = &(data->dpm_table.mem_table);
1275 vega10_setup_default_single_dpm_table(hwmgr,
1278 vega10_init_dpm_state(&(dpm_table->dpm_state));
1280 data->dpm_table.eclk_table.count = 0;
1281 dpm_table = &(data->dpm_table.eclk_table);
1282 for (i = 0; i < dep_mm_table->count; i++) {
1283 if (i == 0 || dpm_table->dpm_levels
1284 [dpm_table->count - 1].value <=
1285 dep_mm_table->entries[i].eclk) {
1286 dpm_table->dpm_levels[dpm_table->count].value =
1287 dep_mm_table->entries[i].eclk;
1288 dpm_table->dpm_levels[dpm_table->count].enabled =
1289 (i == 0) ? true : false;
1293 vega10_init_dpm_state(&(dpm_table->dpm_state));
1295 data->dpm_table.vclk_table.count = 0;
1296 data->dpm_table.dclk_table.count = 0;
1297 dpm_table = &(data->dpm_table.vclk_table);
1298 for (i = 0; i < dep_mm_table->count; i++) {
1299 if (i == 0 || dpm_table->dpm_levels
1300 [dpm_table->count - 1].value <=
1301 dep_mm_table->entries[i].vclk) {
1302 dpm_table->dpm_levels[dpm_table->count].value =
1303 dep_mm_table->entries[i].vclk;
1304 dpm_table->dpm_levels[dpm_table->count].enabled =
1305 (i == 0) ? true : false;
1309 vega10_init_dpm_state(&(dpm_table->dpm_state));
1311 dpm_table = &(data->dpm_table.dclk_table);
1312 for (i = 0; i < dep_mm_table->count; i++) {
1313 if (i == 0 || dpm_table->dpm_levels
1314 [dpm_table->count - 1].value <=
1315 dep_mm_table->entries[i].dclk) {
1316 dpm_table->dpm_levels[dpm_table->count].value =
1317 dep_mm_table->entries[i].dclk;
1318 dpm_table->dpm_levels[dpm_table->count].enabled =
1319 (i == 0) ? true : false;
1323 vega10_init_dpm_state(&(dpm_table->dpm_state));
1325 /* Assume there is no headless Vega10 for now */
1326 dpm_table = &(data->dpm_table.dcef_table);
1327 vega10_setup_default_single_dpm_table(hwmgr,
1331 vega10_init_dpm_state(&(dpm_table->dpm_state));
1333 dpm_table = &(data->dpm_table.pixel_table);
1334 vega10_setup_default_single_dpm_table(hwmgr,
1338 vega10_init_dpm_state(&(dpm_table->dpm_state));
1340 dpm_table = &(data->dpm_table.display_table);
1341 vega10_setup_default_single_dpm_table(hwmgr,
1345 vega10_init_dpm_state(&(dpm_table->dpm_state));
1347 dpm_table = &(data->dpm_table.phy_table);
1348 vega10_setup_default_single_dpm_table(hwmgr,
1352 vega10_init_dpm_state(&(dpm_table->dpm_state));
1354 vega10_setup_default_pcie_table(hwmgr);
1356 /* save a copy of the default DPM table */
1357 memcpy(&(data->golden_dpm_table), &(data->dpm_table),
1358 sizeof(struct vega10_dpm_table));
1360 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
1361 PHM_PlatformCaps_ODNinACSupport) ||
1362 phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
1363 PHM_PlatformCaps_ODNinDCSupport)) {
1364 data->odn_dpm_table.odn_core_clock_dpm_levels.
1365 number_of_performance_levels = data->dpm_table.gfx_table.count;
1366 for (i = 0; i < data->dpm_table.gfx_table.count; i++) {
1367 data->odn_dpm_table.odn_core_clock_dpm_levels.
1368 performance_level_entries[i].clock =
1369 data->dpm_table.gfx_table.dpm_levels[i].value;
1370 data->odn_dpm_table.odn_core_clock_dpm_levels.
1371 performance_level_entries[i].enabled = true;
1374 data->odn_dpm_table.vdd_dependency_on_sclk.count =
1375 dep_gfx_table->count;
1376 for (i = 0; i < dep_gfx_table->count; i++) {
1377 data->odn_dpm_table.vdd_dependency_on_sclk.entries[i].clk =
1378 dep_gfx_table->entries[i].clk;
1379 data->odn_dpm_table.vdd_dependency_on_sclk.entries[i].vddInd =
1380 dep_gfx_table->entries[i].vddInd;
1381 data->odn_dpm_table.vdd_dependency_on_sclk.entries[i].cks_enable =
1382 dep_gfx_table->entries[i].cks_enable;
1383 data->odn_dpm_table.vdd_dependency_on_sclk.entries[i].cks_voffset =
1384 dep_gfx_table->entries[i].cks_voffset;
1387 data->odn_dpm_table.odn_memory_clock_dpm_levels.
1388 number_of_performance_levels = data->dpm_table.mem_table.count;
1389 for (i = 0; i < data->dpm_table.mem_table.count; i++) {
1390 data->odn_dpm_table.odn_memory_clock_dpm_levels.
1391 performance_level_entries[i].clock =
1392 data->dpm_table.mem_table.dpm_levels[i].value;
1393 data->odn_dpm_table.odn_memory_clock_dpm_levels.
1394 performance_level_entries[i].enabled = true;
1397 data->odn_dpm_table.vdd_dependency_on_mclk.count = dep_mclk_table->count;
1398 for (i = 0; i < dep_mclk_table->count; i++) {
1399 data->odn_dpm_table.vdd_dependency_on_mclk.entries[i].clk =
1400 dep_mclk_table->entries[i].clk;
1401 data->odn_dpm_table.vdd_dependency_on_mclk.entries[i].vddInd =
1402 dep_mclk_table->entries[i].vddInd;
1403 data->odn_dpm_table.vdd_dependency_on_mclk.entries[i].vddci =
1404 dep_mclk_table->entries[i].vddci;
1412 * @fn vega10_populate_ulv_state
1413 * @brief Function to provide parameters for Utral Low Voltage state to SMC.
1415 * @param hwmgr - the address of the hardware manager.
1418 static int vega10_populate_ulv_state(struct pp_hwmgr *hwmgr)
1420 struct vega10_hwmgr *data =
1421 (struct vega10_hwmgr *)(hwmgr->backend);
1422 struct phm_ppt_v2_information *table_info =
1423 (struct phm_ppt_v2_information *)(hwmgr->pptable);
1425 data->smc_state_table.pp_table.UlvOffsetVid =
1426 (uint8_t)table_info->us_ulv_voltage_offset;
1428 data->smc_state_table.pp_table.UlvSmnclkDid =
1429 (uint8_t)(table_info->us_ulv_smnclk_did);
1430 data->smc_state_table.pp_table.UlvMp1clkDid =
1431 (uint8_t)(table_info->us_ulv_mp1clk_did);
1432 data->smc_state_table.pp_table.UlvGfxclkBypass =
1433 (uint8_t)(table_info->us_ulv_gfxclk_bypass);
1434 data->smc_state_table.pp_table.UlvPhaseSheddingPsi0 =
1435 (uint8_t)(data->vddc_voltage_table.psi0_enable);
1436 data->smc_state_table.pp_table.UlvPhaseSheddingPsi1 =
1437 (uint8_t)(data->vddc_voltage_table.psi1_enable);
1442 static int vega10_populate_single_lclk_level(struct pp_hwmgr *hwmgr,
1443 uint32_t lclock, uint8_t *curr_lclk_did)
1445 struct pp_atomfwctrl_clock_dividers_soc15 dividers;
1447 PP_ASSERT_WITH_CODE(!pp_atomfwctrl_get_gpu_pll_dividers_vega10(
1449 COMPUTE_GPUCLK_INPUT_FLAG_DEFAULT_GPUCLK,
1451 "Failed to get LCLK clock settings from VBIOS!",
1454 *curr_lclk_did = dividers.ulDid;
1459 static int vega10_populate_smc_link_levels(struct pp_hwmgr *hwmgr)
1462 struct vega10_hwmgr *data =
1463 (struct vega10_hwmgr *)(hwmgr->backend);
1464 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
1465 struct vega10_pcie_table *pcie_table =
1466 &(data->dpm_table.pcie_table);
1469 for (i = 0; i < pcie_table->count; i++) {
1470 pp_table->PcieGenSpeed[i] = pcie_table->pcie_gen[i];
1471 pp_table->PcieLaneCount[i] = pcie_table->pcie_lane[i];
1473 result = vega10_populate_single_lclk_level(hwmgr,
1474 pcie_table->lclk[i], &(pp_table->LclkDid[i]));
1476 pr_info("Populate LClock Level %d Failed!\n", i);
1482 while (i < NUM_LINK_LEVELS) {
1483 pp_table->PcieGenSpeed[i] = pcie_table->pcie_gen[j];
1484 pp_table->PcieLaneCount[i] = pcie_table->pcie_lane[j];
1486 result = vega10_populate_single_lclk_level(hwmgr,
1487 pcie_table->lclk[j], &(pp_table->LclkDid[i]));
1489 pr_info("Populate LClock Level %d Failed!\n", i);
1499 * Populates single SMC GFXSCLK structure using the provided engine clock
1501 * @param hwmgr the address of the hardware manager
1502 * @param gfx_clock the GFX clock to use to populate the structure.
1503 * @param current_gfxclk_level location in PPTable for the SMC GFXCLK structure.
1506 static int vega10_populate_single_gfx_level(struct pp_hwmgr *hwmgr,
1507 uint32_t gfx_clock, PllSetting_t *current_gfxclk_level)
1509 struct phm_ppt_v2_information *table_info =
1510 (struct phm_ppt_v2_information *)(hwmgr->pptable);
1511 struct phm_ppt_v1_clock_voltage_dependency_table *dep_on_sclk =
1512 table_info->vdd_dep_on_sclk;
1513 struct vega10_hwmgr *data =
1514 (struct vega10_hwmgr *)(hwmgr->backend);
1515 struct pp_atomfwctrl_clock_dividers_soc15 dividers;
1516 uint32_t gfx_max_clock =
1517 hwmgr->platform_descriptor.overdriveLimit.engineClock;
1520 if (data->apply_overdrive_next_settings_mask &
1521 DPMTABLE_OD_UPDATE_VDDC)
1522 dep_on_sclk = (struct phm_ppt_v1_clock_voltage_dependency_table *)
1523 &(data->odn_dpm_table.vdd_dependency_on_sclk);
1525 PP_ASSERT_WITH_CODE(dep_on_sclk,
1526 "Invalid SOC_VDD-GFX_CLK Dependency Table!",
1529 if (data->need_update_dpm_table & DPMTABLE_OD_UPDATE_SCLK)
1530 gfx_clock = gfx_clock > gfx_max_clock ? gfx_max_clock : gfx_clock;
1532 for (i = 0; i < dep_on_sclk->count; i++) {
1533 if (dep_on_sclk->entries[i].clk == gfx_clock)
1536 PP_ASSERT_WITH_CODE(dep_on_sclk->count > i,
1537 "Cannot find gfx_clk in SOC_VDD-GFX_CLK!",
1541 PP_ASSERT_WITH_CODE(!pp_atomfwctrl_get_gpu_pll_dividers_vega10(hwmgr,
1542 COMPUTE_GPUCLK_INPUT_FLAG_GFXCLK,
1543 gfx_clock, ÷rs),
1544 "Failed to get GFX Clock settings from VBIOS!",
1547 /* Feedback Multiplier: bit 0:8 int, bit 15:12 post_div, bit 31:16 frac */
1548 current_gfxclk_level->FbMult =
1549 cpu_to_le32(dividers.ulPll_fb_mult);
1550 /* Spread FB Multiplier bit: bit 0:8 int, bit 31:16 frac */
1551 current_gfxclk_level->SsOn = dividers.ucPll_ss_enable;
1552 current_gfxclk_level->SsFbMult =
1553 cpu_to_le32(dividers.ulPll_ss_fbsmult);
1554 current_gfxclk_level->SsSlewFrac =
1555 cpu_to_le16(dividers.usPll_ss_slew_frac);
1556 current_gfxclk_level->Did = (uint8_t)(dividers.ulDid);
1562 * @brief Populates single SMC SOCCLK structure using the provided clock.
1564 * @param hwmgr - the address of the hardware manager.
1565 * @param soc_clock - the SOC clock to use to populate the structure.
1566 * @param current_socclk_level - location in PPTable for the SMC SOCCLK structure.
1567 * @return 0 on success..
1569 static int vega10_populate_single_soc_level(struct pp_hwmgr *hwmgr,
1570 uint32_t soc_clock, uint8_t *current_soc_did,
1571 uint8_t *current_vol_index)
1573 struct phm_ppt_v2_information *table_info =
1574 (struct phm_ppt_v2_information *)(hwmgr->pptable);
1575 struct phm_ppt_v1_clock_voltage_dependency_table *dep_on_soc =
1576 table_info->vdd_dep_on_socclk;
1577 struct pp_atomfwctrl_clock_dividers_soc15 dividers;
1580 PP_ASSERT_WITH_CODE(dep_on_soc,
1581 "Invalid SOC_VDD-SOC_CLK Dependency Table!",
1583 for (i = 0; i < dep_on_soc->count; i++) {
1584 if (dep_on_soc->entries[i].clk == soc_clock)
1587 PP_ASSERT_WITH_CODE(dep_on_soc->count > i,
1588 "Cannot find SOC_CLK in SOC_VDD-SOC_CLK Dependency Table",
1590 PP_ASSERT_WITH_CODE(!pp_atomfwctrl_get_gpu_pll_dividers_vega10(hwmgr,
1591 COMPUTE_GPUCLK_INPUT_FLAG_DEFAULT_GPUCLK,
1592 soc_clock, ÷rs),
1593 "Failed to get SOC Clock settings from VBIOS!",
1596 *current_soc_did = (uint8_t)dividers.ulDid;
1597 *current_vol_index = (uint8_t)(dep_on_soc->entries[i].vddInd);
1602 uint16_t vega10_locate_vddc_given_clock(struct pp_hwmgr *hwmgr,
1604 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table)
1608 for (i = 0; i < dep_table->count; i++) {
1609 if (dep_table->entries[i].clk == clk)
1610 return dep_table->entries[i].vddc;
1613 pr_info("[LocateVddcGivenClock] Cannot locate SOC Vddc for this clock!");
1618 * Populates all SMC SCLK levels' structure based on the trimmed allowed dpm engine clock states
1620 * @param hwmgr the address of the hardware manager
1622 static int vega10_populate_all_graphic_levels(struct pp_hwmgr *hwmgr)
1624 struct vega10_hwmgr *data =
1625 (struct vega10_hwmgr *)(hwmgr->backend);
1626 struct phm_ppt_v2_information *table_info =
1627 (struct phm_ppt_v2_information *)(hwmgr->pptable);
1628 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table =
1629 table_info->vdd_dep_on_socclk;
1630 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
1631 struct vega10_single_dpm_table *dpm_table = &(data->dpm_table.gfx_table);
1635 for (i = 0; i < dpm_table->count; i++) {
1636 result = vega10_populate_single_gfx_level(hwmgr,
1637 dpm_table->dpm_levels[i].value,
1638 &(pp_table->GfxclkLevel[i]));
1644 while (i < NUM_GFXCLK_DPM_LEVELS) {
1645 result = vega10_populate_single_gfx_level(hwmgr,
1646 dpm_table->dpm_levels[j].value,
1647 &(pp_table->GfxclkLevel[i]));
1653 pp_table->GfxclkSlewRate =
1654 cpu_to_le16(table_info->us_gfxclk_slew_rate);
1656 dpm_table = &(data->dpm_table.soc_table);
1657 for (i = 0; i < dpm_table->count; i++) {
1658 pp_table->SocVid[i] =
1659 (uint8_t)convert_to_vid(
1660 vega10_locate_vddc_given_clock(hwmgr,
1661 dpm_table->dpm_levels[i].value,
1663 result = vega10_populate_single_soc_level(hwmgr,
1664 dpm_table->dpm_levels[i].value,
1665 &(pp_table->SocclkDid[i]),
1666 &(pp_table->SocDpmVoltageIndex[i]));
1672 while (i < NUM_SOCCLK_DPM_LEVELS) {
1673 pp_table->SocVid[i] = pp_table->SocVid[j];
1674 result = vega10_populate_single_soc_level(hwmgr,
1675 dpm_table->dpm_levels[j].value,
1676 &(pp_table->SocclkDid[i]),
1677 &(pp_table->SocDpmVoltageIndex[i]));
1687 * @brief Populates single SMC GFXCLK structure using the provided clock.
1689 * @param hwmgr - the address of the hardware manager.
1690 * @param mem_clock - the memory clock to use to populate the structure.
1691 * @return 0 on success..
1693 static int vega10_populate_single_memory_level(struct pp_hwmgr *hwmgr,
1694 uint32_t mem_clock, uint8_t *current_mem_vid,
1695 PllSetting_t *current_memclk_level, uint8_t *current_mem_soc_vind)
1697 struct vega10_hwmgr *data =
1698 (struct vega10_hwmgr *)(hwmgr->backend);
1699 struct phm_ppt_v2_information *table_info =
1700 (struct phm_ppt_v2_information *)(hwmgr->pptable);
1701 struct phm_ppt_v1_clock_voltage_dependency_table *dep_on_mclk =
1702 table_info->vdd_dep_on_mclk;
1703 struct pp_atomfwctrl_clock_dividers_soc15 dividers;
1704 uint32_t mem_max_clock =
1705 hwmgr->platform_descriptor.overdriveLimit.memoryClock;
1708 if (data->apply_overdrive_next_settings_mask &
1709 DPMTABLE_OD_UPDATE_VDDC)
1710 dep_on_mclk = (struct phm_ppt_v1_clock_voltage_dependency_table *)
1711 &data->odn_dpm_table.vdd_dependency_on_mclk;
1713 PP_ASSERT_WITH_CODE(dep_on_mclk,
1714 "Invalid SOC_VDD-UCLK Dependency Table!",
1717 if (data->need_update_dpm_table & DPMTABLE_OD_UPDATE_MCLK)
1718 mem_clock = mem_clock > mem_max_clock ? mem_max_clock : mem_clock;
1720 for (i = 0; i < dep_on_mclk->count; i++) {
1721 if (dep_on_mclk->entries[i].clk == mem_clock)
1724 PP_ASSERT_WITH_CODE(dep_on_mclk->count > i,
1725 "Cannot find UCLK in SOC_VDD-UCLK Dependency Table!",
1729 PP_ASSERT_WITH_CODE(!pp_atomfwctrl_get_gpu_pll_dividers_vega10(
1730 hwmgr, COMPUTE_GPUCLK_INPUT_FLAG_UCLK, mem_clock, ÷rs),
1731 "Failed to get UCLK settings from VBIOS!",
1735 (uint8_t)(convert_to_vid(dep_on_mclk->entries[i].mvdd));
1736 *current_mem_soc_vind =
1737 (uint8_t)(dep_on_mclk->entries[i].vddInd);
1738 current_memclk_level->FbMult = cpu_to_le32(dividers.ulPll_fb_mult);
1739 current_memclk_level->Did = (uint8_t)(dividers.ulDid);
1741 PP_ASSERT_WITH_CODE(current_memclk_level->Did >= 1,
1742 "Invalid Divider ID!",
1749 * @brief Populates all SMC MCLK levels' structure based on the trimmed allowed dpm memory clock states.
1751 * @param pHwMgr - the address of the hardware manager.
1752 * @return PP_Result_OK on success.
1754 static int vega10_populate_all_memory_levels(struct pp_hwmgr *hwmgr)
1756 struct vega10_hwmgr *data =
1757 (struct vega10_hwmgr *)(hwmgr->backend);
1758 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
1759 struct vega10_single_dpm_table *dpm_table =
1760 &(data->dpm_table.mem_table);
1762 uint32_t i, j, reg, mem_channels;
1764 for (i = 0; i < dpm_table->count; i++) {
1765 result = vega10_populate_single_memory_level(hwmgr,
1766 dpm_table->dpm_levels[i].value,
1767 &(pp_table->MemVid[i]),
1768 &(pp_table->UclkLevel[i]),
1769 &(pp_table->MemSocVoltageIndex[i]));
1775 while (i < NUM_UCLK_DPM_LEVELS) {
1776 result = vega10_populate_single_memory_level(hwmgr,
1777 dpm_table->dpm_levels[j].value,
1778 &(pp_table->MemVid[i]),
1779 &(pp_table->UclkLevel[i]),
1780 &(pp_table->MemSocVoltageIndex[i]));
1786 reg = soc15_get_register_offset(DF_HWID, 0,
1787 mmDF_CS_AON0_DramBaseAddress0_BASE_IDX,
1788 mmDF_CS_AON0_DramBaseAddress0);
1789 mem_channels = (cgs_read_register(hwmgr->device, reg) &
1790 DF_CS_AON0_DramBaseAddress0__IntLvNumChan_MASK) >>
1791 DF_CS_AON0_DramBaseAddress0__IntLvNumChan__SHIFT;
1792 pp_table->NumMemoryChannels = cpu_to_le16(mem_channels);
1793 pp_table->MemoryChannelWidth =
1794 cpu_to_le16(HBM_MEMORY_CHANNEL_WIDTH *
1795 channel_number[mem_channels]);
1797 pp_table->LowestUclkReservedForUlv =
1798 (uint8_t)(data->lowest_uclk_reserved_for_ulv);
1803 static int vega10_populate_single_display_type(struct pp_hwmgr *hwmgr,
1804 DSPCLK_e disp_clock)
1806 struct vega10_hwmgr *data =
1807 (struct vega10_hwmgr *)(hwmgr->backend);
1808 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
1809 struct phm_ppt_v2_information *table_info =
1810 (struct phm_ppt_v2_information *)
1812 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table;
1814 uint16_t clk = 0, vddc = 0;
1817 switch (disp_clock) {
1818 case DSPCLK_DCEFCLK:
1819 dep_table = table_info->vdd_dep_on_dcefclk;
1821 case DSPCLK_DISPCLK:
1822 dep_table = table_info->vdd_dep_on_dispclk;
1825 dep_table = table_info->vdd_dep_on_pixclk;
1828 dep_table = table_info->vdd_dep_on_phyclk;
1834 PP_ASSERT_WITH_CODE(dep_table->count <= NUM_DSPCLK_LEVELS,
1835 "Number Of Entries Exceeded maximum!",
1838 for (i = 0; i < dep_table->count; i++) {
1839 clk = (uint16_t)(dep_table->entries[i].clk / 100);
1840 vddc = table_info->vddc_lookup_table->
1841 entries[dep_table->entries[i].vddInd].us_vdd;
1842 vid = (uint8_t)convert_to_vid(vddc);
1843 pp_table->DisplayClockTable[disp_clock][i].Freq =
1845 pp_table->DisplayClockTable[disp_clock][i].Vid =
1849 while (i < NUM_DSPCLK_LEVELS) {
1850 pp_table->DisplayClockTable[disp_clock][i].Freq =
1852 pp_table->DisplayClockTable[disp_clock][i].Vid =
1860 static int vega10_populate_all_display_clock_levels(struct pp_hwmgr *hwmgr)
1864 for (i = 0; i < DSPCLK_COUNT; i++) {
1865 PP_ASSERT_WITH_CODE(!vega10_populate_single_display_type(hwmgr, i),
1866 "Failed to populate Clock in DisplayClockTable!",
1873 static int vega10_populate_single_eclock_level(struct pp_hwmgr *hwmgr,
1874 uint32_t eclock, uint8_t *current_eclk_did,
1875 uint8_t *current_soc_vol)
1877 struct phm_ppt_v2_information *table_info =
1878 (struct phm_ppt_v2_information *)(hwmgr->pptable);
1879 struct phm_ppt_v1_mm_clock_voltage_dependency_table *dep_table =
1880 table_info->mm_dep_table;
1881 struct pp_atomfwctrl_clock_dividers_soc15 dividers;
1884 PP_ASSERT_WITH_CODE(!pp_atomfwctrl_get_gpu_pll_dividers_vega10(hwmgr,
1885 COMPUTE_GPUCLK_INPUT_FLAG_DEFAULT_GPUCLK,
1887 "Failed to get ECLK clock settings from VBIOS!",
1890 *current_eclk_did = (uint8_t)dividers.ulDid;
1892 for (i = 0; i < dep_table->count; i++) {
1893 if (dep_table->entries[i].eclk == eclock)
1894 *current_soc_vol = dep_table->entries[i].vddcInd;
1900 static int vega10_populate_smc_vce_levels(struct pp_hwmgr *hwmgr)
1902 struct vega10_hwmgr *data =
1903 (struct vega10_hwmgr *)(hwmgr->backend);
1904 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
1905 struct vega10_single_dpm_table *dpm_table = &(data->dpm_table.eclk_table);
1906 int result = -EINVAL;
1909 for (i = 0; i < dpm_table->count; i++) {
1910 result = vega10_populate_single_eclock_level(hwmgr,
1911 dpm_table->dpm_levels[i].value,
1912 &(pp_table->EclkDid[i]),
1913 &(pp_table->VceDpmVoltageIndex[i]));
1919 while (i < NUM_VCE_DPM_LEVELS) {
1920 result = vega10_populate_single_eclock_level(hwmgr,
1921 dpm_table->dpm_levels[j].value,
1922 &(pp_table->EclkDid[i]),
1923 &(pp_table->VceDpmVoltageIndex[i]));
1932 static int vega10_populate_single_vclock_level(struct pp_hwmgr *hwmgr,
1933 uint32_t vclock, uint8_t *current_vclk_did)
1935 struct pp_atomfwctrl_clock_dividers_soc15 dividers;
1937 PP_ASSERT_WITH_CODE(!pp_atomfwctrl_get_gpu_pll_dividers_vega10(hwmgr,
1938 COMPUTE_GPUCLK_INPUT_FLAG_DEFAULT_GPUCLK,
1940 "Failed to get VCLK clock settings from VBIOS!",
1943 *current_vclk_did = (uint8_t)dividers.ulDid;
1948 static int vega10_populate_single_dclock_level(struct pp_hwmgr *hwmgr,
1949 uint32_t dclock, uint8_t *current_dclk_did)
1951 struct pp_atomfwctrl_clock_dividers_soc15 dividers;
1953 PP_ASSERT_WITH_CODE(!pp_atomfwctrl_get_gpu_pll_dividers_vega10(hwmgr,
1954 COMPUTE_GPUCLK_INPUT_FLAG_DEFAULT_GPUCLK,
1956 "Failed to get DCLK clock settings from VBIOS!",
1959 *current_dclk_did = (uint8_t)dividers.ulDid;
1964 static int vega10_populate_smc_uvd_levels(struct pp_hwmgr *hwmgr)
1966 struct vega10_hwmgr *data =
1967 (struct vega10_hwmgr *)(hwmgr->backend);
1968 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
1969 struct vega10_single_dpm_table *vclk_dpm_table =
1970 &(data->dpm_table.vclk_table);
1971 struct vega10_single_dpm_table *dclk_dpm_table =
1972 &(data->dpm_table.dclk_table);
1973 struct phm_ppt_v2_information *table_info =
1974 (struct phm_ppt_v2_information *)(hwmgr->pptable);
1975 struct phm_ppt_v1_mm_clock_voltage_dependency_table *dep_table =
1976 table_info->mm_dep_table;
1977 int result = -EINVAL;
1980 for (i = 0; i < vclk_dpm_table->count; i++) {
1981 result = vega10_populate_single_vclock_level(hwmgr,
1982 vclk_dpm_table->dpm_levels[i].value,
1983 &(pp_table->VclkDid[i]));
1989 while (i < NUM_UVD_DPM_LEVELS) {
1990 result = vega10_populate_single_vclock_level(hwmgr,
1991 vclk_dpm_table->dpm_levels[j].value,
1992 &(pp_table->VclkDid[i]));
1998 for (i = 0; i < dclk_dpm_table->count; i++) {
1999 result = vega10_populate_single_dclock_level(hwmgr,
2000 dclk_dpm_table->dpm_levels[i].value,
2001 &(pp_table->DclkDid[i]));
2007 while (i < NUM_UVD_DPM_LEVELS) {
2008 result = vega10_populate_single_dclock_level(hwmgr,
2009 dclk_dpm_table->dpm_levels[j].value,
2010 &(pp_table->DclkDid[i]));
2016 for (i = 0; i < dep_table->count; i++) {
2017 if (dep_table->entries[i].vclk ==
2018 vclk_dpm_table->dpm_levels[i].value &&
2019 dep_table->entries[i].dclk ==
2020 dclk_dpm_table->dpm_levels[i].value)
2021 pp_table->UvdDpmVoltageIndex[i] =
2022 dep_table->entries[i].vddcInd;
2028 while (i < NUM_UVD_DPM_LEVELS) {
2029 pp_table->UvdDpmVoltageIndex[i] = dep_table->entries[j].vddcInd;
2036 static int vega10_populate_clock_stretcher_table(struct pp_hwmgr *hwmgr)
2038 struct vega10_hwmgr *data =
2039 (struct vega10_hwmgr *)(hwmgr->backend);
2040 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
2041 struct phm_ppt_v2_information *table_info =
2042 (struct phm_ppt_v2_information *)(hwmgr->pptable);
2043 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table =
2044 table_info->vdd_dep_on_sclk;
2047 for (i = 0; i < dep_table->count; i++) {
2048 pp_table->CksEnable[i] = dep_table->entries[i].cks_enable;
2049 pp_table->CksVidOffset[i] = (uint8_t)(dep_table->entries[i].cks_voffset
2050 * VOLTAGE_VID_OFFSET_SCALE2 / VOLTAGE_VID_OFFSET_SCALE1);
2056 static int vega10_populate_avfs_parameters(struct pp_hwmgr *hwmgr)
2058 struct vega10_hwmgr *data =
2059 (struct vega10_hwmgr *)(hwmgr->backend);
2060 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
2061 struct phm_ppt_v2_information *table_info =
2062 (struct phm_ppt_v2_information *)(hwmgr->pptable);
2063 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table =
2064 table_info->vdd_dep_on_sclk;
2065 struct pp_atomfwctrl_avfs_parameters avfs_params = {0};
2069 pp_table->MinVoltageVid = (uint8_t)0xff;
2070 pp_table->MaxVoltageVid = (uint8_t)0;
2072 if (data->smu_features[GNLD_AVFS].supported) {
2073 result = pp_atomfwctrl_get_avfs_information(hwmgr, &avfs_params);
2075 pp_table->MinVoltageVid = (uint8_t)
2076 convert_to_vid((uint16_t)(avfs_params.ulMinVddc));
2077 pp_table->MaxVoltageVid = (uint8_t)
2078 convert_to_vid((uint16_t)(avfs_params.ulMaxVddc));
2080 pp_table->AConstant[0] = cpu_to_le32(avfs_params.ulMeanNsigmaAcontant0);
2081 pp_table->AConstant[1] = cpu_to_le32(avfs_params.ulMeanNsigmaAcontant1);
2082 pp_table->AConstant[2] = cpu_to_le32(avfs_params.ulMeanNsigmaAcontant2);
2083 pp_table->DC_tol_sigma = cpu_to_le16(avfs_params.usMeanNsigmaDcTolSigma);
2084 pp_table->Platform_mean = cpu_to_le16(avfs_params.usMeanNsigmaPlatformMean);
2085 pp_table->Platform_sigma = cpu_to_le16(avfs_params.usMeanNsigmaDcTolSigma);
2086 pp_table->PSM_Age_CompFactor = cpu_to_le16(avfs_params.usPsmAgeComfactor);
2088 pp_table->BtcGbVdroopTableCksOff.a0 =
2089 cpu_to_le32(avfs_params.ulGbVdroopTableCksoffA0);
2090 pp_table->BtcGbVdroopTableCksOff.a0_shift = 20;
2091 pp_table->BtcGbVdroopTableCksOff.a1 =
2092 cpu_to_le32(avfs_params.ulGbVdroopTableCksoffA1);
2093 pp_table->BtcGbVdroopTableCksOff.a1_shift = 20;
2094 pp_table->BtcGbVdroopTableCksOff.a2 =
2095 cpu_to_le32(avfs_params.ulGbVdroopTableCksoffA2);
2096 pp_table->BtcGbVdroopTableCksOff.a2_shift = 20;
2098 pp_table->OverrideBtcGbCksOn = avfs_params.ucEnableGbVdroopTableCkson;
2099 pp_table->BtcGbVdroopTableCksOn.a0 =
2100 cpu_to_le32(avfs_params.ulGbVdroopTableCksonA0);
2101 pp_table->BtcGbVdroopTableCksOn.a0_shift = 20;
2102 pp_table->BtcGbVdroopTableCksOn.a1 =
2103 cpu_to_le32(avfs_params.ulGbVdroopTableCksonA1);
2104 pp_table->BtcGbVdroopTableCksOn.a1_shift = 20;
2105 pp_table->BtcGbVdroopTableCksOn.a2 =
2106 cpu_to_le32(avfs_params.ulGbVdroopTableCksonA2);
2107 pp_table->BtcGbVdroopTableCksOn.a2_shift = 20;
2109 pp_table->AvfsGbCksOn.m1 =
2110 cpu_to_le32(avfs_params.ulGbFuseTableCksonM1);
2111 pp_table->AvfsGbCksOn.m2 =
2112 cpu_to_le32(avfs_params.ulGbFuseTableCksonM2);
2113 pp_table->AvfsGbCksOn.b =
2114 cpu_to_le32(avfs_params.ulGbFuseTableCksonB);
2115 pp_table->AvfsGbCksOn.m1_shift = 24;
2116 pp_table->AvfsGbCksOn.m2_shift = 12;
2117 pp_table->AvfsGbCksOn.b_shift = 0;
2119 pp_table->OverrideAvfsGbCksOn =
2120 avfs_params.ucEnableGbFuseTableCkson;
2121 pp_table->AvfsGbCksOff.m1 =
2122 cpu_to_le32(avfs_params.ulGbFuseTableCksoffM1);
2123 pp_table->AvfsGbCksOff.m2 =
2124 cpu_to_le32(avfs_params.ulGbFuseTableCksoffM2);
2125 pp_table->AvfsGbCksOff.b =
2126 cpu_to_le32(avfs_params.ulGbFuseTableCksoffB);
2127 pp_table->AvfsGbCksOff.m1_shift = 24;
2128 pp_table->AvfsGbCksOff.m2_shift = 12;
2129 pp_table->AvfsGbCksOff.b_shift = 0;
2131 for (i = 0; i < dep_table->count; i++)
2132 pp_table->StaticVoltageOffsetVid[i] =
2133 convert_to_vid((uint8_t)(dep_table->entries[i].sclk_offset));
2135 if ((PPREGKEY_VEGA10QUADRATICEQUATION_DFLT !=
2136 data->disp_clk_quad_eqn_a) &&
2137 (PPREGKEY_VEGA10QUADRATICEQUATION_DFLT !=
2138 data->disp_clk_quad_eqn_b)) {
2139 pp_table->DisplayClock2Gfxclk[DSPCLK_DISPCLK].m1 =
2140 (int32_t)data->disp_clk_quad_eqn_a;
2141 pp_table->DisplayClock2Gfxclk[DSPCLK_DISPCLK].m2 =
2142 (int32_t)data->disp_clk_quad_eqn_b;
2143 pp_table->DisplayClock2Gfxclk[DSPCLK_DISPCLK].b =
2144 (int32_t)data->disp_clk_quad_eqn_c;
2146 pp_table->DisplayClock2Gfxclk[DSPCLK_DISPCLK].m1 =
2147 (int32_t)avfs_params.ulDispclk2GfxclkM1;
2148 pp_table->DisplayClock2Gfxclk[DSPCLK_DISPCLK].m2 =
2149 (int32_t)avfs_params.ulDispclk2GfxclkM2;
2150 pp_table->DisplayClock2Gfxclk[DSPCLK_DISPCLK].b =
2151 (int32_t)avfs_params.ulDispclk2GfxclkB;
2154 pp_table->DisplayClock2Gfxclk[DSPCLK_DISPCLK].m1_shift = 24;
2155 pp_table->DisplayClock2Gfxclk[DSPCLK_DISPCLK].m2_shift = 12;
2156 pp_table->DisplayClock2Gfxclk[DSPCLK_DISPCLK].b_shift = 12;
2158 if ((PPREGKEY_VEGA10QUADRATICEQUATION_DFLT !=
2159 data->dcef_clk_quad_eqn_a) &&
2160 (PPREGKEY_VEGA10QUADRATICEQUATION_DFLT !=
2161 data->dcef_clk_quad_eqn_b)) {
2162 pp_table->DisplayClock2Gfxclk[DSPCLK_DCEFCLK].m1 =
2163 (int32_t)data->dcef_clk_quad_eqn_a;
2164 pp_table->DisplayClock2Gfxclk[DSPCLK_DCEFCLK].m2 =
2165 (int32_t)data->dcef_clk_quad_eqn_b;
2166 pp_table->DisplayClock2Gfxclk[DSPCLK_DCEFCLK].b =
2167 (int32_t)data->dcef_clk_quad_eqn_c;
2169 pp_table->DisplayClock2Gfxclk[DSPCLK_DCEFCLK].m1 =
2170 (int32_t)avfs_params.ulDcefclk2GfxclkM1;
2171 pp_table->DisplayClock2Gfxclk[DSPCLK_DCEFCLK].m2 =
2172 (int32_t)avfs_params.ulDcefclk2GfxclkM2;
2173 pp_table->DisplayClock2Gfxclk[DSPCLK_DCEFCLK].b =
2174 (int32_t)avfs_params.ulDcefclk2GfxclkB;
2177 pp_table->DisplayClock2Gfxclk[DSPCLK_DCEFCLK].m1_shift = 24;
2178 pp_table->DisplayClock2Gfxclk[DSPCLK_DCEFCLK].m2_shift = 12;
2179 pp_table->DisplayClock2Gfxclk[DSPCLK_DCEFCLK].b_shift = 12;
2181 if ((PPREGKEY_VEGA10QUADRATICEQUATION_DFLT !=
2182 data->pixel_clk_quad_eqn_a) &&
2183 (PPREGKEY_VEGA10QUADRATICEQUATION_DFLT !=
2184 data->pixel_clk_quad_eqn_b)) {
2185 pp_table->DisplayClock2Gfxclk[DSPCLK_PIXCLK].m1 =
2186 (int32_t)data->pixel_clk_quad_eqn_a;
2187 pp_table->DisplayClock2Gfxclk[DSPCLK_PIXCLK].m2 =
2188 (int32_t)data->pixel_clk_quad_eqn_b;
2189 pp_table->DisplayClock2Gfxclk[DSPCLK_PIXCLK].b =
2190 (int32_t)data->pixel_clk_quad_eqn_c;
2192 pp_table->DisplayClock2Gfxclk[DSPCLK_PIXCLK].m1 =
2193 (int32_t)avfs_params.ulPixelclk2GfxclkM1;
2194 pp_table->DisplayClock2Gfxclk[DSPCLK_PIXCLK].m2 =
2195 (int32_t)avfs_params.ulPixelclk2GfxclkM2;
2196 pp_table->DisplayClock2Gfxclk[DSPCLK_PIXCLK].b =
2197 (int32_t)avfs_params.ulPixelclk2GfxclkB;
2200 pp_table->DisplayClock2Gfxclk[DSPCLK_PIXCLK].m1_shift = 24;
2201 pp_table->DisplayClock2Gfxclk[DSPCLK_PIXCLK].m2_shift = 12;
2202 pp_table->DisplayClock2Gfxclk[DSPCLK_PIXCLK].b_shift = 12;
2203 if ((PPREGKEY_VEGA10QUADRATICEQUATION_DFLT !=
2204 data->phy_clk_quad_eqn_a) &&
2205 (PPREGKEY_VEGA10QUADRATICEQUATION_DFLT !=
2206 data->phy_clk_quad_eqn_b)) {
2207 pp_table->DisplayClock2Gfxclk[DSPCLK_PHYCLK].m1 =
2208 (int32_t)data->phy_clk_quad_eqn_a;
2209 pp_table->DisplayClock2Gfxclk[DSPCLK_PHYCLK].m2 =
2210 (int32_t)data->phy_clk_quad_eqn_b;
2211 pp_table->DisplayClock2Gfxclk[DSPCLK_PHYCLK].b =
2212 (int32_t)data->phy_clk_quad_eqn_c;
2214 pp_table->DisplayClock2Gfxclk[DSPCLK_PHYCLK].m1 =
2215 (int32_t)avfs_params.ulPhyclk2GfxclkM1;
2216 pp_table->DisplayClock2Gfxclk[DSPCLK_PHYCLK].m2 =
2217 (int32_t)avfs_params.ulPhyclk2GfxclkM2;
2218 pp_table->DisplayClock2Gfxclk[DSPCLK_PHYCLK].b =
2219 (int32_t)avfs_params.ulPhyclk2GfxclkB;
2222 pp_table->DisplayClock2Gfxclk[DSPCLK_PHYCLK].m1_shift = 24;
2223 pp_table->DisplayClock2Gfxclk[DSPCLK_PHYCLK].m2_shift = 12;
2224 pp_table->DisplayClock2Gfxclk[DSPCLK_PHYCLK].b_shift = 12;
2226 data->smu_features[GNLD_AVFS].supported = false;
2233 static int vega10_populate_gpio_parameters(struct pp_hwmgr *hwmgr)
2235 struct vega10_hwmgr *data =
2236 (struct vega10_hwmgr *)(hwmgr->backend);
2237 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
2238 struct pp_atomfwctrl_gpio_parameters gpio_params = {0};
2241 result = pp_atomfwctrl_get_gpio_information(hwmgr, &gpio_params);
2243 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
2244 PHM_PlatformCaps_RegulatorHot) &&
2245 (data->registry_data.regulator_hot_gpio_support)) {
2246 pp_table->VR0HotGpio = gpio_params.ucVR0HotGpio;
2247 pp_table->VR0HotPolarity = gpio_params.ucVR0HotPolarity;
2248 pp_table->VR1HotGpio = gpio_params.ucVR1HotGpio;
2249 pp_table->VR1HotPolarity = gpio_params.ucVR1HotPolarity;
2251 pp_table->VR0HotGpio = 0;
2252 pp_table->VR0HotPolarity = 0;
2253 pp_table->VR1HotGpio = 0;
2254 pp_table->VR1HotPolarity = 0;
2257 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
2258 PHM_PlatformCaps_AutomaticDCTransition) &&
2259 (data->registry_data.ac_dc_switch_gpio_support)) {
2260 pp_table->AcDcGpio = gpio_params.ucAcDcGpio;
2261 pp_table->AcDcPolarity = gpio_params.ucAcDcPolarity;
2263 pp_table->AcDcGpio = 0;
2264 pp_table->AcDcPolarity = 0;
2271 static int vega10_avfs_enable(struct pp_hwmgr *hwmgr, bool enable)
2273 struct vega10_hwmgr *data =
2274 (struct vega10_hwmgr *)(hwmgr->backend);
2276 if (data->smu_features[GNLD_AVFS].supported) {
2278 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2280 data->smu_features[GNLD_AVFS].smu_feature_bitmap),
2281 "[avfs_control] Attempt to Enable AVFS feature Failed!",
2283 data->smu_features[GNLD_AVFS].enabled = true;
2285 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2287 data->smu_features[GNLD_AVFS].smu_feature_id),
2288 "[avfs_control] Attempt to Disable AVFS feature Failed!",
2290 data->smu_features[GNLD_AVFS].enabled = false;
2297 static int vega10_populate_and_upload_avfs_fuse_override(struct pp_hwmgr *hwmgr)
2301 uint64_t serial_number = 0;
2302 uint32_t top32, bottom32;
2303 struct phm_fuses_default fuse;
2305 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
2306 AvfsFuseOverride_t *avfs_fuse_table = &(data->smc_state_table.avfs_fuse_override_table);
2308 smum_send_msg_to_smc(hwmgr->smumgr, PPSMC_MSG_ReadSerialNumTop32);
2309 vega10_read_arg_from_smc(hwmgr->smumgr, &top32);
2311 smum_send_msg_to_smc(hwmgr->smumgr, PPSMC_MSG_ReadSerialNumBottom32);
2312 vega10_read_arg_from_smc(hwmgr->smumgr, &bottom32);
2314 serial_number = ((uint64_t)bottom32 << 32) | top32;
2316 if (pp_override_get_default_fuse_value(serial_number, vega10_fuses_default, &fuse) == 0) {
2317 avfs_fuse_table->VFT0_b = fuse.VFT0_b;
2318 avfs_fuse_table->VFT0_m1 = fuse.VFT0_m1;
2319 avfs_fuse_table->VFT0_m2 = fuse.VFT0_m2;
2320 avfs_fuse_table->VFT1_b = fuse.VFT1_b;
2321 avfs_fuse_table->VFT1_m1 = fuse.VFT1_m1;
2322 avfs_fuse_table->VFT1_m2 = fuse.VFT1_m2;
2323 avfs_fuse_table->VFT2_b = fuse.VFT2_b;
2324 avfs_fuse_table->VFT2_m1 = fuse.VFT2_m1;
2325 avfs_fuse_table->VFT2_m2 = fuse.VFT2_m2;
2326 result = vega10_copy_table_to_smc(hwmgr->smumgr,
2327 (uint8_t *)avfs_fuse_table, AVFSFUSETABLE);
2328 PP_ASSERT_WITH_CODE(!result,
2329 "Failed to upload FuseOVerride!",
2336 static int vega10_save_default_power_profile(struct pp_hwmgr *hwmgr)
2338 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
2339 struct vega10_single_dpm_table *dpm_table = &(data->dpm_table.gfx_table);
2342 hwmgr->default_gfx_power_profile.type = AMD_PP_GFX_PROFILE;
2343 hwmgr->default_compute_power_profile.type = AMD_PP_COMPUTE_PROFILE;
2345 /* Optimize compute power profile: Use only highest
2346 * 2 power levels (if more than 2 are available)
2348 if (dpm_table->count > 2)
2349 min_level = dpm_table->count - 2;
2350 else if (dpm_table->count == 2)
2355 hwmgr->default_compute_power_profile.min_sclk =
2356 dpm_table->dpm_levels[min_level].value;
2358 hwmgr->gfx_power_profile = hwmgr->default_gfx_power_profile;
2359 hwmgr->compute_power_profile = hwmgr->default_compute_power_profile;
2365 * Initializes the SMC table and uploads it
2367 * @param hwmgr the address of the powerplay hardware manager.
2368 * @param pInput the pointer to input data (PowerState)
2371 static int vega10_init_smc_table(struct pp_hwmgr *hwmgr)
2374 struct vega10_hwmgr *data =
2375 (struct vega10_hwmgr *)(hwmgr->backend);
2376 struct phm_ppt_v2_information *table_info =
2377 (struct phm_ppt_v2_information *)(hwmgr->pptable);
2378 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
2379 struct pp_atomfwctrl_voltage_table voltage_table;
2380 struct pp_atomfwctrl_bios_boot_up_values boot_up_values;
2382 result = vega10_setup_default_dpm_tables(hwmgr);
2383 PP_ASSERT_WITH_CODE(!result,
2384 "Failed to setup default DPM tables!",
2387 pp_atomfwctrl_get_voltage_table_v4(hwmgr, VOLTAGE_TYPE_VDDC,
2388 VOLTAGE_OBJ_SVID2, &voltage_table);
2389 pp_table->MaxVidStep = voltage_table.max_vid_step;
2391 pp_table->GfxDpmVoltageMode =
2392 (uint8_t)(table_info->uc_gfx_dpm_voltage_mode);
2393 pp_table->SocDpmVoltageMode =
2394 (uint8_t)(table_info->uc_soc_dpm_voltage_mode);
2395 pp_table->UclkDpmVoltageMode =
2396 (uint8_t)(table_info->uc_uclk_dpm_voltage_mode);
2397 pp_table->UvdDpmVoltageMode =
2398 (uint8_t)(table_info->uc_uvd_dpm_voltage_mode);
2399 pp_table->VceDpmVoltageMode =
2400 (uint8_t)(table_info->uc_vce_dpm_voltage_mode);
2401 pp_table->Mp0DpmVoltageMode =
2402 (uint8_t)(table_info->uc_mp0_dpm_voltage_mode);
2404 pp_table->DisplayDpmVoltageMode =
2405 (uint8_t)(table_info->uc_dcef_dpm_voltage_mode);
2407 if (data->registry_data.ulv_support &&
2408 table_info->us_ulv_voltage_offset) {
2409 result = vega10_populate_ulv_state(hwmgr);
2410 PP_ASSERT_WITH_CODE(!result,
2411 "Failed to initialize ULV state!",
2415 result = vega10_populate_smc_link_levels(hwmgr);
2416 PP_ASSERT_WITH_CODE(!result,
2417 "Failed to initialize Link Level!",
2420 result = vega10_populate_all_graphic_levels(hwmgr);
2421 PP_ASSERT_WITH_CODE(!result,
2422 "Failed to initialize Graphics Level!",
2425 result = vega10_populate_all_memory_levels(hwmgr);
2426 PP_ASSERT_WITH_CODE(!result,
2427 "Failed to initialize Memory Level!",
2430 result = vega10_populate_all_display_clock_levels(hwmgr);
2431 PP_ASSERT_WITH_CODE(!result,
2432 "Failed to initialize Display Level!",
2435 result = vega10_populate_smc_vce_levels(hwmgr);
2436 PP_ASSERT_WITH_CODE(!result,
2437 "Failed to initialize VCE Level!",
2440 result = vega10_populate_smc_uvd_levels(hwmgr);
2441 PP_ASSERT_WITH_CODE(!result,
2442 "Failed to initialize UVD Level!",
2445 if (data->registry_data.clock_stretcher_support) {
2446 result = vega10_populate_clock_stretcher_table(hwmgr);
2447 PP_ASSERT_WITH_CODE(!result,
2448 "Failed to populate Clock Stretcher Table!",
2452 result = pp_atomfwctrl_get_vbios_bootup_values(hwmgr, &boot_up_values);
2454 data->vbios_boot_state.vddc = boot_up_values.usVddc;
2455 data->vbios_boot_state.vddci = boot_up_values.usVddci;
2456 data->vbios_boot_state.mvddc = boot_up_values.usMvddc;
2457 data->vbios_boot_state.gfx_clock = boot_up_values.ulGfxClk;
2458 data->vbios_boot_state.mem_clock = boot_up_values.ulUClk;
2459 data->vbios_boot_state.soc_clock = boot_up_values.ulSocClk;
2460 data->vbios_boot_state.dcef_clock = boot_up_values.ulDCEFClk;
2461 if (0 != boot_up_values.usVddc) {
2462 smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
2463 PPSMC_MSG_SetFloorSocVoltage,
2464 (boot_up_values.usVddc * 4));
2465 data->vbios_boot_state.bsoc_vddc_lock = true;
2467 data->vbios_boot_state.bsoc_vddc_lock = false;
2469 smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
2470 PPSMC_MSG_SetMinDeepSleepDcefclk,
2471 (uint32_t)(data->vbios_boot_state.dcef_clock / 100));
2474 result = vega10_populate_avfs_parameters(hwmgr);
2475 PP_ASSERT_WITH_CODE(!result,
2476 "Failed to initialize AVFS Parameters!",
2479 result = vega10_populate_gpio_parameters(hwmgr);
2480 PP_ASSERT_WITH_CODE(!result,
2481 "Failed to initialize GPIO Parameters!",
2484 pp_table->GfxclkAverageAlpha = (uint8_t)
2485 (data->gfxclk_average_alpha);
2486 pp_table->SocclkAverageAlpha = (uint8_t)
2487 (data->socclk_average_alpha);
2488 pp_table->UclkAverageAlpha = (uint8_t)
2489 (data->uclk_average_alpha);
2490 pp_table->GfxActivityAverageAlpha = (uint8_t)
2491 (data->gfx_activity_average_alpha);
2493 vega10_populate_and_upload_avfs_fuse_override(hwmgr);
2495 result = vega10_copy_table_to_smc(hwmgr->smumgr,
2496 (uint8_t *)pp_table, PPTABLE);
2497 PP_ASSERT_WITH_CODE(!result,
2498 "Failed to upload PPtable!", return result);
2500 result = vega10_avfs_enable(hwmgr, true);
2501 PP_ASSERT_WITH_CODE(!result, "Attempt to enable AVFS feature Failed!",
2504 vega10_save_default_power_profile(hwmgr);
2509 static int vega10_enable_thermal_protection(struct pp_hwmgr *hwmgr)
2511 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
2513 if (data->smu_features[GNLD_THERMAL].supported) {
2514 if (data->smu_features[GNLD_THERMAL].enabled)
2515 pr_info("THERMAL Feature Already enabled!");
2517 PP_ASSERT_WITH_CODE(
2518 !vega10_enable_smc_features(hwmgr->smumgr,
2520 data->smu_features[GNLD_THERMAL].smu_feature_bitmap),
2521 "Enable THERMAL Feature Failed!",
2523 data->smu_features[GNLD_THERMAL].enabled = true;
2529 static int vega10_disable_thermal_protection(struct pp_hwmgr *hwmgr)
2531 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
2533 if (data->smu_features[GNLD_THERMAL].supported) {
2534 if (!data->smu_features[GNLD_THERMAL].enabled)
2535 pr_info("THERMAL Feature Already disabled!");
2537 PP_ASSERT_WITH_CODE(
2538 !vega10_enable_smc_features(hwmgr->smumgr,
2540 data->smu_features[GNLD_THERMAL].smu_feature_bitmap),
2541 "disable THERMAL Feature Failed!",
2543 data->smu_features[GNLD_THERMAL].enabled = false;
2549 static int vega10_enable_vrhot_feature(struct pp_hwmgr *hwmgr)
2551 struct vega10_hwmgr *data =
2552 (struct vega10_hwmgr *)(hwmgr->backend);
2554 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
2555 PHM_PlatformCaps_RegulatorHot)) {
2556 if (data->smu_features[GNLD_VR0HOT].supported) {
2557 PP_ASSERT_WITH_CODE(
2558 !vega10_enable_smc_features(hwmgr->smumgr,
2560 data->smu_features[GNLD_VR0HOT].smu_feature_bitmap),
2561 "Attempt to Enable VR0 Hot feature Failed!",
2563 data->smu_features[GNLD_VR0HOT].enabled = true;
2565 if (data->smu_features[GNLD_VR1HOT].supported) {
2566 PP_ASSERT_WITH_CODE(
2567 !vega10_enable_smc_features(hwmgr->smumgr,
2569 data->smu_features[GNLD_VR1HOT].smu_feature_bitmap),
2570 "Attempt to Enable VR0 Hot feature Failed!",
2572 data->smu_features[GNLD_VR1HOT].enabled = true;
2579 static int vega10_enable_ulv(struct pp_hwmgr *hwmgr)
2581 struct vega10_hwmgr *data =
2582 (struct vega10_hwmgr *)(hwmgr->backend);
2584 if (data->registry_data.ulv_support) {
2585 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2586 true, data->smu_features[GNLD_ULV].smu_feature_bitmap),
2587 "Enable ULV Feature Failed!",
2589 data->smu_features[GNLD_ULV].enabled = true;
2595 static int vega10_disable_ulv(struct pp_hwmgr *hwmgr)
2597 struct vega10_hwmgr *data =
2598 (struct vega10_hwmgr *)(hwmgr->backend);
2600 if (data->registry_data.ulv_support) {
2601 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2602 false, data->smu_features[GNLD_ULV].smu_feature_bitmap),
2603 "disable ULV Feature Failed!",
2605 data->smu_features[GNLD_ULV].enabled = false;
2611 static int vega10_enable_deep_sleep_master_switch(struct pp_hwmgr *hwmgr)
2613 struct vega10_hwmgr *data =
2614 (struct vega10_hwmgr *)(hwmgr->backend);
2616 if (data->smu_features[GNLD_DS_GFXCLK].supported) {
2617 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2618 true, data->smu_features[GNLD_DS_GFXCLK].smu_feature_bitmap),
2619 "Attempt to Enable DS_GFXCLK Feature Failed!",
2621 data->smu_features[GNLD_DS_GFXCLK].enabled = true;
2624 if (data->smu_features[GNLD_DS_SOCCLK].supported) {
2625 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2626 true, data->smu_features[GNLD_DS_SOCCLK].smu_feature_bitmap),
2627 "Attempt to Enable DS_SOCCLK Feature Failed!",
2629 data->smu_features[GNLD_DS_SOCCLK].enabled = true;
2632 if (data->smu_features[GNLD_DS_LCLK].supported) {
2633 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2634 true, data->smu_features[GNLD_DS_LCLK].smu_feature_bitmap),
2635 "Attempt to Enable DS_LCLK Feature Failed!",
2637 data->smu_features[GNLD_DS_LCLK].enabled = true;
2640 if (data->smu_features[GNLD_DS_DCEFCLK].supported) {
2641 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2642 true, data->smu_features[GNLD_DS_DCEFCLK].smu_feature_bitmap),
2643 "Attempt to Enable DS_DCEFCLK Feature Failed!",
2645 data->smu_features[GNLD_DS_DCEFCLK].enabled = true;
2651 static int vega10_disable_deep_sleep_master_switch(struct pp_hwmgr *hwmgr)
2653 struct vega10_hwmgr *data =
2654 (struct vega10_hwmgr *)(hwmgr->backend);
2656 if (data->smu_features[GNLD_DS_GFXCLK].supported) {
2657 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2658 false, data->smu_features[GNLD_DS_GFXCLK].smu_feature_bitmap),
2659 "Attempt to disable DS_GFXCLK Feature Failed!",
2661 data->smu_features[GNLD_DS_GFXCLK].enabled = false;
2664 if (data->smu_features[GNLD_DS_SOCCLK].supported) {
2665 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2666 false, data->smu_features[GNLD_DS_SOCCLK].smu_feature_bitmap),
2667 "Attempt to disable DS_ Feature Failed!",
2669 data->smu_features[GNLD_DS_SOCCLK].enabled = false;
2672 if (data->smu_features[GNLD_DS_LCLK].supported) {
2673 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2674 false, data->smu_features[GNLD_DS_LCLK].smu_feature_bitmap),
2675 "Attempt to disable DS_LCLK Feature Failed!",
2677 data->smu_features[GNLD_DS_LCLK].enabled = false;
2680 if (data->smu_features[GNLD_DS_DCEFCLK].supported) {
2681 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2682 false, data->smu_features[GNLD_DS_DCEFCLK].smu_feature_bitmap),
2683 "Attempt to disable DS_DCEFCLK Feature Failed!",
2685 data->smu_features[GNLD_DS_DCEFCLK].enabled = false;
2691 static int vega10_stop_dpm(struct pp_hwmgr *hwmgr, uint32_t bitmap)
2693 struct vega10_hwmgr *data =
2694 (struct vega10_hwmgr *)(hwmgr->backend);
2695 uint32_t i, feature_mask = 0;
2698 if(data->smu_features[GNLD_LED_DISPLAY].supported == true){
2699 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2700 false, data->smu_features[GNLD_LED_DISPLAY].smu_feature_bitmap),
2701 "Attempt to disable LED DPM feature failed!", return -EINVAL);
2702 data->smu_features[GNLD_LED_DISPLAY].enabled = false;
2705 for (i = 0; i < GNLD_DPM_MAX; i++) {
2706 if (data->smu_features[i].smu_feature_bitmap & bitmap) {
2707 if (data->smu_features[i].supported) {
2708 if (data->smu_features[i].enabled) {
2709 feature_mask |= data->smu_features[i].
2711 data->smu_features[i].enabled = false;
2717 vega10_enable_smc_features(hwmgr->smumgr, false, feature_mask);
2723 * @brief Tell SMC to enabled the supported DPMs.
2725 * @param hwmgr - the address of the powerplay hardware manager.
2726 * @Param bitmap - bitmap for the features to enabled.
2727 * @return 0 on at least one DPM is successfully enabled.
2729 static int vega10_start_dpm(struct pp_hwmgr *hwmgr, uint32_t bitmap)
2731 struct vega10_hwmgr *data =
2732 (struct vega10_hwmgr *)(hwmgr->backend);
2733 uint32_t i, feature_mask = 0;
2735 for (i = 0; i < GNLD_DPM_MAX; i++) {
2736 if (data->smu_features[i].smu_feature_bitmap & bitmap) {
2737 if (data->smu_features[i].supported) {
2738 if (!data->smu_features[i].enabled) {
2739 feature_mask |= data->smu_features[i].
2741 data->smu_features[i].enabled = true;
2747 if (vega10_enable_smc_features(hwmgr->smumgr,
2748 true, feature_mask)) {
2749 for (i = 0; i < GNLD_DPM_MAX; i++) {
2750 if (data->smu_features[i].smu_feature_bitmap &
2752 data->smu_features[i].enabled = false;
2756 if(data->smu_features[GNLD_LED_DISPLAY].supported == true){
2757 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2758 true, data->smu_features[GNLD_LED_DISPLAY].smu_feature_bitmap),
2759 "Attempt to Enable LED DPM feature Failed!", return -EINVAL);
2760 data->smu_features[GNLD_LED_DISPLAY].enabled = true;
2763 if (data->vbios_boot_state.bsoc_vddc_lock) {
2764 smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
2765 PPSMC_MSG_SetFloorSocVoltage, 0);
2766 data->vbios_boot_state.bsoc_vddc_lock = false;
2769 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
2770 PHM_PlatformCaps_Falcon_QuickTransition)) {
2771 if (data->smu_features[GNLD_ACDC].supported) {
2772 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
2773 true, data->smu_features[GNLD_ACDC].smu_feature_bitmap),
2774 "Attempt to Enable DS_GFXCLK Feature Failed!",
2776 data->smu_features[GNLD_ACDC].enabled = true;
2783 static int vega10_enable_dpm_tasks(struct pp_hwmgr *hwmgr)
2785 struct vega10_hwmgr *data =
2786 (struct vega10_hwmgr *)(hwmgr->backend);
2787 int tmp_result, result = 0;
2789 tmp_result = smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
2790 PPSMC_MSG_ConfigureTelemetry, data->config_telemetry);
2791 PP_ASSERT_WITH_CODE(!tmp_result,
2792 "Failed to configure telemetry!",
2795 smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
2796 PPSMC_MSG_NumOfDisplays, 0);
2798 tmp_result = (!vega10_is_dpm_running(hwmgr)) ? 0 : -1;
2799 PP_ASSERT_WITH_CODE(!tmp_result,
2800 "DPM is already running right , skipping re-enablement!",
2803 tmp_result = vega10_construct_voltage_tables(hwmgr);
2804 PP_ASSERT_WITH_CODE(!tmp_result,
2805 "Failed to contruct voltage tables!",
2806 result = tmp_result);
2808 tmp_result = vega10_init_smc_table(hwmgr);
2809 PP_ASSERT_WITH_CODE(!tmp_result,
2810 "Failed to initialize SMC table!",
2811 result = tmp_result);
2813 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
2814 PHM_PlatformCaps_ThermalController)) {
2815 tmp_result = vega10_enable_thermal_protection(hwmgr);
2816 PP_ASSERT_WITH_CODE(!tmp_result,
2817 "Failed to enable thermal protection!",
2818 result = tmp_result);
2821 tmp_result = vega10_enable_vrhot_feature(hwmgr);
2822 PP_ASSERT_WITH_CODE(!tmp_result,
2823 "Failed to enable VR hot feature!",
2824 result = tmp_result);
2826 tmp_result = vega10_enable_deep_sleep_master_switch(hwmgr);
2827 PP_ASSERT_WITH_CODE(!tmp_result,
2828 "Failed to enable deep sleep master switch!",
2829 result = tmp_result);
2831 tmp_result = vega10_start_dpm(hwmgr, SMC_DPM_FEATURES);
2832 PP_ASSERT_WITH_CODE(!tmp_result,
2833 "Failed to start DPM!", result = tmp_result);
2835 tmp_result = vega10_enable_power_containment(hwmgr);
2836 PP_ASSERT_WITH_CODE(!tmp_result,
2837 "Failed to enable power containment!",
2838 result = tmp_result);
2840 tmp_result = vega10_power_control_set_level(hwmgr);
2841 PP_ASSERT_WITH_CODE(!tmp_result,
2842 "Failed to power control set level!",
2843 result = tmp_result);
2845 tmp_result = vega10_enable_ulv(hwmgr);
2846 PP_ASSERT_WITH_CODE(!tmp_result,
2847 "Failed to enable ULV!",
2848 result = tmp_result);
2853 static int vega10_get_power_state_size(struct pp_hwmgr *hwmgr)
2855 return sizeof(struct vega10_power_state);
2858 static int vega10_get_pp_table_entry_callback_func(struct pp_hwmgr *hwmgr,
2859 void *state, struct pp_power_state *power_state,
2860 void *pp_table, uint32_t classification_flag)
2862 ATOM_Vega10_GFXCLK_Dependency_Record_V2 *patom_record_V2;
2863 struct vega10_power_state *vega10_power_state =
2864 cast_phw_vega10_power_state(&(power_state->hardware));
2865 struct vega10_performance_level *performance_level;
2866 ATOM_Vega10_State *state_entry = (ATOM_Vega10_State *)state;
2867 ATOM_Vega10_POWERPLAYTABLE *powerplay_table =
2868 (ATOM_Vega10_POWERPLAYTABLE *)pp_table;
2869 ATOM_Vega10_SOCCLK_Dependency_Table *socclk_dep_table =
2870 (ATOM_Vega10_SOCCLK_Dependency_Table *)
2871 (((unsigned long)powerplay_table) +
2872 le16_to_cpu(powerplay_table->usSocclkDependencyTableOffset));
2873 ATOM_Vega10_GFXCLK_Dependency_Table *gfxclk_dep_table =
2874 (ATOM_Vega10_GFXCLK_Dependency_Table *)
2875 (((unsigned long)powerplay_table) +
2876 le16_to_cpu(powerplay_table->usGfxclkDependencyTableOffset));
2877 ATOM_Vega10_MCLK_Dependency_Table *mclk_dep_table =
2878 (ATOM_Vega10_MCLK_Dependency_Table *)
2879 (((unsigned long)powerplay_table) +
2880 le16_to_cpu(powerplay_table->usMclkDependencyTableOffset));
2883 /* The following fields are not initialized here:
2884 * id orderedList allStatesList
2886 power_state->classification.ui_label =
2887 (le16_to_cpu(state_entry->usClassification) &
2888 ATOM_PPLIB_CLASSIFICATION_UI_MASK) >>
2889 ATOM_PPLIB_CLASSIFICATION_UI_SHIFT;
2890 power_state->classification.flags = classification_flag;
2891 /* NOTE: There is a classification2 flag in BIOS
2892 * that is not being used right now
2894 power_state->classification.temporary_state = false;
2895 power_state->classification.to_be_deleted = false;
2897 power_state->validation.disallowOnDC =
2898 ((le32_to_cpu(state_entry->ulCapsAndSettings) &
2899 ATOM_Vega10_DISALLOW_ON_DC) != 0);
2901 power_state->display.disableFrameModulation = false;
2902 power_state->display.limitRefreshrate = false;
2903 power_state->display.enableVariBright =
2904 ((le32_to_cpu(state_entry->ulCapsAndSettings) &
2905 ATOM_Vega10_ENABLE_VARIBRIGHT) != 0);
2907 power_state->validation.supportedPowerLevels = 0;
2908 power_state->uvd_clocks.VCLK = 0;
2909 power_state->uvd_clocks.DCLK = 0;
2910 power_state->temperatures.min = 0;
2911 power_state->temperatures.max = 0;
2913 performance_level = &(vega10_power_state->performance_levels
2914 [vega10_power_state->performance_level_count++]);
2916 PP_ASSERT_WITH_CODE(
2917 (vega10_power_state->performance_level_count <
2918 NUM_GFXCLK_DPM_LEVELS),
2919 "Performance levels exceeds SMC limit!",
2922 PP_ASSERT_WITH_CODE(
2923 (vega10_power_state->performance_level_count <=
2924 hwmgr->platform_descriptor.
2925 hardwareActivityPerformanceLevels),
2926 "Performance levels exceeds Driver limit!",
2929 /* Performance levels are arranged from low to high. */
2930 performance_level->soc_clock = socclk_dep_table->entries
2931 [state_entry->ucSocClockIndexLow].ulClk;
2932 performance_level->gfx_clock = gfxclk_dep_table->entries
2933 [state_entry->ucGfxClockIndexLow].ulClk;
2934 performance_level->mem_clock = mclk_dep_table->entries
2935 [state_entry->ucMemClockIndexLow].ulMemClk;
2937 performance_level = &(vega10_power_state->performance_levels
2938 [vega10_power_state->performance_level_count++]);
2939 performance_level->soc_clock = socclk_dep_table->entries
2940 [state_entry->ucSocClockIndexHigh].ulClk;
2941 if (gfxclk_dep_table->ucRevId == 0) {
2942 performance_level->gfx_clock = gfxclk_dep_table->entries
2943 [state_entry->ucGfxClockIndexHigh].ulClk;
2944 } else if (gfxclk_dep_table->ucRevId == 1) {
2945 patom_record_V2 = (ATOM_Vega10_GFXCLK_Dependency_Record_V2 *)gfxclk_dep_table->entries;
2946 performance_level->gfx_clock = patom_record_V2[state_entry->ucGfxClockIndexHigh].ulClk;
2949 performance_level->mem_clock = mclk_dep_table->entries
2950 [state_entry->ucMemClockIndexHigh].ulMemClk;
2954 static int vega10_get_pp_table_entry(struct pp_hwmgr *hwmgr,
2955 unsigned long entry_index, struct pp_power_state *state)
2958 struct vega10_power_state *ps;
2960 state->hardware.magic = PhwVega10_Magic;
2962 ps = cast_phw_vega10_power_state(&state->hardware);
2964 result = vega10_get_powerplay_table_entry(hwmgr, entry_index, state,
2965 vega10_get_pp_table_entry_callback_func);
2968 * This is the earliest time we have all the dependency table
2969 * and the VBIOS boot state
2971 /* set DC compatible flag if this state supports DC */
2972 if (!state->validation.disallowOnDC)
2973 ps->dc_compatible = true;
2975 ps->uvd_clks.vclk = state->uvd_clocks.VCLK;
2976 ps->uvd_clks.dclk = state->uvd_clocks.DCLK;
2981 static int vega10_patch_boot_state(struct pp_hwmgr *hwmgr,
2982 struct pp_hw_power_state *hw_ps)
2987 static int vega10_apply_state_adjust_rules(struct pp_hwmgr *hwmgr,
2988 struct pp_power_state *request_ps,
2989 const struct pp_power_state *current_ps)
2991 struct vega10_power_state *vega10_ps =
2992 cast_phw_vega10_power_state(&request_ps->hardware);
2995 struct PP_Clocks minimum_clocks = {0};
2996 bool disable_mclk_switching;
2997 bool disable_mclk_switching_for_frame_lock;
2998 bool disable_mclk_switching_for_vr;
2999 bool force_mclk_high;
3000 struct cgs_display_info info = {0};
3001 const struct phm_clock_and_voltage_limits *max_limits;
3003 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
3004 struct phm_ppt_v2_information *table_info =
3005 (struct phm_ppt_v2_information *)(hwmgr->pptable);
3007 uint32_t stable_pstate_sclk_dpm_percentage;
3008 uint32_t stable_pstate_sclk = 0, stable_pstate_mclk = 0;
3011 data->battery_state = (PP_StateUILabel_Battery ==
3012 request_ps->classification.ui_label);
3014 if (vega10_ps->performance_level_count != 2)
3015 pr_info("VI should always have 2 performance levels");
3017 max_limits = (PP_PowerSource_AC == hwmgr->power_source) ?
3018 &(hwmgr->dyn_state.max_clock_voltage_on_ac) :
3019 &(hwmgr->dyn_state.max_clock_voltage_on_dc);
3021 /* Cap clock DPM tables at DC MAX if it is in DC. */
3022 if (PP_PowerSource_DC == hwmgr->power_source) {
3023 for (i = 0; i < vega10_ps->performance_level_count; i++) {
3024 if (vega10_ps->performance_levels[i].mem_clock >
3026 vega10_ps->performance_levels[i].mem_clock =
3028 if (vega10_ps->performance_levels[i].gfx_clock >
3030 vega10_ps->performance_levels[i].gfx_clock =
3035 vega10_ps->vce_clks.evclk = hwmgr->vce_arbiter.evclk;
3036 vega10_ps->vce_clks.ecclk = hwmgr->vce_arbiter.ecclk;
3038 cgs_get_active_displays_info(hwmgr->device, &info);
3040 /* result = PHM_CheckVBlankTime(hwmgr, &vblankTooShort);*/
3041 minimum_clocks.engineClock = hwmgr->display_config.min_core_set_clock;
3042 minimum_clocks.memoryClock = hwmgr->display_config.min_mem_set_clock;
3044 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3045 PHM_PlatformCaps_StablePState)) {
3046 PP_ASSERT_WITH_CODE(
3047 data->registry_data.stable_pstate_sclk_dpm_percentage >= 1 &&
3048 data->registry_data.stable_pstate_sclk_dpm_percentage <= 100,
3049 "percent sclk value must range from 1% to 100%, setting default value",
3050 stable_pstate_sclk_dpm_percentage = 75);
3052 max_limits = &(hwmgr->dyn_state.max_clock_voltage_on_ac);
3053 stable_pstate_sclk = (max_limits->sclk *
3054 stable_pstate_sclk_dpm_percentage) / 100;
3056 for (count = table_info->vdd_dep_on_sclk->count - 1;
3057 count >= 0; count--) {
3058 if (stable_pstate_sclk >=
3059 table_info->vdd_dep_on_sclk->entries[count].clk) {
3060 stable_pstate_sclk =
3061 table_info->vdd_dep_on_sclk->entries[count].clk;
3067 stable_pstate_sclk = table_info->vdd_dep_on_sclk->entries[0].clk;
3069 stable_pstate_mclk = max_limits->mclk;
3071 minimum_clocks.engineClock = stable_pstate_sclk;
3072 minimum_clocks.memoryClock = stable_pstate_mclk;
3075 if (minimum_clocks.engineClock < hwmgr->gfx_arbiter.sclk)
3076 minimum_clocks.engineClock = hwmgr->gfx_arbiter.sclk;
3078 if (minimum_clocks.memoryClock < hwmgr->gfx_arbiter.mclk)
3079 minimum_clocks.memoryClock = hwmgr->gfx_arbiter.mclk;
3081 vega10_ps->sclk_threshold = hwmgr->gfx_arbiter.sclk_threshold;
3083 if (hwmgr->gfx_arbiter.sclk_over_drive) {
3084 PP_ASSERT_WITH_CODE((hwmgr->gfx_arbiter.sclk_over_drive <=
3085 hwmgr->platform_descriptor.overdriveLimit.engineClock),
3086 "Overdrive sclk exceeds limit",
3087 hwmgr->gfx_arbiter.sclk_over_drive =
3088 hwmgr->platform_descriptor.overdriveLimit.engineClock);
3090 if (hwmgr->gfx_arbiter.sclk_over_drive >= hwmgr->gfx_arbiter.sclk)
3091 vega10_ps->performance_levels[1].gfx_clock =
3092 hwmgr->gfx_arbiter.sclk_over_drive;
3095 if (hwmgr->gfx_arbiter.mclk_over_drive) {
3096 PP_ASSERT_WITH_CODE((hwmgr->gfx_arbiter.mclk_over_drive <=
3097 hwmgr->platform_descriptor.overdriveLimit.memoryClock),
3098 "Overdrive mclk exceeds limit",
3099 hwmgr->gfx_arbiter.mclk_over_drive =
3100 hwmgr->platform_descriptor.overdriveLimit.memoryClock);
3102 if (hwmgr->gfx_arbiter.mclk_over_drive >= hwmgr->gfx_arbiter.mclk)
3103 vega10_ps->performance_levels[1].mem_clock =
3104 hwmgr->gfx_arbiter.mclk_over_drive;
3107 disable_mclk_switching_for_frame_lock = phm_cap_enabled(
3108 hwmgr->platform_descriptor.platformCaps,
3109 PHM_PlatformCaps_DisableMclkSwitchingForFrameLock);
3110 disable_mclk_switching_for_vr = phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3111 PHM_PlatformCaps_DisableMclkSwitchForVR);
3112 force_mclk_high = phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3113 PHM_PlatformCaps_ForceMclkHigh);
3115 disable_mclk_switching = (info.display_count > 1) ||
3116 disable_mclk_switching_for_frame_lock ||
3117 disable_mclk_switching_for_vr ||
3120 sclk = vega10_ps->performance_levels[0].gfx_clock;
3121 mclk = vega10_ps->performance_levels[0].mem_clock;
3123 if (sclk < minimum_clocks.engineClock)
3124 sclk = (minimum_clocks.engineClock > max_limits->sclk) ?
3125 max_limits->sclk : minimum_clocks.engineClock;
3127 if (mclk < minimum_clocks.memoryClock)
3128 mclk = (minimum_clocks.memoryClock > max_limits->mclk) ?
3129 max_limits->mclk : minimum_clocks.memoryClock;
3131 vega10_ps->performance_levels[0].gfx_clock = sclk;
3132 vega10_ps->performance_levels[0].mem_clock = mclk;
3134 if (vega10_ps->performance_levels[1].gfx_clock <
3135 vega10_ps->performance_levels[0].gfx_clock)
3136 vega10_ps->performance_levels[0].gfx_clock =
3137 vega10_ps->performance_levels[1].gfx_clock;
3139 if (disable_mclk_switching) {
3140 /* Set Mclk the max of level 0 and level 1 */
3141 if (mclk < vega10_ps->performance_levels[1].mem_clock)
3142 mclk = vega10_ps->performance_levels[1].mem_clock;
3144 /* Find the lowest MCLK frequency that is within
3145 * the tolerable latency defined in DAL
3148 for (i = 0; i < data->mclk_latency_table.count; i++) {
3149 if ((data->mclk_latency_table.entries[i].latency <= latency) &&
3150 (data->mclk_latency_table.entries[i].frequency >=
3151 vega10_ps->performance_levels[0].mem_clock) &&
3152 (data->mclk_latency_table.entries[i].frequency <=
3153 vega10_ps->performance_levels[1].mem_clock))
3154 mclk = data->mclk_latency_table.entries[i].frequency;
3156 vega10_ps->performance_levels[0].mem_clock = mclk;
3158 if (vega10_ps->performance_levels[1].mem_clock <
3159 vega10_ps->performance_levels[0].mem_clock)
3160 vega10_ps->performance_levels[0].mem_clock =
3161 vega10_ps->performance_levels[1].mem_clock;
3164 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3165 PHM_PlatformCaps_StablePState)) {
3166 for (i = 0; i < vega10_ps->performance_level_count; i++) {
3167 vega10_ps->performance_levels[i].gfx_clock = stable_pstate_sclk;
3168 vega10_ps->performance_levels[i].mem_clock = stable_pstate_mclk;
3175 static int vega10_find_dpm_states_clocks_in_dpm_table(struct pp_hwmgr *hwmgr, const void *input)
3177 const struct phm_set_power_state_input *states =
3178 (const struct phm_set_power_state_input *)input;
3179 const struct vega10_power_state *vega10_ps =
3180 cast_const_phw_vega10_power_state(states->pnew_state);
3181 struct vega10_hwmgr *data =
3182 (struct vega10_hwmgr *)(hwmgr->backend);
3183 struct vega10_single_dpm_table *sclk_table =
3184 &(data->dpm_table.gfx_table);
3185 uint32_t sclk = vega10_ps->performance_levels
3186 [vega10_ps->performance_level_count - 1].gfx_clock;
3187 struct vega10_single_dpm_table *mclk_table =
3188 &(data->dpm_table.mem_table);
3189 uint32_t mclk = vega10_ps->performance_levels
3190 [vega10_ps->performance_level_count - 1].mem_clock;
3191 struct PP_Clocks min_clocks = {0};
3193 struct cgs_display_info info = {0};
3195 data->need_update_dpm_table = 0;
3197 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3198 PHM_PlatformCaps_ODNinACSupport) ||
3199 phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3200 PHM_PlatformCaps_ODNinDCSupport)) {
3201 for (i = 0; i < sclk_table->count; i++) {
3202 if (sclk == sclk_table->dpm_levels[i].value)
3206 if (!(data->apply_overdrive_next_settings_mask &
3207 DPMTABLE_OD_UPDATE_SCLK) && i >= sclk_table->count) {
3208 /* Check SCLK in DAL's minimum clocks
3209 * in case DeepSleep divider update is required.
3211 if (data->display_timing.min_clock_in_sr !=
3212 min_clocks.engineClockInSR &&
3213 (min_clocks.engineClockInSR >=
3214 VEGA10_MINIMUM_ENGINE_CLOCK ||
3215 data->display_timing.min_clock_in_sr >=
3216 VEGA10_MINIMUM_ENGINE_CLOCK))
3217 data->need_update_dpm_table |= DPMTABLE_UPDATE_SCLK;
3220 cgs_get_active_displays_info(hwmgr->device, &info);
3222 if (data->display_timing.num_existing_displays !=
3224 data->need_update_dpm_table |= DPMTABLE_UPDATE_MCLK;
3226 for (i = 0; i < sclk_table->count; i++) {
3227 if (sclk == sclk_table->dpm_levels[i].value)
3231 if (i >= sclk_table->count)
3232 data->need_update_dpm_table |= DPMTABLE_OD_UPDATE_SCLK;
3234 /* Check SCLK in DAL's minimum clocks
3235 * in case DeepSleep divider update is required.
3237 if (data->display_timing.min_clock_in_sr !=
3238 min_clocks.engineClockInSR &&
3239 (min_clocks.engineClockInSR >=
3240 VEGA10_MINIMUM_ENGINE_CLOCK ||
3241 data->display_timing.min_clock_in_sr >=
3242 VEGA10_MINIMUM_ENGINE_CLOCK))
3243 data->need_update_dpm_table |= DPMTABLE_UPDATE_SCLK;
3246 for (i = 0; i < mclk_table->count; i++) {
3247 if (mclk == mclk_table->dpm_levels[i].value)
3251 cgs_get_active_displays_info(hwmgr->device, &info);
3253 if (i >= mclk_table->count)
3254 data->need_update_dpm_table |= DPMTABLE_OD_UPDATE_MCLK;
3256 if (data->display_timing.num_existing_displays !=
3257 info.display_count ||
3258 i >= mclk_table->count)
3259 data->need_update_dpm_table |= DPMTABLE_UPDATE_MCLK;
3264 static int vega10_populate_and_upload_sclk_mclk_dpm_levels(
3265 struct pp_hwmgr *hwmgr, const void *input)
3268 const struct phm_set_power_state_input *states =
3269 (const struct phm_set_power_state_input *)input;
3270 const struct vega10_power_state *vega10_ps =
3271 cast_const_phw_vega10_power_state(states->pnew_state);
3272 struct vega10_hwmgr *data =
3273 (struct vega10_hwmgr *)(hwmgr->backend);
3274 uint32_t sclk = vega10_ps->performance_levels
3275 [vega10_ps->performance_level_count - 1].gfx_clock;
3276 uint32_t mclk = vega10_ps->performance_levels
3277 [vega10_ps->performance_level_count - 1].mem_clock;
3278 struct vega10_dpm_table *dpm_table = &data->dpm_table;
3279 struct vega10_dpm_table *golden_dpm_table =
3280 &data->golden_dpm_table;
3281 uint32_t dpm_count, clock_percent;
3284 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3285 PHM_PlatformCaps_ODNinACSupport) ||
3286 phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3287 PHM_PlatformCaps_ODNinDCSupport)) {
3289 if (!data->need_update_dpm_table &&
3290 !data->apply_optimized_settings &&
3291 !data->apply_overdrive_next_settings_mask)
3294 if (data->apply_overdrive_next_settings_mask &
3295 DPMTABLE_OD_UPDATE_SCLK) {
3297 dpm_count < dpm_table->gfx_table.count;
3299 dpm_table->gfx_table.dpm_levels[dpm_count].enabled =
3300 data->odn_dpm_table.odn_core_clock_dpm_levels.
3301 performance_level_entries[dpm_count].enabled;
3302 dpm_table->gfx_table.dpm_levels[dpm_count].value =
3303 data->odn_dpm_table.odn_core_clock_dpm_levels.
3304 performance_level_entries[dpm_count].clock;
3308 if (data->apply_overdrive_next_settings_mask &
3309 DPMTABLE_OD_UPDATE_MCLK) {
3311 dpm_count < dpm_table->mem_table.count;
3313 dpm_table->mem_table.dpm_levels[dpm_count].enabled =
3314 data->odn_dpm_table.odn_memory_clock_dpm_levels.
3315 performance_level_entries[dpm_count].enabled;
3316 dpm_table->mem_table.dpm_levels[dpm_count].value =
3317 data->odn_dpm_table.odn_memory_clock_dpm_levels.
3318 performance_level_entries[dpm_count].clock;
3322 if ((data->need_update_dpm_table & DPMTABLE_UPDATE_SCLK) ||
3323 data->apply_optimized_settings ||
3324 (data->apply_overdrive_next_settings_mask &
3325 DPMTABLE_OD_UPDATE_SCLK)) {
3326 result = vega10_populate_all_graphic_levels(hwmgr);
3327 PP_ASSERT_WITH_CODE(!result,
3328 "Failed to populate SCLK during \
3329 PopulateNewDPMClocksStates Function!",
3333 if ((data->need_update_dpm_table & DPMTABLE_UPDATE_MCLK) ||
3334 (data->apply_overdrive_next_settings_mask &
3335 DPMTABLE_OD_UPDATE_MCLK)){
3336 result = vega10_populate_all_memory_levels(hwmgr);
3337 PP_ASSERT_WITH_CODE(!result,
3338 "Failed to populate MCLK during \
3339 PopulateNewDPMClocksStates Function!",
3343 if (!data->need_update_dpm_table &&
3344 !data->apply_optimized_settings)
3347 if (data->need_update_dpm_table & DPMTABLE_OD_UPDATE_SCLK &&
3348 data->smu_features[GNLD_DPM_GFXCLK].supported) {
3350 gfx_table.dpm_levels[dpm_table->gfx_table.count - 1].
3352 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3353 PHM_PlatformCaps_OD6PlusinACSupport) ||
3354 phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3355 PHM_PlatformCaps_OD6PlusinDCSupport)) {
3356 /* Need to do calculation based on the golden DPM table
3357 * as the Heatmap GPU Clock axis is also based on
3358 * the default values
3360 PP_ASSERT_WITH_CODE(
3361 golden_dpm_table->gfx_table.dpm_levels
3362 [golden_dpm_table->gfx_table.count - 1].value,
3366 dpm_count = dpm_table->gfx_table.count < 2 ?
3367 0 : dpm_table->gfx_table.count - 2;
3368 for (i = dpm_count; i > 1; i--) {
3369 if (sclk > golden_dpm_table->gfx_table.dpm_levels
3370 [golden_dpm_table->gfx_table.count - 1].value) {
3372 ((sclk - golden_dpm_table->gfx_table.dpm_levels
3373 [golden_dpm_table->gfx_table.count - 1].value) *
3375 golden_dpm_table->gfx_table.dpm_levels
3376 [golden_dpm_table->gfx_table.count - 1].value;
3378 dpm_table->gfx_table.dpm_levels[i].value =
3379 golden_dpm_table->gfx_table.dpm_levels[i].value +
3380 (golden_dpm_table->gfx_table.dpm_levels[i].value *
3381 clock_percent) / 100;
3382 } else if (golden_dpm_table->
3383 gfx_table.dpm_levels[dpm_table->gfx_table.count-1].value >
3386 ((golden_dpm_table->gfx_table.dpm_levels
3387 [golden_dpm_table->gfx_table.count - 1].value -
3389 golden_dpm_table->gfx_table.dpm_levels
3390 [golden_dpm_table->gfx_table.count-1].value;
3392 dpm_table->gfx_table.dpm_levels[i].value =
3393 golden_dpm_table->gfx_table.dpm_levels[i].value -
3394 (golden_dpm_table->gfx_table.dpm_levels[i].value *
3395 clock_percent) / 100;
3397 dpm_table->gfx_table.dpm_levels[i].value =
3398 golden_dpm_table->gfx_table.dpm_levels[i].value;
3403 if (data->need_update_dpm_table & DPMTABLE_OD_UPDATE_MCLK &&
3404 data->smu_features[GNLD_DPM_UCLK].supported) {
3406 mem_table.dpm_levels[dpm_table->mem_table.count - 1].
3409 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3410 PHM_PlatformCaps_OD6PlusinACSupport) ||
3411 phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3412 PHM_PlatformCaps_OD6PlusinDCSupport)) {
3414 PP_ASSERT_WITH_CODE(
3415 golden_dpm_table->mem_table.dpm_levels
3416 [golden_dpm_table->mem_table.count - 1].value,
3420 dpm_count = dpm_table->mem_table.count < 2 ?
3421 0 : dpm_table->mem_table.count - 2;
3422 for (i = dpm_count; i > 1; i--) {
3423 if (mclk > golden_dpm_table->mem_table.dpm_levels
3424 [golden_dpm_table->mem_table.count-1].value) {
3425 clock_percent = ((mclk -
3426 golden_dpm_table->mem_table.dpm_levels
3427 [golden_dpm_table->mem_table.count-1].value) *
3429 golden_dpm_table->mem_table.dpm_levels
3430 [golden_dpm_table->mem_table.count-1].value;
3432 dpm_table->mem_table.dpm_levels[i].value =
3433 golden_dpm_table->mem_table.dpm_levels[i].value +
3434 (golden_dpm_table->mem_table.dpm_levels[i].value *
3435 clock_percent) / 100;
3436 } else if (golden_dpm_table->mem_table.dpm_levels
3437 [dpm_table->mem_table.count-1].value > mclk) {
3438 clock_percent = ((golden_dpm_table->mem_table.dpm_levels
3439 [golden_dpm_table->mem_table.count-1].value - mclk) *
3441 golden_dpm_table->mem_table.dpm_levels
3442 [golden_dpm_table->mem_table.count-1].value;
3444 dpm_table->mem_table.dpm_levels[i].value =
3445 golden_dpm_table->mem_table.dpm_levels[i].value -
3446 (golden_dpm_table->mem_table.dpm_levels[i].value *
3447 clock_percent) / 100;
3449 dpm_table->mem_table.dpm_levels[i].value =
3450 golden_dpm_table->mem_table.dpm_levels[i].value;
3455 if ((data->need_update_dpm_table &
3456 (DPMTABLE_OD_UPDATE_SCLK + DPMTABLE_UPDATE_SCLK)) ||
3457 data->apply_optimized_settings) {
3458 result = vega10_populate_all_graphic_levels(hwmgr);
3459 PP_ASSERT_WITH_CODE(!result,
3460 "Failed to populate SCLK during \
3461 PopulateNewDPMClocksStates Function!",
3465 if (data->need_update_dpm_table &
3466 (DPMTABLE_OD_UPDATE_MCLK + DPMTABLE_UPDATE_MCLK)) {
3467 result = vega10_populate_all_memory_levels(hwmgr);
3468 PP_ASSERT_WITH_CODE(!result,
3469 "Failed to populate MCLK during \
3470 PopulateNewDPMClocksStates Function!",
3477 static int vega10_trim_single_dpm_states(struct pp_hwmgr *hwmgr,
3478 struct vega10_single_dpm_table *dpm_table,
3479 uint32_t low_limit, uint32_t high_limit)
3483 for (i = 0; i < dpm_table->count; i++) {
3484 if ((dpm_table->dpm_levels[i].value < low_limit) ||
3485 (dpm_table->dpm_levels[i].value > high_limit))
3486 dpm_table->dpm_levels[i].enabled = false;
3488 dpm_table->dpm_levels[i].enabled = true;
3493 static int vega10_trim_single_dpm_states_with_mask(struct pp_hwmgr *hwmgr,
3494 struct vega10_single_dpm_table *dpm_table,
3495 uint32_t low_limit, uint32_t high_limit,
3496 uint32_t disable_dpm_mask)
3500 for (i = 0; i < dpm_table->count; i++) {
3501 if ((dpm_table->dpm_levels[i].value < low_limit) ||
3502 (dpm_table->dpm_levels[i].value > high_limit))
3503 dpm_table->dpm_levels[i].enabled = false;
3504 else if (!((1 << i) & disable_dpm_mask))
3505 dpm_table->dpm_levels[i].enabled = false;
3507 dpm_table->dpm_levels[i].enabled = true;
3512 static int vega10_trim_dpm_states(struct pp_hwmgr *hwmgr,
3513 const struct vega10_power_state *vega10_ps)
3515 struct vega10_hwmgr *data =
3516 (struct vega10_hwmgr *)(hwmgr->backend);
3517 uint32_t high_limit_count;
3519 PP_ASSERT_WITH_CODE((vega10_ps->performance_level_count >= 1),
3520 "power state did not have any performance level",
3523 high_limit_count = (vega10_ps->performance_level_count == 1) ? 0 : 1;
3525 vega10_trim_single_dpm_states(hwmgr,
3526 &(data->dpm_table.soc_table),
3527 vega10_ps->performance_levels[0].soc_clock,
3528 vega10_ps->performance_levels[high_limit_count].soc_clock);
3530 vega10_trim_single_dpm_states_with_mask(hwmgr,
3531 &(data->dpm_table.gfx_table),
3532 vega10_ps->performance_levels[0].gfx_clock,
3533 vega10_ps->performance_levels[high_limit_count].gfx_clock,
3534 data->disable_dpm_mask);
3536 vega10_trim_single_dpm_states(hwmgr,
3537 &(data->dpm_table.mem_table),
3538 vega10_ps->performance_levels[0].mem_clock,
3539 vega10_ps->performance_levels[high_limit_count].mem_clock);
3544 static uint32_t vega10_find_lowest_dpm_level(
3545 struct vega10_single_dpm_table *table)
3549 for (i = 0; i < table->count; i++) {
3550 if (table->dpm_levels[i].enabled)
3557 static uint32_t vega10_find_highest_dpm_level(
3558 struct vega10_single_dpm_table *table)
3562 if (table->count <= MAX_REGULAR_DPM_NUMBER) {
3563 for (i = table->count; i > 0; i--) {
3564 if (table->dpm_levels[i - 1].enabled)
3568 pr_info("DPM Table Has Too Many Entries!");
3569 return MAX_REGULAR_DPM_NUMBER - 1;
3575 static void vega10_apply_dal_minimum_voltage_request(
3576 struct pp_hwmgr *hwmgr)
3581 static int vega10_upload_dpm_bootup_level(struct pp_hwmgr *hwmgr)
3583 struct vega10_hwmgr *data =
3584 (struct vega10_hwmgr *)(hwmgr->backend);
3586 vega10_apply_dal_minimum_voltage_request(hwmgr);
3588 if (!data->registry_data.sclk_dpm_key_disabled) {
3589 if (data->smc_state_table.gfx_boot_level !=
3590 data->dpm_table.gfx_table.dpm_state.soft_min_level) {
3591 PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc_with_parameter(
3593 PPSMC_MSG_SetSoftMinGfxclkByIndex,
3594 data->smc_state_table.gfx_boot_level),
3595 "Failed to set soft min sclk index!",
3597 data->dpm_table.gfx_table.dpm_state.soft_min_level =
3598 data->smc_state_table.gfx_boot_level;
3602 if (!data->registry_data.mclk_dpm_key_disabled) {
3603 if (data->smc_state_table.mem_boot_level !=
3604 data->dpm_table.mem_table.dpm_state.soft_min_level) {
3605 PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc_with_parameter(
3607 PPSMC_MSG_SetSoftMinUclkByIndex,
3608 data->smc_state_table.mem_boot_level),
3609 "Failed to set soft min mclk index!",
3612 data->dpm_table.mem_table.dpm_state.soft_min_level =
3613 data->smc_state_table.mem_boot_level;
3620 static int vega10_upload_dpm_max_level(struct pp_hwmgr *hwmgr)
3622 struct vega10_hwmgr *data =
3623 (struct vega10_hwmgr *)(hwmgr->backend);
3625 vega10_apply_dal_minimum_voltage_request(hwmgr);
3627 if (!data->registry_data.sclk_dpm_key_disabled) {
3628 if (data->smc_state_table.gfx_max_level !=
3629 data->dpm_table.gfx_table.dpm_state.soft_max_level) {
3630 PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc_with_parameter(
3632 PPSMC_MSG_SetSoftMaxGfxclkByIndex,
3633 data->smc_state_table.gfx_max_level),
3634 "Failed to set soft max sclk index!",
3636 data->dpm_table.gfx_table.dpm_state.soft_max_level =
3637 data->smc_state_table.gfx_max_level;
3641 if (!data->registry_data.mclk_dpm_key_disabled) {
3642 if (data->smc_state_table.mem_max_level !=
3643 data->dpm_table.mem_table.dpm_state.soft_max_level) {
3644 PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc_with_parameter(
3646 PPSMC_MSG_SetSoftMaxUclkByIndex,
3647 data->smc_state_table.mem_max_level),
3648 "Failed to set soft max mclk index!",
3650 data->dpm_table.mem_table.dpm_state.soft_max_level =
3651 data->smc_state_table.mem_max_level;
3658 static int vega10_generate_dpm_level_enable_mask(
3659 struct pp_hwmgr *hwmgr, const void *input)
3661 struct vega10_hwmgr *data =
3662 (struct vega10_hwmgr *)(hwmgr->backend);
3663 const struct phm_set_power_state_input *states =
3664 (const struct phm_set_power_state_input *)input;
3665 const struct vega10_power_state *vega10_ps =
3666 cast_const_phw_vega10_power_state(states->pnew_state);
3669 PP_ASSERT_WITH_CODE(!vega10_trim_dpm_states(hwmgr, vega10_ps),
3670 "Attempt to Trim DPM States Failed!",
3673 data->smc_state_table.gfx_boot_level =
3674 vega10_find_lowest_dpm_level(&(data->dpm_table.gfx_table));
3675 data->smc_state_table.gfx_max_level =
3676 vega10_find_highest_dpm_level(&(data->dpm_table.gfx_table));
3677 data->smc_state_table.mem_boot_level =
3678 vega10_find_lowest_dpm_level(&(data->dpm_table.mem_table));
3679 data->smc_state_table.mem_max_level =
3680 vega10_find_highest_dpm_level(&(data->dpm_table.mem_table));
3682 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_bootup_level(hwmgr),
3683 "Attempt to upload DPM Bootup Levels Failed!",
3685 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_max_level(hwmgr),
3686 "Attempt to upload DPM Max Levels Failed!",
3688 for(i = data->smc_state_table.gfx_boot_level; i < data->smc_state_table.gfx_max_level; i++)
3689 data->dpm_table.gfx_table.dpm_levels[i].enabled = true;
3692 for(i = data->smc_state_table.mem_boot_level; i < data->smc_state_table.mem_max_level; i++)
3693 data->dpm_table.mem_table.dpm_levels[i].enabled = true;
3698 int vega10_enable_disable_vce_dpm(struct pp_hwmgr *hwmgr, bool enable)
3700 struct vega10_hwmgr *data =
3701 (struct vega10_hwmgr *)(hwmgr->backend);
3703 if (data->smu_features[GNLD_DPM_VCE].supported) {
3704 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
3706 data->smu_features[GNLD_DPM_VCE].smu_feature_bitmap),
3707 "Attempt to Enable/Disable DPM VCE Failed!",
3709 data->smu_features[GNLD_DPM_VCE].enabled = enable;
3715 static int vega10_update_sclk_threshold(struct pp_hwmgr *hwmgr)
3717 struct vega10_hwmgr *data =
3718 (struct vega10_hwmgr *)(hwmgr->backend);
3720 uint32_t low_sclk_interrupt_threshold = 0;
3722 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
3723 PHM_PlatformCaps_SclkThrottleLowNotification)
3724 && (hwmgr->gfx_arbiter.sclk_threshold !=
3725 data->low_sclk_interrupt_threshold)) {
3726 data->low_sclk_interrupt_threshold =
3727 hwmgr->gfx_arbiter.sclk_threshold;
3728 low_sclk_interrupt_threshold =
3729 data->low_sclk_interrupt_threshold;
3731 data->smc_state_table.pp_table.LowGfxclkInterruptThreshold =
3732 cpu_to_le32(low_sclk_interrupt_threshold);
3734 /* This message will also enable SmcToHost Interrupt */
3735 result = smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
3736 PPSMC_MSG_SetLowGfxclkInterruptThreshold,
3737 (uint32_t)low_sclk_interrupt_threshold);
3743 static int vega10_set_power_state_tasks(struct pp_hwmgr *hwmgr,
3746 int tmp_result, result = 0;
3747 struct vega10_hwmgr *data =
3748 (struct vega10_hwmgr *)(hwmgr->backend);
3749 PPTable_t *pp_table = &(data->smc_state_table.pp_table);
3751 tmp_result = vega10_find_dpm_states_clocks_in_dpm_table(hwmgr, input);
3752 PP_ASSERT_WITH_CODE(!tmp_result,
3753 "Failed to find DPM states clocks in DPM table!",
3754 result = tmp_result);
3756 tmp_result = vega10_populate_and_upload_sclk_mclk_dpm_levels(hwmgr, input);
3757 PP_ASSERT_WITH_CODE(!tmp_result,
3758 "Failed to populate and upload SCLK MCLK DPM levels!",
3759 result = tmp_result);
3761 tmp_result = vega10_generate_dpm_level_enable_mask(hwmgr, input);
3762 PP_ASSERT_WITH_CODE(!tmp_result,
3763 "Failed to generate DPM level enabled mask!",
3764 result = tmp_result);
3766 tmp_result = vega10_update_sclk_threshold(hwmgr);
3767 PP_ASSERT_WITH_CODE(!tmp_result,
3768 "Failed to update SCLK threshold!",
3769 result = tmp_result);
3771 result = vega10_copy_table_to_smc(hwmgr->smumgr,
3772 (uint8_t *)pp_table, PPTABLE);
3773 PP_ASSERT_WITH_CODE(!result,
3774 "Failed to upload PPtable!", return result);
3776 data->apply_optimized_settings = false;
3777 data->apply_overdrive_next_settings_mask = 0;
3782 static int vega10_dpm_get_sclk(struct pp_hwmgr *hwmgr, bool low)
3784 struct pp_power_state *ps;
3785 struct vega10_power_state *vega10_ps;
3790 ps = hwmgr->request_ps;
3795 vega10_ps = cast_phw_vega10_power_state(&ps->hardware);
3798 return vega10_ps->performance_levels[0].gfx_clock;
3800 return vega10_ps->performance_levels
3801 [vega10_ps->performance_level_count - 1].gfx_clock;
3804 static int vega10_dpm_get_mclk(struct pp_hwmgr *hwmgr, bool low)
3806 struct pp_power_state *ps;
3807 struct vega10_power_state *vega10_ps;
3812 ps = hwmgr->request_ps;
3817 vega10_ps = cast_phw_vega10_power_state(&ps->hardware);
3820 return vega10_ps->performance_levels[0].mem_clock;
3822 return vega10_ps->performance_levels
3823 [vega10_ps->performance_level_count-1].mem_clock;
3826 static int vega10_get_gpu_power(struct pp_hwmgr *hwmgr,
3827 struct pp_gpu_power *query)
3831 PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc(hwmgr->smumgr,
3832 PPSMC_MSG_GetCurrPkgPwr),
3833 "Failed to get current package power!",
3836 vega10_read_arg_from_smc(hwmgr->smumgr, &value);
3837 /* power value is an integer */
3838 query->average_gpu_power = value << 8;
3843 static int vega10_read_sensor(struct pp_hwmgr *hwmgr, int idx,
3844 void *value, int *size)
3846 uint32_t sclk_idx, mclk_idx, activity_percent = 0;
3847 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
3848 struct vega10_dpm_table *dpm_table = &data->dpm_table;
3852 case AMDGPU_PP_SENSOR_GFX_SCLK:
3853 ret = smum_send_msg_to_smc(hwmgr->smumgr, PPSMC_MSG_GetCurrentGfxclkIndex);
3855 vega10_read_arg_from_smc(hwmgr->smumgr, &sclk_idx);
3856 *((uint32_t *)value) = dpm_table->gfx_table.dpm_levels[sclk_idx].value;
3860 case AMDGPU_PP_SENSOR_GFX_MCLK:
3861 ret = smum_send_msg_to_smc(hwmgr->smumgr, PPSMC_MSG_GetCurrentUclkIndex);
3863 vega10_read_arg_from_smc(hwmgr->smumgr, &mclk_idx);
3864 *((uint32_t *)value) = dpm_table->mem_table.dpm_levels[mclk_idx].value;
3868 case AMDGPU_PP_SENSOR_GPU_LOAD:
3869 ret = smum_send_msg_to_smc_with_parameter(hwmgr->smumgr, PPSMC_MSG_GetAverageGfxActivity, 0);
3871 vega10_read_arg_from_smc(hwmgr->smumgr, &activity_percent);
3872 *((uint32_t *)value) = activity_percent > 100 ? 100 : activity_percent;
3876 case AMDGPU_PP_SENSOR_GPU_TEMP:
3877 *((uint32_t *)value) = vega10_thermal_get_temperature(hwmgr);
3880 case AMDGPU_PP_SENSOR_UVD_POWER:
3881 *((uint32_t *)value) = data->uvd_power_gated ? 0 : 1;
3884 case AMDGPU_PP_SENSOR_VCE_POWER:
3885 *((uint32_t *)value) = data->vce_power_gated ? 0 : 1;
3888 case AMDGPU_PP_SENSOR_GPU_POWER:
3889 if (*size < sizeof(struct pp_gpu_power))
3892 *size = sizeof(struct pp_gpu_power);
3893 ret = vega10_get_gpu_power(hwmgr, (struct pp_gpu_power *)value);
3903 static int vega10_notify_smc_display_change(struct pp_hwmgr *hwmgr,
3906 return smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
3907 PPSMC_MSG_SetUclkFastSwitch,
3911 int vega10_display_clock_voltage_request(struct pp_hwmgr *hwmgr,
3912 struct pp_display_clock_request *clock_req)
3915 enum amd_pp_clock_type clk_type = clock_req->clock_type;
3916 uint32_t clk_freq = clock_req->clock_freq_in_khz / 1000;
3917 DSPCLK_e clk_select = 0;
3918 uint32_t clk_request = 0;
3921 case amd_pp_dcef_clock:
3922 clk_select = DSPCLK_DCEFCLK;
3924 case amd_pp_disp_clock:
3925 clk_select = DSPCLK_DISPCLK;
3927 case amd_pp_pixel_clock:
3928 clk_select = DSPCLK_PIXCLK;
3930 case amd_pp_phy_clock:
3931 clk_select = DSPCLK_PHYCLK;
3934 pr_info("[DisplayClockVoltageRequest]Invalid Clock Type!");
3940 clk_request = (clk_freq << 16) | clk_select;
3941 result = smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
3942 PPSMC_MSG_RequestDisplayClockByFreq,
3949 static uint8_t vega10_get_uclk_index(struct pp_hwmgr *hwmgr,
3950 struct phm_ppt_v1_clock_voltage_dependency_table *mclk_table,
3956 if (mclk_table == NULL || mclk_table->count == 0)
3959 count = (uint8_t)(mclk_table->count);
3961 for(i = 0; i < count; i++) {
3962 if(mclk_table->entries[i].clk >= frequency)
3969 static int vega10_notify_smc_display_config_after_ps_adjustment(
3970 struct pp_hwmgr *hwmgr)
3972 struct vega10_hwmgr *data =
3973 (struct vega10_hwmgr *)(hwmgr->backend);
3974 struct vega10_single_dpm_table *dpm_table =
3975 &data->dpm_table.dcef_table;
3976 struct phm_ppt_v2_information *table_info =
3977 (struct phm_ppt_v2_information *)hwmgr->pptable;
3978 struct phm_ppt_v1_clock_voltage_dependency_table *mclk_table = table_info->vdd_dep_on_mclk;
3980 uint32_t num_active_disps = 0;
3981 struct cgs_display_info info = {0};
3982 struct PP_Clocks min_clocks = {0};
3984 struct pp_display_clock_request clock_req;
3986 info.mode_info = NULL;
3988 cgs_get_active_displays_info(hwmgr->device, &info);
3990 num_active_disps = info.display_count;
3992 if (num_active_disps > 1)
3993 vega10_notify_smc_display_change(hwmgr, false);
3995 vega10_notify_smc_display_change(hwmgr, true);
3997 min_clocks.dcefClock = hwmgr->display_config.min_dcef_set_clk;
3998 min_clocks.dcefClockInSR = hwmgr->display_config.min_dcef_deep_sleep_set_clk;
3999 min_clocks.memoryClock = hwmgr->display_config.min_mem_set_clock;
4001 for (i = 0; i < dpm_table->count; i++) {
4002 if (dpm_table->dpm_levels[i].value == min_clocks.dcefClock)
4006 if (i < dpm_table->count) {
4007 clock_req.clock_type = amd_pp_dcef_clock;
4008 clock_req.clock_freq_in_khz = dpm_table->dpm_levels[i].value;
4009 if (!vega10_display_clock_voltage_request(hwmgr, &clock_req)) {
4010 PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc_with_parameter(
4011 hwmgr->smumgr, PPSMC_MSG_SetMinDeepSleepDcefclk,
4012 min_clocks.dcefClockInSR /100),
4013 "Attempt to set divider for DCEFCLK Failed!",);
4015 pr_info("Attempt to set Hard Min for DCEFCLK Failed!");
4018 pr_info("Cannot find requested DCEFCLK!");
4021 if (min_clocks.memoryClock != 0) {
4022 idx = vega10_get_uclk_index(hwmgr, mclk_table, min_clocks.memoryClock);
4023 smum_send_msg_to_smc_with_parameter(hwmgr->smumgr, PPSMC_MSG_SetSoftMinUclkByIndex, idx);
4024 data->dpm_table.mem_table.dpm_state.soft_min_level= idx;
4030 static int vega10_force_dpm_highest(struct pp_hwmgr *hwmgr)
4032 struct vega10_hwmgr *data =
4033 (struct vega10_hwmgr *)(hwmgr->backend);
4035 data->smc_state_table.gfx_boot_level =
4036 data->smc_state_table.gfx_max_level =
4037 vega10_find_highest_dpm_level(&(data->dpm_table.gfx_table));
4038 data->smc_state_table.mem_boot_level =
4039 data->smc_state_table.mem_max_level =
4040 vega10_find_highest_dpm_level(&(data->dpm_table.mem_table));
4042 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_bootup_level(hwmgr),
4043 "Failed to upload boot level to highest!",
4046 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_max_level(hwmgr),
4047 "Failed to upload dpm max level to highest!",
4053 static int vega10_force_dpm_lowest(struct pp_hwmgr *hwmgr)
4055 struct vega10_hwmgr *data =
4056 (struct vega10_hwmgr *)(hwmgr->backend);
4058 data->smc_state_table.gfx_boot_level =
4059 data->smc_state_table.gfx_max_level =
4060 vega10_find_lowest_dpm_level(&(data->dpm_table.gfx_table));
4061 data->smc_state_table.mem_boot_level =
4062 data->smc_state_table.mem_max_level =
4063 vega10_find_lowest_dpm_level(&(data->dpm_table.mem_table));
4065 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_bootup_level(hwmgr),
4066 "Failed to upload boot level to highest!",
4069 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_max_level(hwmgr),
4070 "Failed to upload dpm max level to highest!",
4077 static int vega10_unforce_dpm_levels(struct pp_hwmgr *hwmgr)
4079 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4081 data->smc_state_table.gfx_boot_level =
4082 vega10_find_lowest_dpm_level(&(data->dpm_table.gfx_table));
4083 data->smc_state_table.gfx_max_level =
4084 vega10_find_highest_dpm_level(&(data->dpm_table.gfx_table));
4085 data->smc_state_table.mem_boot_level =
4086 vega10_find_lowest_dpm_level(&(data->dpm_table.mem_table));
4087 data->smc_state_table.mem_max_level =
4088 vega10_find_highest_dpm_level(&(data->dpm_table.mem_table));
4090 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_bootup_level(hwmgr),
4091 "Failed to upload DPM Bootup Levels!",
4094 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_max_level(hwmgr),
4095 "Failed to upload DPM Max Levels!",
4100 static int vega10_dpm_force_dpm_level(struct pp_hwmgr *hwmgr,
4101 enum amd_dpm_forced_level level)
4106 case AMD_DPM_FORCED_LEVEL_HIGH:
4107 ret = vega10_force_dpm_highest(hwmgr);
4111 case AMD_DPM_FORCED_LEVEL_LOW:
4112 ret = vega10_force_dpm_lowest(hwmgr);
4116 case AMD_DPM_FORCED_LEVEL_AUTO:
4117 ret = vega10_unforce_dpm_levels(hwmgr);
4125 hwmgr->dpm_level = level;
4130 static int vega10_set_fan_control_mode(struct pp_hwmgr *hwmgr, uint32_t mode)
4135 case AMD_FAN_CTRL_NONE:
4136 result = vega10_fan_ctrl_set_fan_speed_percent(hwmgr, 100);
4138 case AMD_FAN_CTRL_MANUAL:
4139 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
4140 PHM_PlatformCaps_MicrocodeFanControl))
4141 result = vega10_fan_ctrl_stop_smc_fan_control(hwmgr);
4143 case AMD_FAN_CTRL_AUTO:
4144 result = vega10_fan_ctrl_set_static_mode(hwmgr, mode);
4146 result = vega10_fan_ctrl_start_smc_fan_control(hwmgr);
4154 static int vega10_get_fan_control_mode(struct pp_hwmgr *hwmgr)
4156 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4158 if (data->smu_features[GNLD_FAN_CONTROL].enabled == false)
4159 return AMD_FAN_CTRL_MANUAL;
4161 return AMD_FAN_CTRL_AUTO;
4164 static int vega10_get_dal_power_level(struct pp_hwmgr *hwmgr,
4165 struct amd_pp_simple_clock_info *info)
4167 struct phm_ppt_v2_information *table_info =
4168 (struct phm_ppt_v2_information *)hwmgr->pptable;
4169 struct phm_clock_and_voltage_limits *max_limits =
4170 &table_info->max_clock_voltage_on_ac;
4172 info->engine_max_clock = max_limits->sclk;
4173 info->memory_max_clock = max_limits->mclk;
4178 static void vega10_get_sclks(struct pp_hwmgr *hwmgr,
4179 struct pp_clock_levels_with_latency *clocks)
4181 struct phm_ppt_v2_information *table_info =
4182 (struct phm_ppt_v2_information *)hwmgr->pptable;
4183 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table =
4184 table_info->vdd_dep_on_sclk;
4187 for (i = 0; i < dep_table->count; i++) {
4188 if (dep_table->entries[i].clk) {
4189 clocks->data[clocks->num_levels].clocks_in_khz =
4190 dep_table->entries[i].clk;
4191 clocks->num_levels++;
4197 static uint32_t vega10_get_mem_latency(struct pp_hwmgr *hwmgr,
4200 if (clock >= MEM_FREQ_LOW_LATENCY &&
4201 clock < MEM_FREQ_HIGH_LATENCY)
4202 return MEM_LATENCY_HIGH;
4203 else if (clock >= MEM_FREQ_HIGH_LATENCY)
4204 return MEM_LATENCY_LOW;
4206 return MEM_LATENCY_ERR;
4209 static void vega10_get_memclocks(struct pp_hwmgr *hwmgr,
4210 struct pp_clock_levels_with_latency *clocks)
4212 struct phm_ppt_v2_information *table_info =
4213 (struct phm_ppt_v2_information *)hwmgr->pptable;
4214 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table =
4215 table_info->vdd_dep_on_mclk;
4216 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4219 clocks->num_levels = 0;
4220 data->mclk_latency_table.count = 0;
4222 for (i = 0; i < dep_table->count; i++) {
4223 if (dep_table->entries[i].clk) {
4224 clocks->data[clocks->num_levels].clocks_in_khz =
4225 data->mclk_latency_table.entries
4226 [data->mclk_latency_table.count].frequency =
4227 dep_table->entries[i].clk;
4228 clocks->data[clocks->num_levels].latency_in_us =
4229 data->mclk_latency_table.entries
4230 [data->mclk_latency_table.count].latency =
4231 vega10_get_mem_latency(hwmgr,
4232 dep_table->entries[i].clk);
4233 clocks->num_levels++;
4234 data->mclk_latency_table.count++;
4239 static void vega10_get_dcefclocks(struct pp_hwmgr *hwmgr,
4240 struct pp_clock_levels_with_latency *clocks)
4242 struct phm_ppt_v2_information *table_info =
4243 (struct phm_ppt_v2_information *)hwmgr->pptable;
4244 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table =
4245 table_info->vdd_dep_on_dcefclk;
4248 for (i = 0; i < dep_table->count; i++) {
4249 clocks->data[i].clocks_in_khz = dep_table->entries[i].clk;
4250 clocks->data[i].latency_in_us = 0;
4251 clocks->num_levels++;
4255 static void vega10_get_socclocks(struct pp_hwmgr *hwmgr,
4256 struct pp_clock_levels_with_latency *clocks)
4258 struct phm_ppt_v2_information *table_info =
4259 (struct phm_ppt_v2_information *)hwmgr->pptable;
4260 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table =
4261 table_info->vdd_dep_on_socclk;
4264 for (i = 0; i < dep_table->count; i++) {
4265 clocks->data[i].clocks_in_khz = dep_table->entries[i].clk;
4266 clocks->data[i].latency_in_us = 0;
4267 clocks->num_levels++;
4271 static int vega10_get_clock_by_type_with_latency(struct pp_hwmgr *hwmgr,
4272 enum amd_pp_clock_type type,
4273 struct pp_clock_levels_with_latency *clocks)
4276 case amd_pp_sys_clock:
4277 vega10_get_sclks(hwmgr, clocks);
4279 case amd_pp_mem_clock:
4280 vega10_get_memclocks(hwmgr, clocks);
4282 case amd_pp_dcef_clock:
4283 vega10_get_dcefclocks(hwmgr, clocks);
4285 case amd_pp_soc_clock:
4286 vega10_get_socclocks(hwmgr, clocks);
4295 static int vega10_get_clock_by_type_with_voltage(struct pp_hwmgr *hwmgr,
4296 enum amd_pp_clock_type type,
4297 struct pp_clock_levels_with_voltage *clocks)
4299 struct phm_ppt_v2_information *table_info =
4300 (struct phm_ppt_v2_information *)hwmgr->pptable;
4301 struct phm_ppt_v1_clock_voltage_dependency_table *dep_table;
4305 case amd_pp_mem_clock:
4306 dep_table = table_info->vdd_dep_on_mclk;
4308 case amd_pp_dcef_clock:
4309 dep_table = table_info->vdd_dep_on_dcefclk;
4311 case amd_pp_disp_clock:
4312 dep_table = table_info->vdd_dep_on_dispclk;
4314 case amd_pp_pixel_clock:
4315 dep_table = table_info->vdd_dep_on_pixclk;
4317 case amd_pp_phy_clock:
4318 dep_table = table_info->vdd_dep_on_phyclk;
4324 for (i = 0; i < dep_table->count; i++) {
4325 clocks->data[i].clocks_in_khz = dep_table->entries[i].clk;
4326 clocks->data[i].voltage_in_mv = (uint32_t)(table_info->vddc_lookup_table->
4327 entries[dep_table->entries[i].vddInd].us_vdd);
4328 clocks->num_levels++;
4331 if (i < dep_table->count)
4337 static int vega10_set_watermarks_for_clocks_ranges(struct pp_hwmgr *hwmgr,
4338 struct pp_wm_sets_with_clock_ranges_soc15 *wm_with_clock_ranges)
4340 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4341 Watermarks_t *table = &(data->smc_state_table.water_marks_table);
4345 if (!data->registry_data.disable_water_mark) {
4346 for (i = 0; i < wm_with_clock_ranges->num_wm_sets_dmif; i++) {
4347 table->WatermarkRow[WM_DCEFCLK][i].MinClock =
4348 cpu_to_le16((uint16_t)
4349 (wm_with_clock_ranges->wm_sets_dmif[i].wm_min_dcefclk_in_khz) /
4351 table->WatermarkRow[WM_DCEFCLK][i].MaxClock =
4352 cpu_to_le16((uint16_t)
4353 (wm_with_clock_ranges->wm_sets_dmif[i].wm_max_dcefclk_in_khz) /
4355 table->WatermarkRow[WM_DCEFCLK][i].MinUclk =
4356 cpu_to_le16((uint16_t)
4357 (wm_with_clock_ranges->wm_sets_dmif[i].wm_min_memclk_in_khz) /
4359 table->WatermarkRow[WM_DCEFCLK][i].MaxUclk =
4360 cpu_to_le16((uint16_t)
4361 (wm_with_clock_ranges->wm_sets_dmif[i].wm_max_memclk_in_khz) /
4363 table->WatermarkRow[WM_DCEFCLK][i].WmSetting = (uint8_t)
4364 wm_with_clock_ranges->wm_sets_dmif[i].wm_set_id;
4367 for (i = 0; i < wm_with_clock_ranges->num_wm_sets_mcif; i++) {
4368 table->WatermarkRow[WM_SOCCLK][i].MinClock =
4369 cpu_to_le16((uint16_t)
4370 (wm_with_clock_ranges->wm_sets_mcif[i].wm_min_socclk_in_khz) /
4372 table->WatermarkRow[WM_SOCCLK][i].MaxClock =
4373 cpu_to_le16((uint16_t)
4374 (wm_with_clock_ranges->wm_sets_mcif[i].wm_max_socclk_in_khz) /
4376 table->WatermarkRow[WM_SOCCLK][i].MinUclk =
4377 cpu_to_le16((uint16_t)
4378 (wm_with_clock_ranges->wm_sets_mcif[i].wm_min_memclk_in_khz) /
4380 table->WatermarkRow[WM_SOCCLK][i].MaxUclk =
4381 cpu_to_le16((uint16_t)
4382 (wm_with_clock_ranges->wm_sets_mcif[i].wm_max_memclk_in_khz) /
4384 table->WatermarkRow[WM_SOCCLK][i].WmSetting = (uint8_t)
4385 wm_with_clock_ranges->wm_sets_mcif[i].wm_set_id;
4387 data->water_marks_bitmap = WaterMarksExist;
4393 static int vega10_force_clock_level(struct pp_hwmgr *hwmgr,
4394 enum pp_clock_type type, uint32_t mask)
4396 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4399 if (hwmgr->dpm_level != AMD_DPM_FORCED_LEVEL_MANUAL)
4404 for (i = 0; i < 32; i++) {
4405 if (mask & (1 << i))
4408 data->smc_state_table.gfx_boot_level = i;
4410 for (i = 31; i >= 0; i--) {
4411 if (mask & (1 << i))
4414 data->smc_state_table.gfx_max_level = i;
4416 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_bootup_level(hwmgr),
4417 "Failed to upload boot level to lowest!",
4420 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_max_level(hwmgr),
4421 "Failed to upload dpm max level to highest!",
4426 for (i = 0; i < 32; i++) {
4427 if (mask & (1 << i))
4430 data->smc_state_table.mem_boot_level = i;
4432 for (i = 31; i >= 0; i--) {
4433 if (mask & (1 << i))
4436 data->smc_state_table.mem_max_level = i;
4438 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_bootup_level(hwmgr),
4439 "Failed to upload boot level to lowest!",
4442 PP_ASSERT_WITH_CODE(!vega10_upload_dpm_max_level(hwmgr),
4443 "Failed to upload dpm max level to highest!",
4456 static int vega10_print_clock_levels(struct pp_hwmgr *hwmgr,
4457 enum pp_clock_type type, char *buf)
4459 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4460 struct vega10_single_dpm_table *sclk_table = &(data->dpm_table.gfx_table);
4461 struct vega10_single_dpm_table *mclk_table = &(data->dpm_table.mem_table);
4462 struct vega10_pcie_table *pcie_table = &(data->dpm_table.pcie_table);
4463 int i, now, size = 0;
4467 if (data->registry_data.sclk_dpm_key_disabled)
4470 PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc(hwmgr->smumgr,
4471 PPSMC_MSG_GetCurrentGfxclkIndex),
4472 "Attempt to get current sclk index Failed!",
4474 PP_ASSERT_WITH_CODE(!vega10_read_arg_from_smc(hwmgr->smumgr,
4476 "Attempt to read sclk index Failed!",
4479 for (i = 0; i < sclk_table->count; i++)
4480 size += sprintf(buf + size, "%d: %uMhz %s\n",
4481 i, sclk_table->dpm_levels[i].value / 100,
4482 (i == now) ? "*" : "");
4485 if (data->registry_data.mclk_dpm_key_disabled)
4488 PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc(hwmgr->smumgr,
4489 PPSMC_MSG_GetCurrentUclkIndex),
4490 "Attempt to get current mclk index Failed!",
4492 PP_ASSERT_WITH_CODE(!vega10_read_arg_from_smc(hwmgr->smumgr,
4494 "Attempt to read mclk index Failed!",
4497 for (i = 0; i < mclk_table->count; i++)
4498 size += sprintf(buf + size, "%d: %uMhz %s\n",
4499 i, mclk_table->dpm_levels[i].value / 100,
4500 (i == now) ? "*" : "");
4503 PP_ASSERT_WITH_CODE(!smum_send_msg_to_smc(hwmgr->smumgr,
4504 PPSMC_MSG_GetCurrentLinkIndex),
4505 "Attempt to get current mclk index Failed!",
4507 PP_ASSERT_WITH_CODE(!vega10_read_arg_from_smc(hwmgr->smumgr,
4509 "Attempt to read mclk index Failed!",
4512 for (i = 0; i < pcie_table->count; i++)
4513 size += sprintf(buf + size, "%d: %s %s\n", i,
4514 (pcie_table->pcie_gen[i] == 0) ? "2.5GB, x1" :
4515 (pcie_table->pcie_gen[i] == 1) ? "5.0GB, x16" :
4516 (pcie_table->pcie_gen[i] == 2) ? "8.0GB, x16" : "",
4517 (i == now) ? "*" : "");
4525 static int vega10_display_configuration_changed_task(struct pp_hwmgr *hwmgr)
4527 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4529 uint32_t num_turned_on_displays = 1;
4530 Watermarks_t *wm_table = &(data->smc_state_table.water_marks_table);
4531 struct cgs_display_info info = {0};
4533 if ((data->water_marks_bitmap & WaterMarksExist) &&
4534 !(data->water_marks_bitmap & WaterMarksLoaded)) {
4535 result = vega10_copy_table_to_smc(hwmgr->smumgr,
4536 (uint8_t *)wm_table, WMTABLE);
4537 PP_ASSERT_WITH_CODE(result, "Failed to update WMTABLE!", return EINVAL);
4538 data->water_marks_bitmap |= WaterMarksLoaded;
4541 if (data->water_marks_bitmap & WaterMarksLoaded) {
4542 cgs_get_active_displays_info(hwmgr->device, &info);
4543 num_turned_on_displays = info.display_count;
4544 smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
4545 PPSMC_MSG_NumOfDisplays, num_turned_on_displays);
4551 int vega10_enable_disable_uvd_dpm(struct pp_hwmgr *hwmgr, bool enable)
4553 struct vega10_hwmgr *data =
4554 (struct vega10_hwmgr *)(hwmgr->backend);
4556 if (data->smu_features[GNLD_DPM_UVD].supported) {
4557 PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr->smumgr,
4559 data->smu_features[GNLD_DPM_UVD].smu_feature_bitmap),
4560 "Attempt to Enable/Disable DPM UVD Failed!",
4562 data->smu_features[GNLD_DPM_UVD].enabled = enable;
4567 static int vega10_power_gate_vce(struct pp_hwmgr *hwmgr, bool bgate)
4569 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4571 data->vce_power_gated = bgate;
4572 return vega10_enable_disable_vce_dpm(hwmgr, !bgate);
4575 static int vega10_power_gate_uvd(struct pp_hwmgr *hwmgr, bool bgate)
4577 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4579 data->uvd_power_gated = bgate;
4580 return vega10_enable_disable_uvd_dpm(hwmgr, !bgate);
4583 static inline bool vega10_are_power_levels_equal(
4584 const struct vega10_performance_level *pl1,
4585 const struct vega10_performance_level *pl2)
4587 return ((pl1->soc_clock == pl2->soc_clock) &&
4588 (pl1->gfx_clock == pl2->gfx_clock) &&
4589 (pl1->mem_clock == pl2->mem_clock));
4592 static int vega10_check_states_equal(struct pp_hwmgr *hwmgr,
4593 const struct pp_hw_power_state *pstate1,
4594 const struct pp_hw_power_state *pstate2, bool *equal)
4596 const struct vega10_power_state *psa;
4597 const struct vega10_power_state *psb;
4600 if (pstate1 == NULL || pstate2 == NULL || equal == NULL)
4603 psa = cast_const_phw_vega10_power_state(pstate1);
4604 psb = cast_const_phw_vega10_power_state(pstate2);
4605 /* If the two states don't even have the same number of performance levels they cannot be the same state. */
4606 if (psa->performance_level_count != psb->performance_level_count) {
4611 for (i = 0; i < psa->performance_level_count; i++) {
4612 if (!vega10_are_power_levels_equal(&(psa->performance_levels[i]), &(psb->performance_levels[i]))) {
4613 /* If we have found even one performance level pair that is different the states are different. */
4619 /* If all performance levels are the same try to use the UVD clocks to break the tie.*/
4620 *equal = ((psa->uvd_clks.vclk == psb->uvd_clks.vclk) && (psa->uvd_clks.dclk == psb->uvd_clks.dclk));
4621 *equal &= ((psa->vce_clks.evclk == psb->vce_clks.evclk) && (psa->vce_clks.ecclk == psb->vce_clks.ecclk));
4622 *equal &= (psa->sclk_threshold == psb->sclk_threshold);
4628 vega10_check_smc_update_required_for_display_configuration(struct pp_hwmgr *hwmgr)
4630 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4631 bool is_update_required = false;
4632 struct cgs_display_info info = {0, 0, NULL};
4634 cgs_get_active_displays_info(hwmgr->device, &info);
4636 if (data->display_timing.num_existing_displays != info.display_count)
4637 is_update_required = true;
4639 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_SclkDeepSleep)) {
4640 if (data->display_timing.min_clock_in_sr != hwmgr->display_config.min_core_set_clock_in_sr)
4641 is_update_required = true;
4644 return is_update_required;
4647 static int vega10_disable_dpm_tasks(struct pp_hwmgr *hwmgr)
4649 int tmp_result, result = 0;
4651 tmp_result = (vega10_is_dpm_running(hwmgr)) ? 0 : -1;
4652 PP_ASSERT_WITH_CODE(tmp_result == 0,
4653 "DPM is not running right now, no need to disable DPM!",
4656 if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
4657 PHM_PlatformCaps_ThermalController))
4658 vega10_disable_thermal_protection(hwmgr);
4660 tmp_result = vega10_disable_power_containment(hwmgr);
4661 PP_ASSERT_WITH_CODE((tmp_result == 0),
4662 "Failed to disable power containment!", result = tmp_result);
4664 tmp_result = vega10_avfs_enable(hwmgr, false);
4665 PP_ASSERT_WITH_CODE((tmp_result == 0),
4666 "Failed to disable AVFS!", result = tmp_result);
4668 tmp_result = vega10_stop_dpm(hwmgr, SMC_DPM_FEATURES);
4669 PP_ASSERT_WITH_CODE((tmp_result == 0),
4670 "Failed to stop DPM!", result = tmp_result);
4672 tmp_result = vega10_disable_deep_sleep_master_switch(hwmgr);
4673 PP_ASSERT_WITH_CODE((tmp_result == 0),
4674 "Failed to disable deep sleep!", result = tmp_result);
4676 tmp_result = vega10_disable_ulv(hwmgr);
4677 PP_ASSERT_WITH_CODE((tmp_result == 0),
4678 "Failed to disable ulv!", result = tmp_result);
4683 static int vega10_power_off_asic(struct pp_hwmgr *hwmgr)
4685 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4688 result = vega10_disable_dpm_tasks(hwmgr);
4689 PP_ASSERT_WITH_CODE((0 == result),
4690 "[disable_dpm_tasks] Failed to disable DPM!",
4692 data->water_marks_bitmap &= ~(WaterMarksLoaded);
4697 static void vega10_find_min_clock_index(struct pp_hwmgr *hwmgr,
4698 uint32_t *sclk_idx, uint32_t *mclk_idx,
4699 uint32_t min_sclk, uint32_t min_mclk)
4701 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4702 struct vega10_dpm_table *dpm_table = &(data->dpm_table);
4705 for (i = 0; i < dpm_table->gfx_table.count; i++) {
4706 if (dpm_table->gfx_table.dpm_levels[i].enabled &&
4707 dpm_table->gfx_table.dpm_levels[i].value >= min_sclk) {
4713 for (i = 0; i < dpm_table->mem_table.count; i++) {
4714 if (dpm_table->mem_table.dpm_levels[i].enabled &&
4715 dpm_table->mem_table.dpm_levels[i].value >= min_mclk) {
4722 static int vega10_set_power_profile_state(struct pp_hwmgr *hwmgr,
4723 struct amd_pp_profile *request)
4725 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4726 uint32_t sclk_idx = ~0, mclk_idx = ~0;
4728 if (hwmgr->dpm_level != AMD_DPM_FORCED_LEVEL_AUTO)
4731 vega10_find_min_clock_index(hwmgr, &sclk_idx, &mclk_idx,
4732 request->min_sclk, request->min_mclk);
4734 if (sclk_idx != ~0) {
4735 if (!data->registry_data.sclk_dpm_key_disabled)
4736 PP_ASSERT_WITH_CODE(
4737 !smum_send_msg_to_smc_with_parameter(
4739 PPSMC_MSG_SetSoftMinGfxclkByIndex,
4741 "Failed to set soft min sclk index!",
4745 if (mclk_idx != ~0) {
4746 if (!data->registry_data.mclk_dpm_key_disabled)
4747 PP_ASSERT_WITH_CODE(
4748 !smum_send_msg_to_smc_with_parameter(
4750 PPSMC_MSG_SetSoftMinUclkByIndex,
4752 "Failed to set soft min mclk index!",
4759 static int vega10_get_sclk_od(struct pp_hwmgr *hwmgr)
4761 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4762 struct vega10_single_dpm_table *sclk_table = &(data->dpm_table.gfx_table);
4763 struct vega10_single_dpm_table *golden_sclk_table =
4764 &(data->golden_dpm_table.gfx_table);
4767 value = (sclk_table->dpm_levels[sclk_table->count - 1].value -
4768 golden_sclk_table->dpm_levels
4769 [golden_sclk_table->count - 1].value) *
4771 golden_sclk_table->dpm_levels
4772 [golden_sclk_table->count - 1].value;
4777 static int vega10_set_sclk_od(struct pp_hwmgr *hwmgr, uint32_t value)
4779 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4780 struct vega10_single_dpm_table *golden_sclk_table =
4781 &(data->golden_dpm_table.gfx_table);
4782 struct pp_power_state *ps;
4783 struct vega10_power_state *vega10_ps;
4785 ps = hwmgr->request_ps;
4790 vega10_ps = cast_phw_vega10_power_state(&ps->hardware);
4792 vega10_ps->performance_levels
4793 [vega10_ps->performance_level_count - 1].gfx_clock =
4794 golden_sclk_table->dpm_levels
4795 [golden_sclk_table->count - 1].value *
4797 golden_sclk_table->dpm_levels
4798 [golden_sclk_table->count - 1].value;
4800 if (vega10_ps->performance_levels
4801 [vega10_ps->performance_level_count - 1].gfx_clock >
4802 hwmgr->platform_descriptor.overdriveLimit.engineClock)
4803 vega10_ps->performance_levels
4804 [vega10_ps->performance_level_count - 1].gfx_clock =
4805 hwmgr->platform_descriptor.overdriveLimit.engineClock;
4810 static int vega10_get_mclk_od(struct pp_hwmgr *hwmgr)
4812 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4813 struct vega10_single_dpm_table *mclk_table = &(data->dpm_table.mem_table);
4814 struct vega10_single_dpm_table *golden_mclk_table =
4815 &(data->golden_dpm_table.mem_table);
4818 value = (mclk_table->dpm_levels
4819 [mclk_table->count - 1].value -
4820 golden_mclk_table->dpm_levels
4821 [golden_mclk_table->count - 1].value) *
4823 golden_mclk_table->dpm_levels
4824 [golden_mclk_table->count - 1].value;
4829 static int vega10_set_mclk_od(struct pp_hwmgr *hwmgr, uint32_t value)
4831 struct vega10_hwmgr *data = (struct vega10_hwmgr *)(hwmgr->backend);
4832 struct vega10_single_dpm_table *golden_mclk_table =
4833 &(data->golden_dpm_table.mem_table);
4834 struct pp_power_state *ps;
4835 struct vega10_power_state *vega10_ps;
4837 ps = hwmgr->request_ps;
4842 vega10_ps = cast_phw_vega10_power_state(&ps->hardware);
4844 vega10_ps->performance_levels
4845 [vega10_ps->performance_level_count - 1].mem_clock =
4846 golden_mclk_table->dpm_levels
4847 [golden_mclk_table->count - 1].value *
4849 golden_mclk_table->dpm_levels
4850 [golden_mclk_table->count - 1].value;
4852 if (vega10_ps->performance_levels
4853 [vega10_ps->performance_level_count - 1].mem_clock >
4854 hwmgr->platform_descriptor.overdriveLimit.memoryClock)
4855 vega10_ps->performance_levels
4856 [vega10_ps->performance_level_count - 1].mem_clock =
4857 hwmgr->platform_descriptor.overdriveLimit.memoryClock;
4862 static const struct pp_hwmgr_func vega10_hwmgr_funcs = {
4863 .backend_init = vega10_hwmgr_backend_init,
4864 .backend_fini = vega10_hwmgr_backend_fini,
4865 .asic_setup = vega10_setup_asic_task,
4866 .dynamic_state_management_enable = vega10_enable_dpm_tasks,
4867 .dynamic_state_management_disable = vega10_disable_dpm_tasks,
4868 .get_num_of_pp_table_entries =
4869 vega10_get_number_of_powerplay_table_entries,
4870 .get_power_state_size = vega10_get_power_state_size,
4871 .get_pp_table_entry = vega10_get_pp_table_entry,
4872 .patch_boot_state = vega10_patch_boot_state,
4873 .apply_state_adjust_rules = vega10_apply_state_adjust_rules,
4874 .power_state_set = vega10_set_power_state_tasks,
4875 .get_sclk = vega10_dpm_get_sclk,
4876 .get_mclk = vega10_dpm_get_mclk,
4877 .notify_smc_display_config_after_ps_adjustment =
4878 vega10_notify_smc_display_config_after_ps_adjustment,
4879 .force_dpm_level = vega10_dpm_force_dpm_level,
4880 .get_temperature = vega10_thermal_get_temperature,
4881 .stop_thermal_controller = vega10_thermal_stop_thermal_controller,
4882 .get_fan_speed_info = vega10_fan_ctrl_get_fan_speed_info,
4883 .get_fan_speed_percent = vega10_fan_ctrl_get_fan_speed_percent,
4884 .set_fan_speed_percent = vega10_fan_ctrl_set_fan_speed_percent,
4885 .reset_fan_speed_to_default =
4886 vega10_fan_ctrl_reset_fan_speed_to_default,
4887 .get_fan_speed_rpm = vega10_fan_ctrl_get_fan_speed_rpm,
4888 .set_fan_speed_rpm = vega10_fan_ctrl_set_fan_speed_rpm,
4889 .uninitialize_thermal_controller =
4890 vega10_thermal_ctrl_uninitialize_thermal_controller,
4891 .set_fan_control_mode = vega10_set_fan_control_mode,
4892 .get_fan_control_mode = vega10_get_fan_control_mode,
4893 .read_sensor = vega10_read_sensor,
4894 .get_dal_power_level = vega10_get_dal_power_level,
4895 .get_clock_by_type_with_latency = vega10_get_clock_by_type_with_latency,
4896 .get_clock_by_type_with_voltage = vega10_get_clock_by_type_with_voltage,
4897 .set_watermarks_for_clocks_ranges = vega10_set_watermarks_for_clocks_ranges,
4898 .display_clock_voltage_request = vega10_display_clock_voltage_request,
4899 .force_clock_level = vega10_force_clock_level,
4900 .print_clock_levels = vega10_print_clock_levels,
4901 .display_config_changed = vega10_display_configuration_changed_task,
4902 .powergate_uvd = vega10_power_gate_uvd,
4903 .powergate_vce = vega10_power_gate_vce,
4904 .check_states_equal = vega10_check_states_equal,
4905 .check_smc_update_required_for_display_configuration =
4906 vega10_check_smc_update_required_for_display_configuration,
4907 .power_off_asic = vega10_power_off_asic,
4908 .disable_smc_firmware_ctf = vega10_thermal_disable_alert,
4909 .set_power_profile_state = vega10_set_power_profile_state,
4910 .get_sclk_od = vega10_get_sclk_od,
4911 .set_sclk_od = vega10_set_sclk_od,
4912 .get_mclk_od = vega10_get_mclk_od,
4913 .set_mclk_od = vega10_set_mclk_od,
4914 .avfs_control = vega10_avfs_enable,
4917 int vega10_hwmgr_init(struct pp_hwmgr *hwmgr)
4919 hwmgr->hwmgr_func = &vega10_hwmgr_funcs;
4920 hwmgr->pptable_func = &vega10_pptable_funcs;
4921 pp_vega10_thermal_initialize(hwmgr);