summaryrefslogtreecommitdiffstats
path: root/src/import/chips/p9/procedures
diff options
context:
space:
mode:
authorGreg Still <stillgs@us.ibm.com>2017-11-07 10:15:07 -0600
committerChristian R. Geddes <crgeddes@us.ibm.com>2017-11-13 10:59:38 -0500
commit361addb254f652a949d20611dac5fa612827374b (patch)
tree226bc95add5c24fbbc121c361bda51e2d1100f8f /src/import/chips/p9/procedures
parent86f2ee342aa07201ff5ca286bf3d30eaea785c6a (diff)
downloadtalos-hostboot-361addb254f652a949d20611dac5fa612827374b.tar.gz
talos-hostboot-361addb254f652a949d20611dac5fa612827374b.zip
Pstate Parameter Block/Setup Evid: Safe Pstate Fix
- Use the correct jump field (L_S) for setting safe mode (split variables for better understanding (HWP) - General rearrangement of the safe mode calculations to perform proper voltage uplift (HWP) - Added HWP only consumed elements to common headers (no co-reqs with Hcode!) - Correct VDN and VCS voltage handling for biases - Added VDM jump values to the GPPB for dumping via memory tools. Proven useful for VDM debug. - Fix biases - Deal with Cronus manual mode setting of Safe Mode - Add check that Safe Mode is not above UltraTurbo - Clip freq2pState to positive frequencies - Add check that Boot Frequency is not above UltraTurbo Key_Cronus_Test=PM_REGRESS Change-Id: Ie300c54629d9e97bb5d265db7a00845b2106bd02 HW-Image-Prereq: 975c737f700fb8afd5d2ab416058fcc832dc92a4 CQ: SW405402 Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/49396 Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com> Tested-by: Hostboot CI <hostboot-ci+hostboot@us.ibm.com> Tested-by: Cronus HW CI <cronushw-ci+hostboot@us.ibm.com> Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com> Reviewed-by: RANGANATHPRASAD G. BRAHMASAMUDRA <prasadbgr@in.ibm.com> Reviewed-by: Brian T. Vanderpool <vanderp@us.ibm.com> Reviewed-by: Michael S. Floyd <mfloyd@us.ibm.com> Reviewed-by: Jennifer A. Stofer <stofer@us.ibm.com> Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/49405 Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com> Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com> Reviewed-by: Christian R. Geddes <crgeddes@us.ibm.com>
Diffstat (limited to 'src/import/chips/p9/procedures')
-rw-r--r--src/import/chips/p9/procedures/hwp/lib/p9_pstates_cmeqm.h4
-rw-r--r--src/import/chips/p9/procedures/hwp/lib/p9_pstates_common.h26
-rw-r--r--src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.C665
-rw-r--r--src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.H103
-rw-r--r--src/import/chips/p9/procedures/hwp/pm/p9_setup_evid.C306
-rw-r--r--src/import/chips/p9/procedures/xml/error_info/p9_pstate_parameter_block_errors.xml15
-rw-r--r--src/import/chips/p9/procedures/xml/error_info/p9_setup_evid_errors.xml46
7 files changed, 764 insertions, 401 deletions
diff --git a/src/import/chips/p9/procedures/hwp/lib/p9_pstates_cmeqm.h b/src/import/chips/p9/procedures/hwp/lib/p9_pstates_cmeqm.h
index 581de811a..5c21b8112 100644
--- a/src/import/chips/p9/procedures/hwp/lib/p9_pstates_cmeqm.h
+++ b/src/import/chips/p9/procedures/hwp/lib/p9_pstates_cmeqm.h
@@ -172,8 +172,8 @@ typedef struct
uint16_t ivdd_tdp_dc_current_10ma;
uint8_t vdm_overvolt_small_thresholds;
uint8_t vdm_large_extreme_thresholds;
- uint8_t vdm_small_large_normal_freq;
- uint8_t vdm_large_small_normal_freq;
+ uint8_t vdm_normal_freq_drop; // N_S and N_L Drop
+ uint8_t vdm_normal_freq_return; // L_S and S_N Return
uint8_t vdm_vid_compare_ivid;
uint8_t vdm_spare;
} poundw_entry_t;
diff --git a/src/import/chips/p9/procedures/hwp/lib/p9_pstates_common.h b/src/import/chips/p9/procedures/hwp/lib/p9_pstates_common.h
index fa7d49f73..bc46c3445 100644
--- a/src/import/chips/p9/procedures/hwp/lib/p9_pstates_common.h
+++ b/src/import/chips/p9/procedures/hwp/lib/p9_pstates_common.h
@@ -94,6 +94,32 @@
#define NUM_JUMP_VALUES 4
#define NUM_THRESHOLD_POINTS 4
+// @todo RTC 181607
+// This is synchronization work-around to avoid a co-req update between CME Hcode
+// and the Pstate Parameter Block. The CME uses "IDX" while these use "INDEX".
+// In the future, these should be common between the two platforms.
+//
+// As this file is included in both platforms, the definition below can be used
+// in the CME Hcode and the "IDX" versions deprecated once this file version
+// is included in both platforms.
+#ifndef __ASSEMBLER__
+typedef enum
+{
+ VDM_OVERVOLT_INDEX = 0,
+ VDM_SMALL_INDEX = 1,
+ VDM_LARGE_INDEX = 2,
+ VDM_XTREME_INDEX = 3
+} VDM_THRESHOLD_INDEX;
+
+typedef enum
+{
+ VDM_N_S_INDEX = 0,
+ VDM_N_L_INDEX = 1,
+ VDM_L_S_INDEX = 2,
+ VDM_S_N_INDEX = 3
+} VDM_JUMP_VALUE_INDEX;
+#endif
+
#define NUM_OP_POINTS 4
#define NUM_PV_POINTS 5
#define VPD_PV_POWERSAVE 1
diff --git a/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.C b/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.C
index 933d086ff..e8c35fc3a 100644
--- a/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.C
+++ b/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.C
@@ -163,7 +163,6 @@ uint8_t g_sysvfrtData[] = {0x56, 0x54, 0x00, 0x00, 0x02, 0x01, 0x01, 0x06, /// V
{state = 0; }
-
double internal_ceil(double x)
{
if ((x-(int)(x))>0) return (int)x+1;
@@ -233,6 +232,101 @@ is_vdm_enabled(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
? true : false;
}
+
+void
+load_gppb_attrs(const AttributeList* i_attr,
+ GlobalPstateParmBlock* o_globalppb)
+{
+ //Variables for Loadline, Distribution loss and offset
+ SysPowerDistParms l_vdd_sysparm;
+ memset(&l_vdd_sysparm,0x00,sizeof(SysPowerDistParms));
+
+ SysPowerDistParms l_vcs_sysparm;
+ memset(&l_vcs_sysparm,0x00,sizeof(SysPowerDistParms));
+
+ SysPowerDistParms l_vdn_sysparm;
+ memset(&l_vdn_sysparm,0x00,sizeof(SysPowerDistParms));
+
+ // Frequency step variable
+ double l_frequency_step_khz;
+
+ // -----------------------------------------------
+ // System power distribution parameters
+ // -----------------------------------------------
+ // VDD rail
+ l_vdd_sysparm.loadline_uohm = revle32(i_attr->attr_proc_r_loadline_vdd_uohm);
+ l_vdd_sysparm.distloss_uohm = revle32(i_attr->attr_proc_r_distloss_vdd_uohm);
+ l_vdd_sysparm.distoffset_uv = revle32(i_attr->attr_proc_vrm_voffset_vdd_uv);
+
+ // VCS rail
+ l_vcs_sysparm.loadline_uohm = revle32(i_attr->attr_proc_r_loadline_vcs_uohm);
+ l_vcs_sysparm.distloss_uohm = revle32(i_attr->attr_proc_r_distloss_vcs_uohm);
+ l_vcs_sysparm.distoffset_uv = revle32(i_attr->attr_proc_vrm_voffset_vcs_uv);
+
+ // VDN rail
+ l_vdn_sysparm.loadline_uohm = revle32(i_attr->attr_proc_r_loadline_vdn_uohm);
+ l_vdn_sysparm.distloss_uohm = revle32(i_attr->attr_proc_r_distloss_vdn_uohm);
+ l_vdn_sysparm.distoffset_uv = revle32(i_attr->attr_proc_vrm_voffset_vdn_uv);
+
+ o_globalppb->vdd_sysparm = l_vdd_sysparm;
+ o_globalppb->vcs_sysparm = l_vcs_sysparm;
+ o_globalppb->vdn_sysparm = l_vdn_sysparm;
+
+ // frequency_step_khz
+
+ l_frequency_step_khz = (i_attr->attr_freq_proc_refclock_khz /
+ i_attr->attr_proc_dpll_divider);
+
+ o_globalppb->frequency_step_khz = revle32((uint32_t)l_frequency_step_khz);
+ o_globalppb->nest_frequency_mhz = revle32(i_attr->attr_nest_frequency_mhz);
+
+ // External VRM parameters
+ o_globalppb->ext_vrm_transition_start_ns =
+ revle32(i_attr->attr_ext_vrm_transition_start_ns);
+ o_globalppb->ext_vrm_transition_rate_inc_uv_per_us =
+ revle32(i_attr->attr_ext_vrm_transition_rate_inc_uv_per_us);
+ o_globalppb->ext_vrm_transition_rate_dec_uv_per_us =
+ revle32(i_attr->attr_ext_vrm_transition_rate_dec_uv_per_us);
+ o_globalppb->ext_vrm_stabilization_time_us =
+ revle32(i_attr->attr_ext_vrm_stabilization_time_us);
+ o_globalppb->ext_vrm_step_size_mv =
+ revle32(i_attr->attr_ext_vrm_step_size_mv);
+
+ // load the biases
+ // Note: all are uint8_t so no endianess correction is necessary
+ for (auto p = 0; p < NUM_OP_POINTS; p++)
+ {
+ switch (p)
+ {
+ case POWERSAVE:
+ o_globalppb->ext_biases[p].frequency_hp = i_attr->attr_freq_bias_powersave;
+ o_globalppb->ext_biases[p].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_powersave;
+ o_globalppb->int_biases[p].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_powersave;
+ break;
+ case NOMINAL:
+ o_globalppb->ext_biases[p].frequency_hp = i_attr->attr_freq_bias_nominal;
+ o_globalppb->ext_biases[p].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_nominal;
+ o_globalppb->int_biases[p].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_nominal;
+ break;
+ case TURBO:
+ o_globalppb->ext_biases[p].frequency_hp = i_attr->attr_freq_bias_turbo;
+ o_globalppb->ext_biases[p].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_turbo;
+ o_globalppb->int_biases[p].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_turbo;
+ break;
+ case ULTRA:
+ o_globalppb->ext_biases[p].frequency_hp = i_attr->attr_freq_bias_ultraturbo;
+ o_globalppb->ext_biases[p].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_ultraturbo;
+ o_globalppb->int_biases[p].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_ultraturbo;
+ }
+
+ o_globalppb->ext_biases[p].vdn_ext_hp = i_attr->attr_voltage_ext_vdn_bias;
+ o_globalppb->ext_biases[p].vcs_ext_hp = i_attr->attr_voltage_ext_vcs_bias;
+
+
+ }
+}
+
+
// START OF PSTATE PARAMETER BLOCK function
fapi2::ReturnCode
p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
@@ -245,6 +339,9 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
fapi2::ReturnCode l_rc = 0;
io_size = 0;
+ const uint8_t pv_op_order[NUM_OP_POINTS] = VPD_PV_ORDER;
+ const char* pv_op_str[NUM_OP_POINTS] = VPD_PV_ORDER_STR;
+
do
{
@@ -281,27 +378,15 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
memset (&l_poundw_data,0,sizeof(l_poundw_data));
// MVPD #V variables
- uint32_t attr_mvpd_voltage_control[PV_D][PV_W];
+ uint32_t attr_mvpd_poundv[PV_D][PV_W];
+ uint32_t attr_mvpd_poundv_biased[PV_D][PV_W];
uint8_t present_chiplets = 0;
uint32_t valid_pdv_points = 0;
- //Variables for Loadline, Distribution loss and offset
- SysPowerDistParms l_vdd_sysparm;
- memset(&l_vdd_sysparm,0x00,sizeof(SysPowerDistParms));
-
- SysPowerDistParms l_vcs_sysparm;
- memset(&l_vcs_sysparm,0x00,sizeof(SysPowerDistParms));
-
- SysPowerDistParms l_vdn_sysparm;
- memset(&l_vdn_sysparm,0x00,sizeof(SysPowerDistParms));
-
// Local IDDQ table variable
IddqTable l_iddqt;
memset( & l_iddqt, 0x00, sizeof(IddqTable));
- // Frequency step variable
- double l_frequency_step_khz;
-
//VDM Parm block
GP_VDMParmBlock l_gp_vdmpb;
memset (&l_gp_vdmpb,0x00,sizeof(GP_VDMParmBlock));
@@ -328,6 +413,9 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
FAPI_TRY(proc_get_attributes(i_target, &attr), "Get attributes function failed");
+ // Put attr driven content into GPPB
+ load_gppb_attrs(&attr, &l_globalppb);
+
//if PSTATES_MODE is off then we dont need to execute further to collect
//the data.
if (attr.attr_pstate_mode == fapi2::ENUM_ATTR_SYSTEM_PSTATES_MODE_OFF)
@@ -346,17 +434,29 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
FAPI_IMP("Getting #V Data");
uint8_t l_poundv_bucketId = 0;
- // clear MVPD array
- memset(attr_mvpd_voltage_control, 0, sizeof(attr_mvpd_voltage_control));
+ // clear MVPD arrays
+ memset(attr_mvpd_poundv, 0, sizeof(attr_mvpd_poundv));
+ memset(attr_mvpd_poundv_biased, 0, sizeof(attr_mvpd_poundv_biased));
fapi2::voltageBucketData_t l_poundv_data;
- FAPI_TRY(proc_get_mvpd_data(i_target, attr_mvpd_voltage_control,
+ FAPI_TRY(proc_get_mvpd_data(i_target, attr_mvpd_poundv,
&valid_pdv_points,
&present_chiplets,
l_poundv_bucketId,
&l_poundv_data, &l_state),
"proc_get_mvpd_data function failed to retrieve pound V data");
+ for (int i = 0; i <= NUM_OP_POINTS - 1; i++)
+ {
+ FAPI_DBG("Raw #V operating point (%s) f=%u v=%u i=%u v=%u i=%u",
+ pv_op_str[pv_op_order[i]],
+ attr_mvpd_poundv[pv_op_order[i]][0],
+ attr_mvpd_poundv[pv_op_order[i]][1],
+ attr_mvpd_poundv[pv_op_order[i]][2],
+ attr_mvpd_poundv[pv_op_order[i]][3],
+ attr_mvpd_poundv[pv_op_order[i]][4]);
+ }
+
if (!present_chiplets)
{
FAPI_IMP("**** WARNING : There are no EQ chiplets present which means there is no valid #V VPD");
@@ -373,18 +473,14 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
}
FAPI_DBG("Pstate Base Frequency - Raw %X (%d)",
- attr_mvpd_voltage_control[ULTRA][0] * 1000,
- attr_mvpd_voltage_control[ULTRA][0] * 1000);
-
- //Calculate freq step value
- l_frequency_step_khz = (attr.attr_freq_proc_refclock_khz /
- attr.attr_proc_dpll_divider);
+ attr_mvpd_poundv[ULTRA][0] * 1000,
+ attr_mvpd_poundv[ULTRA][0] * 1000);
VpdOperatingPoint l_raw_operating_points[NUM_OP_POINTS];
FAPI_INF("Load RAW VPD");
- FAPI_TRY(load_mvpd_operating_point(attr_mvpd_voltage_control,
+ FAPI_TRY(load_mvpd_operating_point(attr_mvpd_poundv,
l_raw_operating_points,
- l_frequency_step_khz),
+ revle32(l_globalppb.frequency_step_khz)),
"Loading MVPD operating point failed");
// ---------------------------------------------
@@ -392,7 +488,26 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
// ---------------------------------------------
FAPI_IMP("Apply Biasing to #V");
- FAPI_TRY(proc_get_extint_bias(attr_mvpd_voltage_control,
+ // Copy to Bias array
+ for (int i = 0; i <= NUM_OP_POINTS - 1; i++)
+ {
+ for (int d = 0; d < PV_D; ++d)
+ {
+ for (int w = 0; w < PV_W; ++w)
+ {
+ attr_mvpd_poundv_biased[d][w] = attr_mvpd_poundv[d][w];
+ }
+ }
+ FAPI_DBG("Biased #V operating point (%s) f=%u v=%u i=%u v=%u i=%u",
+ pv_op_str[pv_op_order[i]],
+ attr_mvpd_poundv_biased[pv_op_order[i]][0],
+ attr_mvpd_poundv_biased[pv_op_order[i]][1],
+ attr_mvpd_poundv_biased[pv_op_order[i]][2],
+ attr_mvpd_poundv_biased[pv_op_order[i]][3],
+ attr_mvpd_poundv_biased[pv_op_order[i]][4]);
+ }
+
+ FAPI_TRY(proc_get_extint_bias(attr_mvpd_poundv_biased,
&attr,
l_vpdbias),
"Bias application function failed");
@@ -401,33 +516,15 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
FAPI_INF("Validate Biasd Voltage and Frequency values");
FAPI_TRY(proc_chk_valid_poundv( i_target,
- attr_mvpd_voltage_control,
+ attr_mvpd_poundv_biased,
&valid_pdv_points,
i_target.getChipletNumber(),
l_poundv_bucketId,
&l_state,true));
FAPI_DBG("Pstate Base Frequency - after bias %X (%d)",
- attr_mvpd_voltage_control[ULTRA][0] * 1000,
- attr_mvpd_voltage_control[ULTRA][0] * 1000);
-
- // -----------------------------------------------
- // System power distribution parameters
- // -----------------------------------------------
- // VDD rail
- l_vdd_sysparm.loadline_uohm = revle32(attr.attr_proc_r_loadline_vdd_uohm);
- l_vdd_sysparm.distloss_uohm = revle32(attr.attr_proc_r_distloss_vdd_uohm);
- l_vdd_sysparm.distoffset_uv = revle32(attr.attr_proc_vrm_voffset_vdd_uv);
-
- // VCS rail
- l_vcs_sysparm.loadline_uohm = revle32(attr.attr_proc_r_loadline_vcs_uohm);
- l_vcs_sysparm.distloss_uohm = revle32(attr.attr_proc_r_distloss_vcs_uohm);
- l_vcs_sysparm.distoffset_uv = revle32(attr.attr_proc_vrm_voffset_vcs_uv);
-
- // VDN rail
- l_vdn_sysparm.loadline_uohm = revle32(attr.attr_proc_r_loadline_vdn_uohm);
- l_vdn_sysparm.distloss_uohm = revle32(attr.attr_proc_r_distloss_vdn_uohm);
- l_vdn_sysparm.distoffset_uv = revle32(attr.attr_proc_vrm_voffset_vdn_uv);
+ attr_mvpd_poundv_biased[ULTRA][0] * 1000,
+ attr_mvpd_poundv_biased[ULTRA][0] * 1000);
//if wof is disabled.. don't call IQ function
if (is_wof_enabled(i_target,&l_state))
@@ -505,28 +602,8 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
// frequency point.
// FIXME this should be the l_operating_points[VPD_PT_SET_BIASED][ULTRA].
// frequency_mhz value with p9_pstate_compute_vpd_pts ahead of this!!!!
- l_globalppb.reference_frequency_khz =
- revle32((attr_mvpd_voltage_control[ULTRA][0] * 1000));
-
- FAPI_INF("Pstate Base Frequency %X (%d)",
- revle32(l_globalppb.reference_frequency_khz),
- revle32(l_globalppb.reference_frequency_khz));
-
- // frequency_step_khz
- l_globalppb.frequency_step_khz = revle32(l_frequency_step_khz);
- l_globalppb.nest_frequency_mhz = revle32(attr.attr_nest_frequency_mhz);
-
- // External VRM parameters
- l_globalppb.ext_vrm_transition_start_ns =
- revle32(attr.attr_ext_vrm_transition_start_ns);
- l_globalppb.ext_vrm_transition_rate_inc_uv_per_us =
- revle32(attr.attr_ext_vrm_transition_rate_inc_uv_per_us);
- l_globalppb.ext_vrm_transition_rate_dec_uv_per_us =
- revle32(attr.attr_ext_vrm_transition_rate_dec_uv_per_us);
- l_globalppb.ext_vrm_stabilization_time_us =
- revle32(attr.attr_ext_vrm_stabilization_time_us);
- l_globalppb.ext_vrm_step_size_mv =
- revle32(attr.attr_ext_vrm_step_size_mv);
+// l_globalppb.reference_frequency_khz =
+// revle32((attr_mvpd_poundv_biased[ULTRA][0] * 1000));
// -----------------------------------------------
// populate VpdOperatingPoint with biased MVPD attributes
@@ -534,12 +611,26 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
FAPI_INF("Load VPD");
// VPD operating point
- FAPI_TRY(load_mvpd_operating_point(attr_mvpd_voltage_control,
+ FAPI_TRY(load_mvpd_operating_point(attr_mvpd_poundv,
l_globalppb.operating_points,
- l_frequency_step_khz),
+ revle32(l_globalppb.frequency_step_khz)),
"Loading MVPD operating point failed");
+ VpdOperatingPoint l_operating_points[NUM_VPD_PTS_SET][NUM_OP_POINTS];
+ // Compute VPD pointsp9_pstate_compute_PStateV_slope
+ p9_pstate_compute_vpd_pts(l_operating_points,
+ &l_globalppb,
+ l_raw_operating_points);
+
+ memcpy(l_globalppb.operating_points_set,
+ l_operating_points,
+ sizeof(l_operating_points));
+
+ FAPI_INF("Pstate Base Frequency %X (%d)",
+ revle32(l_globalppb.reference_frequency_khz),
+ revle32(l_globalppb.reference_frequency_khz));
// VpdBias External and Internal Biases for Global and Local parameter
+
// block
for (uint8_t i = 0; i < NUM_OP_POINTS; i++)
{
@@ -550,9 +641,19 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
l_localppb.int_biases[i] = l_vpdbias[i];
}
- l_globalppb.vdd_sysparm = l_vdd_sysparm;
- l_globalppb.vcs_sysparm = l_vcs_sysparm;
- l_globalppb.vdn_sysparm = l_vdn_sysparm;
+
+
+
+ // VpdBias External and Internal Biases for Global and Local parameter
+ // block
+ for (uint8_t i = 0; i < NUM_OP_POINTS; i++)
+ {
+ l_globalppb.ext_biases[i] = l_vpdbias[i];
+ l_globalppb.int_biases[i] = l_vpdbias[i];
+
+ l_localppb.ext_biases[i] = l_vpdbias[i];
+ l_localppb.int_biases[i] = l_vpdbias[i];
+ }
// safe_voltage_mv
l_globalppb.safe_voltage_mv = revle32(attr.attr_pm_safe_voltage_mv);
@@ -570,16 +671,6 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
// vrm_stepdelay_value -@todo RTC 161279 potential attributes to be defined
- VpdOperatingPoint l_operating_points[NUM_VPD_PTS_SET][NUM_OP_POINTS];
- // Compute VPD points
- p9_pstate_compute_vpd_pts(l_operating_points,
- &l_globalppb,
- l_raw_operating_points);
-
- memcpy(l_globalppb.operating_points_set,
- l_operating_points,
- sizeof(l_operating_points));
-
// ----------------
// get Resonant clocking attributes
// ----------------
@@ -622,7 +713,8 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
revle32(revle32(l_globalppb.reference_frequency_khz) /
revle32(l_globalppb.frequency_step_khz));
- FAPI_INF("l_globalppb.dpll_pstate0_value %X",
+ FAPI_INF("l_globalppb.dpll_pstate0_value %X (%d)",
+ revle32(l_globalppb.dpll_pstate0_value),
revle32(l_globalppb.dpll_pstate0_value));
// -----------------------------------------------
@@ -631,12 +723,12 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
l_localppb.magic = revle64(LOCAL_PARMSBLOCK_MAGIC);
// VPD operating point
- FAPI_TRY(load_mvpd_operating_point(attr_mvpd_voltage_control,
+ FAPI_TRY(load_mvpd_operating_point(attr_mvpd_poundv_biased,
l_localppb.operating_points,
- l_frequency_step_khz),
+ revle32(l_globalppb.frequency_step_khz)),
"Loading MVPD operating point failed");
- l_localppb.vdd_sysparm = l_vdd_sysparm;
+ l_localppb.vdd_sysparm = l_globalppb.vdd_sysparm;
// IvrmParmBlock
l_localppb.ivrm = l_ivrmpb;
@@ -648,7 +740,8 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
revle32(revle32(l_globalppb.reference_frequency_khz) /
revle32(l_globalppb.frequency_step_khz));
- FAPI_INF("l_localppb.dpll_pstate0_value %X",
+ FAPI_INF("l_localppb.dpll_pstate0_value %X (%d)",
+ revle32(l_localppb.dpll_pstate0_value),
revle32(l_localppb.dpll_pstate0_value));
uint8_t l_biased_pstate[NUM_OP_POINTS];
@@ -674,7 +767,7 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
p9_pstate_compute_PsVDMJumpSlopes (&l_localppb, l_biased_pstate);
- //Initializing threshold values for GPPB
+ //Initializing threshold and jump values for GPPB
memcpy ( l_globalppb.vid_point_set,
l_localppb.vid_point_set,
sizeof(l_localppb.vid_point_set));
@@ -683,6 +776,10 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
l_localppb.threshold_set,
sizeof(l_localppb.threshold_set));
+ memcpy ( l_globalppb.jump_value_set,
+ l_localppb.jump_value_set,
+ sizeof(l_localppb.jump_value_set));
+
memcpy ( l_globalppb.PsVIDCompSlopes,
l_localppb.PsVIDCompSlopes,
sizeof(l_localppb.PsVIDCompSlopes));
@@ -701,21 +798,24 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
l_occppb.magic = revle64(OCC_PARMSBLOCK_MAGIC);
// VPD operating point
- FAPI_TRY(load_mvpd_operating_point(attr_mvpd_voltage_control, l_occppb.operating_points, l_frequency_step_khz),
+ FAPI_TRY(load_mvpd_operating_point(attr_mvpd_poundv_biased,
+ l_occppb.operating_points,
+ l_globalppb.frequency_step_khz),
"Loading MVPD operating point failed");
- l_occppb.vdd_sysparm = l_vdd_sysparm;
- l_occppb.vcs_sysparm = l_vcs_sysparm;
- l_occppb.vdn_sysparm = l_vdn_sysparm;
+ l_occppb.vdd_sysparm = l_globalppb.vdd_sysparm;
+ l_occppb.vcs_sysparm = l_globalppb.vcs_sysparm;
+ l_occppb.vdn_sysparm = l_globalppb.vdn_sysparm;
- // frequency_min_khz - Value from Power save operating point after biases
- l_occppb.frequency_min_khz = revle32(attr_mvpd_voltage_control[VPD_PV_POWERSAVE][0] * 1000);
+ // frequency_min_khz - Value from Power safe operating point after biases
+
+ l_occppb.frequency_min_khz = revle32(attr.attr_pm_safe_frequency_mhz * 1000);
// frequency_max_khz - Value from Ultra Turbo operating point after biases
- l_occppb.frequency_max_khz = revle32(attr_mvpd_voltage_control[VPD_PV_ULTRA][0] * 1000);
+ l_occppb.frequency_max_khz = l_globalppb.reference_frequency_khz;
// frequency_step_khz
- l_occppb.frequency_step_khz = revle32(l_frequency_step_khz);
+ l_occppb.frequency_step_khz = l_globalppb.frequency_step_khz;
//Power bus nest freq
uint16_t l_pbus_nest_freq = revle16(l_poundv_data.pbFreq);
@@ -746,7 +846,7 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
//Power bus vdn voltage
uint16_t l_vpd_vdn_mv = revle16(l_poundv_data.VdnPbVltg);
- FAPI_INF("l_vpd_vdn_mv %x", (l_vpd_vdn_mv));
+ FAPI_INF("l_vpd_vdn_mv 0x%x (%d)", l_vpd_vdn_mv, l_vpd_vdn_mv);
uint8_t l_nest_leakage_for_occ = 75;
uint16_t l_iac_tdp_vdn = get_iac_vdn_value ( l_vpd_vdn_mv,
@@ -806,7 +906,7 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
o_buf,
io_size,
&l_state,
- attr_mvpd_voltage_control[VPD_PV_ULTRA][0]);
+ attr_mvpd_poundv_biased[VPD_PV_ULTRA][0]);
}
else
{
@@ -1116,6 +1216,30 @@ FAPI_INF("%-60s = 0x%08x %d", #attr_name, io_attr->attr_assign, io_attr->attr_as
DATABLOCK_GET_ATTR(ATTR_NEST_LEAKAGE_PERCENT, FAPI_SYSTEM, attr_nest_leakage_percent);
+ // AVSBus ... needed by p9_setup_evid
+ DATABLOCK_GET_ATTR(ATTR_VDD_AVSBUS_BUSNUM, i_target,vdd_bus_num);
+ DATABLOCK_GET_ATTR(ATTR_VDD_AVSBUS_RAIL, i_target,vdd_rail_select);
+ DATABLOCK_GET_ATTR(ATTR_VDN_AVSBUS_BUSNUM, i_target,vdn_bus_num);
+ DATABLOCK_GET_ATTR(ATTR_VDN_AVSBUS_RAIL, i_target,vdn_rail_select);
+ DATABLOCK_GET_ATTR(ATTR_VCS_AVSBUS_BUSNUM, i_target,vcs_bus_num);
+ DATABLOCK_GET_ATTR(ATTR_VCS_AVSBUS_RAIL, i_target,vcs_rail_select);
+ DATABLOCK_GET_ATTR(ATTR_VCS_BOOT_VOLTAGE, i_target,vcs_voltage_mv);
+ DATABLOCK_GET_ATTR(ATTR_VDD_BOOT_VOLTAGE, i_target,vdd_voltage_mv);
+ DATABLOCK_GET_ATTR(ATTR_VDN_BOOT_VOLTAGE, i_target,vdn_voltage_mv);
+
+ DATABLOCK_GET_ATTR(ATTR_PROC_R_LOADLINE_VDD_UOHM, i_target,r_loadline_vdd_uohm);
+ DATABLOCK_GET_ATTR(ATTR_PROC_R_DISTLOSS_VDD_UOHM, i_target,r_distloss_vdd_uohm);
+ DATABLOCK_GET_ATTR(ATTR_PROC_VRM_VOFFSET_VDD_UV, i_target,vrm_voffset_vdd_uv );
+ DATABLOCK_GET_ATTR(ATTR_PROC_R_LOADLINE_VDN_UOHM, i_target,r_loadline_vdn_uohm);
+ DATABLOCK_GET_ATTR(ATTR_PROC_R_DISTLOSS_VDN_UOHM, i_target,r_distloss_vdn_uohm);
+ DATABLOCK_GET_ATTR(ATTR_PROC_VRM_VOFFSET_VDN_UV, i_target,vrm_voffset_vdn_uv );
+ DATABLOCK_GET_ATTR(ATTR_PROC_R_LOADLINE_VCS_UOHM, i_target,r_loadline_vcs_uohm);
+ DATABLOCK_GET_ATTR(ATTR_PROC_R_DISTLOSS_VCS_UOHM, i_target,r_distloss_vcs_uohm);
+ DATABLOCK_GET_ATTR(ATTR_PROC_VRM_VOFFSET_VCS_UV, i_target,vrm_voffset_vcs_uv);
+ DATABLOCK_GET_ATTR(ATTR_FREQ_PROC_REFCLOCK_KHZ, FAPI_SYSTEM, freq_proc_refclock_khz);
+ DATABLOCK_GET_ATTR(ATTR_PROC_DPLL_DIVIDER, i_target, proc_dpll_divider);
+ // AVSBus ... needed by p9_setup_evid
+
io_attr->attr_ext_vrm_transition_start_ns =
(io_attr->attr_ext_vrm_transition_start_ns) ? io_attr->attr_ext_vrm_transition_start_ns : EXT_VRM_TRANSITION_START_NS;
@@ -1389,8 +1513,8 @@ double
calc_bias(const int8_t i_value)
{
double temp = 1.0 + ((BIAS_PCT_UNIT/100) * (double)i_value);
- FAPI_DBG(" calc_bias: input bias (in 1/2 percent) = %d; biased multiplier = %f",
- i_value, temp);
+ FAPI_DBG(" calc_bias: input bias (in 1/2 percent) = %d; percent = %4.1f%% biased multiplier = %6.3f",
+ i_value, (i_value*BIAS_PCT_UNIT), temp);
return temp;
}
@@ -1906,6 +2030,35 @@ load_mvpd_operating_point ( const uint32_t i_src[PV_D][PV_W],
return fapi2::FAPI2_RC_SUCCESS;
} // end load_mvpd_operating_point
+/// ------------------------------------------------------------
+/// @brief Copy out of operating point set into a destination operating point
+/// @param[in] &i_op_pt_set => reference to array of VpdOperatingPoint sets
+/// @param[out] *dest[NUM_OP_POINTS] => pointer to destination VpdOperatingPoint structure
+/// @param[in] i_frequency_step_khz => Base frequency value for pstate calculation
+/// ------------------------------------------------------------
+fapi2::ReturnCode
+get_operating_point ( const VpdOperatingPoint i_op_pt_set[NUM_VPD_PTS_SET][NUM_OP_POINTS],
+ uint32_t i_set,
+ VpdOperatingPoint* o_op_pt)
+{
+ FAPI_DBG(">> get_operating_point");
+
+ for (uint32_t i = 0; i < NUM_OP_POINTS; i++)
+ {
+ o_op_pt[i].frequency_mhz = i_op_pt_set[i_set][i].frequency_mhz;
+ o_op_pt[i].vdd_mv = i_op_pt_set[i_set][i].vdd_mv;
+ o_op_pt[i].idd_100ma = i_op_pt_set[i_set][i].idd_100ma;
+ o_op_pt[i].vcs_mv = i_op_pt_set[i_set][i].vcs_mv;
+ o_op_pt[i].ics_100ma = i_op_pt_set[i_set][i].ics_100ma;
+ o_op_pt[i].pstate = i_op_pt_set[i_set][i].pstate;
+ }
+
+ FAPI_DBG("<< get_operating_point");
+ return fapi2::FAPI2_RC_SUCCESS;
+} // end load_mvpd_operating_point
+
+
+
fapi2::ReturnCode
proc_get_vdm_parms (const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
const AttributeList* i_attr,
@@ -2028,7 +2181,7 @@ proc_res_clock_setup ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_targ
o_resclk_setup->resclk_freq[i] = pstate;
o_resclk_setup->resclk_index[i] = idx;
- FAPI_DBG("Resclk: pstate = %d; idx = %d", pstate, idx);
+ FAPI_DBG("Resclk: freq = %d kHz; pstate = %d; idx = %d", freq_khz, pstate, idx);
}
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_SYSTEM_RESCLK_L3_VALUE, i_target,
@@ -2117,13 +2270,26 @@ sysparm_uplift(const uint32_t i_vpd_mv,
const uint32_t i_distloss_uohm,
const uint32_t i_distoffset_uohm)
{
- return revle32(i_vpd_mv + // mV
- (
- // mA*uOhm/1000 -> uV
- ((i_vpd_ma * (i_loadline_uohm + i_distloss_uohm)) / 1000 +
- // uv
- i_distoffset_uohm)
- ) / 1000); // uV -> mV
+
+ double l_mv = ((double)i_vpd_mv + // mV
+ (
+ // mA*uOhm/1000 -> uV
+ ((double)(i_vpd_ma * (i_loadline_uohm + i_distloss_uohm)) / 1000 +
+ // uv
+ (double)i_distoffset_uohm)
+ ) / 1000); // uV -> mV
+ uint32_t l_result = (uint32_t)l_mv;
+ FAPI_DBG(" system_uplift_mv: i_vpd_mv=%d; i_vpd_ma=%d; i_loadline_uohm=%d "
+ "i_distloss_uohm = %d i_distoffset_uohm = %d l_mv = %5.3f l_result = %d" ,
+ i_vpd_mv,
+ i_vpd_ma,
+ i_loadline_uohm,
+ i_distloss_uohm,
+ i_distoffset_uohm,
+ l_mv,
+ l_result);
+
+ return revle32(l_result);
}
// Bias Adjust a voltage data value using a 1/2 percent bias amount. Value
@@ -2134,11 +2300,15 @@ bias_adjust_mv(const uint32_t i_value,
{
double l_mult = calc_bias(i_bias_0p5pct);
double l_biased_value = (double)i_value * l_mult;
- FAPI_DBG(" bias_adjust_mv: i_value=%d; mult=%f; biased value=%f",
- i_value,
- l_mult,
- l_biased_value);
- return revle32((uint32_t)internal_ceil(l_biased_value));
+ double l_ceiling = internal_ceil(l_biased_value);
+ uint32_t l_result = (uint32_t)l_ceiling;
+ FAPI_DBG(" bias_adjust_mv: i_value=%d; mult=%5.3f; biased value=%3.0f ceiling = %3.0f result = %d",
+ i_value,
+ l_mult,
+ l_biased_value,
+ l_ceiling,
+ l_result);
+ return revle32(l_result);
}
// Bias Adjust a frequency data value using a 1/2 percent bias amount. Value
@@ -2149,7 +2319,7 @@ bias_adjust_mhz(const uint32_t i_value,
{
double l_mult = calc_bias(i_bias_0p5pct);
double l_biased_value = (double)i_value * l_mult;
- FAPI_DBG(" bias_adjust_mhz: i_value=%d; mult=%f; biased value=%f",
+ FAPI_DBG(" bias_adjust_mhz: i_value=%d; mult=%5.3f; biased value=%3.0f",
i_value,
l_mult,
l_biased_value);
@@ -2240,21 +2410,31 @@ void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[NUM_OP_PO
uint32_t l_vcs_mv = revle32(i_gppb->operating_points[p].vcs_mv);
o_operating_points[VPD_PT_SET_BIASED][p].vdd_mv =
- bias_adjust_mv(l_vdd_mv, revle32(i_gppb->ext_biases[p].vdd_ext_hp));
+ bias_adjust_mv(l_vdd_mv, i_gppb->ext_biases[p].vdd_ext_hp);
o_operating_points[VPD_PT_SET_BIASED][p].vcs_mv =
- bias_adjust_mv(l_vcs_mv, revle32(i_gppb->ext_biases[p].vcs_ext_hp));
+ bias_adjust_mv(l_vcs_mv, i_gppb->ext_biases[p].vcs_ext_hp);
o_operating_points[VPD_PT_SET_BIASED][p].frequency_mhz =
- bias_adjust_mhz(l_frequency_mhz, revle32(i_gppb->ext_biases[p].frequency_hp));
+ bias_adjust_mhz(l_frequency_mhz, i_gppb->ext_biases[p].frequency_hp);
o_operating_points[VPD_PT_SET_BIASED][p].idd_100ma =
i_gppb->operating_points[p].idd_100ma;
o_operating_points[VPD_PT_SET_BIASED][p].ics_100ma =
i_gppb->operating_points[p].ics_100ma;
-
}
+ // As this is memory to memory, Endianess correction is not necessary.
+ uint32_t l_ref_freq_khz =
+ revle32(o_operating_points[VPD_PT_SET_BIASED][ULTRA].frequency_mhz) * 1000;
+ i_gppb->reference_frequency_khz = revle32(l_ref_freq_khz);
+
+ FAPI_DBG("Reference into GPPB: LE local Freq=%X (%d); Freq=%X (%d)",
+ l_ref_freq_khz,
+ l_ref_freq_khz,
+ revle32(i_gppb->reference_frequency_khz),
+ revle32(i_gppb->reference_frequency_khz));
+
// Now that the ULTRA frequency is known, Pstates can be calculated
for (p = 0; p < NUM_OP_POINTS; p++)
{
@@ -2264,7 +2444,7 @@ void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[NUM_OP_PO
revle32(i_gppb->frequency_step_khz));
FAPI_DBG("Bi: OpPoint=[%d][%d], PS=%3d, Freq=%3X (%4d), Vdd=%3X (%4d), UT Freq=%3X (%4d) Step Freq=%5d",
- VPD_PT_SET_RAW, p,
+ VPD_PT_SET_BIASED, p,
o_operating_points[VPD_PT_SET_BIASED][p].pstate,
revle32(o_operating_points[VPD_PT_SET_BIASED][p].frequency_mhz),
revle32(o_operating_points[VPD_PT_SET_BIASED][p].frequency_mhz),
@@ -2309,7 +2489,7 @@ void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[NUM_OP_PO
o_operating_points[VPD_PT_SET_BIASED][p].pstate;
FAPI_DBG("BS: OpPoint=[%d][%d], PS=%3d, Freq=%3X (%4d), Vdd=%3X (%4d)",
- VPD_PT_SET_RAW, p,
+ VPD_PT_SET_BIASED_SYSP, p,
o_operating_points[VPD_PT_SET_SYSP][p].pstate,
revle32(o_operating_points[VPD_PT_SET_SYSP][p].frequency_mhz),
revle32(o_operating_points[VPD_PT_SET_SYSP][p].frequency_mhz),
@@ -3254,7 +3434,8 @@ iddq_print(IddqTable* i_iddqt)
int
freq2pState (const GlobalPstateParmBlock* gppb,
const uint32_t freq_khz,
- Pstate* pstate)
+ Pstate* pstate,
+ const FREQ2PSTATE_ROUNDING i_round)
{
int rc = 0;
float pstate32 = 0;
@@ -3270,8 +3451,12 @@ freq2pState (const GlobalPstateParmBlock* gppb,
// As higher Pstate numbers represent lower frequencies, the pstate must be
// snapped to the nearest *higher* integer value for safety. (e.g. slower
// frequencies are safer).
- //*pstate = (Pstate)internal_ceil(pstate32);
- *pstate = (Pstate)pstate32;
+ if ((i_round == ROUND_SLOW) && (freq_khz))
+ *pstate = (Pstate)internal_ceil(pstate32);
+ else
+ {
+ *pstate = (Pstate)pstate32;
+ }
// ------------------------------
// perform pstate bounds checking
@@ -3523,10 +3708,14 @@ proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target
break;
}
- FAPI_INF("POWERSAVE.vdm_vid_compare_ivid %d",o_data->poundw[POWERSAVE].vdm_vid_compare_ivid);
- FAPI_INF("NOMINAL.vdm_vid_compare_ivid %d",o_data->poundw[NOMINAL].vdm_vid_compare_ivid);
- FAPI_INF("TURBO.vdm_vid_compare_ivid %d",o_data->poundw[TURBO].vdm_vid_compare_ivid);
- FAPI_INF("ULTRA_TURBO.vdm_vid_compare_ivid %d",o_data->poundw[ULTRA].vdm_vid_compare_ivid);
+ for (int i = 0; i < NUM_OP_POINTS; ++i)
+ {
+ uint32_t l_mv = 512 + (o_data->poundw[i].vdm_vid_compare_ivid << 2);
+ FAPI_INF("%10s vdm_vid_compare_ivid %3d => %d mv",
+ pv_op_str[i],
+ o_data->poundw[i].vdm_vid_compare_ivid,
+ l_mv);
+ }
//Validation of VPD Data
//
@@ -3566,11 +3755,6 @@ proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target
break;
}
- FAPI_INF("POWERSAVE.vdm_vid_compare_ivid %d",o_data->poundw[POWERSAVE].vdm_vid_compare_ivid);
- FAPI_INF("NOMINAL.vdm_vid_compare_ivid %d",o_data->poundw[NOMINAL].vdm_vid_compare_ivid);
- FAPI_INF("TURBO.vdm_vid_compare_ivid %d",o_data->poundw[TURBO].vdm_vid_compare_ivid);
- FAPI_INF("ULTRA_TURBO.vdm_vid_compare_ivid %d",o_data->poundw[ULTRA].vdm_vid_compare_ivid);
-
// validate vid values
bool l_compare_vid_value_state = 1;
VALIDATE_VID_VALUES (o_data->poundw[POWERSAVE].vdm_vid_compare_ivid,
@@ -3600,9 +3784,9 @@ proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target
for (uint8_t p = 0; p < NUM_OP_POINTS; ++p)
{
FAPI_INF("o_data->poundw[%d].vdm_overvolt_thresholds 0x%X",p,(o_data->poundw[p].vdm_overvolt_small_thresholds >> 4) & 0x0F);
- FAPI_INF("o_data->poundw[%d].vdm_small_thresholds 0x%X",p,(o_data->poundw[p].vdm_overvolt_small_thresholds ) & 0x0F);
- FAPI_INF("o_data->poundw[%d].vdm_large_thresholds 0x%X",p,(o_data->poundw[p].vdm_large_extreme_thresholds >> 4) & 0x0F);
- FAPI_INF("o_data->poundw[%d].vdm_extreme_thresholds 0x%X",p,(o_data->poundw[p].vdm_large_extreme_thresholds) & 0x0F);
+ FAPI_INF("o_data->poundw[%d].vdm_small_thresholds 0x%X",p,(o_data->poundw[p].vdm_overvolt_small_thresholds ) & 0x0F);
+ FAPI_INF("o_data->poundw[%d].vdm_large_thresholds 0x%X",p,(o_data->poundw[p].vdm_large_extreme_thresholds >> 4) & 0x0F);
+ FAPI_INF("o_data->poundw[%d].vdm_extreme_thresholds 0x%X",p,(o_data->poundw[p].vdm_large_extreme_thresholds) & 0x0F);
VALIDATE_THRESHOLD_VALUES(((o_data->poundw[p].vdm_overvolt_small_thresholds >> 4) & 0x0F), // overvolt
((o_data->poundw[p].vdm_overvolt_small_thresholds) & 0x0F), //small
((o_data->poundw[p].vdm_large_extreme_thresholds >> 4) & 0x0F), //large
@@ -3632,15 +3816,15 @@ proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target
{
// These fields are 4 bits wide, and stored in a uint8, hence the shifting
// N_S, N_L, L_S, S_N
- FAPI_INF("o_data->poundw[%d] VDM_FREQ_DROP N_S = %d", p, ((o_data->poundw[p].vdm_small_large_normal_freq >> 4) & 0x0F));
- FAPI_INF("o_data->poundw[%d] VDM_FREQ_DROP N_L = %d", p, ((o_data->poundw[p].vdm_small_large_normal_freq) & 0x0F));
- FAPI_INF("o_data->poundw[%d] VDM_FREQ_DROP L_S = %d", p, ((o_data->poundw[p].vdm_large_small_normal_freq >> 4) & 0x0F));
- FAPI_INF("o_data->poundw[%d] VDM_FREQ_DROP S_N = %d", p, ((o_data->poundw[p].vdm_large_small_normal_freq) & 0x0F));
-
- VALIDATE_FREQUENCY_DROP_VALUES(((o_data->poundw[p].vdm_small_large_normal_freq) & 0x0F), //N_L
- ((o_data->poundw[p].vdm_small_large_normal_freq >> 4) & 0x0F), // N_S
- ((o_data->poundw[p].vdm_large_small_normal_freq >> 4) & 0x0F), //L_S
- ((o_data->poundw[p].vdm_large_small_normal_freq) & 0x0F), //S_N
+ FAPI_INF("o_data->poundw[%d] VDM_FREQ_DROP N_S = %d", p, ((o_data->poundw[p].vdm_normal_freq_drop >> 4) & 0x0F));
+ FAPI_INF("o_data->poundw[%d] VDM_FREQ_DROP N_L = %d", p, ((o_data->poundw[p].vdm_normal_freq_drop) & 0x0F));
+ FAPI_INF("o_data->poundw[%d] VDM_FREQ_RETURN L_S = %d", p, ((o_data->poundw[p].vdm_normal_freq_return >> 4) & 0x0F));
+ FAPI_INF("o_data->poundw[%d] VDM_FREQ_RETURN S_N = %d", p, ((o_data->poundw[p].vdm_normal_freq_return) & 0x0F));
+
+ VALIDATE_FREQUENCY_DROP_VALUES(((o_data->poundw[p].vdm_normal_freq_drop) & 0x0F), //N_L
+ ((o_data->poundw[p].vdm_normal_freq_drop >> 4) & 0x0F), // N_S
+ ((o_data->poundw[p].vdm_normal_freq_return >> 4) & 0x0F), // L_S
+ ((o_data->poundw[p].vdm_normal_freq_return) & 0x0F), //S_N
l_frequency_value_state);
if (!l_frequency_value_state)
@@ -3650,10 +3834,10 @@ proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target
fapi2::PSTATE_PB_POUND_W_INVALID_FREQ_DROP_VALUE(fapi2::FAPI2_ERRL_SEV_RECOVERED)
.set_CHIP_TARGET(i_target)
.set_OP_POINT_TYPE(p)
- .set_VDM_NORMAL_SMALL((o_data->poundw[p].vdm_small_large_normal_freq >> 4) & 0x0F)
- .set_VDM_NORMAL_LARGE(o_data->poundw[p].vdm_small_large_normal_freq & 0x0F)
- .set_VDM_LARGE_SMALL((o_data->poundw[p].vdm_large_small_normal_freq >> 4) & 0x0F)
- .set_VDM_SMALL_NORMAL((o_data->poundw[p].vdm_large_small_normal_freq) & 0x0F),
+ .set_VDM_NORMAL_SMALL((o_data->poundw[p].vdm_normal_freq_drop >> 4) & 0x0F)
+ .set_VDM_NORMAL_LARGE(o_data->poundw[p].vdm_normal_freq_drop & 0x0F)
+ .set_VDM_LARGE_SMALL((o_data->poundw[p].vdm_normal_freq_return >> 4) & 0x0F)
+ .set_VDM_SMALL_NORMAL((o_data->poundw[p].vdm_normal_freq_return) & 0x0F),
"Pstate Parameter Block #W VDM frequency drop data are invalid");
fapi2::current_err = fapi2::FAPI2_RC_SUCCESS;
break;
@@ -4110,19 +4294,19 @@ void p9_pstate_compute_vdm_threshold_pts(PoundW_data i_data,
for (p = 0; p < NUM_OP_POINTS; p++)
{
// overvolt threshold
- io_lppb->threshold_set[p][0] = g_GreyCodeIndexMapping[(i_data.poundw[p].vdm_overvolt_small_thresholds >> 4) & 0x0F];
+ io_lppb->threshold_set[p][VDM_OVERVOLT_INDEX] = g_GreyCodeIndexMapping[(i_data.poundw[p].vdm_overvolt_small_thresholds >> 4) & 0x0F];
FAPI_INF("Bi: OV TSHLD =%d", io_lppb->threshold_set[p][0]);
// small threshold
- io_lppb->threshold_set[p][1] = (g_GreyCodeIndexMapping[i_data.poundw[p].vdm_overvolt_small_thresholds & 0x0F]);
+ io_lppb->threshold_set[p][VDM_SMALL_INDEX] = (g_GreyCodeIndexMapping[i_data.poundw[p].vdm_overvolt_small_thresholds & 0x0F]);
FAPI_INF("Bi: SM TSHLD =%d", io_lppb->threshold_set[p][1]);
// large threshold
- io_lppb->threshold_set[p][2] = (g_GreyCodeIndexMapping[(i_data.poundw[p].vdm_large_extreme_thresholds >> 4) & 0x0F]);
+ io_lppb->threshold_set[p][VDM_LARGE_INDEX] = (g_GreyCodeIndexMapping[(i_data.poundw[p].vdm_large_extreme_thresholds >> 4) & 0x0F]);
FAPI_INF("Bi: LG TSHLD =%d", io_lppb->threshold_set[p][2]);
// extreme threshold
- io_lppb->threshold_set[p][3] = (g_GreyCodeIndexMapping[i_data.poundw[p].vdm_large_extreme_thresholds & 0x0F]);
+ io_lppb->threshold_set[p][VDM_XTREME_INDEX] = (g_GreyCodeIndexMapping[i_data.poundw[p].vdm_large_extreme_thresholds & 0x0F]);
FAPI_INF("Bi: EX TSHLD =%d", io_lppb->threshold_set[p][3]);
@@ -4131,19 +4315,19 @@ void p9_pstate_compute_vdm_threshold_pts(PoundW_data i_data,
for (p = 0; p < NUM_OP_POINTS; p++)
{
// N_L value
- io_lppb->jump_value_set[p][0] = (i_data.poundw[p].vdm_small_large_normal_freq >> 4) & 0x0F;
+ io_lppb->jump_value_set[p][VDM_N_S_INDEX] = (i_data.poundw[p].vdm_normal_freq_drop >> 4) & 0x0F;
FAPI_INF("Bi: N_S =%d", io_lppb->jump_value_set[p][0]);
// N_S value
- io_lppb->jump_value_set[p][1] = i_data.poundw[p].vdm_small_large_normal_freq & 0x0F;
+ io_lppb->jump_value_set[p][VDM_N_L_INDEX] = i_data.poundw[p].vdm_normal_freq_drop & 0x0F;
FAPI_INF("Bi: N_L =%d", io_lppb->jump_value_set[p][1]);
// L_S value
- io_lppb->jump_value_set[p][2] = (i_data.poundw[p].vdm_large_small_normal_freq >> 4) & 0x0F;
+ io_lppb->jump_value_set[p][VDM_L_S_INDEX] = (i_data.poundw[p].vdm_normal_freq_return >> 4) & 0x0F;
FAPI_INF("Bi: L_S =%d", io_lppb->jump_value_set[p][2]);
// S_L value
- io_lppb->jump_value_set[p][3] = i_data.poundw[p].vdm_large_small_normal_freq & 0x0F;
+ io_lppb->jump_value_set[p][VDM_S_N_INDEX] = i_data.poundw[p].vdm_normal_freq_return & 0x0F;
FAPI_INF("Bi: S_L =%d", io_lppb->jump_value_set[p][3]);
}
@@ -4404,44 +4588,51 @@ fapi_try_exit:
}
//large_jump_interpolate
-uint32_t large_jump_interpolate (const Pstate i_pstate,const uint32_t i_attr_mvpd_data[PV_D][PV_W],
- const uint32_t i_step_frequency, const Pstate i_ps_pstate,
- const PoundW_data i_data)
+uint32_t
+large_jump_interpolate(const Pstate i_pstate,
+ const VpdOperatingPoint i_operating_points[NUM_OP_POINTS],
+ const uint32_t i_step_frequency,
+ const Pstate i_ps_pstate,
+ const PoundW_data i_data)
{
- VpdOperatingPoint operating_points[NUM_OP_POINTS];
- load_mvpd_operating_point(i_attr_mvpd_data, operating_points, i_step_frequency);
- uint8_t l_jump_value_set_ps = (i_data.poundw[POWERSAVE].vdm_small_large_normal_freq >> 4) & 0x0F;
- uint8_t l_jump_value_set_nom = (i_data.poundw[NOMINAL].vdm_small_large_normal_freq >> 4) & 0x0F;
- uint32_t l_slope_value = compute_slope_thresh(l_jump_value_set_nom,l_jump_value_set_ps,
- operating_points[POWERSAVE].pstate,
- operating_points[NOMINAL].pstate);
+ uint8_t l_jump_value_set_ps =
+ i_data.poundw[POWERSAVE].vdm_normal_freq_drop & 0x0F;
+ uint8_t l_jump_value_set_nom =
+ i_data.poundw[NOMINAL].vdm_normal_freq_drop & 0x0F;
+
+ uint32_t l_slope_value =
+ compute_slope_thresh(l_jump_value_set_nom,
+ l_jump_value_set_ps,
+ i_operating_points[POWERSAVE].pstate,
+ i_operating_points[NOMINAL].pstate);
- uint32_t l_vdm_jump_value = (uint32_t)((int32_t)l_jump_value_set_ps + (((int32_t)l_slope_value *
- (i_ps_pstate - i_pstate)) >> THRESH_SLOPE_FP_SHIFT));
+ uint32_t l_vdm_jump_value =
+ (uint32_t)((int32_t)l_jump_value_set_ps + (((int32_t)l_slope_value *
+ (i_ps_pstate - i_pstate)) >> THRESH_SLOPE_FP_SHIFT));
return l_vdm_jump_value;
}
-//pstate2voltage
-uint32_t pstate2voltage(const Pstate i_pstate,
- const uint32_t i_attr_mvpd_data[PV_D][PV_W],
- const uint32_t i_step_frequency)
+
+//ps2v_mv - Pstate to External Voltage in mV
+uint32_t ps2v_mv(const Pstate i_pstate,
+ const VpdOperatingPoint i_operating_points[NUM_OP_POINTS],
+ const uint32_t i_step_frequency)
{
- VpdOperatingPoint operating_points[NUM_OP_POINTS];
- load_mvpd_operating_point(i_attr_mvpd_data, operating_points, i_step_frequency);
+
uint32_t region_start, region_end;
const char* pv_op_str[NUM_OP_POINTS] = PV_OP_ORDER_STR;
FAPI_DBG("i_pstate = 0x%x, (%d)", i_pstate, i_pstate);
// Determine the VPD region
- if(i_pstate > operating_points[NOMINAL].pstate)
+ if(i_pstate > i_operating_points[NOMINAL].pstate)
{
region_start = POWERSAVE;
region_end = NOMINAL;
FAPI_DBG("Region POWERSAVE_NOMINAL detected");
}
- else if(i_pstate > operating_points[TURBO].pstate)
+ else if(i_pstate > i_operating_points[TURBO].pstate)
{
region_start = NOMINAL;
region_end = TURBO;
@@ -4455,50 +4646,50 @@ uint32_t pstate2voltage(const Pstate i_pstate,
}
uint32_t l_SlopeValue =
- compute_slope_4_12(revle32(operating_points[region_end].vdd_mv),
- revle32(operating_points[region_start].vdd_mv),
- operating_points[region_start].pstate,
- operating_points[region_end].pstate);
+ compute_slope_4_12(revle32(i_operating_points[region_end].vdd_mv),
+ revle32(i_operating_points[region_start].vdd_mv),
+ i_operating_points[region_start].pstate,
+ i_operating_points[region_end].pstate);
- FAPI_INF("l_globalppb.operating_points[%s].vdd_mv 0x%-3x (%d)",
+ FAPI_INF("l_globalppb.i_operating_points[%s].vdd_mv 0x%-3x (%d)",
pv_op_str[region_end],
- revle32(operating_points[region_end].vdd_mv),
- revle32(operating_points[region_end].vdd_mv));
- FAPI_INF("l_globalppb.operating_points[%s].vdd_mv 0x%-3x (%d)",
+ revle32(i_operating_points[region_end].vdd_mv),
+ revle32(i_operating_points[region_end].vdd_mv));
+ FAPI_INF("l_globalppb.i_operating_points[%s].vdd_mv 0x%-3x (%d)",
pv_op_str[region_start],
- revle32(operating_points[region_start].vdd_mv),
- revle32(operating_points[region_start].vdd_mv));
- FAPI_INF("l_globalppb.operating_points[%s].pstate 0x%-3x (%d)",
+ revle32(i_operating_points[region_start].vdd_mv),
+ revle32(i_operating_points[region_start].vdd_mv));
+ FAPI_INF("l_globalppb.i_operating_points[%s].pstate 0x%-3x (%d)",
pv_op_str[region_end],
- operating_points[region_end].pstate,
- operating_points[region_end].pstate);
- FAPI_INF("l_globalppb.operating_points[%s].pstate 0x%-3x (%d)",
+ i_operating_points[region_end].pstate,
+ i_operating_points[region_end].pstate);
+ FAPI_INF("l_globalppb.i_operating_points[%s].pstate 0x%-3x (%d)",
pv_op_str[region_start],
- operating_points[region_start].pstate,
- operating_points[region_start].pstate);
+ i_operating_points[region_start].pstate,
+ i_operating_points[region_start].pstate);
FAPI_INF ("l_SlopeValue %x",l_SlopeValue);
- uint32_t x = (l_SlopeValue * (-i_pstate + operating_points[region_start].pstate));
+ uint32_t x = (l_SlopeValue * (-i_pstate + i_operating_points[region_start].pstate));
uint32_t y = x >> VID_SLOPE_FP_SHIFT_12;
uint32_t l_vdd =
- (((l_SlopeValue * (-i_pstate + operating_points[region_start].pstate)) >> VID_SLOPE_FP_SHIFT_12)
- + revle32(operating_points[region_start].vdd_mv));
+ (((l_SlopeValue * (-i_pstate + i_operating_points[region_start].pstate)) >> VID_SLOPE_FP_SHIFT_12)
+ + revle32(i_operating_points[region_start].vdd_mv));
// Round up
l_vdd = (l_vdd << 1) + 1;
l_vdd = l_vdd >> 1;
FAPI_DBG("i_pstate = %d "
- "operating_points[%s].pstate) = %d "
- "operating_points[%s].vdd_mv = %d "
+ "i_operating_points[%s].pstate) = %d "
+ "i_operating_points[%s].vdd_mv = %d "
"VID_SLOPE_FP_SHIFT_12 = %X "
"x = %x (%d) y = %x (%d)",
i_pstate,
- pv_op_str[region_start], operating_points[region_start].pstate,
- pv_op_str[region_start], revle32(operating_points[region_start].vdd_mv),
+ pv_op_str[region_start], i_operating_points[region_start].pstate,
+ pv_op_str[region_start], revle32(i_operating_points[region_start].vdd_mv),
VID_SLOPE_FP_SHIFT_12,
x, x,
y, y);
@@ -4512,7 +4703,7 @@ uint32_t pstate2voltage(const Pstate i_pstate,
//p9_pstate_safe_mode_computation
fapi2::ReturnCode
p9_pstate_safe_mode_computation(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
- const uint32_t i_attr_mvpd_data[PV_D][PV_W],
+ const VpdOperatingPoint i_operating_points[NUM_VPD_PTS_SET][NUM_OP_POINTS],
const uint32_t i_reference_freq,
const uint32_t i_step_frequency,
const Pstate i_ps_pstate,
@@ -4523,8 +4714,14 @@ p9_pstate_safe_mode_computation(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP
const fapi2::Target<fapi2::TARGET_TYPE_SYSTEM> FAPI_SYSTEM;
fapi2::ATTR_SAFE_MODE_FREQUENCY_MHZ_Type l_safe_mode_freq_mhz;
fapi2::ATTR_SAFE_MODE_VOLTAGE_MV_Type l_safe_mode_mv;
+ fapi2::ATTR_VDD_BOOT_VOLTAGE_Type l_boot_mv;
uint32_t l_safe_mode_op_ps2freq_mhz;
+ VpdOperatingPoint l_operating_point[NUM_OP_POINTS];
+ get_operating_point(i_operating_points,
+ VPD_PT_SET_BIASED_SYSP,
+ l_operating_point);
+
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_FREQ_CORE_FLOOR_MHZ,
FAPI_SYSTEM,
l_safe_mode_values.safe_op_freq_mhz));
@@ -4533,18 +4730,26 @@ p9_pstate_safe_mode_computation(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP
// if not log an error
if ((l_safe_mode_values.safe_op_freq_mhz*1000) > i_reference_freq)
{
- FAPI_ERR("Core floor frequency value %08x is greater than ultra turbo freq %08x",
+ FAPI_ERR("Core floor frequency %08x is greater than UltraTurbo frequency %08x",
(l_safe_mode_values.safe_op_freq_mhz*1000), i_reference_freq);
FAPI_ASSERT(false,
fapi2::PSTATE_PB_CORE_FLOOR_FREQ_GT_UT_FREQ()
.set_CHIP_TARGET(i_target)
.set_CORE_FLOOR_FREQ(l_safe_mode_values.safe_op_freq_mhz*1000)
.set_UT_FREQ(i_reference_freq),
- "Core floor freq is greater than UT freq");
+ "Core floor freqency is greater than UltraTurbo frequency");
}
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_SAFE_MODE_FREQUENCY_MHZ, i_target, l_safe_mode_freq_mhz));
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_SAFE_MODE_VOLTAGE_MV, i_target, l_safe_mode_mv));
+ FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDD_BOOT_VOLTAGE, i_target, l_boot_mv));
+
+ FAPI_DBG ("l_safe_mode_freq_mhz 0%08x (%d)",
+ l_safe_mode_freq_mhz, l_safe_mode_freq_mhz);
+ FAPI_DBG ("l_safe_mode_mv 0%08x (%d)",
+ l_safe_mode_mv, l_safe_mode_mv);
+ FAPI_DBG ("l_boot_mv 0%08x (%d)",
+ l_boot_mv, l_boot_mv);
FAPI_INF ("l_safe_mode_values.safe_op_freq_mhz 0%08x (%d)",
l_safe_mode_values.safe_op_freq_mhz,
@@ -4572,12 +4777,15 @@ p9_pstate_safe_mode_computation(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP
}
// Calculate safe jump value for large frequency
- l_safe_mode_values.safe_vdm_jump_value = large_jump_interpolate
- (l_safe_mode_values.safe_op_ps,
- i_attr_mvpd_data, i_step_frequency,
- i_ps_pstate, i_poundw_data);
- FAPI_INF ("l_safe_mode_values.safe_vdm_jump_value %x",
- l_safe_mode_values.safe_vdm_jump_value);
+ l_safe_mode_values.safe_vdm_jump_value =
+ large_jump_interpolate(l_safe_mode_values.safe_op_ps,
+ l_operating_point,
+ i_step_frequency,
+ i_ps_pstate,
+ i_poundw_data);
+ FAPI_INF ("l_safe_mode_values.safe_vdm_jump_value %x -> %5.2f %%",
+ l_safe_mode_values.safe_vdm_jump_value,
+ ((float)l_safe_mode_values.safe_vdm_jump_value/32)*100);
// Calculate safe mode frequency - Round up to nearest MHz
// The uplifted frequency is based on the fact that the DPLL percentage is a
@@ -4590,16 +4798,33 @@ p9_pstate_safe_mode_computation(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP
if (l_safe_mode_freq_mhz)
{
l_safe_mode_values.safe_mode_freq_mhz = l_safe_mode_freq_mhz;
- FAPI_INF("Applying override safe mode freq value");
+ FAPI_INF("Applying override safe mode freq value of %d MHz",
+ l_safe_mode_freq_mhz);
}
else
{
+ FAPI_INF("Setting safe mode frequency to %d MHz (0x%x)",
+ l_safe_mode_values.safe_mode_freq_mhz,
+ l_safe_mode_values.safe_mode_freq_mhz);
FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_SAFE_MODE_FREQUENCY_MHZ, i_target, l_safe_mode_values.safe_mode_freq_mhz));
}
FAPI_INF ("l_safe_mode_values.safe_mode_freq_mhz 0x%0x (%d)",
l_safe_mode_values.safe_mode_freq_mhz,
l_safe_mode_values.safe_mode_freq_mhz);
+ // Safe frequency must be less than ultra turbo freq.
+ // if not log an error
+ if ((l_safe_mode_values.safe_mode_freq_mhz*1000) > i_reference_freq)
+ {
+ FAPI_ERR("Safe mode frequency %08x is greater than UltraTurbo frequency %08x",
+ (l_safe_mode_values.safe_op_freq_mhz*1000), i_reference_freq);
+ FAPI_ASSERT(false,
+ fapi2::PSTATE_PB_SAFE_FREQ_GT_UT_FREQ()
+ .set_CHIP_TARGET(i_target)
+ .set_SAFE_FREQ(l_safe_mode_values.safe_mode_freq_mhz*1000)
+ .set_UT_FREQ(i_reference_freq),
+ "Safe mode freqency is greater than UltraTurbo frequency");
+ }
l_safe_mode_values.safe_mode_ps = ((float)(i_reference_freq) -
(float)(l_safe_mode_values.safe_mode_freq_mhz * 1000)) /
@@ -4610,21 +4835,27 @@ p9_pstate_safe_mode_computation(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP
l_safe_mode_values.safe_mode_ps);
// Calculate safe mode voltage
- l_safe_mode_values.safe_mode_mv = pstate2voltage(l_safe_mode_values.safe_mode_ps,
- i_attr_mvpd_data,
- i_step_frequency);
+ // Use the biased with system parms operating points
+
+ l_safe_mode_values.safe_mode_mv = ps2v_mv(l_safe_mode_values.safe_mode_ps,
+ l_operating_point,
+ i_step_frequency);
if (l_safe_mode_mv)
{
l_safe_mode_values.safe_mode_mv = l_safe_mode_mv;
- FAPI_INF("Applying override safe mode voltage value");
+ FAPI_INF("Applying override safe mode voltage value of %d mV",
+ l_safe_mode_mv);
}
else
{
+ FAPI_INF("Setting safe mode voltage to %d mv (0x%x)",
+ l_safe_mode_values.safe_mode_mv,
+ l_safe_mode_values.safe_mode_mv);
FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_SAFE_MODE_VOLTAGE_MV, i_target, l_safe_mode_values.safe_mode_mv));
}
- FAPI_INF ("l_safe_mode_values.safe_mode_mv %x",
+ FAPI_INF ("l_safe_mode_values.safe_mode_mv 0x%x (%d)",
l_safe_mode_values.safe_mode_mv,
l_safe_mode_values.safe_mode_mv);
diff --git a/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.H b/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.H
index c336d2f6a..a2fb2ed72 100644
--- a/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.H
+++ b/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.H
@@ -79,6 +79,7 @@ typedef struct
} OperatingPoint;
+
typedef struct
{
bool iv_pstates_enabled;
@@ -110,7 +111,6 @@ typedef struct
typedef struct
{
-
uint32_t reference_frequency_khz;
uint32_t frequency_step_khz; // This is the reference frequency / DPPL_DIVIDER
// Load line parameters, This is also called Rloadline
@@ -174,7 +174,7 @@ typedef struct
uint32_t attr_freq_core_ceiling_mhz;
-// Loadline, Distribution loss and Distribution offset attributes
+// Loadline, Distribution loss and Distribution offset attVpdOpributes
uint32_t attr_proc_r_loadline_vdd_uohm;
uint32_t attr_proc_r_distloss_vdd_uohm;
uint32_t attr_proc_vrm_voffset_vdd_uv;
@@ -248,6 +248,28 @@ typedef struct
uint8_t attr_dd_vdm_not_supported;
uint8_t attr_pstate_mode;
+// AVSBus attributes
+ uint8_t vdd_bus_num;
+ uint8_t vdd_rail_select;
+ uint8_t vdn_bus_num;
+ uint8_t vdn_rail_select;
+ uint8_t vcs_bus_num;
+ uint8_t vcs_rail_select;
+ uint32_t vcs_voltage_mv;
+ uint32_t vdd_voltage_mv;
+ uint32_t vdn_voltage_mv;
+ uint32_t r_loadline_vdd_uohm;
+ uint32_t r_distloss_vdd_uohm;
+ uint32_t vrm_voffset_vdd_uv;
+ uint32_t r_loadline_vdn_uohm;
+ uint32_t r_distloss_vdn_uohm;
+ uint32_t vrm_voffset_vdn_uv;
+ uint32_t r_loadline_vcs_uohm;
+ uint32_t r_distloss_vcs_uohm;
+ uint32_t vrm_voffset_vcs_uv;
+ uint32_t freq_proc_refclock_khz;
+ uint32_t proc_dpll_divider;
+
} AttributeList;
/// The layout of the various Pstate Parameter Blocks (PPBs) passed a single
@@ -363,6 +385,33 @@ fapi2::ReturnCode
proc_get_attributes ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
AttributeList* io_attr);
+
+/// -----------------------------------------------------------------------
+/// @brief Load attribute content into the Global Parameter Block
+/// @param[in] i_attr => Reference to attribute list structure
+/// @param[out] o_globalppb => Pointer to Global Parameter Block
+/// -----------------------------------------------------------------------
+void
+load_gppb_attrs(const AttributeList* i_attr,
+ GlobalPstateParmBlock* o_globalppb);
+
+//
+/// -----------------------------------------------------------------------
+/// @brief Apply system parameters to a VPD value
+/// @param[in] i_vpd_mv => Reference to attribute list structure
+/// @param[in] i_vpd_ma = Reference to attribute list structure
+/// @param[in] i_loadline_uohm => Reference to attribute list structure
+/// @param[in] i_distloss_uohm => Reference to attribute list structure
+/// @param[in] i_distoffset_uohm => Reference to attribute list structure
+/// @return[out] uplifted voltage with system parameters added
+/// -----------------------------------------------------------------------
+uint32_t
+sysparm_uplift(const uint32_t i_vpd_mv,
+ const uint32_t i_vpd_ma,
+ const uint32_t i_loadline_uohm,
+ const uint32_t i_distloss_uohm,
+ const uint32_t i_distoffset_uohm);
+
/// ---------------------------------------------------------------------------
/// @brief Check and process #V bias attributes for external and internal
/// @param[in/out] io_attr_mvpd_data => 5x5 array to hold the #V data
@@ -444,6 +493,17 @@ load_mvpd_operating_point ( const uint32_t i_src[PV_D][PV_W],
VpdOperatingPoint* o_dest,
uint32_t i_frequency_step_khz);
+/// ------------------------------------------------------------
+/// @brief Copy out of operating point set into a destination operating point
+/// @param[in] &i_op_pt_set => reference to array of VpdOperatingPoint sets
+/// @param[out] *dest[NUM_OP_POINTS] => pointer to destination VpdOperatingPoint structure
+/// @param[in] i_frequency_step_khz => Base frequency value for pstate calculation
+/// ------------------------------------------------------------
+fapi2::ReturnCode
+get_operating_point ( const VpdOperatingPoint i_op_pt_set[NUM_VPD_PTS_SET][NUM_OP_POINTS],
+ uint32_t i_set,
+ VpdOperatingPoint* o_op_pt);
+
/// ----------------------------------------------------------------
/// @brief Get VDM parameters from attributes
/// @param[in] i_target => Proc Target
@@ -495,7 +555,6 @@ fapi2::ReturnCode
proc_set_resclk_table_attrs(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
PSTATE_attribute_state* o_state);
-//
/// -------------------------------------------------------------------
/// @brief Compute VPD points for different regions
/// @param[out] o_operating_points => VPD operating points
@@ -568,16 +627,28 @@ oppb_print(OCCPstateParmBlock* i_oppb);
void
iddq_print(IddqTable* i_iddqt);
+
+
+enum FREQ2PSTATE_ROUNDING
+{
+ ROUND_FAST,
+ ROUND_SLOW
+};
+
+
/// -------------------------------------------------------------------
/// @brief Convert frequency to Pstate number
/// @param[in] i_gppb The Global Pstate Parameter Block
/// @param[in] i_freq_khz Input frequency to convert
/// @param[out] o_pstate Computed Pstate
+/// @param[out] i_round Pstate rounding (ROUND_FAST, ROUND_SLOW)
// @return pstate state value whether it's lesser than min or greater than max
/// -------------------------------------------------------------------
+
int freq2pState (const GlobalPstateParmBlock* i_gppb,
- const uint32_t i_freq_khz,
- Pstate* o_pstate);
+ const uint32_t i_freq_khz,
+ Pstate* o_pstate,
+ const FREQ2PSTATE_ROUNDING i_round = ROUND_SLOW);
/// -------------------------------------------------------------------
/// @brief Convert Pstate number to frequency
@@ -723,7 +794,7 @@ void p9_pstate_wof_initialization (const GlobalPstateParmBlock* i_gppb,
/// @return FAPI2::SUCCESS
fapi2::ReturnCode
p9_pstate_safe_mode_computation(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
- const uint32_t i_attr_mvpd_data[PV_D][PV_W],
+ const VpdOperatingPoint i_operating_points[NUM_VPD_PTS_SET][NUM_OP_POINTS],
const uint32_t i_reference_freq,
const uint32_t i_step_frequency,
const Pstate i_ps_pstate,
@@ -749,11 +820,23 @@ uint32_t pstate2voltage(const Pstate i_pstate,
/// @param[in] i_ps_pstate power save pstate
/// @paramgin] i_data Pound W vpd data
/// @return uint32_t jump value
-uint32_t large_jump_interpolate (const Pstate i_pstate, const uint32_t i_attr_mvpd_data[PV_D][PV_W],
- const uint32_t i_step_frequency, Pstate i_ps_pstate,
- const PoundW_data i_data);
-
+uint32_t large_jump_interpolate(const Pstate i_pstate,
+ const VpdOperatingPoint i_operating_points[NUM_OP_POINTS],
+ const uint32_t i_step_frequency,
+ Pstate i_ps_pstate,
+ const PoundW_data i_data);
+/// -------------------------------------------------------------------
+/// @brief Interpolate the currents based on frequency
+/// @param[in] i_biased_vpd - Data to interpolate
+/// @param[in] i_freq_mhz - Index grequency
+/// @param[out] o_current_ma - Interpolated Current
+/// @return true or false
+///
+void
+interpolate_current( const uint32_t i_biased_vpd[PV_D][PV_W],
+ const uint32_t i_freq_mhz,
+ uint32_t* o_current_ma);
// p9_pstate_set_global_feature_attributes
/// -------------------------------------------------------------------
diff --git a/src/import/chips/p9/procedures/hwp/pm/p9_setup_evid.C b/src/import/chips/p9/procedures/hwp/pm/p9_setup_evid.C
index e8edf9ae2..b3c731fb0 100644
--- a/src/import/chips/p9/procedures/hwp/pm/p9_setup_evid.C
+++ b/src/import/chips/p9/procedures/hwp/pm/p9_setup_evid.C
@@ -106,54 +106,31 @@ struct avsbus_attrs_t
};
//##############################################################################
-//@brief Initialize VDD/VCS/VDN bus num, rail select and voltage values
-//@param[in] i_target Proc Chip target
-//@param[in] attrs VDD/VCS/VDN attributes
-//@param[in] i_action Voltage Config action
+//@brief Compute the boot and safe frequencies and voltages
+//@param[in] i_target Proc Chip target
+//@param[in] attrs Attributes
+//@param[in] l_globalppb Global Pstate Parameter Block
+//@param[in] i_action Voltage Config action
//@return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
//##############################################################################
fapi2::ReturnCode
-avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
- avsbus_attrs_t* attrs,
+compute_boot_safe(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
+ AttributeList* attrs,
+ GlobalPstateParmBlock* l_globalppb,
const VoltageConfigActions_t i_action)
{
fapi2::ReturnCode l_rc;
- uint32_t attr_mvpd_data[PV_D][PV_W];
+
+ uint32_t attr_mvpd_poundv[PV_D][PV_W];
uint32_t valid_pdv_points;
uint8_t present_chiplets;
+
PSTATE_attribute_state l_state;
l_state.iv_pstates_enabled = true;
l_state.iv_resclk_enabled = true;
l_state.iv_vdm_enabled = true;
l_state.iv_ivrm_enabled = true;
l_state.iv_wof_enabled = true;
- const fapi2::Target<fapi2::TARGET_TYPE_SYSTEM> FAPI_SYSTEM;
-
-#define DATABLOCK_GET_ATTR(_attr_name, _target, _attr_assign) \
- FAPI_TRY(FAPI_ATTR_GET(fapi2::_attr_name, _target, _attr_assign),"Attribute read failed"); \
- FAPI_INF("%-30s = 0x%08x %u", #_attr_name, _attr_assign, _attr_assign);
-
- DATABLOCK_GET_ATTR(ATTR_VDD_AVSBUS_BUSNUM, i_target, attrs->vdd_bus_num);
- DATABLOCK_GET_ATTR(ATTR_VDD_AVSBUS_RAIL, i_target, attrs->vdd_rail_select);
- DATABLOCK_GET_ATTR(ATTR_VDN_AVSBUS_BUSNUM, i_target, attrs->vdn_bus_num);
- DATABLOCK_GET_ATTR(ATTR_VDN_AVSBUS_RAIL, i_target, attrs->vdn_rail_select);
- DATABLOCK_GET_ATTR(ATTR_VCS_AVSBUS_BUSNUM, i_target, attrs->vcs_bus_num);
- DATABLOCK_GET_ATTR(ATTR_VCS_AVSBUS_RAIL, i_target, attrs->vcs_rail_select);
- DATABLOCK_GET_ATTR(ATTR_VCS_BOOT_VOLTAGE, i_target, attrs->vcs_voltage_mv);
- DATABLOCK_GET_ATTR(ATTR_VDD_BOOT_VOLTAGE, i_target, attrs->vdd_voltage_mv);
- DATABLOCK_GET_ATTR(ATTR_VDN_BOOT_VOLTAGE, i_target, attrs->vdn_voltage_mv);
-
- DATABLOCK_GET_ATTR(ATTR_PROC_R_LOADLINE_VDD_UOHM, i_target, attrs->r_loadline_vdd_uohm);
- DATABLOCK_GET_ATTR(ATTR_PROC_R_DISTLOSS_VDD_UOHM, i_target, attrs->r_distloss_vdd_uohm);
- DATABLOCK_GET_ATTR(ATTR_PROC_VRM_VOFFSET_VDD_UV, i_target, attrs->vrm_voffset_vdd_uv );
- DATABLOCK_GET_ATTR(ATTR_PROC_R_LOADLINE_VDN_UOHM, i_target, attrs->r_loadline_vdn_uohm);
- DATABLOCK_GET_ATTR(ATTR_PROC_R_DISTLOSS_VDN_UOHM, i_target, attrs->r_distloss_vdn_uohm);
- DATABLOCK_GET_ATTR(ATTR_PROC_VRM_VOFFSET_VDN_UV, i_target, attrs->vrm_voffset_vdn_uv );
- DATABLOCK_GET_ATTR(ATTR_PROC_R_LOADLINE_VCS_UOHM, i_target, attrs->r_loadline_vcs_uohm);
- DATABLOCK_GET_ATTR(ATTR_PROC_R_DISTLOSS_VCS_UOHM, i_target, attrs->r_distloss_vcs_uohm);
- DATABLOCK_GET_ATTR(ATTR_PROC_VRM_VOFFSET_VCS_UV, i_target, attrs->vrm_voffset_vcs_uv);
- DATABLOCK_GET_ATTR(ATTR_FREQ_PROC_REFCLOCK_KHZ, FAPI_SYSTEM, attrs->freq_proc_refclock_khz);
- DATABLOCK_GET_ATTR(ATTR_PROC_DPLL_DIVIDER, i_target, attrs->proc_dpll_divider);
do
{
@@ -162,17 +139,33 @@ avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
//inputed to the HWP tells us to
if(i_action == COMPUTE_VOLTAGE_SETTINGS)
{
- uint8_t l_poundv_bucketId = 0;
- fapi2::voltageBucketData_t l_poundv_data;
// query VPD if any of the voltage attributes are zero
if (!attrs->vdd_voltage_mv ||
!attrs->vcs_voltage_mv ||
!attrs->vdn_voltage_mv)
{
+
+ uint8_t l_poundv_bucketId = 0;
+ fapi2::voltageBucketData_t l_poundv_data;
+ LP_VDMParmBlock l_lp_vdmpb;
+
+ PoundW_data l_poundw_data;
+ memset (&l_poundw_data, 0, sizeof(PoundW_data));
+
+ LocalPstateParmBlock l_localppb;
+ memset(&l_localppb, 0, sizeof(LocalPstateParmBlock));
+
+ Safe_mode_parameters l_safe_mode_values;
+
+ uint8_t l_ps_pstate = 0xFF;
+
+ VpdBias l_vpdbias[NUM_OP_POINTS];
+ memset (l_vpdbias, 0, sizeof(VpdBias));
+
// Get #V data from MVPD for VDD/VDN and VCS voltage values
FAPI_TRY(proc_get_mvpd_data(i_target,
- attr_mvpd_data,
+ attr_mvpd_poundv,
&valid_pdv_points,
&present_chiplets,
l_poundv_bucketId,
@@ -185,18 +178,6 @@ avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
break;
}
- // Compute safe mode values
- LP_VDMParmBlock l_lp_vdmpb;
- PoundW_data l_poundw_data;
- memset (&l_poundw_data, 0, sizeof(PoundW_data));
- LocalPstateParmBlock l_localppb;
- memset(&l_localppb, 0, sizeof(LocalPstateParmBlock));
- Safe_mode_parameters l_safe_mode_values;
- uint8_t l_pstate = 0xFF;
- AttributeList l_attr;
- VpdBias l_vpdbias[NUM_OP_POINTS];
- memset (l_vpdbias, 0, sizeof(VpdBias));
-
//set to default value if dpll divider is 0
if (!attrs->proc_dpll_divider)
{
@@ -204,22 +185,41 @@ avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
}
// Read the Biased attribute data
- FAPI_TRY(proc_get_attributes(i_target, &l_attr), "Get attributes function failed");
-
- // Apply Bias values
- FAPI_TRY(proc_get_extint_bias(attr_mvpd_data,
- &l_attr,
- l_vpdbias),
- "Bias application function failed");
-
-
- uint32_t l_frequency_step_khz = attrs->freq_proc_refclock_khz / attrs->proc_dpll_divider;
- uint32_t l_ref_freq_khz = attr_mvpd_data[ULTRA][VPD_PV_CORE_FREQ_MHZ] * 1000;
-
- l_pstate = ((attr_mvpd_data[ULTRA][VPD_PV_CORE_FREQ_MHZ] -
- attr_mvpd_data[POWERSAVE][VPD_PV_CORE_FREQ_MHZ]) * 1000) /
- l_frequency_step_khz;
- l_rc = proc_get_mvpd_poundw(i_target, l_poundv_bucketId, &l_lp_vdmpb, &l_poundw_data, l_poundv_data, &l_state);
+// FAPI_TRY(proc_get_attributes(i_target, attrs), "Get attributes function failed");
+
+ VpdOperatingPoint l_raw_operating_points[NUM_OP_POINTS];
+ FAPI_INF("Load RAW VPD");
+ FAPI_TRY(load_mvpd_operating_point(attr_mvpd_poundv,
+ l_raw_operating_points,
+ revle32(l_globalppb->frequency_step_khz)),
+ "Loading MVPD operating points failed");
+
+ // Put raw operating points into the Global Parameter Block
+ FAPI_INF("Place Raw VPD into GPPB");
+ FAPI_TRY(load_mvpd_operating_point(attr_mvpd_poundv,
+ l_globalppb->operating_points,
+ revle32(l_globalppb->frequency_step_khz)),
+ "Putting MVPD into GPPB operating points failed");
+
+ // Compute the VPD operating points
+ VpdOperatingPoint l_operating_points[NUM_VPD_PTS_SET][NUM_OP_POINTS];
+ p9_pstate_compute_vpd_pts(l_operating_points,
+ l_globalppb,
+ l_raw_operating_points);
+
+ uint32_t l_ps_freq_khz = l_operating_points[VPD_PT_SET_BIASED][POWERSAVE].frequency_mhz * 1000;
+ freq2pState(l_globalppb, l_ps_freq_khz, &l_ps_pstate);
+
+ FAPI_INF ("l_frequency_step_khz %08x", revle32(l_globalppb->frequency_step_khz));
+ FAPI_INF ("l_ref_freq_khz %08X", revle32(l_globalppb->reference_frequency_khz));
+ FAPI_INF ("l_ps_pstate %x", l_ps_pstate);
+
+ l_rc = proc_get_mvpd_poundw(i_target,
+ l_poundv_bucketId,
+ &l_lp_vdmpb,
+ &l_poundw_data,
+ l_poundv_data,
+ &l_state);
if (l_rc)
{
@@ -231,15 +231,15 @@ avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
fapi2::current_err = fapi2::FAPI2_RC_SUCCESS;
}
- FAPI_INF ("l_frequency_step_khz %08x", l_frequency_step_khz);
- FAPI_INF ("l_ref_freq_khz %08X", l_ref_freq_khz);
- FAPI_INF ("l_pstate %x", l_pstate);
-
//Compute safe mode values
- FAPI_TRY(p9_pstate_safe_mode_computation (i_target, attr_mvpd_data,
- l_ref_freq_khz, l_frequency_step_khz,
- l_pstate, &l_safe_mode_values,
- l_poundw_data),
+ FAPI_TRY(p9_pstate_safe_mode_computation (
+ i_target,
+ l_operating_points,
+ revle32(l_globalppb->reference_frequency_khz),
+ revle32(l_globalppb->frequency_step_khz),
+ l_ps_pstate,
+ &l_safe_mode_values,
+ l_poundw_data),
"Error from p9_pstate_safe_mode_computation function");
@@ -251,30 +251,11 @@ avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
else
{
attrs->vdd_voltage_mv = l_safe_mode_values.boot_mode_mv;
-
- if (!l_safe_mode_values.boot_mode_mv)
- {
- FAPI_INF("VDD boot voltage override not set, using VPD value and correcting for applicable load line setting");
- uint32_t vpd_vdd_voltage_mv = attr_mvpd_data[POWERSAVE][VPD_PV_VDD_MV];
- attrs->vdd_voltage_mv =
- ( (vpd_vdd_voltage_mv * 1000) + // uV
- ( ( (attr_mvpd_data[POWERSAVE][VPD_PV_IDD_100MA] / 10) * // A
- (attrs->r_loadline_vdd_uohm + attrs->r_distloss_vdd_uohm)) + // uohm -> A*uohm = uV
- attrs->vrm_voffset_vdd_uv )) / 1000; // mV
-
- FAPI_INF("VDD VPD voltage %d mV; Corrected voltage: %d mV; IDD: %d mA; LoadLine: %d uOhm; DistLoss: %d uOhm; Offst: %d uOhm",
- vpd_vdd_voltage_mv,
- attrs->vdd_voltage_mv,
- attr_mvpd_data[POWERSAVE][VPD_PV_IDD_100MA] * 100,
- attrs->r_loadline_vdd_uohm,
- attrs->r_distloss_vdd_uohm,
- attrs->vrm_voffset_vdd_uv);
- }
-
- FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_VDD_BOOT_VOLTAGE, i_target, attrs->vdd_voltage_mv),
- "Error from FAPI_ATTR_SET (ATTR_VDD_BOOT_VOLTAGE)");
+ FAPI_INF("VDD boot voltage set to %d mV.", attrs->vdd_voltage_mv);
}
+
+
// set VCS voltage to UltraTurbo Voltage from MVPD data (if no override)
if (attrs->vcs_voltage_mv)
{
@@ -283,23 +264,19 @@ avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
else
{
FAPI_INF("VCS boot voltage override not set, using VPD value and correcting for applicable load line setting");
- uint32_t vpd_vcs_voltage_mv = attr_mvpd_data[POWERSAVE][VPD_PV_VCS_MV];
- attrs->vcs_voltage_mv =
- ( (vpd_vcs_voltage_mv * 1000) + // uV
- ( ( (attr_mvpd_data[POWERSAVE][VPD_PV_ICS_100MA] / 10) * // A
- (attrs->r_loadline_vcs_uohm + attrs->r_distloss_vcs_uohm)) + // uohm -> A*uohm = uV
- attrs->vrm_voffset_vcs_uv )) / 1000; // mV
-
- FAPI_INF("VCS VPD voltage %d mV; Corrected voltage: %d mV; IDD: %d mA; LoadLine: %d uOhm; DistLoss: %d uOhm; Offst: %d uOhm",
- vpd_vcs_voltage_mv,
- attrs->vcs_voltage_mv,
- attr_mvpd_data[POWERSAVE][VPD_PV_ICS_100MA] * 100,
+ uint32_t l_ext_vcs_mv = revle32(l_operating_points[VPD_PT_SET_BIASED_SYSP][ULTRA].vcs_mv);
+ uint32_t l_int_vcs_mv = revle32(l_operating_points[VPD_PT_SET_BIASED][ULTRA].vcs_mv);
+ uint32_t l_ics_ma = revle32(l_operating_points[VPD_PT_SET_BIASED][ULTRA].ics_100ma) * 100;
+
+ FAPI_INF("VCS VPD voltage %d mV; Corrected voltage: %d mV; ICS: %d mA; LoadLine: %d uOhm; DistLoss: %d uOhm; Offst: %d uOhm",
+ l_int_vcs_mv,
+ l_ext_vcs_mv,
+ l_ics_ma,
attrs->r_loadline_vcs_uohm,
attrs->r_distloss_vcs_uohm,
attrs->vrm_voffset_vcs_uv);
- FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_VCS_BOOT_VOLTAGE, i_target, attrs->vcs_voltage_mv),
- "Error from FAPI_ATTR_SET (ATTR_VCS_BOOT_VOLTAGE)");
+ attrs->vcs_voltage_mv = l_ext_vcs_mv;
}
// set VDN voltage to PowerSave Voltage from MVPD data (if no override)
@@ -310,31 +287,77 @@ avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
else
{
FAPI_INF("VDN boot voltage override not set, using VPD value and correcting for applicable load line setting");
- uint32_t vpd_vdn_voltage_mv = attr_mvpd_data[POWERBUS][VPD_PV_VDN_MV];
- attrs->vdn_voltage_mv =
- ( (vpd_vdn_voltage_mv * 1000) + // uV
- ( ( (attr_mvpd_data[POWERBUS][VPD_PV_IDN_100MA] / 10) * // A
- (attrs->r_loadline_vdn_uohm + attrs->r_distloss_vdn_uohm)) + // uohm -> A*uohm = uV
- attrs->vrm_voffset_vdn_uv )) / 1000; // mV
+ uint32_t l_int_vdn_mv = revle32(attr_mvpd_poundv[POWERBUS][VPD_PV_VDN_MV]);
+ uint32_t l_idn_ma = revle32(attr_mvpd_poundv[POWERBUS][VPD_PV_IDN_100MA]) * 100;
+ // Returns revle32
+ uint32_t l_ext_vdn_mv = sysparm_uplift(l_int_vdn_mv,
+ l_idn_ma,
+ attrs->r_loadline_vdn_uohm,
+ attrs->r_distloss_vdn_uohm,
+ attrs->vrm_voffset_vdn_uv);
FAPI_INF("VDN VPD voltage %d mV; Corrected voltage: %d mV; IDN: %d mA; LoadLine: %d uOhm; DistLoss: %d uOhm; Offst: %d uOhm",
- vpd_vdn_voltage_mv,
- attrs->vdn_voltage_mv,
- attr_mvpd_data[POWERBUS][VPD_PV_IDN_100MA] * 100,
+ revle32(l_int_vdn_mv),
+ l_ext_vdn_mv,
+ revle32(l_idn_ma),
attrs->r_loadline_vdn_uohm,
attrs->r_distloss_vdn_uohm,
attrs->vrm_voffset_vdn_uv);
- FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_VDN_BOOT_VOLTAGE, i_target, attrs->vdn_voltage_mv),
- "Error from FAPI_ATTR_SET (ATTR_VDN_BOOT_VOLTAGE)");
+ attrs->vdn_voltage_mv = l_ext_vdn_mv;
}
}
else
{
- FAPI_INF("Using override for all boot voltages (VDD/VCS/VDN)");
+ FAPI_INF("Using overrides for all boot voltages (VDD/VCS/VDN) and core frequency");
+
+ // Set safe frequency to the default BOOT_FREQ_MULT
+ fapi2::ATTR_BOOT_FREQ_MULT_Type l_boot_freq_mult;
+ FAPI_TRY(FAPI_ATTR_GET( fapi2::ATTR_BOOT_FREQ_MULT,
+ i_target,
+ l_boot_freq_mult));
+
+ uint32_t l_boot_freq_mhz =
+ ((l_boot_freq_mult * attrs->freq_proc_refclock_khz ) /
+ attrs->proc_dpll_divider )
+ / 1000;
+
+ uint32_t l_reference_freq_khz = revle32(l_globalppb->frequency_step_khz);
+
+ // The Boot frequency must be less than ultra turbo frequency
+ // if not log an error
+ if ((l_boot_freq_mhz * 1000) > l_reference_freq_khz)
+ {
+ FAPI_ERR("Boot frequency %d kHz is greater than UltraTurbo frequency %d kHz",
+ (l_boot_freq_mhz * 1000), l_reference_freq_khz);
+ FAPI_ASSERT(false,
+ fapi2::PM_EVID_BOOT_FREQ_GT_UT()
+ .set_CHIP_TARGET(i_target)
+ .set_BOOT_FREQ(l_boot_freq_mhz * 1000)
+ .set_UT_FREQ(l_reference_freq_khz),
+ "Safe mode freqency is greater than UltraTurbo frequency");
+ }
+
+ FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_SAFE_MODE_FREQUENCY_MHZ,
+ i_target,
+ l_boot_freq_mhz));
+ FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_SAFE_MODE_VOLTAGE_MV,
+ i_target,
+ attrs->vdd_voltage_mv));
+ FAPI_INF("Safe mode Frequency = %d MHz (0x%x), Safe mode voltage = %d mV (0x%x)",
+ l_boot_freq_mhz, l_boot_freq_mhz,
+ attrs->vdd_voltage_mv, attrs->vdd_voltage_mv);
}
- }
+ FAPI_INF("Setting Boot Voltage attributes: VDD = %dmV; VCS = %dmV; VDN = %dmV",
+ attrs->vdd_voltage_mv, attrs->vcs_voltage_mv, attrs->vdn_voltage_mv);
+ FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_VDD_BOOT_VOLTAGE, i_target, attrs->vdd_voltage_mv),
+ "Error from FAPI_ATTR_SET (ATTR_VDD_BOOT_VOLTAGE)");
+ FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_VCS_BOOT_VOLTAGE, i_target, attrs->vcs_voltage_mv),
+ "Error from FAPI_ATTR_SET (ATTR_VCS_BOOT_VOLTAGE)");
+ FAPI_TRY(FAPI_ATTR_SET(fapi2::ATTR_VDN_BOOT_VOLTAGE, i_target, attrs->vdn_voltage_mv),
+ "Error from FAPI_ATTR_SET (ATTR_VDN_BOOT_VOLTAGE)");
+ } // COMPUTE_VOLTAGE_SETTINGS
}
while(0);
@@ -348,15 +371,13 @@ avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
fapi_try_exit:
return fapi2::current_err;
-} // avsInitAttributes
+} // compute_boot_safe
fapi2::ReturnCode
p9_setup_evid(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target, const VoltageConfigActions_t i_action)
{
- // AVSBus configuration variables
- avsbus_attrs_t attrs;
fapi2::buffer<uint64_t> l_data64;
fapi2::buffer<uint8_t> l_data8;
@@ -364,8 +385,19 @@ p9_setup_evid(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target, const
uint8_t l_goodResponse = 0;
uint8_t l_throwAssert = 0;
- // Read attribute -
- FAPI_TRY(avsInitAttributes(i_target, &attrs, i_action));
+ AttributeList attrs;
+ GlobalPstateParmBlock l_globalppb;
+ memset (&l_globalppb, 0, sizeof(GlobalPstateParmBlock));
+
+ // Load the attributes
+ FAPI_TRY(proc_get_attributes(i_target, &attrs),
+ "Get attributes function failed");
+
+ // Create Global Parameter Block from attribute structure
+ load_gppb_attrs(&attrs, &l_globalppb);
+
+ // Compute the boot/safe values
+ FAPI_TRY(compute_boot_safe(i_target, &attrs, &l_globalppb, i_action));
//We only wish to apply settings if i_action says to
if(i_action == APPLY_VOLTAGE_SETTINGS)
@@ -545,18 +577,18 @@ p9_setup_dpll_values (const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_targe
// Convert frequency value to a format that needs to be written to the
// register
- uint32_t l_safe_mode_freq = ((l_attr_safe_mode_freq * 1000) * i_proc_dpll_divider) /
- i_freq_proc_refclock_khz;
+ uint32_t l_safe_mode_dpll_value = ((l_attr_safe_mode_freq * 1000) * i_proc_dpll_divider) /
+ i_freq_proc_refclock_khz;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_UNIT_POS, *l_itr, l_chipNum));
- FAPI_INF("For EQ number %u, l_fmult %08X l_safe_mode_freq %08X",
- l_chipNum, l_fmult, l_safe_mode_freq);
+ FAPI_INF("For EQ number %u, l_fmult 0x%08X l_safe_mode_dpll_value 0x%08X (%d)",
+ l_chipNum, l_fmult, l_safe_mode_dpll_value, l_safe_mode_dpll_value);
- if (l_fmult > l_safe_mode_freq)
+ if (l_fmult > l_safe_mode_dpll_value)
{
FAPI_INF("DPLL setting: Lowering the dpll frequency");
}
- else if (l_fmult < l_safe_mode_freq)
+ else if (l_fmult < l_safe_mode_dpll_value)
{
FAPI_INF("DPLL setting: Raising the dpll frequency");
}
@@ -567,13 +599,13 @@ p9_setup_dpll_values (const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_targe
//FMax
l_data64.insertFromRight<EQ_QPPM_DPLL_FREQ_FMAX,
- EQ_QPPM_DPLL_FREQ_FMAX_LEN>(l_safe_mode_freq);
+ EQ_QPPM_DPLL_FREQ_FMAX_LEN>(l_safe_mode_dpll_value);
//FMin
l_data64.insertFromRight<EQ_QPPM_DPLL_FREQ_FMIN,
- EQ_QPPM_DPLL_FREQ_FMIN_LEN>(l_safe_mode_freq);
+ EQ_QPPM_DPLL_FREQ_FMIN_LEN>(l_safe_mode_dpll_value);
//FMult
l_data64.insertFromRight<EQ_QPPM_DPLL_FREQ_FMULT,
- EQ_QPPM_DPLL_FREQ_FMULT_LEN>(l_safe_mode_freq);
+ EQ_QPPM_DPLL_FREQ_FMULT_LEN>(l_safe_mode_dpll_value);
FAPI_TRY(fapi2::putScom(*l_itr, EQ_QPPM_DPLL_FREQ, l_data64),
"ERROR: Failed to write for EQ_QPPM_DPLL_FREQ");
@@ -587,7 +619,9 @@ p9_setup_dpll_values (const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_targe
//the register
uint32_t l_vdm_vid_value = (l_attr_safe_mode_mv - VDM_VOLTAGE_IN_MV) / VDM_GRANULARITY;
- FAPI_INF ("l_vdm_vid_value %x, i_safe_mode_values.safe_mode_mv %x", l_vdm_vid_value, l_attr_safe_mode_mv);
+ FAPI_INF ("l_vdm_vid_value 0x%x (%d), i_safe_mode_values.safe_mode_mv 0x%x (%d)",
+ l_vdm_vid_value, l_vdm_vid_value,
+ l_attr_safe_mode_mv, l_attr_safe_mode_mv);
FAPI_TRY(fapi2::getScom(*l_itr, EQ_QPPM_VDMCFGR, l_data64),
"ERROR: Failed to read EQ_QPPM_VDMCFGR");
diff --git a/src/import/chips/p9/procedures/xml/error_info/p9_pstate_parameter_block_errors.xml b/src/import/chips/p9/procedures/xml/error_info/p9_pstate_parameter_block_errors.xml
index 5c64d1121..18b24d186 100644
--- a/src/import/chips/p9/procedures/xml/error_info/p9_pstate_parameter_block_errors.xml
+++ b/src/import/chips/p9/procedures/xml/error_info/p9_pstate_parameter_block_errors.xml
@@ -439,4 +439,19 @@
</callout>
</hwpError>
<!-- ******************************************************************** -->
+ <hwpError>
+ <rc>RC_PSTATE_PB_SAFE_FREQ_GT_UT_FREQ</rc>
+ <description>The calculated Save Mode frequency, after uplifting to
+ account for VDM droop events, is above the UltraTurbo frequency of
+ the part.
+ </description>
+ <ffdc>CHIP_TARGET</ffdc>
+ <ffdc>SAFE_FREQ</ffdc>
+ <ffdc>UT_FREQ</ffdc>
+ <callout>
+ <procedure>CODE</procedure>
+ <priority>HIGH</priority>
+ </callout>
+ </hwpError>
+ <!-- ******************************************************************** -->
</hwpErrors>
diff --git a/src/import/chips/p9/procedures/xml/error_info/p9_setup_evid_errors.xml b/src/import/chips/p9/procedures/xml/error_info/p9_setup_evid_errors.xml
index 513c68615..7cf588b75 100644
--- a/src/import/chips/p9/procedures/xml/error_info/p9_setup_evid_errors.xml
+++ b/src/import/chips/p9/procedures/xml/error_info/p9_setup_evid_errors.xml
@@ -5,7 +5,7 @@
<!-- -->
<!-- OpenPOWER HostBoot Project -->
<!-- -->
-<!-- Contributors Listed Below - COPYRIGHT 2015,2016 -->
+<!-- Contributors Listed Below - COPYRIGHT 2015,2017 -->
<!-- [+] International Business Machines Corp. -->
<!-- -->
<!-- -->
@@ -33,43 +33,17 @@
<hwpErrors>
<!-- ******************************************************************** -->
<hwpError>
- <rc>RC_PM_EVID_READVOLTAGE_TIMEOUT</rc>
+ <rc>RC_PM_EVID_BOOT_FREQ_GT_UT</rc>
<description>
- A timeout occured reading voltage from an AVSBus interface
+ The Boot Frequency is higher than the part's UltraTurbo value.
</description>
- <ffdc>TARGET</ffdc>
- </hwpError>
- <!-- ******************************************************************** -->
- <hwpError>
- <rc>RC_PM_VDD_EVID_WRITEVOLTAGE_TIMEOUT</rc>
- <description>
- A timeout occured writing a voltage to an AVSBus interface
- </description>
- <ffdc>TARGET</ffdc>
- </hwpError>
- <!-- ******************************************************************** -->
- <hwpError>
- <rc>RC_PM_VDN_EVID_WRITEVOLTAGE_TIMEOUT</rc>
- <description>
- A timeout occured writing a voltage to an AVSBus interface
- </description>
- <ffdc>TARGET</ffdc>
- </hwpError>
- <!-- ******************************************************************** -->
- <hwpError>
- <rc>RC_PM_VCS_EVID_WRITEVOLTAGE_TIMEOUT</rc>
- <description>
- A timeout occured writing a voltage to an AVSBus interface
- </description>
- <ffdc>TARGET</ffdc>
- </hwpError>
- <!-- ******************************************************************** -->
- <hwpError>
- <rc>RC_PM_EVID_IDLEFRAME_TIMEOUT</rc>
- <description>
- A timeout occured writing an idle from to an AVSBus interface
- </description>
- <ffdc>TARGET</ffdc>
+ <ffdc>CHIP_TARGET</ffdc>
+ <ffdc>BOOT_FREQ</ffdc>
+ <ffdc>UT_FREQ</ffdc>
+ <callout>
+ <procedure>CODE</procedure>
+ <priority>HIGH</priority>
+ </callout>
</hwpError>
<!-- ******************************************************************** -->
</hwpErrors>
OpenPOWER on IntegriCloud