p9_pstate_parameter_block: Pound W enhancement for VID Compare

       - Add changes to Compare VID slopes support
       - Added changes for threshold slopes

Change-Id: I6ce9f7630cf8f8bbb19a2914da43c24308c3c7fd
RTC:172523
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/39955
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: PPE CI <ppe-ci+hostboot@us.ibm.com>
Tested-by: Hostboot CI <hostboot-ci+hostboot@us.ibm.com>
Reviewed-by: CHRISTOPHER M. RIEDL <cmriedl@us.ibm.com>
Reviewed-by: Juan R. Medina <jrmedina@us.ibm.com>
Reviewed-by: Gregory S. Still <stillgs@us.ibm.com>
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/39961
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Christian R. Geddes <crgeddes@us.ibm.com>

7 files changed, 389 insertions, 263 deletions

diff --git a/src/import/chips/p9/procedures/hwp/lib/p9_pstate_parameter_block.h b/src/import/chips/p9/procedures/hwp/lib/p9_pstate_parameter_block.h
index 185270126..13f2b2bee 100644
--- a/src/import/chips/p9/procedures/hwp/lib/p9_pstate_parameter_block.h
+++ b/src/import/chips/p9/procedures/hwp/lib/p9_pstate_parameter_block.h
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2016                             */
+/* Contributors Listed Below - COPYRIGHT 2016,2017                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -143,7 +143,7 @@ typedef struct IVRM_PARM_DATA
 
 //Section added back by ssrivath
 // START OF PARMS REQUIRED VPD parsing procedures
-//#define S132A_POINTS       4 - Replaced by  VPD_PV_POINTS
+//#define S132A_POINTS       4 - Replaced by  NUM_OP_POINTS
 #define PSTATE_STEPSIZE    1
 #define EVRM_DELAY_NS      100
 #define DEAD_ZONE_5MV      20       // 100mV
@@ -399,8 +399,8 @@ load_wof_attributes ( PstateSuperStructure* pss,
 
 /// ------------------------------------------------------------
 /// @brief Copy VPD operating point into destination in assending order
-/// @param[in]  &src[VPD_PV_POINTS]   => reference to source VPD structure (array)
-/// @param[out] *dest[VPD_PV_POINTS]  => pointer to destination VpdOperatingPoint structure
+/// @param[in]  &src[NUM_OP_POINTS]   => reference to source VPD structure (array)
+/// @param[out] *dest[NUM_OP_POINTS]  => pointer to destination VpdOperatingPoint structure
 /// @return   FAPI2::SUCCESS
 /// ------------------------------------------------------------
 
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 2b162e417..274ad92de 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
@@ -168,11 +168,12 @@ typedef struct
 {
     uint16_t ivdd_tdp_ac_current_10ma;
     uint16_t ivdd_tdp_dc_current_10ma;
-    uint8_t  vdm_overvold_small_thresholds;
+    uint8_t  vdm_overvolt_small_thresholds;
     uint8_t  vdm_large_extreme_thresholds;
-    uint8_t  vdm_small_frequency_drop;
-    uint8_t  vdm_large_frequency_drop;
-    uint16_t vdm_spare;
+    uint8_t  vdm_small_large_normal_freq;
+    uint8_t  vdm_large_small_normal_freq;
+    uint8_t  vdm_vid_compare_ivid;
+    uint8_t  vdm_spare;
 } poundw_entry_t;
 
 typedef struct
@@ -186,45 +187,18 @@ typedef struct
 
 typedef struct
 {
-    poundw_entry_t poundw_nominal;
-    poundw_entry_t poundw_powersave;
-    poundw_entry_t poundw_turbo;
-    poundw_entry_t poundw_ultraturbo;
+    poundw_entry_t poundw[NUM_OP_POINTS];
     resistance_entry_t resistance_data;
     uint64_t reserved1;
     uint16_t reserved2;
 } PoundW_data;
+
 /// VDM/Droop Parameter Block
 ///
 typedef struct
 {
-    uint8_t  vid_compare_override_mv_enable;
-    uint8_t  vid_compare_override_mv[VPD_PV_POINTS];
-    uint8_t  vdm_response;
-
-    // For the following *_enable fields, bits are defined to indicate
-    // which of the respective *override* array entries are valid.
-    // bit 0: UltraTurbo; bit 1: Turbo; bit 2: Nominal; bit 3: PowSave
-    uint8_t  droop_small_override_enable;
-    uint8_t  droop_large_override_enable;
-    uint8_t  droop_extreme_override_enable;
-    uint8_t  overvolt_override_enable;
-    uint8_t fmin_override_khz_enable;
-    uint8_t fmax_override_khz_enable;
-
-    // The respecitve *_enable above indicate which index values are valid
-    uint8_t  droop_small_override[VPD_PV_POINTS];
-    uint8_t  droop_large_override[VPD_PV_POINTS];
-    uint8_t  droop_extreme_override[VPD_PV_POINTS];
-    uint8_t  overvolt_override[VPD_PV_POINTS];
-    uint8_t fmin_override_khz[VPD_PV_POINTS];
-    uint8_t fmax_override_khz[VPD_PV_POINTS];
-
-    /// Pad structure to 8-byte alignment
-    /// @todo pad once fully structure is complete.
-    // uint8_t pad[1];
-
-} VDMParmBlock;
+    PoundW_data vpd_w_data;
+} LP_VDMParmBlock;
 
 
 /// The layout of the data created by the Pstate table creation firmware for
@@ -278,6 +252,7 @@ typedef struct iVRMInfo
 
 } IvrmParmBlock;
 
+typedef uint8_t CompareVIDPoints;
 
 /// The layout of the data created by the Pstate table creation firmware for
 /// comsumption by the CME Quad Manager.  This data will reside in the Core
@@ -297,7 +272,7 @@ typedef struct
     /// VPD operating points are stored without load-line correction.  Frequencies
     /// are in MHz, voltages are specified in units of 5mV, and currents are
     /// in units of 500mA.
-    VpdOperatingPoint operating_points[VPD_PV_POINTS];
+    VpdOperatingPoint operating_points[NUM_OP_POINTS];
 
     /// Loadlines and Distribution values for the VDD rail
     SysPowerDistParms vdd_sysparm;
@@ -308,7 +283,7 @@ typedef struct
     /// in setting the external voltages.  This is used to recompute the Vin voltage
     /// based on the Global Actual Pstate .
     /// Values in 0.5%
-    VpdBias ext_biases[VPD_PV_POINTS];
+    VpdBias ext_biases[NUM_OP_POINTS];
 
     /// Internal Biases
     ///
@@ -316,7 +291,7 @@ typedef struct
     /// in setting the internal voltages (eg Vout to the iVRMs) as part of the
     /// Local Actual Pstate.
     /// Values in 0.5%
-    VpdBias int_biases[VPD_PV_POINTS];
+    VpdBias int_biases[NUM_OP_POINTS];
 
     /// IVRM Data
     IvrmParmBlock ivrm;
@@ -325,11 +300,23 @@ typedef struct
     ResonantClockingSetup resclk;
 
     /// VDM Data
-    VDMParmBlock vdm;
+    LP_VDMParmBlock vdm;
 
     /// DPLL pstate 0 value
     uint32_t dpll_pstate0_value;
 
+    // Biased Compare VID operating points
+    CompareVIDPoints vid_point_set[NUM_OP_POINTS];
+
+    // Biased Threshold operation points
+    int8_t threshold_set[NUM_OP_POINTS][NUM_THRESHOLD_POINTS];
+
+    //pstate-volt compare slopes
+    uint16_t PsVIDCompSlopes[VPD_NUM_SLOPES_REGION];
+
+    //pstate-volt threshold slopes
+    uint16_t PsVDMThreshSlopes[VPD_NUM_SLOPES_REGION][NUM_THRESHOLD_POINTS];
+
 } LocalPstateParmBlock;
 
 #ifdef __cplusplus
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 a45f93fcc..9f7457e53 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
@@ -90,15 +90,17 @@
 // are warrented
 
 /// VPD #V Data from keyword (eg VPD order)
-#define VPD_PV_POINTS 4
+#define NUM_OP_POINTS 4
+#define NUM_THRESHOLD_POINTS 4
 #define VPD_PV_POWERSAVE   1
 #define VPD_PV_NOMINAL     0
 #define VPD_PV_TURBO       2
 #define VPD_PV_ULTRA       3
 #define VPD_PV_ORDER {VPD_PV_POWERSAVE, VPD_PV_NOMINAL, VPD_PV_TURBO, VPD_PV_ULTRA}
 #define VPD_PV_ORDER_STR {"Nominal   ","PowerSave ", "Turbo     ", "UltraTurbo"}
+#define VPD_THRESHOLD_ORDER_STR {"Overvolt", "Small", "Large", "Extreme" }
 
-/// VPD #V Operating Points (eg Natureal order)
+/// VPD #V Operating Points (eg Natural order)
 #define POWERSAVE   0
 #define NOMINAL     1
 #define TURBO       2
@@ -133,7 +135,12 @@
 #define VPD_PT_SET_ORDER {VPD_PT_SET_RAW, VPD_PT_SET_SYSP, VPD_PT_SET_BIASED, VPD_PT_SET_BIASED_SYSP}
 #define VPD_PT_SET_ORDER_STR {"Raw          ", "SysParam       ","Biased        ", "Biased/SysParam"}
 
-#define EVID_SLOPE_FP_SHIFT         13
+#define VID_SLOPE_FP_SHIFT         13
+#define THRESH_SLOPE_FP_SHIFT       12
+
+// 0 = PowerSave, 1 = Nominal; 2 = Turbo; 3 = UltraTurbo; 4 = Enable
+#define VDM_DROOP_OP_POINTS   5
+
 
 
 /// IDDQ readings,
diff --git a/src/import/chips/p9/procedures/hwp/lib/p9_pstates_occ.h b/src/import/chips/p9/procedures/hwp/lib/p9_pstates_occ.h
index acae42877..8f3f41556 100644
--- a/src/import/chips/p9/procedures/hwp/lib/p9_pstates_occ.h
+++ b/src/import/chips/p9/procedures/hwp/lib/p9_pstates_occ.h
@@ -167,7 +167,7 @@ typedef struct
     /// VPD operating points are stored without load-line correction.  Frequencies
     /// are in MHz, voltages are specified in units of 5mV, and currents are
     /// in units of 500mA.
-    VpdOperatingPoint operating_points[VPD_PV_POINTS];
+    VpdOperatingPoint operating_points[NUM_OP_POINTS];
 
     /// Loadlines and Distribution values for the VDD rail
     SysPowerDistParms vdd_sysparm;
diff --git a/src/import/chips/p9/procedures/hwp/lib/p9_pstates_pgpe.h b/src/import/chips/p9/procedures/hwp/lib/p9_pstates_pgpe.h
index a089611cb..3c7752630 100644
--- a/src/import/chips/p9/procedures/hwp/lib/p9_pstates_pgpe.h
+++ b/src/import/chips/p9/procedures/hwp/lib/p9_pstates_pgpe.h
@@ -120,6 +120,30 @@ typedef struct
 
 } WOFElements;
 
+/// VDM/Droop Parameter Block
+///
+typedef struct
+{
+    uint8_t  vid_compare_override_mv[VDM_DROOP_OP_POINTS];
+    uint8_t  vdm_response;
+
+    // For the following *_enable fields, bits are defined to indicate
+    // which of the respective *override* array entries are valid.
+    // bit 0: UltraTurbo; bit 1: Turbo; bit 2: Nominal; bit 3: PowSave
+
+    // The respecitve *_enable above indicate which index values are valid
+    uint8_t  droop_small_override[VDM_DROOP_OP_POINTS];
+    uint8_t  droop_large_override[VDM_DROOP_OP_POINTS];
+    uint8_t  droop_extreme_override[VDM_DROOP_OP_POINTS];
+    uint8_t  overvolt_override[VDM_DROOP_OP_POINTS];
+    uint16_t fmin_override_khz[VDM_DROOP_OP_POINTS];
+    uint16_t fmax_override_khz[VDM_DROOP_OP_POINTS];
+
+    /// Pad structure to 8-byte alignment
+    /// @todo pad once fully structure is complete.
+    // uint8_t pad[1];
+
+} GP_VDMParmBlock;
 
 /// Global Pstate Parameter Block
 ///
@@ -162,14 +186,14 @@ typedef struct
     /// VPD operating points are stored without load-line correction.  Frequencies
     /// are in MHz, voltages are specified in units of 5mV, and currents are
     /// in units of 500mA.
-    VpdOperatingPoint operating_points[VPD_PV_POINTS];
+    VpdOperatingPoint operating_points[NUM_OP_POINTS];
 
     /// Biases
     ///
     /// Biases applied to the VPD operating points prior to load-line correction
     /// in setting the external voltages.
     /// Values in 0.5%
-    VpdBias ext_biases[VPD_PV_POINTS];
+    VpdBias ext_biases[NUM_OP_POINTS];
 
     /// Loadlines and Distribution values for the VDD rail
     SysPowerDistParms vdd_sysparm;
@@ -199,7 +223,7 @@ typedef struct
     uint8_t vrm_stepdelay_value;
 
     /// VDM Data
-    VDMParmBlock vdm;
+    GP_VDMParmBlock vdm;
 
     /// The following are needed to generated the Pstate Table to HOMER.
 
@@ -209,7 +233,7 @@ typedef struct
     /// in setting the internal voltages (eg Vout to the iVRMs) as part of the
     /// Local Actual Pstate.
     /// Values in 0.5%
-    VpdBias int_biases[VPD_PV_POINTS];
+    VpdBias int_biases[NUM_OP_POINTS];
 
     /// IVRM Data
     IvrmParmBlock ivrm;
@@ -242,7 +266,7 @@ typedef struct
     uint16_t VPsSlopes[VPD_NUM_SLOPES_SET][VPD_NUM_SLOPES_REGION];
 
     /// All operating points
-    VpdOperatingPoint operating_points_set[NUM_VPD_PTS_SET][VPD_PV_POINTS];
+    VpdOperatingPoint operating_points_set[NUM_VPD_PTS_SET][NUM_OP_POINTS];
 
     //DPLL pstate 0 value
     uint32_t dpll_pstate0_value;
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 48bacd861..f808296be 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
@@ -48,6 +48,11 @@
 #include "p9_resclk_defines.H"
 #include <attribute_ids.H>
 #include <math.h>
+//the value in this table are in Index format
+uint8_t g_GreyCodeIndexMapping [] =
+{
+    0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8,
+};
 
 fapi2::vdmData_t g_vpdData = {1,
                               2,
@@ -132,7 +137,7 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         memset (&l_localppb, 0, sizeof(LocalPstateParmBlock));
         memset (&l_occppb , 0, sizeof (OCCPstateParmBlock));
 
-        PoundW_data l_w_data;
+        PoundW_data l_poundw_data;
 
         // Struct Variable for all attributes
         AttributeList attr;
@@ -156,7 +161,9 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         double l_frequency_step_khz;
 
         //VDM Parm block
-        VDMParmBlock l_vdmpb;
+        GP_VDMParmBlock l_gp_vdmpb;
+
+        LP_VDMParmBlock   l_lp_vdmpb;
 
         //Resonant Clocking setup
         ResonantClockingSetup l_resclk_setup;
@@ -165,7 +172,7 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         IvrmParmBlock l_ivrmpb;
 
         // VPD voltage and frequency biases
-        VpdBias l_vpdbias[VPD_PV_POINTS];
+        VpdBias l_vpdbias[NUM_OP_POINTS];
 
         // Quad Manager Flags
         QuadManagerFlags l_qm_flags;
@@ -237,11 +244,10 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         // get VDM Parameters data
         // ----------------
         FAPI_INF("Getting VDM Parameters Data");
-        FAPI_TRY(proc_get_vdm_parms(i_target, &l_vdmpb));
-
+        FAPI_TRY(proc_get_vdm_parms(i_target, &l_gp_vdmpb));
 
         FAPI_INF("Getting VDM points (#W) Data");
-        FAPI_TRY(proc_get_mvpd_poundw(i_target, l_poundv_bucketId, &l_vdmpb, &l_w_data));
+        FAPI_TRY(proc_get_mvpd_poundw(i_target, l_poundv_bucketId, &l_lp_vdmpb, &l_poundw_data, l_poundv_data));
 
         // ----------------
         // get IVRM Parameters data
@@ -299,7 +305,7 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
                  "Loading MVPD operating point failed");
 
         // VpdBias External and Internal Biases for Global and Local parameter block
-        for (uint8_t i = 0; i < VPD_PV_POINTS; i++)
+        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];
@@ -331,15 +337,16 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         // vrm_stepdelay_value -@todo RTC 161279 potential attributes to be defined
 
         // VDMParmBlock vdm
-        l_globalppb.vdm = l_vdmpb;
+        l_globalppb.vdm = l_gp_vdmpb;
 
         // IvrmParmBlock
         l_globalppb.ivrm = l_ivrmpb;
 
-        VpdOperatingPoint l_operating_points[NUM_VPD_PTS_SET][VPD_PV_POINTS];
+        VpdOperatingPoint l_operating_points[NUM_VPD_PTS_SET][NUM_OP_POINTS];
         // Compute VPD points
         p9_pstate_compute_vpd_pts(l_operating_points, &l_globalppb);
 
+
         memcpy(l_globalppb.operating_points_set, l_operating_points, sizeof(l_operating_points));
 
         // Calculate pre-calculated slopes
@@ -371,13 +378,28 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         l_localppb.ivrm = l_ivrmpb;
 
         // VDMParmBlock
-        l_localppb.vdm = l_vdmpb;
+        l_localppb.vdm = l_lp_vdmpb;
 
 
         l_localppb.dpll_pstate0_value = revle32((revle32(l_localppb.operating_points[ULTRA].frequency_mhz) * 1000 / revle32(
                 l_globalppb.frequency_step_khz)));
 
         FAPI_INF("l_localppb.dpll_pstate0_value %X", revle32(l_localppb.dpll_pstate0_value));
+
+        uint8_t l_biased_pstate[NUM_OP_POINTS];
+
+        for (uint8_t i = 0; i < NUM_OP_POINTS; ++i)
+        {
+            l_biased_pstate[i] = l_operating_points[VPD_PT_SET_BIASED][i].pstate;
+            FAPI_INF ("l_biased_pstate %d ", l_biased_pstate[i]);
+        }
+
+        p9_pstate_compute_vdm_threshold_pts(l_poundw_data, &l_localppb);
+
+
+        p9_pstate_compute_PsVIDCompSlopes_slopes(l_poundw_data, &l_localppb, l_biased_pstate);
+
+        p9_pstate_compute_PsVDMThreshSlopes(&l_localppb, l_biased_pstate);
         // -----------------------------------------------
         // OCC parameter block
         // -----------------------------------------------
@@ -412,8 +434,8 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
 
         FAPI_INF("l_occppb.nest_leakage_percent %x", l_occppb.nest_leakage_percent);
 
-        l_occppb.lac_tdp_vdd_turbo_10ma   = revle16(l_w_data.poundw_turbo.ivdd_tdp_ac_current_10ma);
-        l_occppb.lac_tdp_vdd_nominal_10ma = revle16(l_w_data.poundw_nominal.ivdd_tdp_ac_current_10ma);
+        l_occppb.lac_tdp_vdd_turbo_10ma   = revle16(l_poundw_data.poundw[TURBO].ivdd_tdp_ac_current_10ma);
+        l_occppb.lac_tdp_vdd_nominal_10ma = revle16(l_poundw_data.poundw[NOMINAL].ivdd_tdp_ac_current_10ma);
 
         FAPI_INF("l_occppb.lac_tdp_vdd_turbo_10ma %x", revle16(l_occppb.lac_tdp_vdd_turbo_10ma));
         FAPI_INF("l_occppb.lac_tdp_vdd_nominal_10ma %x", revle16(l_occppb.lac_tdp_vdd_nominal_10ma));
@@ -1196,7 +1218,7 @@ fapi_try_exit:
 fapi2::ReturnCode
 proc_get_extint_bias( uint32_t io_attr_mvpd_data[PV_D][PV_W],
                       const AttributeList* i_attr,
-                      VpdBias o_vpdbias[VPD_PV_POINTS]
+                      VpdBias o_vpdbias[NUM_OP_POINTS]
                     )
 {
 
@@ -1324,8 +1346,8 @@ proc_chk_valid_poundv(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_targe
                       const uint8_t  i_bucket_id)
 {
 
-    const uint8_t pv_op_order[VPD_PV_POINTS] = VPD_PV_ORDER;
-    const char*    pv_op_str[VPD_PV_POINTS] = VPD_PV_ORDER_STR;
+    const uint8_t pv_op_order[NUM_OP_POINTS] = VPD_PV_ORDER;
+    const char*    pv_op_str[NUM_OP_POINTS] = VPD_PV_ORDER_STR;
     uint8_t       i = 0;
     bool          suspend_ut_check = false;
     uint8_t  l_attr_system_wof_enabled;
@@ -1337,7 +1359,7 @@ proc_chk_valid_poundv(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_targe
                                l_attr_system_wof_enabled));
 
         // check for non-zero freq, voltage, or current in valid operating points
-        for (i = 0; i <= VPD_PV_POINTS - 1; i++)
+        for (i = 0; i <= NUM_OP_POINTS - 1; i++)
         {
             FAPI_INF("Checking for Zero valued data in each #V operating point (%s) f=%u v=%u i=%u v=%u i=%u",
                      pv_op_str[pv_op_order[i]],
@@ -1409,7 +1431,7 @@ proc_chk_valid_poundv(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_targe
 
         // Adjust the valid operating point based on UltraTurbo presence
         // and WOF enablement
-        *o_valid_pdv_points = VPD_PV_POINTS;
+        *o_valid_pdv_points = NUM_OP_POINTS;
 
         if (suspend_ut_check)
         {
@@ -1465,8 +1487,8 @@ fapi_try_exit:
 
 /// ------------------------------------------------------------
 /// \brief Copy VPD operating point into destination in assending order
-/// \param[in]  &src[VPD_PV_POINTS]   => reference to source VPD structure (array)
-/// \param[out] *dest[VPD_PV_POINTS]  => pointer to destination VpdOperatingPoint structure
+/// \param[in]  &src[NUM_OP_POINTS]   => reference to source VPD structure (array)
+/// \param[out] *dest[NUM_OP_POINTS]  => pointer to destination VpdOperatingPoint structure
 //  \param[in]  i_frequency_step_khz  => Base frequency value for pstate calculation
 /// ------------------------------------------------------------
 /// \note:  this routine reads the keyword information in "VPD order" (eg Nominal,
@@ -1479,9 +1501,9 @@ load_mvpd_operating_point ( const uint32_t i_src[PV_D][PV_W],
                             uint32_t i_frequency_step_khz)
 {
     FAPI_INF(">> load_mvpd_operating_point");
-    const uint8_t pv_op_order[VPD_PV_POINTS] = VPD_PV_ORDER;
+    const uint8_t pv_op_order[NUM_OP_POINTS] = VPD_PV_ORDER;
 
-    for (uint32_t i = 0; i < VPD_PV_POINTS; i++)
+    for (uint32_t i = 0; i < NUM_OP_POINTS; i++)
     {
         o_dest[i].frequency_mhz  = revle32(i_src[pv_op_order[i]][0]);
         o_dest[i].vdd_mv        = revle32(i_src[pv_op_order[i]][1]);
@@ -1495,62 +1517,34 @@ load_mvpd_operating_point ( const uint32_t i_src[PV_D][PV_W],
     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,
-                     VDMParmBlock* o_vdmpb)
+                     GP_VDMParmBlock* o_vdmpb)
 {
-    uint8_t l_droop_small_override[VPD_PV_POINTS + 1];
-    uint8_t l_droop_large_override[VPD_PV_POINTS + 1];
-    uint8_t l_droop_extreme_override[VPD_PV_POINTS + 1];
-    uint8_t l_overvolt_override[VPD_PV_POINTS + 1];
-    uint16_t l_fmin_override_khz[VPD_PV_POINTS + 1];
-    uint16_t l_fmax_override_khz[VPD_PV_POINTS + 1];
-    uint8_t l_vid_compare_override_mv[VPD_PV_POINTS + 1];
-    uint8_t l_vdm_response;
-
     FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDM_DROOP_SMALL_OVERRIDE, fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(),
-                           l_droop_small_override));
+                           o_vdmpb->droop_small_override));
     FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDM_DROOP_LARGE_OVERRIDE, fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(),
-                           l_droop_large_override));
+                           o_vdmpb->droop_large_override));
     FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDM_DROOP_EXTREME_OVERRIDE, fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(),
-                           l_droop_extreme_override));
+                           o_vdmpb->droop_extreme_override));
     FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDM_OVERVOLT_OVERRIDE, fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(),
-                           l_overvolt_override));
+                           o_vdmpb->overvolt_override));
     FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDM_FMIN_OVERRIDE_KHZ, fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(),
-                           l_fmin_override_khz));
+                           o_vdmpb->fmin_override_khz));
     FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDM_FMAX_OVERRIDE_KHZ, fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(),
-                           l_fmax_override_khz));
+                           o_vdmpb->fmax_override_khz));
     FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDM_VID_COMPARE_OVERRIDE_MV, fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(),
-                           l_vid_compare_override_mv));
-    FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_DPLL_VDM_RESPONSE, fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(), l_vdm_response));
+                           o_vdmpb->vid_compare_override_mv));
+    FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_DPLL_VDM_RESPONSE, fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(),
+                           o_vdmpb->vdm_response));
 
-    o_vdmpb->droop_small_override_enable = l_droop_small_override[VPD_PV_POINTS];
-    o_vdmpb->droop_large_override_enable = l_droop_large_override[VPD_PV_POINTS];
-    o_vdmpb->droop_extreme_override_enable = l_droop_extreme_override[VPD_PV_POINTS];
-    o_vdmpb->overvolt_override_enable = l_overvolt_override[VPD_PV_POINTS];
-    o_vdmpb->fmin_override_khz_enable = l_fmin_override_khz[VPD_PV_POINTS];
-    o_vdmpb->fmax_override_khz_enable = l_fmax_override_khz[VPD_PV_POINTS];
-    o_vdmpb->vid_compare_override_mv_enable = l_vid_compare_override_mv[VPD_PV_POINTS];
-
-    o_vdmpb->vdm_response = l_vdm_response;
-
-    for (uint8_t i = 0; i < VPD_PV_POINTS; i++)
-    {
-        o_vdmpb->droop_small_override[i] = l_droop_small_override[i];
-        o_vdmpb->droop_large_override[i] = l_droop_large_override[i];
-        o_vdmpb->droop_extreme_override[i] = l_droop_extreme_override[i];
-        o_vdmpb->overvolt_override[i] = l_overvolt_override[i];
-        o_vdmpb->fmin_override_khz[i] = l_fmin_override_khz[i];
-        o_vdmpb->fmax_override_khz[i] = l_fmax_override_khz[i];
-        o_vdmpb->vid_compare_override_mv[i] = l_vid_compare_override_mv[i];
-    }
 
 fapi_try_exit:
     return fapi2::current_err;
 
 }
 
+
 fapi2::ReturnCode
 proc_res_clock_setup ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                        ResonantClockingSetup* o_resclk_setup,
@@ -1666,13 +1660,13 @@ fapi_try_exit:
 //
 //p9_pstate_compute_vpd_pts
 //
-void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[VPD_PV_POINTS],
+void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[NUM_OP_POINTS],
                                GlobalPstateParmBlock* i_gppb)
 {
     int p = 0;
 
     //RAW POINTS. We just copy them as is
-    for (p = 0; p < VPD_PV_POINTS; p++)
+    for (p = 0; p < NUM_OP_POINTS; p++)
     {
         o_operating_points[VPD_PT_SET_RAW][p].vdd_mv = (i_gppb->operating_points[p].vdd_mv) ;
         o_operating_points[VPD_PT_SET_RAW][p].vcs_mv = (i_gppb->operating_points[p].vcs_mv);
@@ -1691,7 +1685,7 @@ void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[VPD_PV_PO
     //SYSTEM PARAMS APPLIED POINTS
     //We first calculate everything in uV, and then divide by 1000. Doing this ensures
     //that integer division doesn't result in 0 for intermediate terms
-    for (p = 0; p < VPD_PV_POINTS; p++)
+    for (p = 0; p < NUM_OP_POINTS; p++)
     {
         o_operating_points[VPD_PT_SET_SYSP][p].vdd_mv =
             revle32((revle32(i_gppb->operating_points[p].vdd_mv) * 1000 +
@@ -1717,7 +1711,7 @@ void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[VPD_PV_PO
     }
 
     //BIASED POINTS
-    for (p = 0; p < VPD_PV_POINTS; p++)
+    for (p = 0; p < NUM_OP_POINTS; p++)
     {
         o_operating_points[VPD_PT_SET_BIASED][p].vdd_mv = revle32((revle32(i_gppb->operating_points[p].vdd_mv) *
                 (200 + revle32(i_gppb->ext_biases[p].vdd_ext_hp))) / 200);
@@ -1733,7 +1727,7 @@ void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[VPD_PV_PO
                  revle32(o_operating_points[VPD_PT_SET_BIASED][p].frequency_mhz));
     }
 
-    for (p = 0; p < VPD_PV_POINTS; p++)
+    for (p = 0; p < NUM_OP_POINTS; p++)
     {
         o_operating_points[VPD_PT_SET_BIASED][p].pstate =
             (((revle32(o_operating_points[VPD_PT_SET_BIASED][ULTRA].frequency_mhz) -
@@ -1748,7 +1742,7 @@ void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[VPD_PV_PO
     //BIASED POINTS and SYSTEM PARMS APPLIED POINTS
     //We first calculate everything in uV, and then divide by 1000. Doing this ensures
     //that integer division doesn't result in 0 for intermediate terms
-    for (p = 0; p < VPD_PV_POINTS; p++)
+    for (p = 0; p < NUM_OP_POINTS; p++)
     {
         o_operating_points[VPD_PT_SET_BIASED_SYSP][p].vdd_mv =
             revle32(((revle32(o_operating_points[VPD_PT_SET_BIASED][p].vdd_mv) * 1000) +
@@ -1798,7 +1792,7 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
                                   GlobalPstateParmBlock* o_gppb)
 {
     uint32_t tmp;
-    uint32_t eVidFP[VPD_PV_POINTS];
+    uint32_t eVidFP[NUM_OP_POINTS];
 
     do
     {
@@ -1806,10 +1800,10 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
         //RAW VPD PTS SLOPES
         //
         //convert to a fixed-point number
-        eVidFP[POWERSAVE] = revle32(revle32(i_operating_points[VPD_PT_SET_RAW][POWERSAVE].vdd_mv) << EVID_SLOPE_FP_SHIFT);
-        eVidFP[NOMINAL] = revle32(revle32(i_operating_points[VPD_PT_SET_RAW][NOMINAL].vdd_mv) << EVID_SLOPE_FP_SHIFT);
-        eVidFP[TURBO] = revle32(revle32(i_operating_points[VPD_PT_SET_RAW][TURBO].vdd_mv) << EVID_SLOPE_FP_SHIFT);
-        eVidFP[ULTRA] = revle32(revle32(i_operating_points[VPD_PT_SET_RAW][ULTRA].vdd_mv) << EVID_SLOPE_FP_SHIFT);
+        eVidFP[POWERSAVE] = revle32(revle32(i_operating_points[VPD_PT_SET_RAW][POWERSAVE].vdd_mv) << VID_SLOPE_FP_SHIFT);
+        eVidFP[NOMINAL] = revle32(revle32(i_operating_points[VPD_PT_SET_RAW][NOMINAL].vdd_mv) << VID_SLOPE_FP_SHIFT);
+        eVidFP[TURBO] = revle32(revle32(i_operating_points[VPD_PT_SET_RAW][TURBO].vdd_mv) << VID_SLOPE_FP_SHIFT);
+        eVidFP[ULTRA] = revle32(revle32(i_operating_points[VPD_PT_SET_RAW][ULTRA].vdd_mv) << VID_SLOPE_FP_SHIFT);
 
         FAPI_INF("eVidFP[POWERSAVE] %x %04x", revle32(eVidFP[POWERSAVE]),
                  revle32(i_operating_points[VPD_PT_SET_RAW][POWERSAVE].vdd_mv));
@@ -1818,7 +1812,7 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
         FAPI_INF("eVidFP[TURBO] %x %04x", revle32(eVidFP[TURBO]), revle32(i_operating_points[VPD_PT_SET_RAW][TURBO].vdd_mv));
         FAPI_INF("eVidFP[ULTRA] %x %04x", revle32(eVidFP[ULTRA]), revle32(i_operating_points[VPD_PT_SET_RAW][ULTRA].vdd_mv));
 
-        // ULTRA TURBO pstate check is not required..because it's pstate will be
+        // ULTRA TURBO pstate check is not required..because its pstate will be
         // 0
         if (!(i_operating_points[VPD_PT_SET_RAW][POWERSAVE].pstate) ||
             !(i_operating_points[VPD_PT_SET_RAW][NOMINAL].pstate) ||
@@ -1854,7 +1848,7 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
 
         //Calculate inverted slopes
         tmp =  revle32((uint32_t)((-i_operating_points[VPD_PT_SET_RAW][NOMINAL].pstate +
-                                   i_operating_points[VPD_PT_SET_RAW][POWERSAVE].pstate) << EVID_SLOPE_FP_SHIFT)
+                                   i_operating_points[VPD_PT_SET_RAW][POWERSAVE].pstate) << VID_SLOPE_FP_SHIFT)
                        / (uint32_t) (revle32(i_operating_points[VPD_PT_SET_RAW][NOMINAL].vdd_mv) -
                                      revle32(i_operating_points[VPD_PT_SET_RAW][POWERSAVE].vdd_mv)));
         o_gppb->VPsSlopes[VPD_SLOPES_RAW][REGION_POWERSAVE_NOMINAL] = revle16( revle32(tmp));
@@ -1863,7 +1857,7 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
 
 
         tmp =  revle32((uint32_t)((-i_operating_points[VPD_PT_SET_RAW][TURBO].pstate +
-                                   i_operating_points[VPD_PT_SET_RAW][NOMINAL].pstate) << EVID_SLOPE_FP_SHIFT)
+                                   i_operating_points[VPD_PT_SET_RAW][NOMINAL].pstate) << VID_SLOPE_FP_SHIFT)
                        / (uint32_t) (revle32(i_operating_points[VPD_PT_SET_RAW][TURBO].vdd_mv) -
                                      revle32(i_operating_points[VPD_PT_SET_RAW][NOMINAL].vdd_mv)));
         o_gppb->VPsSlopes[VPD_SLOPES_RAW][REGION_NOMINAL_TURBO] = revle16( revle32(tmp));
@@ -1872,7 +1866,7 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
 
 
         tmp =  revle32((uint32_t)((-i_operating_points[VPD_PT_SET_RAW][ULTRA].pstate +
-                                   i_operating_points[VPD_PT_SET_RAW][TURBO].pstate) << EVID_SLOPE_FP_SHIFT)
+                                   i_operating_points[VPD_PT_SET_RAW][TURBO].pstate) << VID_SLOPE_FP_SHIFT)
                        / (uint32_t) (revle32(i_operating_points[VPD_PT_SET_RAW][ULTRA].vdd_mv) -
                                      revle32(i_operating_points[VPD_PT_SET_RAW][TURBO].vdd_mv)));
         o_gppb->VPsSlopes[VPD_SLOPES_RAW][REGION_TURBO_ULTRA] = revle16( revle32(tmp));
@@ -1883,17 +1877,17 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
         //BIASED VPD PTS SLOPES
         //
         //convert to fixed-point number
-        eVidFP[POWERSAVE] = revle32(revle32(i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].vdd_mv) << EVID_SLOPE_FP_SHIFT);
-        eVidFP[NOMINAL] = revle32(revle32(i_operating_points[VPD_PT_SET_BIASED][NOMINAL].vdd_mv) << EVID_SLOPE_FP_SHIFT);
-        eVidFP[TURBO] = revle32(revle32(i_operating_points[VPD_PT_SET_BIASED][TURBO].vdd_mv) << EVID_SLOPE_FP_SHIFT);
-        eVidFP[ULTRA] = revle32(revle32(i_operating_points[VPD_PT_SET_BIASED][ULTRA].vdd_mv) << EVID_SLOPE_FP_SHIFT);
+        eVidFP[POWERSAVE] = revle32(revle32(i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].vdd_mv) << VID_SLOPE_FP_SHIFT);
+        eVidFP[NOMINAL] = revle32(revle32(i_operating_points[VPD_PT_SET_BIASED][NOMINAL].vdd_mv) << VID_SLOPE_FP_SHIFT);
+        eVidFP[TURBO] = revle32(revle32(i_operating_points[VPD_PT_SET_BIASED][TURBO].vdd_mv) << VID_SLOPE_FP_SHIFT);
+        eVidFP[ULTRA] = revle32(revle32(i_operating_points[VPD_PT_SET_BIASED][ULTRA].vdd_mv) << VID_SLOPE_FP_SHIFT);
 
         FAPI_INF("eVidFP[POWERSAVE] Biased %x", revle32(eVidFP[POWERSAVE]));
         FAPI_INF("eVidFP[NOMINAL] Biased %x", revle32(eVidFP[NOMINAL]));
         FAPI_INF("eVidFP[TURBO] Biased %x", revle32(eVidFP[TURBO]));
         FAPI_INF("eVidFP[ULTRA] Biased %x", revle32(eVidFP[ULTRA]));
 
-        // ULTRA TURBO pstate check is not required..because it's pstate will be
+        // ULTRA TURBO pstate check is not required..because its pstate will be
         // 0
         if (!(i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].pstate) ||
             !(i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate) ||
@@ -1945,7 +1939,7 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
 
         //Calculate inverted slopes
         tmp =  revle32((uint32_t)((-i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate +
-                                   i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].pstate) << EVID_SLOPE_FP_SHIFT)
+                                   i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].pstate) << VID_SLOPE_FP_SHIFT)
                        / (uint32_t) (revle32(i_operating_points[VPD_PT_SET_BIASED][NOMINAL].vdd_mv) -
                                      revle32(i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].vdd_mv)));
         o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_POWERSAVE_NOMINAL] = revle16(revle32(tmp));
@@ -1955,7 +1949,7 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
 
 
         tmp =  revle32((uint32_t)((-i_operating_points[VPD_PT_SET_BIASED][TURBO].pstate +
-                                   i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate) << EVID_SLOPE_FP_SHIFT)
+                                   i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate) << VID_SLOPE_FP_SHIFT)
                        / (uint32_t) (revle32(i_operating_points[VPD_PT_SET_BIASED][TURBO].vdd_mv) -
                                      revle32(i_operating_points[VPD_PT_SET_BIASED][NOMINAL].vdd_mv)));
         o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_NOMINAL_TURBO] = revle16(revle32(tmp));
@@ -1963,7 +1957,7 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
                   (revle16(o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_NOMINAL_TURBO])), revle32(tmp));
 
         tmp =  revle32((uint32_t)((-i_operating_points[VPD_PT_SET_BIASED][ULTRA].pstate +
-                                   i_operating_points[VPD_PT_SET_BIASED][TURBO].pstate) << EVID_SLOPE_FP_SHIFT)
+                                   i_operating_points[VPD_PT_SET_BIASED][TURBO].pstate) << VID_SLOPE_FP_SHIFT)
                        / (uint32_t) (revle32(i_operating_points[VPD_PT_SET_BIASED][ULTRA].vdd_mv) -
                                      revle32(i_operating_points[VPD_PT_SET_BIASED][TURBO].vdd_mv)));
         o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_TURBO_ULTRA] = revle16(revle32(tmp));
@@ -1999,7 +1993,7 @@ gppb_print(GlobalPstateParmBlock* i_gppb)
 
     FAPI_INF("Operating Points:     Frequency     VDD(mV)    IDD(100mA)     VCS(mV)    ICS(100mA)");
 
-    for (uint32_t i = 0; i < VPD_PV_POINTS; i++)
+    for (uint32_t i = 0; i < NUM_OP_POINTS; i++)
     {
         sprintf(l_buffer, "                 ");
         sprintf(l_temp_buffer, " %04X (%4d) ",
@@ -2169,45 +2163,6 @@ gppb_print(GlobalPstateParmBlock* i_gppb)
         FAPI_INF("%s", l_buffer);
     }
 
-    FAPI_INF( "VDM Param Block ");
-    FAPI_INF("Operating Points:     Overvolt Thr      Small Thr    Large Thr     Extreme Thr  Small Freq Drop   Large Freq Drop");
-
-    for (uint32_t i = 0; i < VPD_PV_POINTS; i++)
-    {
-        sprintf(l_buffer, "                 ");
-        sprintf(l_temp_buffer, " %04X (%4d) ",
-                i_gppb->vdm.overvolt_override[i],
-                (i_gppb->vdm.overvolt_override[i]));
-        strcat(l_buffer, l_temp_buffer);
-
-        sprintf(l_temp_buffer, " %04X (%4d) ",
-                i_gppb->vdm.droop_small_override[i],
-                (i_gppb->vdm.droop_small_override[i]));
-        strcat(l_buffer, l_temp_buffer);
-
-        sprintf(l_temp_buffer, " %04X (%4d) ",
-                i_gppb->vdm.droop_large_override[i],
-                (i_gppb->vdm.droop_large_override[i]));
-        strcat(l_buffer, l_temp_buffer);
-
-        sprintf(l_temp_buffer, " %04X (%4d) ",
-                i_gppb->vdm.droop_extreme_override[i],
-                (i_gppb->vdm.droop_extreme_override[i]));
-        strcat(l_buffer, l_temp_buffer);
-
-        sprintf(l_temp_buffer, " %04X (%4d) ",
-                i_gppb->vdm.fmin_override_khz[i],
-                (i_gppb->vdm.fmin_override_khz[i]));
-        strcat(l_buffer, l_temp_buffer);
-
-        sprintf(l_temp_buffer, " %04X (%4d) ",
-                i_gppb->vdm.fmax_override_khz[i],
-                (i_gppb->vdm.fmax_override_khz[i]));
-        strcat(l_buffer, l_temp_buffer);
-
-        FAPI_INF("%s", l_buffer);
-    }
-
     // Resonant Clocking
     FAPI_DBG("Resonant Clocking Setup:");
     FAPI_DBG("Pstates ResClk Index");
@@ -2241,7 +2196,7 @@ oppb_print(OCCPstateParmBlock* i_oppb)
 //    fprintf(stream, "Magic:               %llu\n", revle64(i_oppb->magic));
     FAPI_INF("Operating Points:     Frequency     VDD(mV)    IDD(100mA)     VCS(mV)    ICS(100mA)");
 
-    for (uint32_t i = 0; i < VPD_PV_POINTS; i++)
+    for (uint32_t i = 0; i < NUM_OP_POINTS; i++)
     {
         sprintf(l_buffer, "                 ");
         sprintf(l_temp_buffer, " %04X (%4d) ",
@@ -2379,23 +2334,20 @@ int freq2pState (const GlobalPstateParmBlock* gppb,
 fapi2::ReturnCode
 proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                      uint8_t       i_poundv_bucketId,
-                     VDMParmBlock* o_vdmpb,
-                     PoundW_data* o_data)
+                     LP_VDMParmBlock* o_vdmpb,
+                     PoundW_data* o_data,
+                     fapi2::voltageBucketData_t i_poundv_data)
 {
     std::vector<fapi2::Target<fapi2::TARGET_TYPE_EQ>> l_eqChiplets;
     fapi2::vdmData_t l_vdmBuf;
     uint8_t    j                = 0;
     uint8_t    bucket_id        = 0;
-    uint8_t    l_overvolt_small_offset  = 4;
-    uint8_t    l_large_extreme_offset = 5;
-    uint8_t    l_min_freq_offset = 6;
-    uint8_t    l_max_freq_offset = 7;
-    uint8_t    jump_to_next_mode = 0;
-    uint8_t    l_data = 0;
+    const uint16_t VDM_VOLTAGE_IN_MV = 512;
+    const uint16_t VDM_GRANULARITY = 4;
 
     do
     {
-        // Below fiels for Nominal, Powersave, Turbo, Ultra Turbo
+        // Below fields for Nominal, Powersave, Turbo, Ultra Turbo
         // I-VDD Nominal TDP AC current  2B
         // I-VDD Nominal TDP DC current 2B
         // Overvolt Threshold 0.5  Upper nibble of byte
@@ -2441,97 +2393,78 @@ proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target
         if (l_poundw_static_data)
         {
             FAPI_INF("attribute ATTR_POUND_W_STATIC_DATA_ENABLE is set");
-            memcpy (&l_vdmBuf, &g_vpdData, sizeof (g_vpdData));
-
-            // copy the data to the pound w structure
+            // copy the data to the pound w structure from a hardcoded table
             memcpy (o_data, &g_vpdData, sizeof (g_vpdData));
         }
         else
         {
             FAPI_INF("attribute ATTR_POUND_W_STATIC_DATA_ENABLE is NOT set");
-            // copy the data to the pound w structure
+            // copy the data to the pound w structure from the actual VPD image
             memcpy (o_data, l_vdmBuf.vdmData, sizeof (l_vdmBuf.vdmData));
         }
 
-        const uint8_t pv_op_order[VPD_PV_POINTS] = VPD_PV_ORDER;
-
-        if (!(o_vdmpb->overvolt_override_enable))
-        {
-            jump_to_next_mode = 0;
+        //Re-ordering to Natural order
+        // When we read the data from VPD image the order will be N,PS,T,UT.
+        // But we need the order PS,N,T,UT.. hence we are swapping the data
+        // between PS and Nominal.
+        poundw_entry_t l_tmp_data;
+        memcpy (&l_tmp_data, &(o_data->poundw[VPD_PV_NOMINAL]), sizeof (poundw_entry_t));
+        memcpy(&(o_data->poundw[VPD_PV_NOMINAL]), &(o_data->poundw[VPD_PV_POWERSAVE]), sizeof(poundw_entry_t));
+        memcpy (&(o_data->poundw[VPD_PV_POWERSAVE]), &l_tmp_data, sizeof(poundw_entry_t));
 
-            for (uint8_t i = 0; i < (VPD_PV_POINTS); i++)
-            {
-                l_data = l_vdmBuf.vdmData[l_overvolt_small_offset + jump_to_next_mode];
-                jump_to_next_mode += 10;
-                l_data = l_data >> 4;
-                o_vdmpb->overvolt_override[pv_op_order[i]] = l_data;
-            }
-        }
 
-        if (!(o_vdmpb->droop_small_override_enable))
+        //Validation of VPD Data
+        //
+        //If all VID compares are zero then use #V VDD voltage to populate local
+        //data structure..So that we make progress in lab with early hardware
+        if ( !(o_data->poundw[NOMINAL].vdm_vid_compare_ivid) &&
+             !(o_data->poundw[POWERSAVE].vdm_vid_compare_ivid) &&
+             !(o_data->poundw[TURBO].vdm_vid_compare_ivid) &&
+             !(o_data->poundw[ULTRA].vdm_vid_compare_ivid))
         {
-            jump_to_next_mode = 0;
-
-            for (uint8_t i = 0; i < (VPD_PV_POINTS); i++)
-            {
-                l_data = l_vdmBuf.vdmData[l_overvolt_small_offset + jump_to_next_mode];
-                jump_to_next_mode += 10;
-                l_data = l_data & 0x0F;
-                o_vdmpb->droop_small_override[pv_op_order[i]] = l_data;
-            }
-        }
-
-        if (!(o_vdmpb->droop_large_override_enable))
+            //vdm_vid_compare_ivid will be in ivid units (eg HEX((Compare
+            //Voltage (mv) - 512mV)/4mV).
+            o_data->poundw[NOMINAL].vdm_vid_compare_ivid    =
+                (i_poundv_data.VddNomVltg    - VDM_VOLTAGE_IN_MV) / VDM_GRANULARITY;
+            o_data->poundw[POWERSAVE].vdm_vid_compare_ivid  =
+                (i_poundv_data.VddPSVltg     - VDM_VOLTAGE_IN_MV ) / VDM_GRANULARITY;
+            o_data->poundw[TURBO].vdm_vid_compare_ivid      =
+                (i_poundv_data.VddTurboVltg  - VDM_VOLTAGE_IN_MV ) / VDM_GRANULARITY;
+            o_data->poundw[ULTRA].vdm_vid_compare_ivid =
+                (i_poundv_data.VddUTurboVltg - VDM_VOLTAGE_IN_MV) / VDM_GRANULARITY;
+        }//if any one of the VID compares are zero, then need to fail because of BAD VPD image.
+        else if ( !(o_data->poundw[NOMINAL].vdm_vid_compare_ivid) ||
+                  !(o_data->poundw[POWERSAVE].vdm_vid_compare_ivid) ||
+                  !(o_data->poundw[TURBO].vdm_vid_compare_ivid) ||
+                  !(o_data->poundw[ULTRA].vdm_vid_compare_ivid))
         {
-            jump_to_next_mode = 0;
-
-            for (uint8_t i = 0; i < (VPD_PV_POINTS); i++)
-            {
-                l_data = l_vdmBuf.vdmData[l_large_extreme_offset + jump_to_next_mode];
-                jump_to_next_mode += 10;
-                l_data = l_data >> 4;
-                o_vdmpb->droop_large_override[pv_op_order[i]] = l_data;
-            }
+            FAPI_ERR("Pound W data contains invalid values");
+            break;
         }
 
-        if (!(o_vdmpb->droop_extreme_override_enable))
-        {
-            jump_to_next_mode = 0;
 
-            for (uint8_t i = 0; i < (VPD_PV_POINTS); i++)
-            {
-                l_data = l_vdmBuf.vdmData[l_large_extreme_offset + jump_to_next_mode];
-                jump_to_next_mode += 10;
-                l_data = l_data & 0x0F;
-                o_vdmpb->droop_extreme_override[pv_op_order[i]] = l_data;
-            }
-        }
+        //Biased compare vid data
+        fapi2::ATTR_VDM_VID_COMPARE_BIAS_0P5PCT_Type l_bias_value;
 
-        if (!(o_vdmpb->fmin_override_khz_enable))
-        {
-            jump_to_next_mode = 0;
 
-            for (uint8_t i = 0; i < (VPD_PV_POINTS); i++)
-            {
-                l_data = l_vdmBuf.vdmData[l_min_freq_offset + jump_to_next_mode];
-                jump_to_next_mode += 10;
-                o_vdmpb->fmin_override_khz[pv_op_order[i]] = l_data;
-            }
-        }
+        FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_VDM_VID_COMPARE_BIAS_0P5PCT,
+                               i_target,
+                               l_bias_value),
+                 "Error from FAPI_ATTR_GET for attribute ATTR_VDM_VID_COMPARE_BIAS_0P5PCT");
 
-        if (!(o_vdmpb->fmax_override_khz_enable))
+        float l_pound_w_points[NUM_OP_POINTS];
+
+        for (uint8_t i = 0; i < NUM_OP_POINTS; i++)
         {
-            jump_to_next_mode = 0;
+            l_pound_w_points[i]  = 1.0 + (BIAS_PCT_UNIT * (float)l_bias_value[i]);
+            o_data->poundw[i].vdm_vid_compare_ivid = (uint32_t)(o_data->poundw[i].vdm_vid_compare_ivid * l_pound_w_points[i]);
 
-            for (uint8_t i = 0; i < (VPD_PV_POINTS); i++)
-            {
-                l_data = l_vdmBuf.vdmData[l_max_freq_offset + jump_to_next_mode];
-                jump_to_next_mode += 10;
-                o_vdmpb->fmax_override_khz[pv_op_order[i]] = l_data;
-            }
+            FAPI_INF ("vdm_vid_compare_ivid %x %x, %x", o_data->poundw[i].vdm_vid_compare_ivid,
+                      o_data->poundw[i].vdm_vid_compare_ivid, l_pound_w_points[i]);
         }
 
 
+        memcpy(&(o_vdmpb->vpd_w_data), o_data, sizeof(o_vdmpb->vpd_w_data));
     }
     while(0);
 
@@ -2800,3 +2733,159 @@ uint16_t roundUp(float i_value)
 {
     return ((uint16_t)(i_value == (uint16_t)i_value ? i_value : i_value + 1));
 }
+//
+// p9_pstate_compute_vdm_threshold_pts
+//
+void p9_pstate_compute_vdm_threshold_pts(PoundW_data i_data,
+        LocalPstateParmBlock* io_lppb)
+{
+    int p = 0;
+
+    //VID POINTS
+    for (p = 0; p < NUM_OP_POINTS; p++)
+    {
+        io_lppb->vid_point_set[p] = i_data.poundw[p].vdm_vid_compare_ivid;
+        FAPI_INF("Bi:VID=%x", io_lppb->vid_point_set[p]);
+    }
+
+    // Threshold points
+    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];
+
+        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]);
+
+        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]);
+
+        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]);
+
+        FAPI_INF("Bi: EX TSHLD =%d", io_lppb->threshold_set[p][3]);
+
+    }
+}
+//
+//
+// p9_pstate_compute_PsVIDCompSlopes_slopes
+//
+void p9_pstate_compute_PsVIDCompSlopes_slopes(PoundW_data i_data,
+        LocalPstateParmBlock* io_lppb,
+        uint8_t* i_pstate)
+{
+    uint32_t tmp;
+    uint32_t cVidFP[NUM_OP_POINTS];
+
+    do
+    {
+        //
+        //BIASED VPD PTS SLOPES
+        //
+        //convert to fixed-point number
+        for (uint8_t p = 0; p < NUM_OP_POINTS; ++p)
+        {
+            cVidFP[p] = revle32((io_lppb->vid_point_set[p]) << VID_SLOPE_FP_SHIFT);
+        }
+
+
+        FAPI_INF("cVidFP[POWERSAVE] Biased %x", revle32(cVidFP[POWERSAVE]));
+        FAPI_INF("cVidFP[NOMINAL] Biased   %x", revle32(cVidFP[NOMINAL]));
+        FAPI_INF("cVidFP[TURBO] Biased     %x", revle32(cVidFP[TURBO]));
+        FAPI_INF("cVidFP[ULTRA] Biased     %x", revle32(cVidFP[ULTRA]));
+
+        // ULTRA TURBO pstate check is not required..because its pstate will be
+        // 0
+        if (!(i_pstate[POWERSAVE]) ||
+            !(i_pstate[NOMINAL]) ||
+            !(i_pstate[TURBO]))
+        {
+            FAPI_ERR("PSTATE value shouldn't be zero for VPD_PT_SET_BIASED");
+            break;
+        }
+
+        //Calculate slopes
+
+        tmp = ((uint32_t)(cVidFP[NOMINAL] - cVidFP[POWERSAVE]) /
+               (uint32_t)(-i_pstate[NOMINAL] + i_pstate[POWERSAVE]));
+        io_lppb->PsVIDCompSlopes[REGION_POWERSAVE_NOMINAL] = revle32(tmp);
+        FAPI_INF("PsVIDCompSlopes[REGION_POWERSAVE_NOMINAL] %X tmp %X",
+                 (revle16(io_lppb->PsVIDCompSlopes[REGION_POWERSAVE_NOMINAL])), revle32(tmp));
+
+
+        tmp = ((uint32_t)(cVidFP[TURBO] - cVidFP[NOMINAL]) /
+               (uint32_t)(-i_pstate[TURBO] + i_pstate[NOMINAL]));
+        io_lppb->PsVIDCompSlopes[REGION_NOMINAL_TURBO] = revle32(tmp);
+        FAPI_INF("PsVIDCompSlopes[REGION_NOMINAL_TURBO] %X tmp %X",
+                 (revle16(io_lppb->PsVIDCompSlopes[REGION_NOMINAL_TURBO])), revle32(tmp));
+
+        tmp = ((uint32_t)(cVidFP[ULTRA] - cVidFP[TURBO]) /
+               (uint32_t)(-i_pstate[ULTRA] + i_pstate[TURBO]));
+        io_lppb->PsVIDCompSlopes[REGION_TURBO_ULTRA] = revle32(tmp);
+        FAPI_INF("PsVIDCompSlopes[REGION_TURBO_ULTRA] %X tmp %X",
+                 (revle16(io_lppb->PsVIDCompSlopes[REGION_TURBO_ULTRA])), revle32(tmp));
+    }
+    while(0);
+}
+
+//
+//
+// p9_pstate_compute_PsVDMThreshSlopes
+//
+void p9_pstate_compute_PsVDMThreshSlopes(
+    LocalPstateParmBlock* io_lppb,
+    uint8_t* i_pstate)
+{
+    do
+    {
+        // ULTRA TURBO pstate check is not required..because its pstate will be
+        // 0
+        if (!(i_pstate[POWERSAVE]) ||
+            !(i_pstate[NOMINAL]) ||
+            !(i_pstate[TURBO]))
+        {
+            FAPI_ERR("PSTATE value shouldn't be zero");
+            break;
+        }
+
+        //Calculate slopes
+        //
+        for (uint8_t i = 0; i < NUM_THRESHOLD_POINTS; ++i)
+        {
+            io_lppb->PsVDMThreshSlopes[REGION_POWERSAVE_NOMINAL][i] =
+                revle16((uint16_t)((float)(1 << THRESH_SLOPE_FP_SHIFT) * ((float)(io_lppb->threshold_set[NOMINAL][i] -
+                                   io_lppb->threshold_set[POWERSAVE][i]) /
+                                   (float)(-i_pstate[NOMINAL] + i_pstate[POWERSAVE]))));
+            FAPI_INF("PsVDMThreshSlopes REGION_POWERSAVE_NOMINAL %x TH_N %d TH_P %d PS_P %d PS_N %d",
+                     revle16(io_lppb->PsVDMThreshSlopes[REGION_POWERSAVE_NOMINAL][i]), io_lppb->threshold_set[NOMINAL][i],
+                     io_lppb->threshold_set[POWERSAVE][i], i_pstate[POWERSAVE], i_pstate[NOMINAL]);
+        }
+
+        for (uint8_t i = 0; i < NUM_THRESHOLD_POINTS; ++i)
+        {
+            io_lppb->PsVDMThreshSlopes[REGION_NOMINAL_TURBO][i] =
+                revle16((uint16_t)((float)(1 << THRESH_SLOPE_FP_SHIFT) * ((float)(io_lppb->threshold_set[TURBO][i] -
+                                   io_lppb->threshold_set[NOMINAL][i]) /
+                                   (float)(-i_pstate[TURBO] + i_pstate[NOMINAL]))));
+            FAPI_INF("PsVDMThreshSlopes REGION_NOMINAL_TURBO %x TH_T %d TH_N %d",
+                     revle16(io_lppb->PsVDMThreshSlopes[REGION_NOMINAL_TURBO][i]), io_lppb->threshold_set[TURBO][i],
+                     io_lppb->threshold_set[NOMINAL][i]);
+        }
+
+        for (uint8_t i = 0; i < NUM_THRESHOLD_POINTS; ++i)
+        {
+            io_lppb->PsVDMThreshSlopes[REGION_TURBO_ULTRA][i] =
+                revle16((uint16_t)((float)(1 << THRESH_SLOPE_FP_SHIFT) * ((float)(io_lppb->threshold_set[ULTRA][i] -
+                                   io_lppb->threshold_set[TURBO][i]) /
+                                   (float) (-i_pstate[ULTRA] + i_pstate[TURBO]))));
+            FAPI_INF("PsVDMThreshSlopes REGION_TURBO_ULTRA %x TH_U %d TH_T %d",
+                     revle16(io_lppb->PsVDMThreshSlopes[REGION_TURBO_ULTRA][i]),
+                     io_lppb->threshold_set[ULTRA][i], io_lppb->threshold_set[TURBO][i]);
+        }
+    }
+    while(0);
+}
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 3c49cc4ad..db7efc8f6 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
@@ -127,7 +127,7 @@ typedef struct
 
 //Section added back by ssrivath
 // START OF PARMS REQUIRED VPD parsing procedures
-//#define S132A_POINTS       4 - Replaced by  VPD_PV_POINTS
+//#define S132A_POINTS       4 - Replaced by  NUM_OP_POINTS
 #define PSTATE_STEPSIZE    1
 #define EVRM_DELAY_NS      100
 #define DEAD_ZONE_5MV      20       // 100mV
@@ -319,16 +319,18 @@ proc_get_mvpd_iddq ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target
 /// ----------------------------------------------------------------
 /// @brief Get #W data and put into array
 /// @param[in]    i_target          => Chip Target
-/// @param[in]    i_poundv_bucketId => Pound V bucket id
+/// @param[in]    i_poundv_bucketId => #V bucket id
 /// @param[out]   o_vdmpb           => Vdmparamblock data
-/// @param[out]   o_data            => Pound w data
+/// @param[out]   o_poundw_data     => #W data
+/// @paramg[in]   i_poundv_data     => #V data
 /// @return   FAPI2::SUCCESS
 /// ----------------------------------------------------------------
 fapi2::ReturnCode
 proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                      uint8_t       i_poundv_bucketId,
-                     VDMParmBlock* o_vdmpb,
-                     PoundW_data* o_data
+                     LP_VDMParmBlock* o_vdmpb,
+                     PoundW_data* o_poundw_data,
+                     fapi2::voltageBucketData_t i_poundv_data
                     );
 /// -----------------------------------------------------------------------
 /// @brief Get needed attributes
@@ -352,7 +354,7 @@ proc_get_attributes ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_targe
 fapi2::ReturnCode
 proc_get_extint_bias ( uint32_t io_attr_mvpd_data[PV_D][PV_W],
                        const AttributeList* i_attr,
-                       VpdBias o_vpdbias[VPD_PV_POINTS] );
+                       VpdBias o_vpdbias[NUM_OP_POINTS] );
 
 /// -------------------------------------------------------------------
 /// @brief Boost max frequency in pstate table based on boost attribute
@@ -411,8 +413,8 @@ load_wof_attributes ( PstateSuperStructure* io_pss,
 
 /// ------------------------------------------------------------
 /// @brief Copy VPD operating point into destination in assending order
-/// @param[in]    i_src[VPD_PV_POINTS]   => Source VPD structure (array)
-/// @param[out] * o_dest[VPD_PV_POINTS]  => pointer to destination VpdOperatingPoint structure
+/// @param[in]    i_src[NUM_OP_POINTS]   => Source VPD structure (array)
+/// @param[out] * o_dest[NUM_OP_POINTS]  => pointer to destination VpdOperatingPoint structure
 /// @return   FAPI2::SUCCESS
 /// ------------------------------------------------------------
 
@@ -430,7 +432,8 @@ load_mvpd_operating_point ( const uint32_t i_src[PV_D][PV_W],
 
 fapi2::ReturnCode
 proc_get_vdm_parms ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
-                     VDMParmBlock* o_vdmpb);
+                     GP_VDMParmBlock* o_vdmpb);
+
 
 /// ----------------------------------------------------------------
 /// @brief Get resonant clocking parameters from attributes
@@ -467,7 +470,7 @@ proc_set_resclk_table_attrs(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i
 //
 // p9_pstate_compute_vpd_pts
 //
-void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[VPD_PV_POINTS],
+void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[NUM_OP_POINTS],
                                GlobalPstateParmBlock* i_gppb);
 //
 // p9_pstate_compute_PsV_slopes
@@ -558,6 +561,22 @@ uint16_t get_iac_vdn_value (uint16_t i_vdd_value,
 ///round up the floating point value
 uint16_t roundUp(float i_value);
 
+
+///Compute VID points
+void p9_pstate_compute_vdm_threshold_pts(PoundW_data i_data,
+        LocalPstateParmBlock* io_lppb);
+
+///Biased slope calculation
+void p9_pstate_compute_PsVIDCompSlopes_slopes(PoundW_data i_data,
+        LocalPstateParmBlock* io_lppb,
+        uint8_t* i_pstate);
+
+// p9_pstate_compute_PsVDMThreshSlopes
+//
+void p9_pstate_compute_PsVDMThreshSlopes(
+    LocalPstateParmBlock* io_lppb,
+    uint8_t* i_pstate);
+
 /// @typedef p9_pstate_parameter_block_FP_t
 /// function pointer typedef definition for HWP call support
 typedef fapi2::ReturnCode (*p9_pstate_parameter_block_FP_t) (