p9_pstate_parameter_block: access #W and populate parameter block stucture

Change-Id: I2d996c848d893074cec0eb74408b3300b60ff1d9
RTC:167146
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/35721
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: RAHUL BATRA <rbatra@us.ibm.com>
Reviewed-by: Gregory S. Still <stillgs@us.ibm.com>
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/35723
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: Daniel M. Crowell <dcrowell@us.ibm.com>

9 files changed, 438 insertions, 107 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 6a7cab9b1..35113b73c 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
@@ -163,7 +163,37 @@ typedef struct ResonantClockControl
 
 } ResonantClockingSetup;
 
+// #W data points (version 2)
+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_large_extreme_thresholds;
+    uint8_t  vdm_small_frequency_drop;
+    uint8_t  vdm_large_frequency_drop;
+    uint16_t vdm_spare;
+} poundw_entry_t;
 
+typedef struct
+{
+    uint16_t r_package_common;
+    uint16_t r_quad;
+    uint16_t r_core;
+    uint16_t r_quad_header;
+    uint16_t r_core_header;
+} resistance_entry_t;
+
+typedef struct
+{
+    poundw_entry_t poundw_nominal;
+    poundw_entry_t poundw_powersave;
+    poundw_entry_t poundw_turbo;
+    poundw_entry_t poundw_ultraturbo;
+    resistance_entry_t resistance_data;
+    uint64_t reserved1;
+    uint16_t reserved2;
+} PoundW_data;
 /// VDM/Droop Parameter Block
 ///
 typedef struct
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 a240d0223..35cd762c9 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
@@ -45,6 +45,19 @@
 #include <fapi2.H>
 #include <p9_pstate_parameter_block.H>
 #include "p9_pm_get_poundv_bucket.H"
+#include "p9_pm_get_poundw_bucket.H"
+
+fapi2::vdmData_t g_vpdData = {1,
+                              2,
+{
+    0x29, 0x0C, 0x05, 0xC3, 0x61, 0x36, 0x1, 0x3, 0x0, 0x0,   //Nominal
+    0x28, 0xa8, 0x05, 0x5f, 0x21, 0x36, 0x1, 0x3, 0x0, 0x0,   //PowerSave
+    0x29, 0x70, 0x06, 0x27, 0x71, 0x36, 0x1, 0x3, 0x0, 0x0,   //Turbo
+    0x29, 0xD4, 0x06, 0x8b, 0x51, 0x36, 0x1, 0x3, 0x0, 0x0,   //UltraTurbo
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x0, 0x0, 0x0,   //Resistance
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0, 0x0, 0x0, 0x0    //Spare
+}
+                             };
 
 // START OF PSTATE PARAMETER BLOCK function
 
@@ -133,11 +146,13 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         // get #V data
         // ----------------
         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));
 
-        FAPI_TRY(proc_get_mvpd_data( i_target, attr_mvpd_voltage_control, &valid_pdv_points, &present_chiplets),
+        FAPI_TRY(proc_get_mvpd_data( i_target, attr_mvpd_voltage_control, &valid_pdv_points, &present_chiplets,
+                                     l_poundv_bucketId),
                  "Get MVPD #V data failed");
 
         if (!present_chiplets)
@@ -186,6 +201,9 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         FAPI_INF("Getting VDM Parameters Data");
         FAPI_TRY(proc_get_vdm_parms(i_target, &l_vdmpb));
 
+
+        FAPI_INF("Getting VDM points (#W) Data");
+        FAPI_TRY(proc_get_mvpd_poundw(i_target, l_poundv_bucketId, &l_vdmpb));
         // ----------------
         // get Resonant clocking attributes
         // ----------------
@@ -267,8 +285,6 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         // safe_frequency_khz
         l_globalppb.safe_frequency_khz = revle32(attr.attr_pm_safe_frequency_mhz / 1000);
 
-        // nest_frequency_khz
-        l_globalppb.nest_frequency_mhz = revle32(attr.attr_nest_freq_mhz);
 
         // @todo RTC 161279
         l_globalppb.ext_vrm_transition_start_ns = revle32(8000);
@@ -343,10 +359,10 @@ p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_
         l_occppb.wof.tdp_rdp_factor = revle32(attr.attr_tdp_rdp_current_factor);
 
         // frequency_min_khz - Value from Power save operating point after biases
-        l_occppb.frequency_min_khz = revle32(attr_mvpd_voltage_control[POWERSAVE][0] * 1000);
+        l_occppb.frequency_min_khz = revle32(attr_mvpd_voltage_control[VPD_PV_POWERSAVE][0] * 1000);
 
         // frequency_max_khz - Value from Ultra Turbo operating point after biases
-        l_occppb.frequency_max_khz = revle32(attr_mvpd_voltage_control[ULTRA][0] * 1000);
+        l_occppb.frequency_max_khz = revle32(attr_mvpd_voltage_control[VPD_PV_ULTRA][0] * 1000);
 
         // frequency_step_khz
         l_occppb.frequency_step_khz = revle32(l_frequency_step_khz);
@@ -502,7 +518,8 @@ fapi2::ReturnCode
 proc_get_mvpd_data(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                    uint32_t      o_attr_mvpd_data[PV_D][PV_W],
                    uint32_t*     o_valid_pdv_points,
-                   uint8_t*      o_present_chiplets
+                   uint8_t*      o_present_chiplets,
+                   uint8_t&      o_bucketId
                   )
 {
 
@@ -596,6 +613,8 @@ proc_get_mvpd_data(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
             // on first chiplet put each bucket's data into attr_mvpd_voltage_control
             if (first_chplt)
             {
+                o_bucketId = bucket_id;
+
                 for (i = 0; i <= 4; i++)
                 {
                     for (ii = 0; ii <= 4; ii++)
@@ -638,6 +657,7 @@ proc_get_mvpd_data(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                     o_attr_mvpd_data[i][2] = chiplet_mvpd_data[i][2];
                     o_attr_mvpd_data[i][3] = chiplet_mvpd_data[i][3];
                     o_attr_mvpd_data[i][4] = chiplet_mvpd_data[i][4];
+                    o_bucketId = bucket_id;
                 }
             }
         } // end for loop
@@ -1034,57 +1054,67 @@ proc_get_extint_bias( uint32_t io_attr_mvpd_data[PV_D][PV_W],
 
 
     // Nominal frequency operating point
-    io_attr_mvpd_data[NOMINAL][0] = (uint32_t) ((( (double)io_attr_mvpd_data[NOMINAL][0]) * freq_bias_nominal));
-    io_attr_mvpd_data[NOMINAL][1] = (uint32_t) ((( (double)io_attr_mvpd_data[NOMINAL][1]) * voltage_ext_vdd_bias_nominal));
-    io_attr_mvpd_data[NOMINAL][3] = (uint32_t) ((( (double)io_attr_mvpd_data[NOMINAL][3]) * voltage_ext_vcs_bias));
+    io_attr_mvpd_data[VPD_PV_NOMINAL][0] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_NOMINAL][0]) *
+                                           freq_bias_nominal));
+    io_attr_mvpd_data[VPD_PV_NOMINAL][1] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_NOMINAL][1]) *
+                                           voltage_ext_vdd_bias_nominal));
+    io_attr_mvpd_data[VPD_PV_NOMINAL][3] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_NOMINAL][3]) *
+                                           voltage_ext_vcs_bias));
 
     // Power Save frequency operating point
-    io_attr_mvpd_data[POWERSAVE][0] = (uint32_t) ((( (double)io_attr_mvpd_data[POWERSAVE][0]) * freq_bias_powersave));
-    io_attr_mvpd_data[POWERSAVE][1] = (uint32_t) ((( (double)io_attr_mvpd_data[POWERSAVE][1]) *
-                                      voltage_ext_vdd_bias_powersave));
-    io_attr_mvpd_data[POWERSAVE][3] = (uint32_t) ((( (double)io_attr_mvpd_data[POWERSAVE][3]) * voltage_ext_vcs_bias));
+    io_attr_mvpd_data[VPD_PV_POWERSAVE][0] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_POWERSAVE][0]) *
+            freq_bias_powersave));
+    io_attr_mvpd_data[VPD_PV_POWERSAVE][1] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_POWERSAVE][1]) *
+            voltage_ext_vdd_bias_powersave));
+    io_attr_mvpd_data[VPD_PV_POWERSAVE][3] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_POWERSAVE][3]) *
+            voltage_ext_vcs_bias));
 
     // Turbo frequency operating point
-    io_attr_mvpd_data[TURBO][0] = (uint32_t) ((( (double)io_attr_mvpd_data[TURBO][0]) * freq_bias_turbo));
-    io_attr_mvpd_data[TURBO][1] = (uint32_t) ((( (double)io_attr_mvpd_data[TURBO][1]) * voltage_ext_vdd_bias_turbo));
-    io_attr_mvpd_data[TURBO][3] = (uint32_t) ((( (double)io_attr_mvpd_data[TURBO][3]) * voltage_ext_vcs_bias));
+    io_attr_mvpd_data[VPD_PV_TURBO][0] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_TURBO][0]) * freq_bias_turbo));
+    io_attr_mvpd_data[VPD_PV_TURBO][1] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_TURBO][1]) *
+                                         voltage_ext_vdd_bias_turbo));
+    io_attr_mvpd_data[VPD_PV_TURBO][3] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_TURBO][3]) *
+                                         voltage_ext_vcs_bias));
 
     // Ultraturbo frequency operating point
-    io_attr_mvpd_data[ULTRA][0] = (uint32_t) ((( (double)io_attr_mvpd_data[ULTRA][0]) * freq_bias_ultraturbo));
-    io_attr_mvpd_data[ULTRA][1] = (uint32_t) ((( (double)io_attr_mvpd_data[ULTRA][1]) * voltage_ext_vdd_bias_ultraturbo));
-    io_attr_mvpd_data[ULTRA][3] = (uint32_t) ((( (double)io_attr_mvpd_data[ULTRA][3]) * voltage_ext_vcs_bias));
+    io_attr_mvpd_data[VPD_PV_ULTRA][0] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_ULTRA][0]) *
+                                         freq_bias_ultraturbo));
+    io_attr_mvpd_data[VPD_PV_ULTRA][1] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_ULTRA][1]) *
+                                         voltage_ext_vdd_bias_ultraturbo));
+    io_attr_mvpd_data[VPD_PV_ULTRA][3] = (uint32_t) ((( (double)io_attr_mvpd_data[VPD_PV_ULTRA][3]) *
+                                         voltage_ext_vcs_bias));
 
     // Power bus operating point
     io_attr_mvpd_data[4][1] = (uint32_t) ((( (double)io_attr_mvpd_data[4][1]) * voltage_ext_vdn_bias));
 
     //VPD Biases per operating point
     // Nominal
-    o_vpdbias[NOMINAL].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_nominal;
-    o_vpdbias[NOMINAL].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_nominal;
-    o_vpdbias[NOMINAL].vdn_ext_hp = i_attr->attr_voltage_ext_vdn_bias;
-    o_vpdbias[NOMINAL].vcs_ext_hp = i_attr->attr_voltage_ext_vcs_bias;
-    o_vpdbias[NOMINAL].frequency_hp = i_attr->attr_freq_bias_nominal;
+    o_vpdbias[VPD_PV_NOMINAL].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_nominal;
+    o_vpdbias[VPD_PV_NOMINAL].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_nominal;
+    o_vpdbias[VPD_PV_NOMINAL].vdn_ext_hp = i_attr->attr_voltage_ext_vdn_bias;
+    o_vpdbias[VPD_PV_NOMINAL].vcs_ext_hp = i_attr->attr_voltage_ext_vcs_bias;
+    o_vpdbias[VPD_PV_NOMINAL].frequency_hp = i_attr->attr_freq_bias_nominal;
 
     // PowerSave
-    o_vpdbias[POWERSAVE].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_powersave;
-    o_vpdbias[POWERSAVE].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_powersave;
-    o_vpdbias[POWERSAVE].vdn_ext_hp = i_attr->attr_voltage_ext_vdn_bias;
-    o_vpdbias[POWERSAVE].vcs_ext_hp = i_attr->attr_voltage_ext_vcs_bias;
-    o_vpdbias[POWERSAVE].frequency_hp = i_attr->attr_freq_bias_powersave;
+    o_vpdbias[VPD_PV_POWERSAVE].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_powersave;
+    o_vpdbias[VPD_PV_POWERSAVE].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_powersave;
+    o_vpdbias[VPD_PV_POWERSAVE].vdn_ext_hp = i_attr->attr_voltage_ext_vdn_bias;
+    o_vpdbias[VPD_PV_POWERSAVE].vcs_ext_hp = i_attr->attr_voltage_ext_vcs_bias;
+    o_vpdbias[VPD_PV_POWERSAVE].frequency_hp = i_attr->attr_freq_bias_powersave;
 
     // Turbo
-    o_vpdbias[TURBO].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_turbo;
-    o_vpdbias[TURBO].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_turbo;
-    o_vpdbias[TURBO].vdn_ext_hp = i_attr->attr_voltage_ext_vdn_bias;
-    o_vpdbias[TURBO].vcs_ext_hp = i_attr->attr_voltage_ext_vcs_bias;
-    o_vpdbias[TURBO].frequency_hp = i_attr->attr_freq_bias_turbo;
+    o_vpdbias[VPD_PV_TURBO].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_turbo;
+    o_vpdbias[VPD_PV_TURBO].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_turbo;
+    o_vpdbias[VPD_PV_TURBO].vdn_ext_hp = i_attr->attr_voltage_ext_vdn_bias;
+    o_vpdbias[VPD_PV_TURBO].vcs_ext_hp = i_attr->attr_voltage_ext_vcs_bias;
+    o_vpdbias[VPD_PV_TURBO].frequency_hp = i_attr->attr_freq_bias_turbo;
 
     // UltraTurbo
-    o_vpdbias[ULTRA].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_ultraturbo;
-    o_vpdbias[ULTRA].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_ultraturbo;
-    o_vpdbias[ULTRA].vdn_ext_hp = i_attr->attr_voltage_ext_vdn_bias;
-    o_vpdbias[ULTRA].vcs_ext_hp = i_attr->attr_voltage_ext_vcs_bias;
-    o_vpdbias[ULTRA].frequency_hp = i_attr->attr_freq_bias_ultraturbo;
+    o_vpdbias[VPD_PV_ULTRA].vdd_ext_hp = i_attr->attr_voltage_ext_vdd_bias_ultraturbo;
+    o_vpdbias[VPD_PV_ULTRA].vdd_int_hp = i_attr->attr_voltage_int_vdd_bias_ultraturbo;
+    o_vpdbias[VPD_PV_ULTRA].vdn_ext_hp = i_attr->attr_voltage_ext_vdn_bias;
+    o_vpdbias[VPD_PV_ULTRA].vcs_ext_hp = i_attr->attr_voltage_ext_vcs_bias;
+    o_vpdbias[VPD_PV_ULTRA].frequency_hp = i_attr->attr_freq_bias_ultraturbo;
 
     return fapi2::FAPI2_RC_SUCCESS;
 
@@ -1523,66 +1553,70 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
         //RAW VPD PTS SLOPES
         //
         //convert to a fixed-point number
-        eVidFP[POWERSAVE] = i_operating_points[VPD_PT_SET_RAW][POWERSAVE].vdd_mv << EVID_SLOPE_FP_SHIFT;
-        eVidFP[NOMINAL] = i_operating_points[VPD_PT_SET_RAW][NOMINAL].vdd_mv << EVID_SLOPE_FP_SHIFT;
-        eVidFP[TURBO] = i_operating_points[VPD_PT_SET_RAW][TURBO].vdd_mv << EVID_SLOPE_FP_SHIFT;
-        eVidFP[ULTRA] = i_operating_points[VPD_PT_SET_RAW][ULTRA].vdd_mv << EVID_SLOPE_FP_SHIFT;
+        eVidFP[VPD_PV_POWERSAVE] = i_operating_points[VPD_PT_SET_RAW][VPD_PV_POWERSAVE].vdd_mv << EVID_SLOPE_FP_SHIFT;
+        eVidFP[VPD_PV_NOMINAL] = i_operating_points[VPD_PT_SET_RAW][VPD_PV_NOMINAL].vdd_mv << EVID_SLOPE_FP_SHIFT;
+        eVidFP[VPD_PV_TURBO] = i_operating_points[VPD_PT_SET_RAW][VPD_PV_TURBO].vdd_mv << EVID_SLOPE_FP_SHIFT;
+        eVidFP[VPD_PV_ULTRA] = i_operating_points[VPD_PT_SET_RAW][VPD_PV_ULTRA].vdd_mv << EVID_SLOPE_FP_SHIFT;
 
-        FAPI_INF("eVidFP[POWERSAVE] %u %04x", eVidFP[POWERSAVE], i_operating_points[VPD_PT_SET_RAW][POWERSAVE].vdd_mv);
-        FAPI_INF("eVidFP[NOMINAL] %u %04x", eVidFP[NOMINAL], i_operating_points[VPD_PT_SET_RAW][NOMINAL].vdd_mv);
-        FAPI_INF("eVidFP[TURBO] %u %04x", eVidFP[TURBO], i_operating_points[VPD_PT_SET_RAW][TURBO].vdd_mv);
-        FAPI_INF("eVidFP[ULTRA] %u %04x", eVidFP[ULTRA], i_operating_points[VPD_PT_SET_RAW][ULTRA].vdd_mv);
+        FAPI_INF("eVidFP[VPD_PV_POWERSAVE] %u %04x", eVidFP[VPD_PV_POWERSAVE],
+                 i_operating_points[VPD_PT_SET_RAW][VPD_PV_POWERSAVE].vdd_mv);
+        FAPI_INF("eVidFP[NOMINAL] %u %04x", eVidFP[VPD_PV_NOMINAL], i_operating_points[VPD_PT_SET_RAW][VPD_PV_NOMINAL].vdd_mv);
+        FAPI_INF("eVidFP[TURBO] %u %04x", eVidFP[VPD_PV_TURBO], i_operating_points[VPD_PT_SET_RAW][VPD_PV_TURBO].vdd_mv);
+        FAPI_INF("eVidFP[ULTRA] %u %04x", eVidFP[VPD_PV_ULTRA], i_operating_points[VPD_PT_SET_RAW][VPD_PV_ULTRA].vdd_mv);
 
         // ULTRA TURBO pstate check is not required..because it's pstate will be
         // 0
-        if (!(i_operating_points[VPD_PT_SET_RAW][POWERSAVE].pstate) ||
-            !(i_operating_points[VPD_PT_SET_RAW][NOMINAL].pstate) ||
-            !(i_operating_points[VPD_PT_SET_RAW][TURBO].pstate))
+        if (!(i_operating_points[VPD_PT_SET_RAW][VPD_PV_POWERSAVE].pstate) ||
+            !(i_operating_points[VPD_PT_SET_RAW][VPD_PV_NOMINAL].pstate) ||
+            !(i_operating_points[VPD_PT_SET_RAW][VPD_PV_TURBO].pstate))
         {
             FAPI_ERR("PSTATE value shouldn't be zero for VPD_PT_SET_RAW");
             break;
         }
 
         //Calculate slopes
-        tmp = (uint32_t)(eVidFP[NOMINAL] - eVidFP[POWERSAVE]) /
-              (uint32_t)(-i_operating_points[VPD_PT_SET_RAW][NOMINAL].pstate + i_operating_points[VPD_PT_SET_RAW][POWERSAVE].pstate);
+        tmp = (uint32_t)(eVidFP[VPD_PV_NOMINAL] - eVidFP[VPD_PV_POWERSAVE]) /
+              (uint32_t)(-i_operating_points[VPD_PT_SET_RAW][VPD_PV_NOMINAL].pstate +
+                         i_operating_points[VPD_PT_SET_RAW][VPD_PV_POWERSAVE].pstate);
         o_gppb->PsVSlopes[VPD_SLOPES_RAW][REGION_POWERSAVE_NOMINAL] = revle16((uint16_t)tmp);
         FAPI_INF("PsVSlopes[VPD_SLOPES_RAW][REGION_POWERSAVE_NOMINAL] %X tmp %X",
                  (revle16(o_gppb->PsVSlopes[VPD_SLOPES_RAW][REGION_POWERSAVE_NOMINAL])), (tmp));
 
-        tmp = (uint32_t)(eVidFP[TURBO] - eVidFP[NOMINAL]) /
-              (uint32_t)(-i_operating_points[VPD_PT_SET_RAW][TURBO].pstate + i_operating_points[VPD_PT_SET_RAW][NOMINAL].pstate);
+        tmp = (uint32_t)(eVidFP[VPD_PV_TURBO] - eVidFP[VPD_PV_NOMINAL]) /
+              (uint32_t)(-i_operating_points[VPD_PT_SET_RAW][VPD_PV_TURBO].pstate +
+                         i_operating_points[VPD_PT_SET_RAW][VPD_PV_NOMINAL].pstate);
         o_gppb->PsVSlopes[VPD_SLOPES_RAW][REGION_NOMINAL_TURBO] = revle16((uint16_t)tmp);
         FAPI_INF("PsVSlopes[VPD_SLOPES_RAW][REGION_NOMINAL_TURBO] %X tmp %X",
                  (revle16(o_gppb->PsVSlopes[VPD_SLOPES_RAW][REGION_NOMINAL_TURBO])), (tmp));
 
-        tmp = (uint32_t)(eVidFP[ULTRA] - eVidFP[TURBO]) /
-              (uint32_t)(-i_operating_points[VPD_PT_SET_RAW][ULTRA].pstate + i_operating_points[VPD_PT_SET_RAW][TURBO].pstate);
+        tmp = (uint32_t)(eVidFP[VPD_PV_ULTRA] - eVidFP[VPD_PV_TURBO]) /
+              (uint32_t)(-i_operating_points[VPD_PT_SET_RAW][VPD_PV_ULTRA].pstate +
+                         i_operating_points[VPD_PT_SET_RAW][VPD_PV_TURBO].pstate);
         o_gppb->PsVSlopes[VPD_SLOPES_RAW][REGION_TURBO_ULTRA] = revle16((uint16_t)tmp);
         FAPI_INF("PsVSlopes[VPD_SLOPES_RAW][REGION_TURBO_ULTRA] %X tmp %X",
                  (revle16(o_gppb->PsVSlopes[VPD_SLOPES_RAW][REGION_TURBO_ULTRA])), (tmp));
 
         //Calculate inverted slopes
-        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_RAW][NOMINAL].pstate +
-                           i_operating_points[VPD_PT_SET_RAW][POWERSAVE].pstate) << EVID_SLOPE_FP_SHIFT)
-               / (uint32_t) (i_operating_points[VPD_PT_SET_RAW][NOMINAL].vdd_mv -
-                             i_operating_points[VPD_PT_SET_RAW][POWERSAVE].vdd_mv);
+        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_RAW][VPD_PV_NOMINAL].pstate +
+                           i_operating_points[VPD_PT_SET_RAW][VPD_PV_POWERSAVE].pstate) << EVID_SLOPE_FP_SHIFT)
+               / (uint32_t) (i_operating_points[VPD_PT_SET_RAW][VPD_PV_NOMINAL].vdd_mv -
+                             i_operating_points[VPD_PT_SET_RAW][VPD_PV_POWERSAVE].vdd_mv);
         o_gppb->VPsSlopes[VPD_SLOPES_RAW][REGION_POWERSAVE_NOMINAL] = revle16((uint16_t)tmp);
         FAPI_INF("VPsSlopes[VPD_SLOPES_RAW][REGION_POWERSAVE_NOMINAL] %X tmp %X",
                  (revle16(o_gppb->VPsSlopes[VPD_SLOPES_RAW][REGION_POWERSAVE_NOMINAL])), (tmp));
 
-        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_RAW][TURBO].pstate +
-                           i_operating_points[VPD_PT_SET_RAW][NOMINAL].pstate) << EVID_SLOPE_FP_SHIFT)
-               / (uint32_t) (i_operating_points[VPD_PT_SET_RAW][TURBO].vdd_mv -
-                             i_operating_points[VPD_PT_SET_RAW][NOMINAL].vdd_mv);
+        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_RAW][VPD_PV_TURBO].pstate +
+                           i_operating_points[VPD_PT_SET_RAW][VPD_PV_NOMINAL].pstate) << EVID_SLOPE_FP_SHIFT)
+               / (uint32_t) (i_operating_points[VPD_PT_SET_RAW][VPD_PV_TURBO].vdd_mv -
+                             i_operating_points[VPD_PT_SET_RAW][VPD_PV_NOMINAL].vdd_mv);
         o_gppb->VPsSlopes[VPD_SLOPES_RAW][REGION_NOMINAL_TURBO] = revle16((uint16_t)tmp);
         FAPI_INF("VPsSlopes[VPD_SLOPES_RAW][REGION_NOMINAL_TURBO] %X tmp %X",
                  (revle16(o_gppb->VPsSlopes[VPD_SLOPES_RAW][REGION_NOMINAL_TURBO])), (tmp));
 
-        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_RAW][ULTRA].pstate +
-                           i_operating_points[VPD_PT_SET_RAW][TURBO].pstate) << EVID_SLOPE_FP_SHIFT)
-               / (uint32_t) (i_operating_points[VPD_PT_SET_RAW][ULTRA].vdd_mv -
-                             i_operating_points[VPD_PT_SET_RAW][TURBO].vdd_mv);
+        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_RAW][VPD_PV_ULTRA].pstate +
+                           i_operating_points[VPD_PT_SET_RAW][VPD_PV_TURBO].pstate) << EVID_SLOPE_FP_SHIFT)
+               / (uint32_t) (i_operating_points[VPD_PT_SET_RAW][VPD_PV_ULTRA].vdd_mv -
+                             i_operating_points[VPD_PT_SET_RAW][VPD_PV_TURBO].vdd_mv);
         o_gppb->VPsSlopes[VPD_SLOPES_RAW][REGION_TURBO_ULTRA] = revle16((uint16_t)tmp);
         FAPI_INF("VPsSlopes[VPD_SLOPES_RAW][REGION_TURBO_ULTRA] %X tmp %X",
                  (revle16(o_gppb->VPsSlopes[VPD_SLOPES_RAW][REGION_TURBO_ULTRA])), (tmp));
@@ -1591,21 +1625,21 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
         //BIASED VPD PTS SLOPES
         //
         //convert to fixed-point number
-        eVidFP[POWERSAVE] = i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].vdd_mv << EVID_SLOPE_FP_SHIFT;
-        eVidFP[NOMINAL] = i_operating_points[VPD_PT_SET_BIASED][NOMINAL].vdd_mv << EVID_SLOPE_FP_SHIFT;
-        eVidFP[TURBO] = i_operating_points[VPD_PT_SET_BIASED][TURBO].vdd_mv << EVID_SLOPE_FP_SHIFT;
-        eVidFP[ULTRA] = i_operating_points[VPD_PT_SET_BIASED][ULTRA].vdd_mv << EVID_SLOPE_FP_SHIFT;
+        eVidFP[VPD_PV_POWERSAVE] = i_operating_points[VPD_PT_SET_BIASED][VPD_PV_POWERSAVE].vdd_mv << EVID_SLOPE_FP_SHIFT;
+        eVidFP[VPD_PV_NOMINAL] = i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].vdd_mv << EVID_SLOPE_FP_SHIFT;
+        eVidFP[VPD_PV_TURBO] = i_operating_points[VPD_PT_SET_BIASED][VPD_PV_TURBO].vdd_mv << EVID_SLOPE_FP_SHIFT;
+        eVidFP[VPD_PV_ULTRA] = i_operating_points[VPD_PT_SET_BIASED][VPD_PV_ULTRA].vdd_mv << EVID_SLOPE_FP_SHIFT;
 
-        FAPI_INF("eVidFP[POWERSAVE] Biased %u", eVidFP[POWERSAVE]);
-        FAPI_INF("eVidFP[NOMINAL] Biased %u", eVidFP[NOMINAL]);
-        FAPI_INF("eVidFP[TURBO] Biased %u", eVidFP[TURBO]);
-        FAPI_INF("eVidFP[ULTRA] Biased %u", eVidFP[ULTRA]);
+        FAPI_INF("eVidFP[VPD_PV_POWERSAVE] Biased %u", eVidFP[VPD_PV_POWERSAVE]);
+        FAPI_INF("eVidFP[NOMINAL] Biased %u", eVidFP[VPD_PV_NOMINAL]);
+        FAPI_INF("eVidFP[TURBO] Biased %u", eVidFP[VPD_PV_TURBO]);
+        FAPI_INF("eVidFP[ULTRA] Biased %u", eVidFP[VPD_PV_ULTRA]);
 
         // ULTRA TURBO pstate check is not required..because it's pstate will be
         // 0
-        if (!(i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].pstate) ||
-            !(i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate) ||
-            !(i_operating_points[VPD_PT_SET_BIASED][TURBO].pstate))
+        if (!(i_operating_points[VPD_PT_SET_BIASED][VPD_PV_POWERSAVE].pstate) ||
+            !(i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].pstate) ||
+            !(i_operating_points[VPD_PT_SET_BIASED][VPD_PV_TURBO].pstate))
         {
             FAPI_ERR("PSTATE value shouldn't be zero for VPD_PT_SET_BIASED");
             break;
@@ -1613,52 +1647,53 @@ void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
 
         //Calculate slopes
         FAPI_INF(" num %u denom %u %u %u",
-                 (uint32_t)(eVidFP[NOMINAL] - eVidFP[POWERSAVE]),
-                 (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate +
-                            i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].pstate),
-                 (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate),
-                 (uint32_t)i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].pstate);
-        tmp = (uint32_t)(eVidFP[NOMINAL] - eVidFP[POWERSAVE]) /
-              (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate +
-                         i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].pstate);
+                 (uint32_t)(eVidFP[VPD_PV_NOMINAL] - eVidFP[VPD_PV_POWERSAVE]),
+                 (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].pstate +
+                            i_operating_points[VPD_PT_SET_BIASED][VPD_PV_POWERSAVE].pstate),
+                 (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].pstate),
+                 (uint32_t)i_operating_points[VPD_PT_SET_BIASED][VPD_PV_POWERSAVE].pstate);
+        tmp = (uint32_t)(eVidFP[VPD_PV_NOMINAL] - eVidFP[VPD_PV_POWERSAVE]) /
+              (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].pstate +
+                         i_operating_points[VPD_PT_SET_BIASED][VPD_PV_POWERSAVE].pstate);
         o_gppb->PsVSlopes[VPD_SLOPES_BIASED][REGION_POWERSAVE_NOMINAL] = revle16((uint16_t)tmp);
         FAPI_INF("PsVSlopes[VPD_SLOPES_BIASED][REGION_POWERSAVE_NOMINAL] %X tmp %X",
                  (revle16(o_gppb->PsVSlopes[VPD_SLOPES_BIASED][REGION_POWERSAVE_NOMINAL])), (tmp));
 
-        tmp = (uint32_t)(eVidFP[TURBO] - eVidFP[NOMINAL]) /
-              (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][TURBO].pstate +
-                         i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate);
+        tmp = (uint32_t)(eVidFP[VPD_PV_TURBO] - eVidFP[VPD_PV_NOMINAL]) /
+              (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][VPD_PV_TURBO].pstate +
+                         i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].pstate);
         o_gppb->PsVSlopes[VPD_SLOPES_BIASED][REGION_NOMINAL_TURBO] = revle16((uint16_t)tmp);
         FAPI_INF("PsVSlopes[VPD_SLOPES_BIASED][REGION_NOMINAL_TURBO] %X tmp %X",
                  (revle16(o_gppb->PsVSlopes[VPD_SLOPES_BIASED][REGION_NOMINAL_TURBO])), (tmp));
 
-        tmp = (uint32_t)(eVidFP[ULTRA] - eVidFP[TURBO]) /
-              (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][ULTRA].pstate + i_operating_points[VPD_PT_SET_BIASED][TURBO].pstate);
+        tmp = (uint32_t)(eVidFP[VPD_PV_ULTRA] - eVidFP[VPD_PV_TURBO]) /
+              (uint32_t)(-i_operating_points[VPD_PT_SET_BIASED][VPD_PV_ULTRA].pstate +
+                         i_operating_points[VPD_PT_SET_BIASED][VPD_PV_TURBO].pstate);
         o_gppb->PsVSlopes[VPD_SLOPES_BIASED][REGION_TURBO_ULTRA] = revle16((uint16_t)tmp);
         FAPI_INF("PsVSlopes[VPD_SLOPES_BIASED][REGION_TURBO_ULTRA] %X tmp %X",
                  (revle16(o_gppb->PsVSlopes[VPD_SLOPES_BIASED][REGION_TURBO_ULTRA])), (tmp));
 
         //Calculate inverted slopes
-        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate +
-                           i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].pstate) << EVID_SLOPE_FP_SHIFT)
-               / (uint32_t) (i_operating_points[VPD_PT_SET_BIASED][NOMINAL].vdd_mv -
-                             i_operating_points[VPD_PT_SET_BIASED][POWERSAVE].vdd_mv);
+        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].pstate +
+                           i_operating_points[VPD_PT_SET_BIASED][VPD_PV_POWERSAVE].pstate) << EVID_SLOPE_FP_SHIFT)
+               / (uint32_t) (i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].vdd_mv -
+                             i_operating_points[VPD_PT_SET_BIASED][VPD_PV_POWERSAVE].vdd_mv);
         o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_POWERSAVE_NOMINAL] = revle16((uint16_t)tmp);
         FAPI_INF ("VPsSlopes[VPD_SLOPES_BIASED][REGION_POWERSAVE_NOMINAL] %X tmp %X",
                   (revle16(o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_POWERSAVE_NOMINAL])), (tmp));
 
-        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_BIASED][TURBO].pstate +
-                           i_operating_points[VPD_PT_SET_BIASED][NOMINAL].pstate) << EVID_SLOPE_FP_SHIFT)
-               / (uint32_t) (i_operating_points[VPD_PT_SET_BIASED][TURBO].vdd_mv -
-                             i_operating_points[VPD_PT_SET_BIASED][NOMINAL].vdd_mv);
+        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_BIASED][VPD_PV_TURBO].pstate +
+                           i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].pstate) << EVID_SLOPE_FP_SHIFT)
+               / (uint32_t) (i_operating_points[VPD_PT_SET_BIASED][VPD_PV_TURBO].vdd_mv -
+                             i_operating_points[VPD_PT_SET_BIASED][VPD_PV_NOMINAL].vdd_mv);
         o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_NOMINAL_TURBO] = revle16((uint16_t)tmp);
         FAPI_INF("VPsSlopes[VPD_SLOPES_BIASED][REGION_NOMINAL_TURBO] %X tmp %X",
                  (revle16(o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_NOMINAL_TURBO])), (tmp));
 
-        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_BIASED][ULTRA].pstate +
-                           i_operating_points[VPD_PT_SET_BIASED][TURBO].pstate) << EVID_SLOPE_FP_SHIFT)
-               / (uint32_t) (i_operating_points[VPD_PT_SET_BIASED][ULTRA].vdd_mv -
-                             i_operating_points[VPD_PT_SET_BIASED][TURBO].vdd_mv);
+        tmp =  (uint32_t)((-i_operating_points[VPD_PT_SET_BIASED][VPD_PV_ULTRA].pstate +
+                           i_operating_points[VPD_PT_SET_BIASED][VPD_PV_TURBO].pstate) << EVID_SLOPE_FP_SHIFT)
+               / (uint32_t) (i_operating_points[VPD_PT_SET_BIASED][VPD_PV_ULTRA].vdd_mv -
+                             i_operating_points[VPD_PT_SET_BIASED][VPD_PV_TURBO].vdd_mv);
         o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_TURBO_ULTRA] = revle16((uint16_t)tmp);
         FAPI_INF("VPsSlopes[VPD_SLOPES_BIASED][REGION_TURBO_ULTRA] %X tmp %X",
                  (revle16(o_gppb->VPsSlopes[VPD_SLOPES_BIASED][REGION_TURBO_ULTRA])), (tmp));
@@ -1862,6 +1897,47 @@ 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);
+    }
+
+
+
 
     FAPI_INF("---------------------------------------------------------------------------------------");
 }
@@ -2021,3 +2097,162 @@ int freq2pState (const GlobalPstateParmBlock* gppb,
 
     return rc;
 }
+fapi2::ReturnCode
+proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
+                     uint8_t       i_poundv_bucketId,
+                     VDMParmBlock* o_vdmpb)
+{
+    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;
+
+    do
+    {
+        // Below fiels 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
+        // Small Threshold 0.5  Lower nibble of byte
+        // Large Threshold 0.5  Upper nibble of byte
+        // eXtreme Threshold 0.5 Lower nibble of byte
+        // Small Frequency Drop  1B
+        // Large Frequency Drop 1B
+        // -----------------------------------------------------------------
+        l_eqChiplets = i_target.getChildren<fapi2::TARGET_TYPE_EQ>(fapi2::TARGET_STATE_FUNCTIONAL);
+
+        for (j = 0; j < l_eqChiplets.size(); j++)
+        {
+            uint8_t l_chipNum = 0xFF;
+
+            FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_UNIT_POS, l_eqChiplets[j], l_chipNum));
+
+            FAPI_INF("Chip Number => %u", l_chipNum);
+
+            // clear out buffer to known value before calling fapiGetMvpdField
+            memset(&l_vdmBuf, 0, sizeof(l_vdmBuf));
+
+            FAPI_TRY(p9_pm_get_poundw_bucket(l_eqChiplets[j], l_vdmBuf));
+
+            bucket_id = l_vdmBuf.bucketId;
+
+            FAPI_INF("#W chiplet = %u bucket id = %u", l_chipNum, bucket_id);
+
+            //if we match with the bucket id, then we don't need to continue
+            if (i_poundv_bucketId == bucket_id)
+            {
+                break;
+            }
+        }
+
+        uint8_t l_poundw_static_data = 0;
+        const fapi2::Target<fapi2::TARGET_TYPE_SYSTEM> FAPI_SYSTEM;
+        FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_POUND_W_STATIC_DATA_ENABLE,
+                               FAPI_SYSTEM,
+                               l_poundw_static_data),
+                 "Error from FAPI_ATTR_GET for attribute ATTR_POUND_W_STATIC_DATA_ENABLE");
+
+        if (l_poundw_static_data)
+        {
+            FAPI_INF("attribute ATTR_POUND_W_STATIC_DATA_ENABLE is set");
+            memcpy (&l_vdmBuf, &g_vpdData, sizeof (g_vpdData));
+        }
+        else
+        {
+            FAPI_INF("attribute ATTR_POUND_W_STATIC_DATA_ENABLE is NOT set");
+
+        }
+
+        const uint8_t pv_op_order[VPD_PV_POINTS] = VPD_PV_ORDER;
+
+        if (!(o_vdmpb->overvolt_override_enable))
+        {
+            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 >> 4;
+                o_vdmpb->overvolt_override[pv_op_order[i]] = l_data;
+            }
+        }
+
+        if (!(o_vdmpb->droop_small_override_enable))
+        {
+            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))
+        {
+            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;
+            }
+        }
+
+        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;
+            }
+        }
+
+        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;
+            }
+        }
+
+        if (!(o_vdmpb->fmax_override_khz_enable))
+        {
+            jump_to_next_mode = 0;
+
+            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;
+            }
+        }
+
+
+    }
+    while(0);
+
+
+fapi_try_exit:
+    return fapi2::current_err;
+
+}
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 0b9a2a0e2..16eec80bd 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
@@ -132,6 +132,7 @@ typedef struct
 #define PDV_BUFFER_SIZE    51
 #define PDV_BUFFER_ALLOC   512
 
+#define POUND_W_VERSION_2_BUCKET_SIZE 60
 //#define PDM_BUFFER_SIZE    105
 #define PDM_BUFFER_SIZE    257      // Value is for version 3 @ 256 + 1 for version number
 #define PDM_BUFFER_ALLOC   513      // Value is for version 2 @ 512 + 1 for version number
@@ -280,7 +281,8 @@ fapi2::ReturnCode
 proc_get_mvpd_data ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                      uint32_t o_attr_mvpd_data[PV_D][PV_W],
                      uint32_t* o_valid_pdv_points,
-                     uint8_t* o_present_chiplets );
+                     uint8_t* o_present_chiplets,
+                     uint8_t& o_poundv_bucketId );
 
 /// -------------------------------------------------------------------
 /// @brief Perform data validity check on #V data
@@ -309,7 +311,18 @@ proc_chk_valid_poundv ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_tar
 fapi2::ReturnCode
 proc_get_mvpd_iddq ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                      IddqTable* io_iddqt);
-
+/// ----------------------------------------------------------------
+/// @brief Get #W data and put into array
+/// @param[in]    i_target          => Chip Target
+/// @param[in]    i_poundv_bucketId => Pound V bucket id
+/// @param[out]   o_vdmpb           => Vdmparamblock 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
+                    );
 /// -----------------------------------------------------------------------
 /// @brief Get needed attributes
 /// @param[in]    i_target          => Chip Target
diff --git a/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.mk b/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.mk
index 3faafe8ca..1b33bc094 100644
--- a/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.mk
+++ b/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.mk
@@ -31,5 +31,6 @@ $(call ADD_MODULE_INCDIR,$(PROCEDURE),$(PPB_INCLUDES))
 #$(call ADD_MODULE_SRCDIR,$(PROCEDURE),$(ROOTPATH)/chips/p9/procedures/hwp/lib)
 lib$(PROCEDURE)_DEPLIBS+=p9_pm_utils
 lib$(PROCEDURE)_DEPLIBS+=p9_pm_get_poundv_bucket
+lib$(PROCEDURE)_DEPLIBS+=p9_pm_get_poundw_bucket
 #lib$(PROCEDURE)_DEPLIBS+=p9_pstate_utils
 $(call BUILD_PROCEDURE)
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 08891e468..794048e15 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
@@ -217,8 +217,9 @@ avsInitAttributes(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
             !attrs->vcs_voltage_mv ||
             !attrs->vdn_voltage_mv)
         {
+            uint8_t l_poundv_bucketId = 0;
             // Get #V data from MVPD for VDD/VDN and VCS voltage values
-            FAPI_TRY(proc_get_mvpd_data(i_target, attr_mvpd_data, &valid_pdv_points, &present_chiplets));
+            FAPI_TRY(proc_get_mvpd_data(i_target, attr_mvpd_data, &valid_pdv_points, &present_chiplets, l_poundv_bucketId));
 
             // set VDD voltage to PowerSave Voltage from MVPD data (if no override)
             if (attrs->vdd_voltage_mv)
diff --git a/src/import/chips/p9/procedures/xml/attribute_info/pm_plat_attributes.xml b/src/import/chips/p9/procedures/xml/attribute_info/pm_plat_attributes.xml
index 29aedfca4..3381bdf4e 100644
--- a/src/import/chips/p9/procedures/xml/attribute_info/pm_plat_attributes.xml
+++ b/src/import/chips/p9/procedures/xml/attribute_info/pm_plat_attributes.xml
@@ -1629,4 +1629,27 @@
     <initToZero/>
   </attribute>
   <!-- ********************************************************************* -->
+  <attribute>
+     <id>ATTR_POUND_W_STATIC_DATA_ENABLE</id>
+     <description>
+
+     Enables pstate parameter block code to use the static #W data
+     Consumer: p9_pstate_parameter_block.C ->
+
+     Platform default:  OFF
+     <!--
+        @todo RTC 169662 at some point in the program, this default may be switched to
+         the opposite setting.  However, coordination needs to occur with all CIs
+         as this will enable functions that may not be modeled across the board.
+     -->
+     </description>
+     <targetType>TARGET_TYPE_SYSTEM</targetType>
+     <valueType>uint8</valueType>
+     <enum>
+        OFF = 0x00, ON = 0x01
+    </enum>
+    <platInit/>
+    <initToZero/>
+  </attribute>
+  <!-- ********************************************************************* -->
 </attributes>
diff --git a/src/import/hwpf/fapi2/xml/attribute_info/hb_temp_defaults.xml b/src/import/hwpf/fapi2/xml/attribute_info/hb_temp_defaults.xml
index 8ca8d58d6..813022be0 100644
--- a/src/import/hwpf/fapi2/xml/attribute_info/hb_temp_defaults.xml
+++ b/src/import/hwpf/fapi2/xml/attribute_info/hb_temp_defaults.xml
@@ -107,6 +107,12 @@
        <id>ATTR_CME_INSTRUCTION_TRACE_ENABLE</id>
        <default>0x0</default>
      </attribute>
+      <attribute>
+       <id>ATTR_POUND_W_STATIC_DATA_ENABLE</id>
+       <!-- this setting enables to use #W static data-->
+       <default>0x0</default>
+     </attribute>
+
      <attribute>
          <id>ATTR_IO_OBUS_DCCAL_FLAGS</id>
          <default>0x0</default>
diff --git a/src/usr/targeting/common/xmltohb/attribute_types.xml b/src/usr/targeting/common/xmltohb/attribute_types.xml
index 0dc196474..140c4b009 100644
--- a/src/usr/targeting/common/xmltohb/attribute_types.xml
+++ b/src/usr/targeting/common/xmltohb/attribute_types.xml
@@ -32910,6 +32910,27 @@ Measured in GB</description>
 </attribute>
 
 <attribute>
+   <id>POUND_W_STATIC_DATA_ENABLE</id>
+   <description>
+     Enables pstate parameter block code to use the static #W data
+     Consumer: p9_pstate_parameter_block.C ->
+
+     Platform default:  OFF=0
+   </description>
+   <simpleType>
+        <uint8_t>
+            <default>0</default>
+        </uint8_t>
+   </simpleType>
+   <persistency>non-volatile</persistency>
+   <readable/>
+   <hwpfToHbAttrMap>
+      <id>ATTR_POUND_W_STATIC_DATA_ENABLE</id>
+      <macro>DIRECT</macro>
+   </hwpfToHbAttrMap>
+</attribute>
+
+<attribute>
     <id>PGPE_HCODE_FUNCTION_ENABLE</id>
     <description>
         Enables the PGPE Hcode to physically perform frequency and voltage
diff --git a/src/usr/targeting/common/xmltohb/target_types.xml b/src/usr/targeting/common/xmltohb/target_types.xml
index efe4dee33..61f3fec4f 100755
--- a/src/usr/targeting/common/xmltohb/target_types.xml
+++ b/src/usr/targeting/common/xmltohb/target_types.xml
@@ -915,6 +915,7 @@
     <attribute><id>SYSTEM_RING_DBG_MODE</id></attribute>
     <attribute><id>NEST_LEAKAGE_PERCENT</id></attribute>
     <attribute><id>MSS_MRW_DRAM_WRITE_CRC</id></attribute>
+    <attribute><id>POUND_W_STATIC_DATA_ENABLE</id></attribute>
     <attribute><id>PGPE_HCODE_FUNCTION_ENABLE</id></attribute>
     <attribute><id>SYSTEM_DISABLE_QUEUED_SCAN</id></attribute>
 </targetType>