From 312ef3702c9e9c4e332b586e19bbf097a16efc1d Mon Sep 17 00:00:00 2001 From: Rahul Batra Date: Thu, 23 Mar 2017 09:01:54 -0500 Subject: 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 Reviewed-by: AMIT KUMAR Reviewed-by: Michael S. Floyd Reviewed-by: Jennifer A. Stofer --- .../procedures/ppe_closed/pgpe/pstate_gpe/link.cmd | 4 + .../ppe_closed/pgpe/pstate_gpe/p9_pgpe.h | 9 - .../ppe_closed/pgpe/pstate_gpe/p9_pgpe_gppb.c | 1 - .../pgpe/pstate_gpe/p9_pgpe_ipc_handlers.c | 154 +++++----- .../pgpe/pstate_gpe/p9_pgpe_irq_handlers.c | 13 +- .../ppe_closed/pgpe/pstate_gpe/p9_pgpe_main.c | 55 ++-- .../ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.c | 310 ++++++++++----------- .../ppe_closed/pgpe/pstate_gpe/p9_pgpe_pstate.h | 46 ++- .../pstate_gpe/p9_pgpe_thread_actuate_pstates.c | 217 ++++++--------- .../pstate_gpe/p9_pgpe_thread_process_requests.c | 232 ++++++++------- 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 @@ -63,15 +63,6 @@ #define CCSR_CORE_CONFIG_MASK 0x80000000 -/// 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); 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); @@ -83,14 +61,6 @@ inline void p9_pgpe_pstate_freq_updt(uint32_t activeCores); 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 // @@ -98,36 +68,34 @@ 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"); } -- cgit v1.2.3