PGPE: Move all state data to a fixed spot

Change-Id: Ife6d79566067242869d72c6a4c465267cfbffbb5
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/38355
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Reviewed-by: AMIT KUMAR <akumar3@us.ibm.com>
Reviewed-by: Michael S. Floyd <mfloyd@us.ibm.com>
Reviewed-by: Jennifer A. Stofer <stofer@us.ibm.com>

10 files changed, 500 insertions, 541 deletions

diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/link.cmd b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/link.cmd
index 6059a2b9..c0a39b20 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/link.cmd
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/link.cmd
@@ -38,6 +38,7 @@ OUTPUT_FORMAT(elf32-powerpc);
 #define PGPE_HEADER_OFFSET    0x180
 //debug pointer offset at an offset of 0x200
 #define PPE_DEBUG_PTRS_OFFSET PGPE_HEADER_OFFSET + 0x80
+#define PPE_DEBUG_PTRS_SIZE     0x24
 
 MEMORY
 {
@@ -88,6 +89,9 @@ SECTIONS
     _DEBUG_PTRS_START = _VECTOR_START + PPE_DEBUG_PTRS_OFFSET;
     .debug_ptrs _DEBUG_PTRS_START : { *(.debug_ptrs) } > sram
 
+    _DUMP_PTRS_START = _DEBUG_PTRS_START + PPE_DEBUG_PTRS_SIZE;
+    .dump_ptrs _DUMP_PTRS_START : { *(.dump_ptrs) } > sram
+
     ////////////////////////////////
     // All non-vector code goes here
     ////////////////////////////////
diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe.h b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe.h
index 95e1dabc..93d68083 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe.h
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe.h
@@ -64,15 +64,6 @@
 
 
 /// PGPE PState
-typedef struct
-{
-    PkSemaphore sem_process_req;
-    PkSemaphore sem_actuate;
-    PkSemaphore sem_sgpe_wait;
-    PkSemaphore sem_safe_mode_and_pm_suspend_req;
-} PgpePstateRecord;
-
-/// PGPE PState
 void p9_pgpe_irq_handler_occ_error(void* arg, PkIrqId irq);
 void p9_pgpe_irq_handler_sgpe_halt(void* arg, PkIrqId irq);
 void p9_pgpe_irq_handler_xstop_gpe2(void* arg, PkIrqId irq);
diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_gppb.c b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_gppb.c
index 636a6707..844ade02 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_gppb.c
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_gppb.c
@@ -28,7 +28,6 @@
 //Global pointer to GlobalPstateParmBlock
 GlobalPstateParmBlock* G_gppb;
 
-//VpdOperatingPoint *G_gppb->operating_points_set[NUM_VPD_PTS_SET][VPD_PV_POINTS];
 uint32_t G_pstate0_dpll_value;
 uint32_t G_ext_vrm_inc_rate_mult_usperus;
 uint32_t G_ext_vrm_dec_rate_mult_usperus;
diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_ipc_handlers.c b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_ipc_handlers.c
index 45bff7d3..dbb1417a 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_ipc_handlers.c
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_ipc_handlers.c
@@ -43,12 +43,8 @@
 //
 //External Global Data
 //
-extern ipc_req_t G_ipc_pend_tbl[MAX_IPC_PEND_TBL_ENTRIES];
-extern uint32_t G_pstatesStatus;
-extern PgpePstateRecord G_pgpe_pstate_record;
-extern uint32_t G_already_sem_posted;
-//extern uint8_t G_pmcrOwner;
 extern PgpeHeader_t* G_pgpe_header_data;
+extern PgpePstateRecord G_pgpe_pstate_record;
 
 //
 //p9_pgpe_ipc_init
@@ -65,12 +61,12 @@ void p9_pgpe_ipc_init()
 
     for (i = 0; i < MAX_IPC_PEND_TBL_ENTRIES; i++)
     {
-        G_ipc_pend_tbl[i].cmd = NULL;
-        G_ipc_pend_tbl[i].pending_ack = 0;
-        G_ipc_pend_tbl[i].pending_processing = 0;
+        G_pgpe_pstate_record.ipcPendTbl[i].cmd = NULL;
+        G_pgpe_pstate_record.ipcPendTbl[i].pending_ack = 0;
+        G_pgpe_pstate_record.ipcPendTbl[i].pending_processing = 0;
     }
 
-    G_already_sem_posted = 0;
+    G_pgpe_pstate_record.alreadySemPosted = 0;
 }
 
 //
@@ -90,34 +86,34 @@ void p9_pgpe_ipc_405_start_stop(ipc_msg_t* cmd, void* arg)
         PK_TRACE_DBG("START_STOP: Imm\n");
         args->msg_cb.rc = PGPE_RC_SUCCESS;
         ipc_send_rsp(cmd, IPC_RC_SUCCESS);
-        G_ipc_pend_tbl[IPC_PEND_PSTATE_START].pending_ack = 0;
-        G_ipc_pend_tbl[IPC_PEND_PSTATE_START].pending_processing = 0;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].pending_ack = 0;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].pending_processing = 0;
 
         //Yes, here we post to process thread when START/STOP is rcv.
         //This is done to ensure that pk_irq_vec_restore is called correctly
         //We can call it here, but other IPCs could be processed in this invocation
         //of IPC interrupt handler and pk_irq_vec_restore can get called twice.
         //Much cleaner to call it always from process thread.
-        if (G_already_sem_posted == 0)
+        if (G_pgpe_pstate_record.alreadySemPosted == 0)
         {
             pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
-            G_already_sem_posted  = 1;
+            G_pgpe_pstate_record.alreadySemPosted  = 1;
         }
     }
-    else if(G_pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
-            G_pstatesStatus == PSTATE_PM_SUSPENDED ||
-            G_pstatesStatus == PSTATE_SAFE_MODE)
+    else if(G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
+            G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPENDED ||
+            G_pgpe_pstate_record.pstatesStatus == PSTATE_SAFE_MODE)
     {
         PK_TRACE_DBG("START_STOP: PM_SUSP/Safe\n");
         args->msg_cb.rc = PGPE_RC_PM_COMPLEX_SUSPEND_SAFE_MODE;
         ipc_send_rsp(cmd, IPC_RC_SUCCESS);
-        G_ipc_pend_tbl[IPC_PEND_PSTATE_START].pending_ack = 0;
-        G_ipc_pend_tbl[IPC_PEND_PSTATE_START].pending_processing = 0;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].pending_ack = 0;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].pending_processing = 0;
 
-        if (G_already_sem_posted == 0)
+        if (G_pgpe_pstate_record.alreadySemPosted == 0)
         {
             pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
-            G_already_sem_posted  = 1;
+            G_pgpe_pstate_record.alreadySemPosted  = 1;
         }
     }
     else
@@ -125,21 +121,21 @@ void p9_pgpe_ipc_405_start_stop(ipc_msg_t* cmd, void* arg)
         //START
         if (args->action == PGPE_ACTION_PSTATE_START)
         {
-            if (G_ipc_pend_tbl[IPC_PEND_PSTATE_START].pending_ack == 0)
+            if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].pending_ack == 0)
             {
-                if(G_pstatesStatus == PSTATE_INIT || G_pstatesStatus == PSTATE_STOPPED)
+                if(G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT || G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED)
                 {
                     PK_TRACE_DBG("START_STOP: Start Rcvd\n");
 
                     //Add task
-                    G_ipc_pend_tbl[IPC_PEND_PSTATE_START].cmd = cmd;
-                    G_ipc_pend_tbl[IPC_PEND_PSTATE_START].pending_ack = 1;
-                    G_ipc_pend_tbl[IPC_PEND_PSTATE_START].pending_processing = 0;
+                    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].cmd = cmd;
+                    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].pending_ack = 1;
+                    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].pending_processing = 0;
 
                     //Post to Actuate Thread
                     pk_semaphore_post(&G_pgpe_pstate_record.sem_actuate);
                 }
-                else if (G_pstatesStatus == PSTATE_ACTIVE)
+                else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_ACTIVE)
                 {
                     //\todo
                 }
@@ -156,9 +152,9 @@ void p9_pgpe_ipc_405_start_stop(ipc_msg_t* cmd, void* arg)
         {
             PK_TRACE_DBG("START_STOP: Stop Rcvd\n");
 
-            if (G_ipc_pend_tbl[IPC_PEND_PSTATE_STOP].pending_ack == 0)
+            if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_STOP].pending_ack == 0)
             {
-                if(G_pstatesStatus != PSTATE_ACTIVE)
+                if(G_pgpe_pstate_record.pstatesStatus != PSTATE_ACTIVE)
                 {
                     PK_TRACE_DBG("START_STOP: Pstate Already Stopped\n");
                     args->msg_cb.rc = PGPE_RC_REQ_PSTATE_ALREADY_STOPPED;
@@ -166,10 +162,10 @@ void p9_pgpe_ipc_405_start_stop(ipc_msg_t* cmd, void* arg)
                 }
                 else
                 {
-                    G_pstatesStatus = PSTATE_STOPPED;
-                    G_ipc_pend_tbl[IPC_PEND_PSTATE_STOP].cmd = cmd;
-                    G_ipc_pend_tbl[IPC_PEND_PSTATE_STOP].pending_ack = 1;
-                    G_ipc_pend_tbl[IPC_PEND_PSTATE_STOP].pending_processing = 0;
+                    G_pgpe_pstate_record.pstatesStatus = PSTATE_STOPPED;
+                    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_STOP].cmd = cmd;
+                    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_STOP].pending_ack = 1;
+                    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_STOP].pending_processing = 0;
 
                 }
             }
@@ -196,11 +192,11 @@ void p9_pgpe_ipc_405_clips(ipc_msg_t* cmd, void* arg)
     ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)cmd;
     ipcmsg_set_pmcr_t* args = (ipcmsg_set_pmcr_t*)async_cmd->cmd_data;
 
-    if (G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].pending_ack == 0)
+    if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].pending_ack == 0)
     {
-        G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].cmd = cmd;
-        G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].pending_processing = 1;
-        G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].pending_ack = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].cmd = cmd;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].pending_processing = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].pending_ack = 1;
     }
     else
     {
@@ -208,10 +204,10 @@ void p9_pgpe_ipc_405_clips(ipc_msg_t* cmd, void* arg)
         ipc_send_rsp(cmd, IPC_RC_SUCCESS);
     }
 
-    if (G_already_sem_posted == 0)
+    if (G_pgpe_pstate_record.alreadySemPosted == 0)
     {
         pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
-        G_already_sem_posted  = 1;
+        G_pgpe_pstate_record.alreadySemPosted  = 1;
     }
 
     PK_TRACE_DBG("405_CLIPS: Exit\n");
@@ -228,11 +224,11 @@ void p9_pgpe_ipc_405_set_pmcr(ipc_msg_t* cmd, void* arg)
     ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)cmd;
     ipcmsg_set_pmcr_t* args = (ipcmsg_set_pmcr_t*)async_cmd->cmd_data;
 
-    if (G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].pending_ack == 0)
+    if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].pending_ack == 0)
     {
-        G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].cmd = cmd;
-        G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].pending_processing = 1;
-        G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].pending_ack = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].cmd = cmd;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].pending_processing = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].pending_ack = 1;
     }
     else
     {
@@ -241,10 +237,10 @@ void p9_pgpe_ipc_405_set_pmcr(ipc_msg_t* cmd, void* arg)
         ipc_send_rsp(cmd, IPC_RC_SUCCESS);
     }
 
-    if (G_already_sem_posted == 0)
+    if (G_pgpe_pstate_record.alreadySemPosted == 0)
     {
         pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
-        G_already_sem_posted  = 1;
+        G_pgpe_pstate_record.alreadySemPosted  = 1;
     }
 
     PK_TRACE_DBG("405_SET_PMCR: Exit\n");
@@ -261,11 +257,11 @@ void p9_pgpe_ipc_405_wof_control(ipc_msg_t* cmd, void* arg)
     ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)cmd;
     ipcmsg_wof_control_t* args = (ipcmsg_wof_control_t*)async_cmd->cmd_data;
 
-    if (G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].pending_ack == 0)
+    if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].pending_ack == 0)
     {
-        G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].cmd = cmd;
-        G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].pending_processing = 1;
-        G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].pending_ack = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].cmd = cmd;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].pending_processing = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].pending_ack = 1;
     }
     else
     {
@@ -273,10 +269,10 @@ void p9_pgpe_ipc_405_wof_control(ipc_msg_t* cmd, void* arg)
         ipc_send_rsp(cmd, IPC_RC_SUCCESS);
     }
 
-    if (G_already_sem_posted == 0)
+    if (G_pgpe_pstate_record.alreadySemPosted == 0)
     {
         pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
-        G_already_sem_posted  = 1;
+        G_pgpe_pstate_record.alreadySemPosted  = 1;
     }
 
     PK_TRACE_DBG("405_WOF_CTRL: Exit\n");
@@ -293,11 +289,11 @@ void p9_pgpe_ipc_405_wof_vfrt(ipc_msg_t* cmd, void* arg)
     ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)cmd;
     ipcmsg_wof_vfrt_t* args = (ipcmsg_wof_vfrt_t*)async_cmd->cmd_data;
 
-    if (G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].pending_ack == 0)
+    if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].pending_ack == 0)
     {
-        G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].cmd = cmd;
-        G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].pending_processing = 1;
-        G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].pending_ack = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].cmd = cmd;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].pending_processing = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].pending_ack = 1;
     }
     else
     {
@@ -305,10 +301,10 @@ void p9_pgpe_ipc_405_wof_vfrt(ipc_msg_t* cmd, void* arg)
         ipc_send_rsp(cmd, IPC_RC_SUCCESS);
     }
 
-    if (G_already_sem_posted == 0)
+    if (G_pgpe_pstate_record.alreadySemPosted == 0)
     {
         pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
-        G_already_sem_posted  = 1;
+        G_pgpe_pstate_record.alreadySemPosted  = 1;
     }
 
     PK_TRACE_DBG("405_WOF_VFRT: Exit\n");
@@ -323,12 +319,12 @@ void p9_pgpe_ipc_sgpe_suspend_pstates(ipc_msg_t* cmd, void* arg)
 {
     PK_TRACE_DBG("SGPE_SUSPEND_PSTATES: Entry\n");
 
-    if (G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack == 0 &&
-        G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_processing == 0)
+    if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack == 0 &&
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_processing == 0)
     {
-        G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].cmd = cmd;
-        G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_processing = 1;
-        G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].cmd = cmd;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_processing = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack = 1;
     }
     else
     {
@@ -339,10 +335,10 @@ void p9_pgpe_ipc_sgpe_suspend_pstates(ipc_msg_t* cmd, void* arg)
         ipc_send_rsp(cmd, IPC_RC_SUCCESS);
     }
 
-    if (G_already_sem_posted == 0)
+    if (G_pgpe_pstate_record.alreadySemPosted == 0)
     {
         pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
-        G_already_sem_posted  = 1;
+        G_pgpe_pstate_record.alreadySemPosted  = 1;
     }
 
     PK_TRACE_DBG("SGPE_SUSPEND_PSTATES: Exit\n");
@@ -357,12 +353,12 @@ void p9_pgpe_ipc_sgpe_updt_active_cores(ipc_msg_t* cmd, void* arg)
 {
     PK_TRACE_DBG("SGPE_UPDT_CORES: Entry\n");
 
-    if (G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack == 0 &&
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing == 0)
+    if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack == 0 &&
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing == 0)
     {
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd = cmd;
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing = 1;
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd = cmd;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack = 1;
     }
     else
     {
@@ -373,10 +369,10 @@ void p9_pgpe_ipc_sgpe_updt_active_cores(ipc_msg_t* cmd, void* arg)
         ipc_send_rsp(cmd, IPC_RC_SUCCESS);
     }
 
-    if (G_already_sem_posted == 0)
+    if (G_pgpe_pstate_record.alreadySemPosted == 0)
     {
         pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
-        G_already_sem_posted  = 1;
+        G_pgpe_pstate_record.alreadySemPosted  = 1;
     }
 
     PK_TRACE_DBG("SGPE_UPDT_CORES: Exit\n");
@@ -391,14 +387,14 @@ void p9_pgpe_ipc_sgpe_updt_active_quads(ipc_msg_t* cmd, void* arg)
 {
     PK_TRACE_DBG("SGPE_UPDT_QUADS: Entry\n");
 
-    if (G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack == 0 &&
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing == 0 &&
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack == 0 &&
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing == 0)
+    if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack == 0 &&
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing == 0 &&
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack == 0 &&
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing == 0)
     {
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd = cmd;
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing = 1;
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd = cmd;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing = 1;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack = 1;
 
     }
     else
@@ -410,10 +406,10 @@ void p9_pgpe_ipc_sgpe_updt_active_quads(ipc_msg_t* cmd, void* arg)
         ipc_send_rsp(cmd, IPC_RC_SUCCESS);
     }
 
-    if (G_already_sem_posted == 0)
+    if (G_pgpe_pstate_record.alreadySemPosted == 0)
     {
         pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
-        G_already_sem_posted  = 1;
+        G_pgpe_pstate_record.alreadySemPosted  = 1;
     }
 
     PK_TRACE_DBG("SGPE_UPDT_QUADS: Exit\n");
diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_irq_handlers.c b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_irq_handlers.c
index c0decc2f..27e34e17 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_irq_handlers.c
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_irq_handlers.c
@@ -30,12 +30,7 @@
 //
 //External Global Data
 //
-extern uint8_t G_coresPSRequest[MAX_CORES];    //per core requested pstate
-extern uint8_t G_pmcrOwner;
-extern uint32_t G_pstatesStatus;
-//extern uint32_t G_process_occ_hb_error;
-//extern uint32_t G_process_safe_mode;
-//extern uint32_t G_process_pm_suspend;
+extern PgpePstateRecord G_pgpe_pstate_record;
 
 //
 //OCB Error Interrupt Handler
@@ -169,8 +164,8 @@ void p9_pgpe_irq_handler_pcb_type1(void* arg, PkIrqId irq)
     uint32_t coresPendPSReq = in32(OCB_OPIT1PRA);
     uint32_t c;
 
-    if (G_pstatesStatus == PSTATE_ACTIVE && (G_pmcrOwner == PMCR_OWNER_HOST ||
-            G_pmcrOwner == PMCR_OWNER_CHAR))
+    if (G_pgpe_pstate_record.pstatesStatus == PSTATE_ACTIVE && (G_pgpe_pstate_record.pmcrOwner == PMCR_OWNER_HOST ||
+            G_pgpe_pstate_record.pmcrOwner == PMCR_OWNER_CHAR))
     {
 
         //Process pending requests
@@ -193,7 +188,7 @@ void p9_pgpe_irq_handler_pcb_type1(void* arg, PkIrqId irq)
                     ((op1 >> 10) && 0x3))
                 {
                     //Extract the LowerPState field
-                    G_coresPSRequest[c] = op1 & 0xff;
+                    G_pgpe_pstate_record.coresPSRequest[c] = op1 & 0xff;
                     out32(OCB_OPIT1PRA_CLR, 0x80000000 >> c); //Clear out pending bits
                 }
             }
diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_main.c b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_main.c
index 30f1123a..29a5c1db 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_main.c
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_main.c
@@ -29,7 +29,42 @@
 #include "p9_pgpe_boot_temp.h"
 #include "p9_pgpe_pstate.h"
 
-PgpePstateRecord G_pgpe_pstate_record;
+PgpePstateRecord G_pgpe_pstate_record __attribute__((section (".dump_ptrs"))) =
+{
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    {0, 0, 0, 0, 0, 0},
+    {0, 0, 0, 0, 0, 0},
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+    {0, 0, 0, 0, 0, 0},
+    0,
+    0,
+    {0, 0, 0, 0, 0, 0},
+    0,
+    0,
+    {0, 0, 0, 0, 0, 0},
+    0,
+    0,
+    {0, 0, 0, 0, 0, 0},
+    0,
+    0,
+    0,
+    0,
+    0,
+    {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
+    0,
+    0,
+    0,
+    0,
+    {0},
+    {0},
+    {0}
+};
+
 
 EXTERNAL_IRQ_TABLE_START
 IRQ_HANDLER_DEFAULT            //OCCHW_IRQ_DEBUGGER
@@ -101,19 +136,16 @@ EXTERNAL_IRQ_TABLE_END
 #define  KERNEL_STACK_SIZE  512
 #define  THREAD_STACK_SIZE  512
 
-//#define  PGPE_THREAD_PRIORITY_SAFE_MODE_AND_PM_SUSPEND  1
 #define  PGPE_THREAD_PRIORITY_PROCESS_REQUESTS  1
 #define  PGPE_THREAD_PRIORITY_ACTUATE_PSTATES   2
 
 uint8_t  G_kernel_stack[KERNEL_STACK_SIZE];
 
 //Thread Stacks
-//uint8_t  G_p9_pgpe_thread_safe_mode_and_pm_suspend_stack[THREAD_STACK_SIZE];
 uint8_t  G_p9_pgpe_thread_process_requests_stack[THREAD_STACK_SIZE];
 uint8_t  G_p9_pgpe_thread_actuate_pstates_stack[THREAD_STACK_SIZE];
 
 //Thread Control Block
-//PkThread G_p9_pgpe_thread_safe_mode_and_pm_suspend;
 PkThread G_p9_pgpe_thread_process_requests;
 PkThread G_p9_pgpe_thread_actuate_pstates;
 
@@ -140,20 +172,6 @@ main(int argc, char** argv)
         asm volatile ("trap");
     }
 
-    /*
-    // Initialize the thread control block for G_p9_pgpe_thread_safe_mode_and_pm_suspend
-    pk_thread_create(&G_p9_pgpe_thread_safe_mode_and_pm_suspend,
-                     (PkThreadRoutine)p9_pgpe_thread_safe_mode_and_pm_suspend,
-                     (void*)NULL,
-                     (PkAddress)G_p9_pgpe_thread_safe_mode_and_pm_suspend_stack,
-                     (size_t)THREAD_STACK_SIZE,
-                     (PkThreadPriority)PGPE_THREAD_PRIORITY_SAFE_MODE_AND_PM_SUSPEND);
-
-    PK_TRACE_BIN("G_p9_pgpe_thread_safe_mode_and_pm_suspend",
-                 &G_p9_pgpe_thread_safe_mode_and_pm_suspend,
-                 sizeof(G_p9_pgpe_thread_safe_mode_and_pm_suspend));
-    */
-
     // Initialize the thread control block for G_p9_pgpe_thread_process_requests
     pk_thread_create(&G_p9_pgpe_thread_process_requests,
                      (PkThreadRoutine)p9_pgpe_thread_process_requests,
@@ -179,7 +197,6 @@ main(int argc, char** argv)
                  sizeof(G_p9_pgpe_thread_actuate_pstates));
 
     // Make G_p9_pgpe_thread pstates_update runnable
-//    pk_thread_resume(&G_p9_pgpe_thread_safe_mode_and_pm_suspend);
     pk_thread_resume(&G_p9_pgpe_thread_process_requests);
     pk_thread_resume(&G_p9_pgpe_thread_actuate_pstates);
 
diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.c b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.c
index ee1cc294..c0616f94 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.c
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.c
@@ -47,33 +47,11 @@ extern PgpeHeader_t* G_pgpe_header_data;
 extern GlobalPstateParmBlock* G_gppb;
 extern uint32_t G_ext_vrm_inc_rate_mult_usperus;
 extern uint32_t G_ext_vrm_dec_rate_mult_usperus;
+extern PgpePstateRecord G_pgpe_pstate_record;
 
 //
 //Global Data
 //
-//uint8_t G_safeModeEnabled;              //safe mode enabled/disabled
-uint32_t G_pstatesStatus;
-uint8_t G_pmcrOwner;
-uint8_t G_wofEnabled;                   //wof enable/disable
-uint8_t G_wofPending;                   //wof enable pending
-uint8_t G_psClipMax[MAX_QUADS],         //higher numbered(min freq and volt)
-        G_psClipMin[MAX_QUADS];         //lower numbered(max freq and volt)
-uint8_t G_wofClip;                      //wof clip
-uint8_t G_coresPSRequest[MAX_CORES];    //per core requested pstate
-uint8_t G_quadPSComputed[MAX_QUADS];    //computed Pstate per quad
-uint8_t G_globalPSComputed;             //computed global Pstate
-uint8_t G_quadPSTarget[MAX_QUADS];      //target Pstate per quad
-uint8_t G_globalPSTarget;               //target global Pstate
-uint8_t G_quadPSCurr[MAX_QUADS];      //target Pstate per quad
-uint8_t G_globalPSCurr;               //target global Pstate
-uint8_t G_quadPSNext[MAX_QUADS];      //target Pstate per quad
-uint8_t G_globalPSNext;
-uint8_t G_safe_pstate;
-uint32_t G_eVidCurr, G_eVidNext;
-VFRT_Hcode_t* G_vfrt_ptr;
-quad_state0_t* G_quadState0;
-quad_state1_t* G_quadState1;
-requested_active_quads_t* G_reqActQuads;
 GPE_BUFFER(ipc_async_cmd_t G_ipc_msg_pgpe_sgpe);
 GPE_BUFFER(ipcmsg_p2s_ctrl_stop_updates_t G_sgpe_control_updt);
 GPE_BUFFER(ipcmsg_s2p_suspend_pstate_t G_sgpe_suspend_stop);
@@ -84,50 +62,40 @@ void p9_pgpe_suspend_stop_callback(ipc_msg_t* msg, void* arg);
 void p9_pgpe_wait_cme_db_ack(uint8_t msg_id, uint32_t activeCores);
 
 //
-//Data passing between IPC interrupt and threads
-//
-ipc_req_t G_ipc_pend_tbl[MAX_IPC_PEND_TBL_ENTRIES];
-uint32_t G_already_sem_posted;
-uint32_t G_process_pm_suspend;
-
-
-//
 //p9_pgpe_pstate_init
 //
 void p9_pgpe_pstate_init()
 {
     uint32_t q;
 
-    G_process_pm_suspend = 0;
-//    G_safeModeEnabled = 0;
-    G_pstatesStatus = PSTATE_INIT;
-    G_wofEnabled = 0;
-    G_wofPending = 0;
+    G_pgpe_pstate_record.pstatesStatus = PSTATE_INIT;
+    G_pgpe_pstate_record.wofEnabled = 0;
+    G_pgpe_pstate_record.wofPending = 0;
 
     for (q = 0; q < MAX_QUADS; q++)
     {
-        G_psClipMax[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
-        G_psClipMin[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
-        G_quadPSComputed[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
-        G_globalPSComputed = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
-        G_quadPSTarget[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
-        G_globalPSTarget = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
-        G_quadPSCurr[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
-        G_globalPSCurr  = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
-        G_quadPSNext[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
-        G_globalPSNext  = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.psClipMax[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.psClipMin[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.quadPSComputed[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.globalPSComputed = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.quadPSTarget[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][NOMINAL].pstate;
+        G_pgpe_pstate_record.globalPSTarget = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.quadPSCurr[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.globalPSCurr  = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.quadPSNext[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.globalPSNext  = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
     }
 
-    G_quadState0 = (quad_state0_t*)G_pgpe_header_data->g_quad_status_addr;
-    G_quadState1 = (quad_state1_t*)(G_pgpe_header_data->g_quad_status_addr + 2);
-    G_reqActQuads = (requested_active_quads_t*)(G_pgpe_header_data->g_req_active_quad_addr);
-    G_safe_pstate = (G_gppb->reference_frequency_khz - G_gppb->safe_frequency_khz +
-                     (G_gppb->frequency_step_khz - 1)) / G_gppb->frequency_step_khz;
+    G_pgpe_pstate_record.pQuadState0 = (quad_state0_t*)G_pgpe_header_data->g_quad_status_addr;
+    G_pgpe_pstate_record.pQuadState1 = (quad_state1_t*)(G_pgpe_header_data->g_quad_status_addr + 2);
+    G_pgpe_pstate_record.pReqActQuads = (requested_active_quads_t*)(G_pgpe_header_data->g_req_active_quad_addr);
+    G_pgpe_pstate_record.safePstate = (G_gppb->reference_frequency_khz - G_gppb->safe_frequency_khz +
+                                       (G_gppb->frequency_step_khz - 1)) / G_gppb->frequency_step_khz;
 #if OVERRIDE_PSAFE_PSTATE == 1
-    G_safe_pstate = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][NOMINAL].pstate;
+    G_pgpe_pstate_record.safePstate = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][NOMINAL].pstate;
 #endif
 
-    PK_TRACE_INF("PS: G_safe_pstate=0x%x", G_safe_pstate);
+    PK_TRACE_INF("PS: G_pgpe_pstate_record.safePstate=0x%x", G_pgpe_pstate_record.safePstate);
 }
 
 //
@@ -141,7 +109,7 @@ void p9_pgpe_pstate_update(uint8_t* s)
     {
         for (c = (q * CORES_PER_QUAD); c < (q + 1)*CORES_PER_QUAD; c++)
         {
-            G_coresPSRequest[c] = s[q];
+            G_pgpe_pstate_record.coresPSRequest[c] = s[q];
         }
     }
 
@@ -157,9 +125,9 @@ void p9_pgpe_pstate_do_auction(uint8_t quadAuctionRequest)
     PK_TRACE_INF("AUCT: Enter");
     //Get active cores and quads
     uint32_t q, c;
-    uint32_t activeCores = G_quadState0->fields.active_cores;
-    activeCores = (activeCores << 16) | (G_quadState1->fields.active_cores);
-    uint32_t activeQuads = G_reqActQuads->fields.requested_active_quads;
+    uint32_t activeCores = G_pgpe_pstate_record.pQuadState0->fields.active_cores;
+    activeCores = (activeCores << 16) | (G_pgpe_pstate_record.pQuadState1->fields.active_cores);
+    uint32_t activeQuads = G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads;
 
     //Local PStates Auction
     for (q = 0; q < MAX_QUADS; q++)
@@ -170,42 +138,42 @@ void p9_pgpe_pstate_do_auction(uint8_t quadAuctionRequest)
         {
             //Go through all the cores in this quad with pending request
             //and find the lowest numbered PState
-            G_quadPSComputed[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+            G_pgpe_pstate_record.quadPSComputed[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
 
             for (c = (q * CORES_PER_QUAD); c < (q + 1)*CORES_PER_QUAD; c++)
             {
                 if (activeCores & (0x80000000 >> c))
                 {
-                    if (G_quadPSComputed[q] > G_coresPSRequest[c])
+                    if (G_pgpe_pstate_record.quadPSComputed[q] > G_pgpe_pstate_record.coresPSRequest[c])
                     {
-                        G_quadPSComputed[q] = G_coresPSRequest[c];
+                        G_pgpe_pstate_record.quadPSComputed[q] = G_pgpe_pstate_record.coresPSRequest[c];
                     }
                 }
             }
         }
         else
         {
-            G_quadPSComputed[q] = 0xFF;
+            G_pgpe_pstate_record.quadPSComputed[q] = 0xFF;
         }
 
-        PK_TRACE_INF("AUCTION: G_quadPSComputed: 0x%x", G_quadPSComputed[q]);
+        PK_TRACE_INF("AUCTION: G_quadPSComputed: 0x%x", G_pgpe_pstate_record.quadPSComputed[q]);
     }
 
     //Global PState Auction
-    G_globalPSComputed = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+    G_pgpe_pstate_record.globalPSComputed = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
 
     for (q = 0; q < MAX_QUADS; q++)
     {
         if (activeQuads & (QUAD0_BIT_MASK >> q))
         {
-            if (G_globalPSComputed  > G_quadPSComputed[q])
+            if (G_pgpe_pstate_record.globalPSComputed  > G_pgpe_pstate_record.quadPSComputed[q])
             {
-                G_globalPSComputed  = G_quadPSComputed[q];
+                G_pgpe_pstate_record.globalPSComputed  = G_pgpe_pstate_record.quadPSComputed[q];
             }
         }
     }
 
-    PK_TRACE_INF("AUCT glbPSCmpted: 0x%x", G_globalPSComputed);
+    PK_TRACE_INF("AUCT glbPSCmpted: 0x%x", G_pgpe_pstate_record.globalPSComputed);
     PK_TRACE_INF("AUCT: Exit");
 }
 
@@ -216,64 +184,65 @@ void p9_pgpe_pstate_apply_clips()
 {
     PK_TRACE_INF("APCLP: Enter");
     uint32_t q;
-    uint32_t activeQuads = G_reqActQuads->fields.requested_active_quads;
+    uint32_t activeQuads = G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads;
 
     //Apply clips to quad computed
     PK_TRACE_INF("APCLP: 0x%x", activeQuads);
 
     for (q = 0; q < MAX_QUADS; q++)
     {
-        uint8_t maxPS = G_psClipMax[q];
+        uint8_t maxPS = G_pgpe_pstate_record.psClipMax[q];
 
-        G_quadPSTarget[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+        G_pgpe_pstate_record.quadPSTarget[q] = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
 
         if (activeQuads & (QUAD0_BIT_MASK >> q))
         {
 
-            if (G_wofEnabled == 1)
+            if (G_pgpe_pstate_record.wofEnabled == 1)
             {
-                if (G_wofClip <= G_psClipMax[q])
+                if (G_pgpe_pstate_record.wofClip <= G_pgpe_pstate_record.psClipMax[q])
                 {
-                    maxPS = G_wofClip;
+                    maxPS = G_pgpe_pstate_record.wofClip;
                 }
             }
 
-            if (G_quadPSComputed[q] > maxPS)
+            if (G_pgpe_pstate_record.quadPSComputed[q] > maxPS)
             {
-                G_quadPSTarget[q] = maxPS;
+                G_pgpe_pstate_record.quadPSTarget[q] = maxPS;
             }
-            else if(G_quadPSComputed[q] < G_psClipMin[q])
+            else if(G_pgpe_pstate_record.quadPSComputed[q] < G_pgpe_pstate_record.psClipMin[q])
             {
-                G_quadPSTarget[q] = G_psClipMin[q];
+                G_pgpe_pstate_record.quadPSTarget[q] = G_pgpe_pstate_record.psClipMin[q];
             }
             else
             {
-                G_quadPSTarget[q] = G_quadPSComputed[q];
+                G_pgpe_pstate_record.quadPSTarget[q] = G_pgpe_pstate_record.quadPSComputed[q];
             }
         }
         else
         {
-            G_quadPSTarget[q] = 0xFF;
+            G_pgpe_pstate_record.quadPSTarget[q] = 0xFF;
         }
 
-        PK_TRACE_INF("APCLP: qPSTgt: 0x%x,cl=0x%x,0x%x", G_quadPSTarget[q], maxPS, G_psClipMin[q]);
+        PK_TRACE_INF("APCLP: qPSTgt: 0x%x,cl=0x%x,0x%x", G_pgpe_pstate_record.quadPSTarget[q], maxPS,
+                     G_pgpe_pstate_record.psClipMin[q]);
     }
 
     //Global PState Auction
-    G_globalPSTarget = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
+    G_pgpe_pstate_record.globalPSTarget = G_gppb->operating_points_set[VPD_PT_SET_BIASED_SYSP][POWERSAVE].pstate;
 
     for (q = 0; q < MAX_QUADS; q++)
     {
         if (activeQuads & (QUAD0_BIT_MASK >> q))
         {
-            if (G_globalPSTarget  > G_quadPSTarget[q])
+            if (G_pgpe_pstate_record.globalPSTarget  > G_pgpe_pstate_record.quadPSTarget[q])
             {
-                G_globalPSTarget  = G_quadPSTarget[q];
+                G_pgpe_pstate_record.globalPSTarget  = G_pgpe_pstate_record.quadPSTarget[q];
             }
         }
     }
 
-    PK_TRACE_INF("APCLP: glbPSTgt: 0x%x", G_globalPSTarget);
+    PK_TRACE_INF("APCLP: glbPSTgt: 0x%x", G_pgpe_pstate_record.globalPSTarget);
     PK_TRACE_INF("APCLP: Exit");
 }
 
@@ -284,7 +253,7 @@ void p9_pgpe_pstate_calc_wof()
 {
     //\TODO RTC 162896
     //Figure out how to calculate WOF Clip
-    G_wofClip = 150;
+    G_pgpe_pstate_record.wofClip = 150;
 
     p9_pgpe_pstate_apply_clips();
 }
@@ -301,20 +270,20 @@ void p9_pgpe_pstate_pm_complex_suspend()
 {
     PK_TRACE_INF("PS:PM Susp Enter");
 
-    if (G_pstatesStatus == PSTATE_ACTIVE)
+    if (G_pgpe_pstate_record.pstatesStatus == PSTATE_ACTIVE)
     {
-        G_pstatesStatus = PSTATE_PM_SUSPEND_PENDING;
+        G_pgpe_pstate_record.pstatesStatus = PSTATE_PM_SUSPEND_PENDING;
         p9_pgpe_pstate_apply_safe_clips();
     }
-    else if (G_pstatesStatus == PSTATE_STOPPED)
+    else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED)
     {
         //todo Set FIR[Bit] need to determine which one
         PK_TRACE_INF("PS:PM Susp in PSTATE_STOPPED(Halting)");
         pk_halt();
     }
-    else if (G_pstatesStatus == PSTATE_INIT)
+    else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT)
     {
-        G_pstatesStatus = PSTATE_PM_SUSPEND_PENDING;
+        G_pgpe_pstate_record.pstatesStatus = PSTATE_PM_SUSPEND_PENDING;
         p9_pgpe_pstate_send_suspend_stop();
     }
 
@@ -358,7 +327,7 @@ void p9_pgpe_suspend_stop_callback(ipc_msg_t* msg, void* arg)
     PK_TRACE_INF("PS: Susp Stop Cb");
     uint32_t occScr2 = in32(OCB_OCCS2);
     occScr2 |= BIT32(PM_COMPLEX_SUSPENDED);
-    G_pstatesStatus = PSTATE_PM_SUSPENDED;
+    G_pgpe_pstate_record.pstatesStatus = PSTATE_PM_SUSPENDED;
     out32(OCB_OCCS2, occScr2);
 }
 
@@ -371,20 +340,20 @@ void p9_pgpe_pstate_safe_mode()
 {
     PK_TRACE_INF("PS:Safe Mode Enter");
 
-    if (G_pstatesStatus == PSTATE_ACTIVE)
+    if (G_pgpe_pstate_record.pstatesStatus == PSTATE_ACTIVE)
     {
-        G_pstatesStatus = PSTATE_SAFE_MODE;
+        G_pgpe_pstate_record.pstatesStatus = PSTATE_SAFE_MODE;
         p9_pgpe_pstate_apply_safe_clips();
     }
-    else if (G_pstatesStatus == PSTATE_STOPPED)
+    else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED)
     {
         //todo Set FIR[Bit] need to determine which one
         PK_TRACE_INF("PS:PM Susp in PSTATE_STOPPED(Halting)");
         pk_halt();
     }
-    else if (G_pstatesStatus == PSTATE_INIT)
+    else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT)
     {
-        G_pstatesStatus = PSTATE_SAFE_MODE;
+        G_pgpe_pstate_record.pstatesStatus = PSTATE_SAFE_MODE;
     }
 
     PK_TRACE_INF("PS:Safe Mode Exit");
@@ -401,8 +370,8 @@ void p9_pgpe_pstate_apply_safe_clips()
     //Set clips to safe pstate
     for (q = 0; q < MAX_QUADS; q++)
     {
-        G_psClipMax[q] = G_safe_pstate;
-        G_psClipMin[q] = G_safe_pstate;
+        G_pgpe_pstate_record.psClipMax[q] = G_pgpe_pstate_record.safePstate;
+        G_pgpe_pstate_record.psClipMin[q] = G_pgpe_pstate_record.safePstate;
     }
 
     //Update clips
@@ -416,13 +385,13 @@ void p9_pgpe_pstate_apply_safe_clips()
 //
 int32_t p9_pgpe_pstate_at_target()
 {
-    if( G_globalPSCurr != G_globalPSTarget ||
-        G_quadPSCurr[0] ^ G_quadPSTarget[0] ||
-        G_quadPSCurr[1] ^ G_quadPSTarget[1] ||
-        G_quadPSCurr[2] ^ G_quadPSTarget[2] ||
-        G_quadPSCurr[3] ^ G_quadPSTarget[3] ||
-        G_quadPSCurr[4] ^ G_quadPSTarget[4] ||
-        G_quadPSCurr[5] ^ G_quadPSTarget[5] )
+    if( G_pgpe_pstate_record.globalPSCurr != G_pgpe_pstate_record.globalPSTarget ||
+        G_pgpe_pstate_record.quadPSCurr[0] ^ G_pgpe_pstate_record.quadPSTarget[0] ||
+        G_pgpe_pstate_record.quadPSCurr[1] ^ G_pgpe_pstate_record.quadPSTarget[1] ||
+        G_pgpe_pstate_record.quadPSCurr[2] ^ G_pgpe_pstate_record.quadPSTarget[2] ||
+        G_pgpe_pstate_record.quadPSCurr[3] ^ G_pgpe_pstate_record.quadPSTarget[3] ||
+        G_pgpe_pstate_record.quadPSCurr[4] ^ G_pgpe_pstate_record.quadPSTarget[4] ||
+        G_pgpe_pstate_record.quadPSCurr[5] ^ G_pgpe_pstate_record.quadPSTarget[5] )
     {
         return 0;
     }
@@ -446,26 +415,35 @@ void p9_pgpe_pstate_do_step()
     pk_critical_section_exit(&ctx);
 
     //Do one actuate step
-    PK_TRACE_DBG("ACT_TH: PSTgt: 0x%x PSCurr: 0x%x", G_globalPSTarget, G_globalPSCurr);
+    PK_TRACE_DBG("ACT_TH: PSTgt: 0x%x PSCurr: 0x%x", G_pgpe_pstate_record.globalPSTarget,
+                 G_pgpe_pstate_record.globalPSCurr);
 
     PK_TRACE_DBG("ACT_TH: Step Entry");
-    PK_TRACE_DBG("ACT_TH: PSTgt: 0x%x PSCurr: 0x%x", G_globalPSTarget, G_globalPSCurr);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[0], G_quadPSCurr[0]);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[1], G_quadPSCurr[1]);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[2], G_quadPSCurr[2]);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[3], G_quadPSCurr[3]);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[4], G_quadPSCurr[4]);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[5], G_quadPSCurr[5]);
+    PK_TRACE_DBG("ACT_TH: PSTgt: 0x%x PSCurr: 0x%x", G_pgpe_pstate_record.globalPSTarget,
+                 G_pgpe_pstate_record.globalPSCurr);
+    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_pgpe_pstate_record.quadPSTarget[0],
+                 G_pgpe_pstate_record.quadPSCurr[0]);
+    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_pgpe_pstate_record.quadPSTarget[1],
+                 G_pgpe_pstate_record.quadPSCurr[1]);
+    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_pgpe_pstate_record.quadPSTarget[2],
+                 G_pgpe_pstate_record.quadPSCurr[2]);
+    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_pgpe_pstate_record.quadPSTarget[3],
+                 G_pgpe_pstate_record.quadPSCurr[3]);
+    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_pgpe_pstate_record.quadPSTarget[4],
+                 G_pgpe_pstate_record.quadPSCurr[4]);
+    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_pgpe_pstate_record.quadPSTarget[5],
+                 G_pgpe_pstate_record.quadPSCurr[5]);
     uint32_t q;
     ocb_qcsr_t qcsr;
     qcsr.value = in32(OCB_QCSR);
     uint32_t active_conf_cores = 0;
-    uint32_t targetEVid = p9_pgpe_gppb_intp_vdd_from_ps(G_globalPSTarget, VPD_PT_SET_BIASED_SYSP, VPD_SLOPES_BIASED);
+    uint32_t targetEVid = p9_pgpe_gppb_intp_vdd_from_ps(G_pgpe_pstate_record.globalPSTarget, VPD_PT_SET_BIASED_SYSP,
+                          VPD_SLOPES_BIASED);
 
     //Determine active and configured cores
     for (q = 0; q < MAX_QUADS; q++)
     {
-        if(G_reqActQuads->fields.requested_active_quads & (0x80 >> q))
+        if(G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads & (0x80 >> q))
         {
             if (qcsr.fields.ex_config & (0x800 >> (q << 1)))
             {
@@ -482,32 +460,32 @@ void p9_pgpe_pstate_do_step()
     }
 
     //Higher number PState
-    if (((int16_t)(G_globalPSTarget) - (int16_t)(G_globalPSCurr)) > 0)
+    if (((int16_t)(G_pgpe_pstate_record.globalPSTarget) - (int16_t)(G_pgpe_pstate_record.globalPSCurr)) > 0)
     {
-        if ((G_eVidCurr - targetEVid ) <= G_gppb->ext_vrm_step_size_mv)
+        if ((G_pgpe_pstate_record.eVidCurr - targetEVid ) <= G_gppb->ext_vrm_step_size_mv)
         {
-            G_eVidNext = targetEVid;
-            G_globalPSNext = G_globalPSTarget;
+            G_pgpe_pstate_record.eVidNext = targetEVid;
+            G_pgpe_pstate_record.globalPSNext = G_pgpe_pstate_record.globalPSTarget;
 
             for (q = 0; q < MAX_QUADS; q++)
             {
-                G_quadPSNext[q] = G_quadPSTarget[q];
+                G_pgpe_pstate_record.quadPSNext[q] = G_pgpe_pstate_record.quadPSTarget[q];
             }
         }
         else
         {
-            G_eVidNext = G_eVidCurr - G_gppb->ext_vrm_step_size_mv;
-            G_globalPSNext = p9_pgpe_gppb_intp_ps_from_ext_vdd(G_eVidNext);
+            G_pgpe_pstate_record.eVidNext = G_pgpe_pstate_record.eVidCurr - G_gppb->ext_vrm_step_size_mv;
+            G_pgpe_pstate_record.globalPSNext = p9_pgpe_gppb_intp_ps_from_ext_vdd(G_pgpe_pstate_record.eVidNext);
 
             for (q = 0; q < MAX_QUADS; q++)
             {
-                if (G_quadPSTarget[q] > G_globalPSNext)   //Keep localPS under GlobalPS
+                if (G_pgpe_pstate_record.quadPSTarget[q] > G_pgpe_pstate_record.globalPSNext)   //Keep localPS under GlobalPS
                 {
-                    G_quadPSNext[q] = G_globalPSNext;
+                    G_pgpe_pstate_record.quadPSNext[q] = G_pgpe_pstate_record.globalPSNext;
                 }
                 else
                 {
-                    G_quadPSNext[q] = G_quadPSTarget[q];
+                    G_pgpe_pstate_record.quadPSNext[q] = G_pgpe_pstate_record.quadPSTarget[q];
                 }
             }
         }
@@ -516,32 +494,32 @@ void p9_pgpe_pstate_do_step()
         p9_pgpe_pstate_updt_ext_volt(targetEVid);
     }
     //Lower number PState
-    else if (((int16_t)(G_globalPSTarget) - (int16_t)(G_globalPSCurr)) < 0)
+    else if (((int16_t)(G_pgpe_pstate_record.globalPSTarget) - (int16_t)(G_pgpe_pstate_record.globalPSCurr)) < 0)
     {
-        if ((targetEVid - G_eVidCurr) <= G_gppb->ext_vrm_step_size_mv)
+        if ((targetEVid - G_pgpe_pstate_record.eVidCurr) <= G_gppb->ext_vrm_step_size_mv)
         {
-            G_eVidNext = targetEVid;
-            G_globalPSNext = G_globalPSTarget;
+            G_pgpe_pstate_record.eVidNext = targetEVid;
+            G_pgpe_pstate_record.globalPSNext = G_pgpe_pstate_record.globalPSTarget;
 
             for (q = 0; q < MAX_QUADS; q++)
             {
-                G_quadPSNext[q] = G_quadPSTarget[q];
+                G_pgpe_pstate_record.quadPSNext[q] = G_pgpe_pstate_record.quadPSTarget[q];
             }
         }
         else
         {
-            G_eVidNext = G_eVidCurr + G_gppb->ext_vrm_step_size_mv;
-            G_globalPSNext = p9_pgpe_gppb_intp_ps_from_ext_vdd(G_eVidNext);
+            G_pgpe_pstate_record.eVidNext = G_pgpe_pstate_record.eVidCurr + G_gppb->ext_vrm_step_size_mv;
+            G_pgpe_pstate_record.globalPSNext = p9_pgpe_gppb_intp_ps_from_ext_vdd(G_pgpe_pstate_record.eVidNext);
 
             for (q = 0; q < MAX_QUADS; q++)
             {
-                if (G_quadPSTarget[q] < G_globalPSNext)   //Keep localPS under GlobalPS
+                if (G_pgpe_pstate_record.quadPSTarget[q] < G_pgpe_pstate_record.globalPSNext)   //Keep localPS under GlobalPS
                 {
-                    G_quadPSNext[q] = G_globalPSNext;
+                    G_pgpe_pstate_record.quadPSNext[q] = G_pgpe_pstate_record.globalPSNext;
                 }
                 else
                 {
-                    G_quadPSNext[q] = G_quadPSTarget[q];
+                    G_pgpe_pstate_record.quadPSNext[q] = G_pgpe_pstate_record.quadPSTarget[q];
                 }
             }
         }
@@ -553,38 +531,38 @@ void p9_pgpe_pstate_do_step()
     {
         for (q = 0; q < MAX_QUADS; q++)
         {
-            G_quadPSNext[q] = G_quadPSTarget[q];
+            G_pgpe_pstate_record.quadPSNext[q] = G_pgpe_pstate_record.quadPSTarget[q];
         }
 
         p9_pgpe_pstate_freq_updt(active_conf_cores);
     }
 
     //Update current
-    G_globalPSCurr = G_globalPSNext;
+    G_pgpe_pstate_record.globalPSCurr = G_pgpe_pstate_record.globalPSNext;
 
     for (q = 0; q < MAX_QUADS; q++)
     {
-        if(G_reqActQuads->fields.requested_active_quads & (0x80 >> q) &&
+        if(G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads & (0x80 >> q) &&
            (qcsr.fields.ex_config & (0xC00 >> 2 * q)))
         {
-            G_quadPSCurr[q] = G_quadPSNext[q];
+            G_pgpe_pstate_record.quadPSCurr[q] = G_pgpe_pstate_record.quadPSNext[q];
         }
     }
 
     //Update Shared SRAM
-    G_quadState0->fields.quad0_pstate = G_quadPSCurr[0];
-    G_quadState0->fields.quad1_pstate = G_quadPSCurr[1];
-    G_quadState0->fields.quad2_pstate = G_quadPSCurr[2];
-    G_quadState0->fields.quad3_pstate = G_quadPSCurr[3];
-    G_quadState1->fields.quad4_pstate = G_quadPSCurr[4];
-    G_quadState1->fields.quad5_pstate = G_quadPSCurr[5];
-
-    PK_TRACE_DBG("ACT_TH: PSTgt: 0x%x PSCurr: 0x%x", G_globalPSTarget, G_globalPSCurr);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[0], G_quadPSCurr[0]);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[1], G_quadPSCurr[1]);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[2], G_quadPSCurr[2]);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[3], G_quadPSCurr[3]);
-    PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", G_quadPSTarget[4], G_quadPSCurr[4]);
+    G_pgpe_pstate_record.pQuadState0->fields.quad0_pstate = G_pgpe_pstate_record.quadPSCurr[0];
+    G_pgpe_pstate_record.pQuadState0->fields.quad1_pstate = G_pgpe_pstate_record.quadPSCurr[1];
+    G_pgpe_pstate_record.pQuadState0->fields.quad2_pstate = G_pgpe_pstate_record.quadPSCurr[2];
+    G_pgpe_pstate_record.pQuadState0->fields.quad3_pstate = G_pgpe_pstate_record.quadPSCurr[3];
+    G_pgpe_pstate_record.pQuadState1->fields.quad4_pstate = G_pgpe_pstate_record.quadPSCurr[4];
+    G_pgpe_pstate_record.pQuadState1->fields.quad5_pstate = G_pgpe_pstate_record.quadPSCurr[5];
+
+    /*    PK_TRACE_DBG("ACT_TH: PSTgt: 0x%x PSCurr: 0x%x", globalPSTarget, globalPSCurr);
+        PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", quadPSTarget[0], quadPSCurr[0]);
+        PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", quadPSTarget[1], quadPSCurr[1]);
+        PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", quadPSTarget[2], quadPSCurr[2]);
+        PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", quadPSTarget[3], quadPSCurr[3]);
+        PK_TRACE_DBG("ACT_TH: QTgt: 0x%x QCurr: 0x%x", quadPSTarget[4], quadPSCurr[4]);*/
     PK_TRACE_DBG("ACT_TH: Step Exit");
 
 
@@ -603,22 +581,22 @@ void p9_pgpe_pstate_updt_ext_volt(uint32_t tgtEVid)
     uint32_t delay_us = 0;
 
     //Decreasing
-    if (G_eVidNext < G_eVidCurr)
+    if (G_pgpe_pstate_record.eVidNext < G_pgpe_pstate_record.eVidCurr)
     {
-        delay_us = (G_eVidCurr - G_eVidNext) *
+        delay_us = (G_pgpe_pstate_record.eVidCurr - G_pgpe_pstate_record.eVidNext) *
                    G_ext_vrm_dec_rate_mult_usperus;
     }
     //Increasing
-    else if(G_eVidNext > G_eVidCurr)
+    else if(G_pgpe_pstate_record.eVidNext > G_pgpe_pstate_record.eVidCurr)
     {
-        delay_us  = (G_eVidNext - G_eVidCurr) *
+        delay_us  = (G_pgpe_pstate_record.eVidNext - G_pgpe_pstate_record.eVidCurr) *
                     G_ext_vrm_inc_rate_mult_usperus;
     }
 
 #endif
 
     //Update external voltage
-    external_voltage_control_write(G_eVidNext);
+    external_voltage_control_write(G_pgpe_pstate_record.eVidNext);
 
 #if !EPM_P9_TUNING
 
@@ -628,14 +606,14 @@ void p9_pgpe_pstate_updt_ext_volt(uint32_t tgtEVid)
         pk_sleep(PK_MICROSECONDS((delay_us)));
     }
 
-    if(G_eVidNext == tgtEVid)
+    if(G_pgpe_pstate_record.eVidNext == tgtEVid)
     {
         pk_sleep(PK_MICROSECONDS((G_gppb->ext_vrm_stabilization_time_us)));
     }
 
 #endif
 
-    G_eVidCurr = G_eVidNext;
+    G_pgpe_pstate_record.eVidCurr = G_pgpe_pstate_record.eVidNext;
 }
 
 //
@@ -649,13 +627,13 @@ inline void p9_pgpe_pstate_freq_updt(uint32_t activeCores)
     pgpe_db0_glb_bcast_t db0;
     db0.value = 0;
     db0.fields.msg_id = MSGID_DB0_GLOBAL_ACTUAL_BROADCAST;
-    db0.fields.global_actual = G_globalPSNext;
-    db0.fields.quad0_ps = G_quadPSNext[0];
-    db0.fields.quad1_ps = G_quadPSNext[1];
-    db0.fields.quad2_ps = G_quadPSNext[2];
-    db0.fields.quad3_ps = G_quadPSNext[3];
-    db0.fields.quad4_ps = G_quadPSNext[4];
-    db0.fields.quad5_ps = G_quadPSNext[5];
+    db0.fields.global_actual = G_pgpe_pstate_record.globalPSNext;
+    db0.fields.quad0_ps = G_pgpe_pstate_record.quadPSNext[0];
+    db0.fields.quad1_ps = G_pgpe_pstate_record.quadPSNext[1];
+    db0.fields.quad2_ps = G_pgpe_pstate_record.quadPSNext[2];
+    db0.fields.quad3_ps = G_pgpe_pstate_record.quadPSNext[3];
+    db0.fields.quad4_ps = G_pgpe_pstate_record.quadPSNext[4];
+    db0.fields.quad5_ps = G_pgpe_pstate_record.quadPSNext[5];
     p9_dd1_db_multicast_wr(PCB_MUTLICAST_GRP1 | CPPM_CMEDB0, db0.value, activeCores);
     PK_TRACE_INF("ACT_TH: MCAST DB0");
     p9_pgpe_wait_cme_db_ack(MSGID_DB0_GLOBAL_ACTUAL_BROADCAST, activeCores);//Wait for ACKs from all CMEs
@@ -737,7 +715,7 @@ void p9_pgpe_pstate_set_pmcr_owner(uint32_t owner)
 
     for (q = 0; q < MAX_QUADS; q++)
     {
-        if(G_reqActQuads->fields.requested_active_quads & (0x80 >> q))
+        if(G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads & (0x80 >> q))
         {
             //CME0 within this quad
             if (qcsr.fields.ex_config & (0x800 >> 2 * q))
diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.h b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.h
index 29790422..84498803 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.h
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.h
@@ -28,6 +28,10 @@
 #include "pk.h"
 #include "ipc_api.h"
 #include "ipc_async_cmd.h"
+#include "pstate_pgpe_occ_api.h"
+#include "ipc_messages.h"
+#include "p9_pgpe_header.h"
+
 
 #define MAX_IPC_PEND_TBL_ENTRIES                9
 #define IPC_PEND_PSTATE_START                   0
@@ -40,7 +44,6 @@
 #define IPC_PEND_SET_PMCR_REQ                   7
 #define IPC_PEND_SGPE_SUSPEND_PSTATES           8
 
-
 #define ALL_QUADS_BIT_MASK      QUAD0_BIT_MASK | QUAD1_BIT_MASK | \
     QUAD2_BIT_MASK | QUAD3_BIT_MASK | \
     QUAD4_BIT_MASK | QUAD5_BIT_MASK
@@ -51,6 +54,7 @@
 #define QUAD4_BIT_MASK          0x8
 #define QUAD5_BIT_MASK          0x4
 
+
 enum PSTATE_STATUS
 {
     PSTATE_INIT                                 =    0,
@@ -63,16 +67,52 @@ enum PSTATE_STATUS
     PSTATE_SAFE_MODE                            =    7
 };
 
-//
 //Task list entry
-//
 typedef struct ipc_req
 {
     ipc_msg_t* cmd;
     uint8_t pending_ack;
     uint8_t pending_processing;
+    uint8_t pad[2];
 } ipc_req_t;
 
+/// PGPE PState
+typedef struct
+{
+    uint8_t pstatesStatus;
+    uint8_t safePstate;
+    uint8_t pmcrOwner;
+    uint8_t wofEnabled;                   //wof enable/disable
+    uint8_t wofPending;                   //wof enable pending
+    uint8_t wofClip;                      //wof clip
+    uint8_t psClipMax[MAX_QUADS],         //higher numbered(min freq and volt)
+            psClipMin[MAX_QUADS];         //lower numbered(max freq and volt)
+    uint8_t coresPSRequest[MAX_CORES];    //per core requested pstate
+    uint8_t quadPSComputed[MAX_QUADS];    //computed Pstate per quad
+    uint8_t globalPSComputed;             //computed global Pstate
+    uint8_t pad0;
+    uint8_t quadPSTarget[MAX_QUADS];      //target Pstate per quad
+    uint8_t globalPSTarget;               //target global Pstate
+    uint8_t pad1;
+    uint8_t quadPSCurr[MAX_QUADS];      //target Pstate per quad
+    uint8_t globalPSCurr;               //target global Pstate
+    uint8_t pad2;
+    uint8_t quadPSNext[MAX_QUADS];      //target Pstate per quad
+    uint8_t globalPSNext;
+    uint8_t pad3;
+    uint16_t alreadySemPosted;
+    uint32_t eVidCurr, eVidNext;
+    ipc_req_t ipcPendTbl[MAX_IPC_PEND_TBL_ENTRIES];
+    VFRT_Hcode_t* pVFRT;
+    quad_state0_t* pQuadState0;
+    quad_state1_t* pQuadState1;
+    requested_active_quads_t* pReqActQuads;
+    PkSemaphore sem_process_req;
+    PkSemaphore sem_actuate;
+    PkSemaphore sem_sgpe_wait;
+} PgpePstateRecord;
+
+
 //
 //Functions called by threads
 //
diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_thread_actuate_pstates.c b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_thread_actuate_pstates.c
index 05a80187..d559022c 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_thread_actuate_pstates.c
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_thread_actuate_pstates.c
@@ -43,26 +43,9 @@ void p9_pgpe_thread_actuate_init_actual_quad();
 //External Global Data
 //
 extern PgpePstateRecord G_pgpe_pstate_record;
-extern uint32_t G_pstatesStatus;
-extern uint8_t G_wofEnabled;                   //wof enable/disable
-extern uint8_t G_quadPSTarget[MAX_QUADS];      //target Pstate per quad
-extern volatile uint8_t G_globalPSTarget;               //target global Pstate
-extern uint8_t G_quadPSCurr[MAX_QUADS];      //target Pstate per quad
-extern volatile uint8_t G_globalPSCurr;               //target global Pstate
-extern uint8_t G_quadPSNext[MAX_QUADS];      //target Pstate per quad
-extern uint8_t G_globalPSNext;
-extern uint32_t G_eVidCurr, G_eVidNext;
-extern GlobalPstateParmBlock* G_gppb;
-extern uint8_t G_psClipMax[MAX_QUADS],
-       G_psClipMin[MAX_QUADS];         //pmin and pmax clips
-extern uint8_t G_pmcrOwner;
-extern ipc_req_t G_ipc_pend_tbl[MAX_IPC_PEND_TBL_ENTRIES];
-extern uint8_t G_pstate0_dpll_value;
-extern quad_state0_t* G_quadState0;
-extern quad_state1_t* G_quadState1;
-extern requested_active_quads_t* G_reqActQuads;
 extern ipc_async_cmd_t G_ipc_msg_pgpe_sgpe;
 GPE_BUFFER(extern ipcmsg_p2s_ctrl_stop_updates_t G_sgpe_control_updt);
+extern uint32_t G_pstate0_dpll_value;
 
 //Payload data non-cacheable region for IPCs sent to SGPE
 //
@@ -102,13 +85,13 @@ void p9_pgpe_thread_actuate_pstates(void* arg)
         p9_pgpe_thread_actuate_start();
 
         //Loop while Pstate is enabled
-        PK_TRACE_DBG("ACT_TH: Status=%d", G_pstatesStatus);
+        PK_TRACE_DBG("ACT_TH: Status=%d", G_pgpe_pstate_record.pstatesStatus);
 
         restore_irq = 0;
 
-        while(G_pstatesStatus == PSTATE_ACTIVE || G_pstatesStatus == PSTATE_SUSPENDED)
+        while(G_pgpe_pstate_record.pstatesStatus == PSTATE_ACTIVE || G_pgpe_pstate_record.pstatesStatus == PSTATE_SUSPENDED)
         {
-            if(G_pstatesStatus != PSTATE_SUSPENDED)
+            if(G_pgpe_pstate_record.pstatesStatus != PSTATE_SUSPENDED)
             {
                 //Actuate step(if needed)
                 if(p9_pgpe_pstate_at_target() == 0)
@@ -117,19 +100,19 @@ void p9_pgpe_thread_actuate_pstates(void* arg)
                 }
 
                 //Check if CLIP_UPDT is pending and Pstates are clipped
-                if (G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].pending_ack == 1)
+                if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].pending_ack == 1)
                 {
                     inRange = 1;
 
                     for (q = 0; q < MAX_QUADS; q++)
                     {
-                        if((G_reqActQuads->fields.requested_active_quads & (0x80 >> q)) &&
+                        if((G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads & (0x80 >> q)) &&
                            (qcsr.fields.ex_config & (0xC00 >> (2 * q))))
                         {
-                            if (G_quadPSCurr[q] > G_psClipMax[q] ||
-                                G_quadPSCurr[q] <  G_psClipMin[q])
+                            if (G_pgpe_pstate_record.quadPSCurr[q] > G_pgpe_pstate_record.psClipMax[q] ||
+                                G_pgpe_pstate_record.quadPSCurr[q] <  G_pgpe_pstate_record.psClipMin[q])
                             {
-                                PK_TRACE_DBG("ACT_TH:!Clipped[%d) qPSCur: 0x%x", q, G_quadPSCurr[q]);
+                                PK_TRACE_DBG("ACT_TH:!Clipped[%d) qPSCur: 0x%x", q, G_pgpe_pstate_record.quadPSCurr[q]);
                                 inRange = 0;
                             }
                         }
@@ -138,11 +121,11 @@ void p9_pgpe_thread_actuate_pstates(void* arg)
                     //ACK any pending and unmask IPC interrupt
                     if (inRange == 1)
                     {
-                        ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].cmd;
+                        ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].cmd;
                         ipcmsg_clip_update_t* args = (ipcmsg_clip_update_t*)async_cmd->cmd_data;
                         args->msg_cb.rc = PGPE_RC_SUCCESS;
-                        G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].pending_ack = 0;
-                        ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].cmd, IPC_RC_SUCCESS);
+                        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].pending_ack = 0;
+                        ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].cmd, IPC_RC_SUCCESS);
                         restore_irq = 1;
                     }
                 }
@@ -158,14 +141,15 @@ void p9_pgpe_thread_actuate_pstates(void* arg)
             }
         } //while loop
 
-        if (G_pstatesStatus == PSTATE_STOPPED)
+        if (G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED)
         {
             //Pstates Stop
             //If we entered SAFE_MODE already, then do STOP protocol
             //This call will unmask IPC and block on SGPE ACK
             p9_pgpe_thread_actuate_stop();
         }
-        else if (G_pstatesStatus == PSTATE_PM_SUSPEND_PENDING || G_pstatesStatus == PSTATE_SAFE_MODE)
+        else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPEND_PENDING
+                 || G_pgpe_pstate_record.pstatesStatus == PSTATE_SAFE_MODE)
         {
             //Actuate to PSAFE Pstate
             while (p9_pgpe_pstate_at_target() == 0)
@@ -173,11 +157,11 @@ void p9_pgpe_thread_actuate_pstates(void* arg)
                 p9_pgpe_pstate_do_step();
             }
 
-            if (G_pstatesStatus == PSTATE_PM_SUSPEND_PENDING)
+            if (G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPEND_PENDING)
             {
                 p9_pgpe_pstate_send_suspend_stop(); //Notify SGPE}
             }
-            else if (G_pstatesStatus == PSTATE_SAFE_MODE)
+            else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_SAFE_MODE)
             {
                 uint32_t occScr2 = in32(OCB_OCCS2);
                 occScr2 |= BIT32(PGPE_SAFE_MODE_ACTIVE);
@@ -204,7 +188,7 @@ void p9_pgpe_thread_actuate_start()
     uint32_t active_conf_cores = 0;
     uint32_t q;
 
-    G_pstatesStatus = PSTATE_START_PENDING;
+    G_pgpe_pstate_record.pstatesStatus = PSTATE_START_PENDING;
 
     //1. Send 'Control Stop Updates' IPC to SGPE
 #if SGPE_IPC_ENABLED == 1
@@ -237,12 +221,13 @@ void p9_pgpe_thread_actuate_start()
     {
         //Update Shared Memory Region
         PK_TRACE_DBG("ACT_TH: ctrl_updt=0x%08x%08x", G_sgpe_control_updt.value >> 32, G_sgpe_control_updt.value);
-        G_quadState0->fields.active_cores = (ccsr.value >> 16);
-        G_quadState1->fields.active_cores = ccsr.value & 0xFF00 ;
-        G_reqActQuads->fields.requested_active_quads = G_sgpe_control_updt.fields.active_quads << 2;
-        PK_TRACE_DBG("ACT_TH: core_pwr_st0=0x%x", (uint32_t)G_quadState0->fields.active_cores);
-        PK_TRACE_DBG("ACT_TH: core_pwr_st1=0x%x", (uint32_t)G_quadState1->fields.active_cores);
-        PK_TRACE_DBG("ACT_TH: req_active_quad=0x%x", (uint32_t)G_reqActQuads->fields.requested_active_quads);
+        G_pgpe_pstate_record.pQuadState0->fields.active_cores = (ccsr.value >> 16);
+        G_pgpe_pstate_record.pQuadState1->fields.active_cores = ccsr.value & 0xFF00 ;
+        G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads = G_sgpe_control_updt.fields.active_quads << 2;
+        PK_TRACE_DBG("ACT_TH: core_pwr_st0=0x%x", (uint32_t)G_pgpe_pstate_record.pQuadState0->fields.active_cores);
+        PK_TRACE_DBG("ACT_TH: core_pwr_st1=0x%x", (uint32_t)G_pgpe_pstate_record.pQuadState1->fields.active_cores);
+        PK_TRACE_DBG("ACT_TH: req_active_quad=0x%x",
+                     (uint32_t)G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads);
     }
     else
     {
@@ -251,15 +236,15 @@ void p9_pgpe_thread_actuate_start()
     }
 
 #else
-    G_quadState0->fields.active_cores = (ccsr.value >> 16);
-    G_quadState1->fields.active_cores = (ccsr.value & 0xFF00);
+    G_pgpe_pstate_record.pQuadState0->fields.active_cores = (ccsr.value >> 16);
+    G_pgpe_pstate_record.pQuadState1->fields.active_cores = (ccsr.value & 0xFF00);
 
     for (q = 0; q < MAX_QUADS; q++ )
     {
         if ((qcsr.fields.ex_config & (0x800 >> (2 * q))) ||
             (qcsr.fields.ex_config & (0x400 >> (2 * q))))
         {
-            G_reqActQuads->fields.requested_active_quads |= (0x80 >> q) ;
+            G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads |= (0x80 >> q) ;
         }
     }
 
@@ -274,7 +259,7 @@ void p9_pgpe_thread_actuate_start()
 
     for (q = 0; q < MAX_QUADS; q++)
     {
-        if((G_reqActQuads->fields.requested_active_quads & (0x80 >> q)) &&
+        if((G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads & (0x80 >> q)) &&
            (qcsr.fields.ex_config & (0xC00 >> 2 * q)))
         {
 #if SIMICS_TUNING == 0
@@ -327,33 +312,33 @@ void p9_pgpe_thread_actuate_start()
     p9_pgpe_pstate_update(quadPstates);
     PK_TRACE_INF("ACT_TH: Sync Pstate=0x%x", syncPstate);
     PK_TRACE_INF("ACT_TH: LowDPLL:0x%x", lowestDpll);
-    PK_TRACE_INF("ACT_TH: GlblPsTgt:0x%x", G_globalPSTarget);
+    PK_TRACE_INF("ACT_TH: GlblPsTgt:0x%x", G_pgpe_pstate_record.globalPSTarget);
 
     //4. Determine PMCR Owner
     //We save it off so that CMEs that are currently in STOP11
     //can be told upon STOP11 Exit
     PK_TRACE_DBG("ACT_TH: g_oimr_override:0x%llx", g_oimr_override);
-    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_PSTATE_START].cmd;
+    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].cmd;
     ipcmsg_start_stop_t* args = (ipcmsg_start_stop_t*)async_cmd->cmd_data;
 
     if (args->pmcr_owner == PMCR_OWNER_HOST)
     {
         PK_TRACE_DBG("ACT_TH: OWNER_HOST");
-        G_pmcrOwner = PMCR_OWNER_HOST;
+        G_pgpe_pstate_record.pmcrOwner = PMCR_OWNER_HOST;
         g_oimr_override &= ~(BIT64(46));
         out32(OCB_OIMR1_CLR, BIT32(14)); //Enable PCB_INTR_TYPE1
     }
     else if (args->pmcr_owner == PMCR_OWNER_OCC)
     {
         PK_TRACE_DBG("ACT_TH: OWNER_OCC");
-        G_pmcrOwner = PMCR_OWNER_OCC;
+        G_pgpe_pstate_record.pmcrOwner = PMCR_OWNER_OCC;
         g_oimr_override |= BIT64(46);
         out32(OCB_OIMR1_OR, BIT32(14)); //Disable PCB_INTR_TYPE1
     }
     else if (args->pmcr_owner == PMCR_OWNER_CHAR)
     {
         PK_TRACE_DBG("ACT_TH: OWNER_CHAR");
-        G_pmcrOwner = PMCR_OWNER_CHAR;
+        G_pgpe_pstate_record.pmcrOwner = PMCR_OWNER_CHAR;
         g_oimr_override &= ~(BIT64(46));
         out32(OCB_OIMR1_CLR, BIT32(14)); //Enable PCB_INTR_TYPE1
     }
@@ -363,117 +348,85 @@ void p9_pgpe_thread_actuate_start()
     }
 
     //Set LMCR for each CME
-    if (G_pmcrOwner == PMCR_OWNER_HOST)
+    if (G_pgpe_pstate_record.pmcrOwner == PMCR_OWNER_HOST)
     {
         p9_pgpe_pstate_set_pmcr_owner(PMCR_OWNER_HOST);
     }
-    else if (G_pmcrOwner == PMCR_OWNER_OCC)
+    else if (G_pgpe_pstate_record.pmcrOwner == PMCR_OWNER_OCC)
     {
         p9_pgpe_pstate_set_pmcr_owner(PMCR_OWNER_OCC);
     }
 
-    /*
-        for (q = 0; q < MAX_QUADS; q++)
-        {
-            if(G_reqActQuads->fields.requested_active_quads & (0x80 >> q))
-            {
-                //CME0 within this quad
-                if (qcsr.fields.ex_config & (0x800 >> 2 * q))
-                {
-                    if (G_pmcrOwner == PMCR_OWNER_HOST)
-                    {
-                        GPE_PUTSCOM(GPE_SCOM_ADDR_CME(CME_SCOM_LMCR_CLR, q, 0), BIT64(0));
-                    }
-                    else if (G_pmcrOwner == PMCR_OWNER_OCC)
-                    {
-                        GPE_PUTSCOM(GPE_SCOM_ADDR_CME(CME_SCOM_LMCR_OR, q, 0), BIT64(0));
-                    }
-                }
-
-                //CME1 within this quad
-                if (qcsr.fields.ex_config & (0x400 >> 2 * q))
-                {
-                    if (G_pmcrOwner == PMCR_OWNER_HOST)
-                    {
-                        GPE_PUTSCOM(GPE_SCOM_ADDR_CME(CME_SCOM_LMCR_CLR, q, 1), BIT64(0));
-                    }
-                    else if (G_pmcrOwner == PMCR_OWNER_OCC)
-                    {
-                        GPE_PUTSCOM(GPE_SCOM_ADDR_CME(CME_SCOM_LMCR_OR, q, 1), BIT64(0));
-                    }
-                }
-            }
-        }
-    */
-
     //4. Set External VRM and Send DB0 to every active CME
     //\TODO: Need Greg's Response
     //Why does spec says to read external VDD. Is there
     //any other reason besides PGPE storing it
-    external_voltage_control_init(&G_eVidCurr);
-    PK_TRACE_INF("ACT_TH: eVidCurr=%umV", G_eVidCurr);
+    external_voltage_control_init(&G_pgpe_pstate_record.eVidCurr);
+    PK_TRACE_INF("ACT_TH: eVidCurr=%umV", G_pgpe_pstate_record.eVidCurr);
 #if SIMICS_TUNING == 1
-    G_eVidCurr = p9_pgpe_gppb_intp_vdd_from_ps(G_globalPSTarget, VPD_PT_SET_BIASED_SYSP, VPD_SLOPES_BIASED);
+    G_pgpe_pstate_record.eVidCurr = p9_pgpe_gppb_intp_vdd_from_ps(G_pgpe_pstate_record.globalPSTarget,
+                                    VPD_PT_SET_BIASED_SYSP, VPD_SLOPES_BIASED);
 #endif
-    G_eVidNext = p9_pgpe_gppb_intp_vdd_from_ps(G_globalPSTarget, VPD_PT_SET_BIASED_SYSP, VPD_SLOPES_BIASED);
-    PK_TRACE_INF("ACT_TH: eVidNext=%umV", G_eVidNext);
+    G_pgpe_pstate_record.eVidNext = p9_pgpe_gppb_intp_vdd_from_ps(G_pgpe_pstate_record.globalPSTarget,
+                                    VPD_PT_SET_BIASED_SYSP, VPD_SLOPES_BIASED);
+    PK_TRACE_INF("ACT_TH: eVidNext=%umV", G_pgpe_pstate_record.eVidNext);
 
     pgpe_db0_start_ps_bcast_t db0;
     db0.value = 0;
     db0.fields.msg_id = MSGID_DB0_START_PSTATE_BROADCAST;
-    db0.fields.global_actual = G_globalPSTarget;
-    db0.fields.quad0_ps = G_quadPSTarget[0];
-    db0.fields.quad1_ps = G_quadPSTarget[1];
-    db0.fields.quad2_ps = G_quadPSTarget[2];
-    db0.fields.quad3_ps = G_quadPSTarget[3];
-    db0.fields.quad4_ps = G_quadPSTarget[4];
-    db0.fields.quad5_ps = G_quadPSTarget[5];
-
-    if (G_eVidCurr > G_eVidNext)
+    db0.fields.global_actual = G_pgpe_pstate_record.globalPSTarget;
+    db0.fields.quad0_ps = G_pgpe_pstate_record.quadPSTarget[0];
+    db0.fields.quad1_ps = G_pgpe_pstate_record.quadPSTarget[1];
+    db0.fields.quad2_ps = G_pgpe_pstate_record.quadPSTarget[2];
+    db0.fields.quad3_ps = G_pgpe_pstate_record.quadPSTarget[3];
+    db0.fields.quad4_ps = G_pgpe_pstate_record.quadPSTarget[4];
+    db0.fields.quad5_ps = G_pgpe_pstate_record.quadPSTarget[5];
+
+    if (G_pgpe_pstate_record.eVidCurr > G_pgpe_pstate_record.eVidNext)
     {
         p9_dd1_db_multicast_wr(PCB_MUTLICAST_GRP1 | CPPM_CMEDB0, db0.value, active_conf_cores);
         PK_TRACE_DBG("ACT_TH: Send DB0");
         p9_pgpe_wait_cme_db_ack(MSGID_DB0_START_PSTATE_BROADCAST, active_conf_cores);//Wait for ACKs from all QuadManagers
         PK_TRACE_DBG("ACT_TH: DB0 ACK");
-        p9_pgpe_pstate_updt_ext_volt(G_eVidNext);
+        p9_pgpe_pstate_updt_ext_volt(G_pgpe_pstate_record.eVidNext);
     }
     else
     {
-        p9_pgpe_pstate_updt_ext_volt(G_eVidNext);
+        p9_pgpe_pstate_updt_ext_volt(G_pgpe_pstate_record.eVidNext);
         p9_dd1_db_multicast_wr(PCB_MUTLICAST_GRP1 | CPPM_CMEDB0, db0.value, active_conf_cores);
         PK_TRACE_DBG("ACT_TH: Send DB0");
         p9_pgpe_wait_cme_db_ack(MSGID_DB0_START_PSTATE_BROADCAST, active_conf_cores);//Wait for ACKs from all QuadManagers
         PK_TRACE_DBG("ACT_TH: DB0 ACK");
     }
 
-    G_globalPSCurr = G_globalPSTarget;
-    PK_TRACE_INF("ACT_TH: GlbPSCurr:0x%x", G_globalPSCurr );
+    G_pgpe_pstate_record.globalPSCurr = G_pgpe_pstate_record.globalPSTarget;
+    PK_TRACE_INF("ACT_TH: GlbPSCurr:0x%x", G_pgpe_pstate_record.globalPSCurr );
 
     for (q = 0; q < MAX_QUADS; q++)
     {
-        G_quadPSCurr[q] = G_quadPSTarget[q];
+        G_pgpe_pstate_record.quadPSCurr[q] = G_pgpe_pstate_record.quadPSTarget[q];
     }
 
     //Update Shared SRAM
-    G_quadState0->fields.quad0_pstate = G_quadPSCurr[0];
-    G_quadState0->fields.quad1_pstate = G_quadPSCurr[1];
-    G_quadState0->fields.quad2_pstate = G_quadPSCurr[2];
-    G_quadState0->fields.quad3_pstate = G_quadPSCurr[3];
-    G_quadState1->fields.quad4_pstate = G_quadPSCurr[4];
-    G_quadState1->fields.quad5_pstate = G_quadPSCurr[5];
+    G_pgpe_pstate_record.pQuadState0->fields.quad0_pstate = G_pgpe_pstate_record.quadPSCurr[0];
+    G_pgpe_pstate_record.pQuadState0->fields.quad1_pstate = G_pgpe_pstate_record.quadPSCurr[1];
+    G_pgpe_pstate_record.pQuadState0->fields.quad2_pstate = G_pgpe_pstate_record.quadPSCurr[2];
+    G_pgpe_pstate_record.pQuadState0->fields.quad3_pstate = G_pgpe_pstate_record.quadPSCurr[3];
+    G_pgpe_pstate_record.pQuadState1->fields.quad4_pstate = G_pgpe_pstate_record.quadPSCurr[4];
+    G_pgpe_pstate_record.pQuadState1->fields.quad5_pstate = G_pgpe_pstate_record.quadPSCurr[5];
 
 
     //7. Enable PStates
-    G_pstatesStatus = PSTATE_ACTIVE;
+    G_pgpe_pstate_record.pstatesStatus = PSTATE_ACTIVE;
     PK_TRACE_DBG("ACT_TH: PSTATE_ACTIVE");
 
     //8. Send Pstate Start ACK to OCC
     args->msg_cb.rc = PGPE_RC_SUCCESS;
-    G_ipc_pend_tbl[IPC_PEND_PSTATE_START].pending_ack = 0;
-    ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_PSTATE_START].cmd, IPC_RC_SUCCESS);
+    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].pending_ack = 0;
+    ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].cmd, IPC_RC_SUCCESS);
 
-    if ((G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing == 1) ||
-        (G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing == 1))
+    if ((G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing == 1) ||
+        (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing == 1))
     {
         PK_TRACE_DBG("ACT_TH: Post PROC_TH");
         pk_semaphore_post(&G_pgpe_pstate_record.sem_process_req);
@@ -493,8 +446,8 @@ void p9_pgpe_thread_actuate_start()
 void p9_pgpe_thread_actuate_stop()
 {
     PK_TRACE_DBG("ACT_TH: Stop Enter");
-    PK_TRACE_DBG("ACT_TH: GlbPSCurr:0x%x", G_globalPSCurr );
-    PK_TRACE_DBG("ACT_TH: GlblPsTgt:0x%x", G_globalPSTarget);
+    PK_TRACE_DBG("ACT_TH: GlbPSCurr:0x%x", G_pgpe_pstate_record.globalPSCurr );
+    PK_TRACE_DBG("ACT_TH: GlblPsTgt:0x%x", G_pgpe_pstate_record.globalPSTarget);
     uint32_t q;
     PkMachineContext  ctx;
     uint32_t active_conf_cores = 0;
@@ -504,7 +457,7 @@ void p9_pgpe_thread_actuate_stop()
     //Determine active and configured cores
     for (q = 0; q < MAX_QUADS; q++)
     {
-        if(G_reqActQuads->fields.requested_active_quads & (0x80 >> q))
+        if(G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads & (0x80 >> q))
         {
             if (qcsr.fields.ex_config & (0x800 >> 2 * q))
             {
@@ -560,14 +513,12 @@ void p9_pgpe_thread_actuate_stop()
 #endif// _SGPE_IPC_ENABLED_
 
     //Send STOP ACK to OCC
-    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_PSTATE_STOP].cmd;
+    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_STOP].cmd;
     ipcmsg_start_stop_t* args = (ipcmsg_start_stop_t*)async_cmd->cmd_data;
     args->msg_cb.rc = PGPE_RC_SUCCESS;
-    G_ipc_pend_tbl[IPC_PEND_PSTATE_STOP].pending_ack = 0;
-    ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_PSTATE_STOP].cmd, IPC_RC_SUCCESS);
+    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_STOP].pending_ack = 0;
+    ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_STOP].cmd, IPC_RC_SUCCESS);
 
-    // PK_TRACE_DBG("ACT_TH: GlbPSCurr:0x%x", G_globalPSCurr );
-    // PK_TRACE_DBG("ACT_TH: GlblPsTgt:0x%x", G_globalPSTarget);
     pk_irq_vec_restore(&ctx);
     PK_TRACE_DBG("ACT_TH: Stop Exit");
 }
@@ -581,14 +532,14 @@ void p9_pgpe_thread_actuate_stop()
 
 void p9_pgpe_thread_actuate_init_actual_quad()
 {
-    G_quadState0->fields.quad0_pstate = 0xff;
-    G_quadState0->fields.quad1_pstate = 0xff;
-    G_quadState0->fields.quad2_pstate = 0xff;
-    G_quadState0->fields.quad3_pstate = 0xff;
-    G_quadState0->fields.active_cores = 0;
-
-    G_quadState1->fields.quad4_pstate = 0xff;
-    G_quadState1->fields.quad5_pstate = 0xff;
-    G_quadState1->fields.active_cores = 0x0;
-    G_reqActQuads->fields.requested_active_quads = 0x0;
+    G_pgpe_pstate_record.pQuadState0->fields.quad0_pstate = 0xff;
+    G_pgpe_pstate_record.pQuadState0->fields.quad1_pstate = 0xff;
+    G_pgpe_pstate_record.pQuadState0->fields.quad2_pstate = 0xff;
+    G_pgpe_pstate_record.pQuadState0->fields.quad3_pstate = 0xff;
+    G_pgpe_pstate_record.pQuadState0->fields.active_cores = 0;
+
+    G_pgpe_pstate_record.pQuadState1->fields.quad4_pstate = 0xff;
+    G_pgpe_pstate_record.pQuadState1->fields.quad5_pstate = 0xff;
+    G_pgpe_pstate_record.pQuadState1->fields.active_cores = 0x0;
+    G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads = 0x0;
 }
diff --git a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_thread_process_requests.c b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_thread_process_requests.c
index 2dabab12..f1f44155 100644
--- a/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_thread_process_requests.c
+++ b/import/chips/p9/procedures/ppe_closed/pgpe/pstate_gpe/p9_pgpe_thread_process_requests.c
@@ -36,21 +36,8 @@
 //
 extern PgpePstateRecord G_pgpe_pstate_record;
 extern PgpeHeader_t* G_pgpe_header_data;
-extern uint32_t G_pstatesStatus;               //pstates_enabled/disable
-extern uint8_t G_wofEnabled;               //pstates_enabled/disable
-extern uint8_t G_wofPending;                   //wof enable pending
-extern VFRT_Hcode_t* G_vfrt_ptr;
-extern ipc_req_t G_ipc_pend_tbl[MAX_IPC_PEND_TBL_ENTRIES];
-extern uint8_t G_psClipMax[MAX_QUADS],
-       G_psClipMin[MAX_QUADS];         //pmin and pmax clips
-extern uint8_t G_coresPSRequest[MAX_CORES];    //per core requested pstate
-extern uint32_t G_already_sem_posted;
-extern quad_state0_t* G_quadState0;
-extern quad_state1_t* G_quadState1;
-extern requested_active_quads_t* G_reqActQuads;
-extern ipc_async_cmd_t G_ipc_msg_pgpe_sgpe;
-extern uint8_t G_pmcrOwner;
 GPE_BUFFER(extern ipcmsg_p2s_ctrl_stop_updates_t G_sgpe_control_updt);
+extern ipc_async_cmd_t G_ipc_msg_pgpe_sgpe;
 
 //
 //Local Function Prototypes
@@ -96,77 +83,77 @@ void p9_pgpe_thread_process_requests(void* arg)
         pk_irq_save_and_set_mask(0);
         pk_critical_section_exit(&ctx);
 
-        G_already_sem_posted  = 0;
+        G_pgpe_pstate_record.alreadySemPosted  = 0;
         restore_irq  = 1;
 
         PK_TRACE_DBG("PROCTH: Process Task\n");
 
         //Go through IPC Pending Table
-        if (G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing)
+        if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing)
         {
             p9_pgpe_process_sgpe_updt_active_cores();
 
-            if(G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack == 1)
+            if(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack == 1)
             {
                 restore_irq = 0;
             }
         }
 
-        if (G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing)
+        if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing)
         {
             p9_pgpe_process_sgpe_updt_active_quads();
 
-            if(G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack == 1)
+            if(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack == 1)
             {
                 restore_irq = 0;
             }
         }
 
-        if (G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_processing)
+        if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_processing)
         {
             p9_pgpe_process_sgpe_suspend_pstates();
 
-            if(G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack == 1)
+            if(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack == 1)
             {
                 restore_irq = 0;
             }
         }
 
-        if (G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].pending_processing)
+        if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].pending_processing)
         {
             p9_pgpe_process_clip_updt();
 
-            if(G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].pending_ack == 1)
+            if(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].pending_ack == 1)
             {
                 restore_irq = 0;
             }
         }
 
-        if (G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].pending_processing)
+        if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].pending_processing)
         {
             p9_pgpe_process_wof_ctrl();
 
-            if(G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].pending_ack == 1)
+            if(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].pending_ack == 1)
             {
                 restore_irq = 0;
             }
         }
 
-        if (G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].pending_processing)
+        if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].pending_processing)
         {
             p9_pgpe_process_wof_vfrt();
 
-            if(G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].pending_ack == 1)
+            if(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].pending_ack == 1)
             {
                 restore_irq = 0;
             }
         }
 
-        if (G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].pending_processing)
+        if (G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].pending_processing)
         {
             p9_pgpe_process_set_pmcr_req();
 
-            if(G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].pending_ack == 1)
+            if(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].pending_ack == 1)
             {
                 restore_irq = 0;
             }
@@ -174,8 +161,8 @@ void p9_pgpe_thread_process_requests(void* arg)
 
         //Pstate START/STOP IPCs are processed and acked in actuate thread,
         //so don't call pk_irq_vec_restore if they are pending.
-        if(G_ipc_pend_tbl[IPC_PEND_PSTATE_START].pending_ack == 1 ||
-           G_ipc_pend_tbl[IPC_PEND_PSTATE_STOP].pending_ack == 1 )
+        if(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_START].pending_ack == 1 ||
+           G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_PSTATE_STOP].pending_ack == 1 )
         {
             restore_irq = 0;
         }
@@ -199,15 +186,15 @@ void p9_pgpe_process_sgpe_updt_active_cores()
 {
     PK_TRACE_DBG("PROCTH: Core Updt Entry\n");
 
-    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd;
+    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd;
     ipcmsg_s2p_update_active_cores_t* args = (ipcmsg_s2p_update_active_cores_t*)async_cmd->cmd_data;
 
     //If in PM_SUSPENDED state, then ack back with error
-    if (G_pstatesStatus == PSTATE_PM_SUSPENDED )
+    if (G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPENDED )
     {
         args->fields.return_code = SGPE_PGPE_RC_PM_COMPLEX_SUSPEND;
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack = 0;
-        ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd, IPC_RC_SUCCESS);
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack = 0;
+        ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd, IPC_RC_SUCCESS);
         pk_halt();
     }
     //Active quad updates should only be received if Pstates and WOF are enabled.
@@ -215,13 +202,14 @@ void p9_pgpe_process_sgpe_updt_active_cores()
     //actuate thread completes actuate_start, it checks for any pending_processing tasks,
     //if there are any it post to process thread(this thread). This cmd will get processed
     //then
-    else if(G_pstatesStatus != PSTATE_START_PENDING)
+    else if(G_pgpe_pstate_record.pstatesStatus != PSTATE_START_PENDING)
     {
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing = 0;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_processing = 0;
 
-        if(G_pstatesStatus == PSTATE_STOPPED || G_pstatesStatus == PSTATE_INIT || G_wofEnabled == 0)
+        if(G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED || G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT
+           || G_pgpe_pstate_record.wofEnabled == 0)
         {
-            if(G_pstatesStatus == PSTATE_STOPPED || G_pstatesStatus == PSTATE_INIT)
+            if(G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED || G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT)
             {
                 PK_TRACE_DBG("PROCTH: C Updt(Pstate !Started)\n");
                 args->fields.return_code = PGPE_RC_PSTATES_NOT_STARTED;
@@ -232,14 +220,14 @@ void p9_pgpe_process_sgpe_updt_active_cores()
                 args->fields.return_code = PGPE_WOF_RC_NOT_ENABLED;
             }
 
-            G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack = 0;
-            ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd, IPC_RC_SUCCESS);
+            G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack = 0;
+            ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd, IPC_RC_SUCCESS);
         }
         else
         {
             //Update Shared Memory Region
-            G_quadState0->fields.active_cores = (args->fields.active_cores >> 8);
-            G_quadState1->fields.active_cores = (args->fields.active_cores & 0xFF) << 8;
+            G_pgpe_pstate_record.pQuadState0->fields.active_cores = (args->fields.active_cores >> 8);
+            G_pgpe_pstate_record.pQuadState1->fields.active_cores = (args->fields.active_cores & 0xFF) << 8;
 
             //Do auction and wof calculation
             p9_pgpe_pstate_do_auction(ALL_QUADS_BIT_MASK);
@@ -250,8 +238,8 @@ void p9_pgpe_process_sgpe_updt_active_cores()
             if (args->fields.update_type == UPDATE_ACTIVE_TYPE_ENTRY)
             {
                 args->fields.return_code = SGPE_PGPE_IPC_RC_SUCCESS;
-                G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack = 0;
-                ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd, IPC_RC_SUCCESS);
+                G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].pending_ack = 0;
+                ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_CORES_UPDT].cmd, IPC_RC_SUCCESS);
             }
         }
     }
@@ -266,15 +254,15 @@ void p9_pgpe_process_sgpe_updt_active_quads()
 {
     PK_TRACE_DBG("PROCTH: Quad Updt Entry\n");
 
-    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd;
+    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd;
     ipcmsg_s2p_update_active_quads_t* args = (ipcmsg_s2p_update_active_quads_t*)async_cmd->cmd_data;
 
     //If in PM_SUSPENDED state, then ack back with error
-    if (G_pstatesStatus == PSTATE_PM_SUSPENDED )
+    if (G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPENDED )
     {
         args->fields.return_code = SGPE_PGPE_RC_PM_COMPLEX_SUSPEND;
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack = 0;
-        ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd, IPC_RC_SUCCESS);
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack = 0;
+        ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd, IPC_RC_SUCCESS);
         pk_halt();
     }
     //Active quad updates should only be received if Pstates are enabled.
@@ -282,16 +270,16 @@ void p9_pgpe_process_sgpe_updt_active_quads()
     //actuate thread completes actuate_start, it checks for any pending_processing tasks,
     //if there are any it post to process thread(this thread). This cmd will get processed
     //then
-    else if(G_pstatesStatus != PSTATE_START_PENDING)
+    else if(G_pgpe_pstate_record.pstatesStatus != PSTATE_START_PENDING)
     {
-        G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing = 0;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_processing = 0;
 
-        if(G_pstatesStatus == PSTATE_INIT || G_pstatesStatus == PSTATE_STOPPED)
+        if(G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT || G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED)
         {
             PK_TRACE_DBG("PROCTH: Q Updt(Pstate Stopped)\n");
             args->fields.return_code = PGPE_RC_PSTATES_NOT_STARTED;
-            G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack = 0;
-            ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd, IPC_RC_SUCCESS);
+            G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack = 0;
+            ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd, IPC_RC_SUCCESS);
         }
         else
         {
@@ -301,17 +289,17 @@ void p9_pgpe_process_sgpe_updt_active_quads()
             //If ENTRY then ACK to SGPE immediately
             if (args->fields.update_type == UPDATE_ACTIVE_TYPE_ENTRY)
             {
-                G_reqActQuads->fields.requested_active_quads &= (~(args->fields.requested_quads << 2));
+                G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads &= (~(args->fields.requested_quads << 2));
                 args->fields.return_code = SGPE_PGPE_IPC_RC_SUCCESS;
-                G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack = 0;
-                ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd, IPC_RC_SUCCESS);
+                G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].pending_ack = 0;
+                ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_ACTIVE_QUADS_UPDT].cmd, IPC_RC_SUCCESS);
             }
             else
             {
-                G_reqActQuads->fields.requested_active_quads |= (args->fields.requested_quads << 2);
+                G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads |= (args->fields.requested_quads << 2);
             }
 
-            if(G_wofEnabled == 1)
+            if(G_pgpe_pstate_record.wofEnabled == 1)
             {
                 //Set OCCFLG[REQUESTED_ACTIVE_QUAD_UPDATE]
                 GPE_PUTSCOM(OCB_OCCFLG_OR, BIT32(30));
@@ -331,15 +319,15 @@ void p9_pgpe_process_sgpe_updt_active_quads()
 void p9_pgpe_process_sgpe_suspend_pstates()
 {
     PK_TRACE_DBG("PROCTH: Susp Pst Entry\n");
-    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].cmd;
+    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].cmd;
     ipcmsg_s2p_suspend_pstate_t* args = (ipcmsg_s2p_suspend_pstate_t*)async_cmd->cmd_data;
 
     //If in PM_SUSPENDED state, then ack back with error
-    if (G_pstatesStatus == PSTATE_PM_SUSPENDED )
+    if (G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPENDED )
     {
         args->fields.return_code = SGPE_PGPE_RC_PM_COMPLEX_SUSPEND;
-        G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack = 0;
-        ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].cmd, IPC_RC_SUCCESS);
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack = 0;
+        ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].cmd, IPC_RC_SUCCESS);
         pk_halt();
         //Active quad updates should only be received if Pstates are enabled.
         //However, if we have start pending, then we should not process it here. Once,
@@ -347,20 +335,20 @@ void p9_pgpe_process_sgpe_suspend_pstates()
         //if there are any it posts to process thread(this thread).
         //This cmd will get processed then
     }
-    else if(G_pstatesStatus != PSTATE_START_PENDING)
+    else if(G_pgpe_pstate_record.pstatesStatus != PSTATE_START_PENDING)
     {
-        G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_processing = 0;
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_processing = 0;
 
-        if(G_pstatesStatus == PSTATE_INIT || G_pstatesStatus == PSTATE_STOPPED)
+        if(G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT || G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED)
         {
             PK_TRACE_DBG("PROCTH: Susp Pst(Pstate !Started)\n");
             args->fields.return_code = PGPE_RC_PSTATES_NOT_STARTED;
-            G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack = 0;
-            ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_SGPE_SUSPEND_PSTATES].cmd, IPC_RC_SUCCESS);
+            G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].pending_ack = 0;
+            ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SGPE_SUSPEND_PSTATES].cmd, IPC_RC_SUCCESS);
         }
         else
         {
-            G_pstatesStatus = PSTATE_SUSPENDED;
+            G_pgpe_pstate_record.pstatesStatus = PSTATE_SUSPENDED;
         }
     }
 
@@ -375,10 +363,10 @@ void p9_pgpe_process_clip_updt()
     PK_TRACE_DBG("PROCTH: Clip Updt Entry\n");
 
     uint32_t q, ack = 0;
-    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].cmd;
+    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].cmd;
     ipcmsg_clip_update_t* args = (ipcmsg_clip_update_t*)async_cmd->cmd_data;
 
-    G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].pending_processing = 0;
+    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].pending_processing = 0;
 
     if(G_pgpe_header_data->g_pgpe_qm_flags & OCC_IPC_IMMEDIATE_RESP)
     {
@@ -386,9 +374,9 @@ void p9_pgpe_process_clip_updt()
         args->msg_cb.rc = PGPE_RC_SUCCESS;
         ack = 1;
     }
-    else if (G_pstatesStatus == PSTATE_PM_SUSPENDED ||
-             G_pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
-             G_pstatesStatus == PSTATE_SAFE_MODE)
+    else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPENDED ||
+             G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
+             G_pgpe_pstate_record.pstatesStatus == PSTATE_SAFE_MODE)
     {
         PK_TRACE_DBG("PROCTH: Clip Updt PMSUSP/Safe\n");
         args->msg_cb.rc = PGPE_RC_PM_COMPLEX_SUSPEND_SAFE_MODE;
@@ -401,13 +389,13 @@ void p9_pgpe_process_clip_updt()
         //Hcode stores them with reverse interpretation.
         for (q = 0; q < MAX_QUADS; q++)
         {
-            G_psClipMax[q] = args->ps_val_clip_min[q];
-            G_psClipMin[q] = args->ps_val_clip_max[q];
+            G_pgpe_pstate_record.psClipMax[q] = args->ps_val_clip_min[q];
+            G_pgpe_pstate_record.psClipMin[q] = args->ps_val_clip_max[q];
         }
 
-        p9_pgpe_pstate_apply_clips(&G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT]);
+        p9_pgpe_pstate_apply_clips(&G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT]);
 
-        if (G_pstatesStatus == PSTATE_INIT || G_pstatesStatus == PSTATE_STOPPED)
+        if (G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT || G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED)
         {
             args->msg_cb.rc = PGPE_RC_SUCCESS;
             ack = 1;
@@ -417,8 +405,8 @@ void p9_pgpe_process_clip_updt()
     //Clips ACKed in error cases or if Pstates are not active
     if (ack == 1)
     {
-        G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].pending_ack = 0;
-        ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_CLIP_UPDT].cmd, IPC_RC_SUCCESS);
+        G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].pending_ack = 0;
+        ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_CLIP_UPDT].cmd, IPC_RC_SUCCESS);
     }
 
     PK_TRACE_DBG("PROCTH: Clip Upd Exit\n");
@@ -431,24 +419,24 @@ void p9_pgpe_process_wof_ctrl()
 {
     PK_TRACE_DBG("PROCTH: WOF Ctrl Enter\n");
 
-    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].cmd;
+    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].cmd;
     ipcmsg_wof_control_t* args = (ipcmsg_wof_control_t*)async_cmd->cmd_data;
 
-    G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].pending_processing = 0;
+    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].pending_processing = 0;
 
     if(G_pgpe_header_data->g_pgpe_qm_flags & OCC_IPC_IMMEDIATE_RESP)
     {
         PK_TRACE_DBG("PROCTH: WOF Ctrl Updt Imme\n");
         args->msg_cb.rc = PGPE_RC_SUCCESS;
     }
-    else if (G_pstatesStatus == PSTATE_PM_SUSPENDED ||
-             G_pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
-             G_pstatesStatus == PSTATE_SAFE_MODE)
+    else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPENDED ||
+             G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
+             G_pgpe_pstate_record.pstatesStatus == PSTATE_SAFE_MODE)
     {
         PK_TRACE_DBG("PROCTH: Clip Updt PMSUSP/Safe\n");
         args->msg_cb.rc = PGPE_RC_PM_COMPLEX_SUSPEND_SAFE_MODE;
     }
-    else if(G_pstatesStatus == PSTATE_INIT || G_pstatesStatus == PSTATE_STOPPED)
+    else if(G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT || G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED)
     {
         args->msg_cb.rc = PGPE_RC_PSTATES_NOT_STARTED;
     }
@@ -459,14 +447,14 @@ void p9_pgpe_process_wof_ctrl()
         //If WOF ON
         if (args->action == PGPE_ACTION_WOF_ON)
         {
-            if(G_wofEnabled == 0)
+            if(G_pgpe_pstate_record.wofEnabled == 0)
             {
-                G_wofPending = 1;
+                G_pgpe_pstate_record.wofPending = 1;
             }
         }
         else if (args->action == PGPE_ACTION_WOF_OFF)
         {
-            if(G_wofEnabled == 1)
+            if(G_pgpe_pstate_record.wofEnabled == 1)
             {
 #if SGPE_IPC_ENABLED == 1
                 uint32_t rc;
@@ -495,9 +483,9 @@ void p9_pgpe_process_wof_ctrl()
                 if (G_sgpe_control_updt.fields.return_code == SGPE_PGPE_IPC_RC_SUCCESS)
                 {
                     //Update Shared Memory Region
-                    G_quadState0->fields.active_cores = G_sgpe_control_updt.fields.active_cores >> 8;
-                    G_quadState1->fields.active_cores = G_sgpe_control_updt.fields.active_cores & 0xFF;
-                    G_reqActQuads->fields.requested_active_quads = G_sgpe_control_updt.fields.active_quads;
+                    G_pgpe_pstate_record.pQuadState0->fields.active_cores = G_sgpe_control_updt.fields.active_cores >> 8;
+                    G_pgpe_pstate_record.pQuadState1->fields.active_cores = G_sgpe_control_updt.fields.active_cores & 0xFF;
+                    G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads = G_sgpe_control_updt.fields.active_quads;
                 }
                 else
                 {
@@ -509,8 +497,8 @@ void p9_pgpe_process_wof_ctrl()
         }
     }
 
-    G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].pending_ack = 0;
-    ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_WOF_CTRL].cmd, IPC_RC_SUCCESS);
+    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].pending_ack = 0;
+    ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_CTRL].cmd, IPC_RC_SUCCESS);
 
     PK_TRACE_DBG("PROCTH: WOF Ctrl Exit\n");
 }
@@ -522,45 +510,45 @@ void p9_pgpe_process_wof_vfrt()
 {
     PK_TRACE_DBG("PROCTH: WOF VFRT Enter\n");
 
-    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].cmd;
+    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].cmd;
     ipcmsg_wof_vfrt_t* args = (ipcmsg_wof_vfrt_t*)async_cmd->cmd_data;
 
-    G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].pending_processing = 0;
+    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].pending_processing = 0;
 
     if(G_pgpe_header_data->g_pgpe_qm_flags & OCC_IPC_IMMEDIATE_RESP)
     {
         PK_TRACE_DBG("PROCTH: WOF VFRT Imme\n");
         args->msg_cb.rc = PGPE_RC_SUCCESS;
     }
-    else if (G_pstatesStatus == PSTATE_PM_SUSPENDED ||
-             G_pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
-             G_pstatesStatus == PSTATE_SAFE_MODE)
+    else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPENDED ||
+             G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
+             G_pgpe_pstate_record.pstatesStatus == PSTATE_SAFE_MODE)
     {
         PK_TRACE_DBG("PROCTH: Clip Updt PMSUSP/Safe\n");
         args->msg_cb.rc = PGPE_RC_PM_COMPLEX_SUSPEND_SAFE_MODE;
     }
-    else if(G_pstatesStatus == PSTATE_STOPPED || G_pstatesStatus == PSTATE_INIT ||
-            (G_wofEnabled == 0 && G_wofPending == 0))
+    else if(G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED || G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT ||
+            (G_pgpe_pstate_record.wofEnabled == 0 && G_pgpe_pstate_record.wofPending == 0))
     {
         args->msg_cb.rc = PGPE_RC_PSTATES_NOT_STARTED;
     }
     else
     {
         //Update VFRT pointer
-        G_vfrt_ptr = args->vfrt_ptr;
+        G_pgpe_pstate_record.pVFRT = args->vfrt_ptr;
 
         //If active_quads field of this IPC matches requested active quads
         //in Shared SRAM, then clear OCCFLG[REQUESTED_ACTIVE_QUAD_UPDATE]
-        if (args->active_quads == G_reqActQuads->fields.requested_active_quads)
+        if (args->active_quads == G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads)
         {
             GPE_PUTSCOM(OCB_OCCFLG_CLR, BIT32(30));
             p9_pgpe_pstate_calc_wof();
         }
 
-        if (G_wofPending == 1)
+        if (G_pgpe_pstate_record.wofPending == 1)
         {
-            G_wofEnabled = 1;
-            G_wofPending = 0;
+            G_pgpe_pstate_record.wofEnabled = 1;
+            G_pgpe_pstate_record.wofPending = 0;
 
 #if SGPE_IPC_ENABLED == 1
             uint32_t rc;
@@ -589,9 +577,9 @@ void p9_pgpe_process_wof_vfrt()
             if (G_sgpe_control_updt.fields.return_code == SGPE_PGPE_IPC_RC_SUCCESS)
             {
                 //Update Shared Memory Region
-                G_quadState0->fields.active_cores = G_sgpe_control_updt.fields.active_cores >> 8;
-                G_quadState1->fields.active_cores = G_sgpe_control_updt.fields.active_cores & 0xFF;
-                G_reqActQuads->fields.requested_active_quads = G_sgpe_control_updt.fields.active_quads;
+                G_pgpe_pstate_record.pQuadState0->fields.active_cores = G_sgpe_control_updt.fields.active_cores >> 8;
+                G_pgpe_pstate_record.pQuadState1->fields.active_cores = G_sgpe_control_updt.fields.active_cores & 0xFF;
+                G_pgpe_pstate_record.pReqActQuads->fields.requested_active_quads = G_sgpe_control_updt.fields.active_quads;
             }
             else
             {
@@ -604,8 +592,8 @@ void p9_pgpe_process_wof_vfrt()
         args->msg_cb.rc = PGPE_RC_SUCCESS;
     }
 
-    G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].pending_ack = 0;
-    ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_WOF_VFRT].cmd, IPC_RC_SUCCESS);
+    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].pending_ack = 0;
+    ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_WOF_VFRT].cmd, IPC_RC_SUCCESS);
 
     PK_TRACE_DBG("PROCTH: WOF VFRT Exit\n");
 }
@@ -618,29 +606,29 @@ void p9_pgpe_process_set_pmcr_req()
     PK_TRACE_DBG("PROCTH: Set PMCR Enter\n");
 
     uint32_t q, c;
-    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].cmd;
+    ipc_async_cmd_t* async_cmd = (ipc_async_cmd_t*)G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].cmd;
     ipcmsg_set_pmcr_t* args = (ipcmsg_set_pmcr_t*)async_cmd->cmd_data;
 
-    G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].pending_processing = 0;
+    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].pending_processing = 0;
 
     if(G_pgpe_header_data->g_pgpe_qm_flags & OCC_IPC_IMMEDIATE_RESP)
     {
         PK_TRACE_DBG("PROCTH: Set PMCR Imme\n");
         args->msg_cb.rc = PGPE_RC_SUCCESS;
     }
-    else  if(G_pmcrOwner != PMCR_OWNER_OCC)
+    else  if(G_pgpe_pstate_record.pmcrOwner != PMCR_OWNER_OCC)
     {
         PK_TRACE_DBG("PROCTH: !OCC_PMCR_OWNER\n");
         args->msg_cb.rc = PGPE_RC_OCC_NOT_PMCR_OWNER;
     }
-    else if (G_pstatesStatus == PSTATE_INIT || G_pstatesStatus == PSTATE_STOPPED)
+    else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_INIT || G_pgpe_pstate_record.pstatesStatus == PSTATE_STOPPED)
     {
         PK_TRACE_DBG("PROCTH: Pstates !Started\n");
         args->msg_cb.rc = PGPE_RC_PSTATES_NOT_STARTED;
     }
-    else if (G_pstatesStatus == PSTATE_PM_SUSPENDED ||
-             G_pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
-             G_pstatesStatus == PSTATE_SAFE_MODE)
+    else if (G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPENDED ||
+             G_pgpe_pstate_record.pstatesStatus == PSTATE_PM_SUSPEND_PENDING ||
+             G_pgpe_pstate_record.pstatesStatus == PSTATE_SAFE_MODE)
     {
         PK_TRACE_DBG("PROCTH: Clip Updt PMSUSP/Safe\n");
         args->msg_cb.rc = PGPE_RC_PM_COMPLEX_SUSPEND_SAFE_MODE;
@@ -653,10 +641,10 @@ void p9_pgpe_process_set_pmcr_req()
         {
             for (c = (q * CORES_PER_QUAD); c < (q + 1)*CORES_PER_QUAD; c++)
             {
-                G_coresPSRequest[c] = (args->pmcr[q] >> 48) & 0x00FF;
+                G_pgpe_pstate_record.coresPSRequest[c] = (args->pmcr[q] >> 48) & 0x00FF;
             }
 
-            PK_TRACE_DBG("PROCTH: coresPSReq: 0x%x\n", G_coresPSRequest[q * CORES_PER_QUAD]);
+            PK_TRACE_DBG("PROCTH: coresPSReq: 0x%x\n", G_pgpe_pstate_record.coresPSRequest[q * CORES_PER_QUAD]);
         }
 
         p9_pgpe_pstate_do_auction(ALL_QUADS_BIT_MASK);
@@ -666,8 +654,8 @@ void p9_pgpe_process_set_pmcr_req()
     }
 
     //Ack back to OCC
-    G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].pending_ack = 0;
-    ipc_send_rsp(G_ipc_pend_tbl[IPC_PEND_SET_PMCR_REQ].cmd, IPC_RC_SUCCESS);
+    G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].pending_ack = 0;
+    ipc_send_rsp(G_pgpe_pstate_record.ipcPendTbl[IPC_PEND_SET_PMCR_REQ].cmd, IPC_RC_SUCCESS);
 
     PK_TRACE_DBG("PROCTH: Set PMCR Exit\n");
 }