stv0g/embeddedsw
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

PMUFW: PM: Cleanup

Browse source 
improve comments and messages; remove unused code/structures

Signed-off-by: Davorin Mista <davorin.mista@aggios.com>
Acked-by: Sören Brinkmann <soren.brinkmann@xilinx.com>
Acked-by: Jyotheeswar Reddy Mutthareddyvari <jyothee@xilinx.com>
This commit is contained in:
Davorin Mista 2015-05-27 15:26:27 -07:00 • committed by Nava kishore Manne
parent b8db439393
commit 0e9de73072
12 changed files with 85 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
lib/sw_apps/zynqmp_pmufw/src/pm_common.c
View file

@ -30,7 +30,8 @@
/*********************************************************************
* Definitions of commonly used functions for debugging PMU Power
* Management (PM).
* Management (PM). Conditionaly compiled code for debugging is not
* intended to be MISRA compliant.
*********************************************************************/
#include "pm_common.h"
@ -38,20 +39,13 @@
#include "pm_master.h"
#ifdef DEBUG_PM
const char* PmStrMaster(const u32 master)
{
switch (master) {
case PM_MASTER_APU:
return "MASTER_APU";
case PM_MASTER_RPU_0:
return "MASTER_RPU0";
case PM_MASTER_RPU_1:
return "MASTER_RPU1";
default:
return "ERROR_MASTER";
}
}
/**
* PmStrNode() - Converts integer node id into node string
* @node Node id to be converted to string
*
* @return String name of given node id
*/
const char* PmStrNode(const u32 node)
{
switch (node) {
@ -110,6 +104,12 @@ const char* PmStrNode(const u32 node)
}
}
/**
* PmStrAck() - Converts integer acknowledge into matching string
* @ack Acknowlegde integer id to be converted to string
*
* @return String name of given acknowledge id
*/
const char* PmStrAck(const u32 ack)
{
switch (ack) {
@ -126,6 +126,12 @@ const char* PmStrAck(const u32 ack)
}
}
/**
* PmStrReason() - Converts integer reason id into matching string
* @reason Integer reason id to be converted
*
* @return String name of given reason integer
*/
const char* PmStrReason(const u32 reason)
{
switch (reason) {

27
lib/sw_apps/zynqmp_pmufw/src/pm_core.c
View file

@ -120,8 +120,8 @@ static void PmRequestSuspend(const PmMaster *const master,
{
PmProc* proc = PmGetProcOfOtherMaster(master, node);
PmDbg("(%s, %s, %d, %d)\n",
PmStrNode(node), PmStrAck(ack), latency, state);
PmDbg("(%s, %s, %d, %d)\n", PmStrNode(node), PmStrAck(ack),
latency, state);
if (NULL == proc) {
PmDbg("ERROR processor not found by node %d\n", node);
@ -257,6 +257,7 @@ static void PmReleaseNode(const PmMaster *master,
const u32 latency)
{
u32 status;
/* Get static requirements structure for this master/slave pair */
PmRequirement* masterReq = PmGetRequirementForSlave(master, node);
if (NULL == masterReq) {
@ -270,8 +271,7 @@ static void PmReleaseNode(const PmMaster *master,
masterReq->info &= ~PM_MASTER_USING_SLAVE_MASK;
if (PM_RET_SUCCESS != status) {
PmDbg("ERROR PmRequirementUpdate status = %d (should be 0!!)\n",
status);
PmDbg("ERROR PmRequirementUpdate status = %d\n", status);
goto done;
}
@ -283,6 +283,7 @@ static void PmReleaseNode(const PmMaster *master,
done:
PmDbg("(%s, %d)\n", PmStrNode(node), latency);
return;
}
/**
@ -301,6 +302,11 @@ static void PmRequestNode(const PmMaster *master,
{
u32 status;
u32 oppoint = 0U;
/*
* Each legal master/slave pair will have one static PmRequirement data
* structure. Retrieve the pointer to the structure in order to set the
* requested capabilities and mark slave as used by this master.
*/
PmRequirement* masterReq = PmGetRequirementForSlave(master, node);
PmDbg("(%s, %d, %d, %s)\n", PmStrNode(node), capabilities,
@ -318,12 +324,6 @@ static void PmRequestNode(const PmMaster *master,
goto done;
}
if (PM_PROC_STATE_ACTIVE != master->procs->node.currState) {
PmDbg("ERROR Master isn't active!\n");
status = PM_RET_ERROR_ACCESS;
goto done;
}
/* Set requested capabilities if they are valid */
masterReq->info |= PM_MASTER_USING_SLAVE_MASK;
status = PmRequirementUpdate(masterReq, capabilities);
@ -337,13 +337,13 @@ done:
* @master Master who initiated the request
* @node Node whose requirements setting is requested
* @capabilities Requested capabilities
* @qos Not supported
* @qos Requested quality of service - Not supported
* @ack Acknowledge request
*
* @note If processor which initiated request is in suspending state,
* requirement will be set once PMU handles processor's WFI
* interrupt. If processor is active, setting is done
* immidiately (if possible).
* immediately (if possible).
*/
static void PmSetRequirement(const PmMaster *master,
const u32 node,
@ -674,7 +674,8 @@ void PmProcessRequest(const PmMaster *const master,
if (PM_PAYLOAD_ERR_API_ID != status) {
u32 ack = PmRequestAcknowledge(pload);
if (REQUEST_ACK_NO != ack) {
PmAcknowledgeCb(master, NODE_UNKNOWN, PM_RET_ERROR_API_ID, 0);
PmAcknowledgeCb(master, NODE_UNKNOWN,
PM_RET_ERROR_API_ID, 0);
}
}
}

11
lib/sw_apps/zynqmp_pmufw/src/pm_master.c
View file

@ -279,11 +279,9 @@ u32 PmRequirementUpdate(PmRequirement* const masterReq, const u32 caps)
u32 status;
u32 tmpCaps;
PmDbg("\n");
/* Check if slave has a state with requested capabilities */
status = PmCheckCapabilities(masterReq->slave, caps);
PmDbg("PmCheckCapabilities status=%d\n", status);
if (PM_RET_SUCCESS != status) {
goto done;
}
@ -293,8 +291,6 @@ u32 PmRequirementUpdate(PmRequirement* const masterReq, const u32 caps)
masterReq->currReq = caps;
status = PmUpdateSlave(masterReq->slave);
PmDbg("PmUpdateSlave status=%d\n", status);
if (PM_RET_SUCCESS == status) {
/* All capabilities requested in active state are constant */
masterReq->nextReq = masterReq->currReq;
@ -323,12 +319,13 @@ done:
* next requirements (swapping means the current requirements will be
* saved as next, and will be configured once master wakes-up)
*/
void PmRequirementUpdateScheduled(const PmMaster* const master, const bool swap)
static void PmRequirementUpdateScheduled(const PmMaster* const master,
const bool swap)
{
u32 status;
PmRequirementId i;
PmDbg("master %s\n", PmStrNode(master->procs[0].node.nodeId));
PmDbg("%s\n", PmStrNode(master->procs[0].node.nodeId));
for (i = 0; i < master->reqsCnt; i++) {
if (master->reqs[i].currReq != master->reqs[i].nextReq) {
@ -692,7 +689,7 @@ void PmMasterNotify(PmMaster* const master, const PmProcEvent event)
PmWakeUpCancelScheduled(master);
break;
default:
PmDbg("undefined event #%d\n", event);
PmDbg("ERROR: undefined event #%d\n", event);
break;
}
}

47
lib/sw_apps/zynqmp_pmufw/src/pm_master.h
View file

@ -54,29 +54,6 @@ typedef struct PmMaster PmMaster;
/*********************************************************************
* Macros
********************************************************************/
/* Supported masters (macros are used as indexes in array of all masters) */
#define PM_MASTER_APU 0U
#define PM_MASTER_RPU_0 1U
#define PM_MASTER_RPU_1 2U
#define PM_MASTER_MAX 3U
/* Master states */
/* All processors within the master are sleeping */
#define PM_MASTER_STATE_SLEEP 0U
/* At least one processor within master is not sleeping */
#define PM_MASTER_STATE_ACTIVE 1U
/* Master FSM events */
/* Triggered after a processor within the master goes to sleep */
#define PM_MASTER_EVENT_SLEEP 1U
/* Triggered before a processor within the master wakes-up */
#define PM_MASTER_EVENT_WAKE 2U
/* Triggered by abort suspend */
#define PM_MASTER_EVENT_ABORT 3U
/* Apu slaves */
#define PM_MASTER_APU_SLAVE_OCM0 0U
#define PM_MASTER_APU_SLAVE_OCM1 1U
@ -116,13 +93,12 @@ typedef struct PmMaster PmMaster;
* setting. One structure should be statically assigned for each
* possible combination of master/slave, because dynamic memory
* allocation cannot be used.
* @info Contains information about master's request - a bit for
* encoding has master requested or released node, other bits
* are used to encode master index in array of all masters.
* PM_MASTER_USING_SLAVE_MASK - extracts a bitfield for usage flag
* @slave Pointer to the slave structure
* @master Pointer to the master structure. Can be removed if need to
* @requestor Pointer to the master structure. Can be removed if need to
* optimize for space instead performance
* @info Contains information about master's request - a bit for
* encoding has master requested or released node, and a bit to
* encode has master requested a wake-up of this slave.
* @currReq Currently holding requirements of a master for this slave
* @nextReq Requirements of a master to be configured when it changes the
* state (after it goes to sleep or before it gets awake)
@ -145,7 +121,8 @@ typedef struct PmRequirement {
* @buffer IPI buffer address into which this master can write
* (master's buffer)
* @reqs Pointer to the masters array of requirements for slave
* capabilities
* capabilities. For every slave the master can use, there has to
* be a statically initialized structure for that master/slave pair
* @reqsCnt Number of requirement elements (= worst case for number of
* used slaves)
*/
@ -175,6 +152,7 @@ extern PmRequirement pmRpu0Req_g[PM_MASTER_RPU_0_SLAVE_MAX];
********************************************************************/
/* Get functions */
const PmMaster* PmGetMasterByIpiMask(const u32 mask);
PmProc* PmGetProcByWfiStatus(const u32 mask);
PmProc* PmGetProcByWakeStatus(const u32 mask);
PmProc* PmGetProcByNodeId(const PmNodeId nodeId);
@ -183,18 +161,19 @@ PmProc* PmGetProcOfThisMaster(const PmMaster* const master,
PmProc* PmGetProcOfOtherMaster(const PmMaster* const master,
const PmNodeId nodeId);
PmRequirement* PmGetRequirementForSlave(const PmMaster* const master,
const PmNodeId nodeId);
u32 PmMasterGetAwakeProcCnt(const PmMaster* const master);
const PmNodeId nodeId);
/* Requirements related functions */
u32 PmRequirementSchedule(PmRequirement* const masterReq, const u32 caps);
u32 PmRequirementUpdate(PmRequirement* const masterReq, const u32 caps);
void PmRequirementUpdateScheduled(const PmMaster* const master,
const bool swap);
void PmRequirementCancelScheduled(const PmMaster* const master);
/* Call at initialization to enable all masters' IPI interrupts */
void PmEnableAllMasterIpis(void);
/* Notify master by a primary core when changing state */
void PmMasterNotify(PmMaster* const master, const PmProcEvent event);
/* Call when FPD goes down to enable GIC Proxy interrupts */
void PmEnableProxyWake(PmMaster* const master);
#endif

17
lib/sw_apps/zynqmp_pmufw/src/pm_node.h
View file

@ -43,7 +43,6 @@ typedef u8 PmNodeId;
typedef u8 PmStateId;
typedef u8 PmTransitionId;
typedef u8 PmNodeTypeId;
typedef u8 PmWakeEventId;
/* Forward declaration */
typedef struct PmPower PmPower;
@ -77,17 +76,6 @@ typedef u32 (*const PmNodeTranHandler)(PmNode* const nodePtr);
#define HAS_SLEEP(opsPtr) ((NULL != opsPtr) && (NULL != (opsPtr)->sleep))
/* Wake events */
#define PM_WAKE_EVENT_GPI1_APU0_GIC 0U
#define PM_WAKE_EVENT_GPI1_APU1_GIC 1U
#define PM_WAKE_EVENT_GPI1_APU2_GIC 2U
#define PM_WAKE_EVENT_GPI1_APU3_GIC 3U
#define PM_WAKE_EVENT_GPI1_RPU0_GIC 4U
#define PM_WAKE_EVENT_GPI1_RPU1_GIC 5U
#define PM_WAKE_EVENT_GPI1_USB0 6U
#define PM_WAKE_EVENT_GPI1_USB1 7U
#define PM_WAKE_EVENT_GPI1_FPD_PROX 8U
#define PM_WAKE_EVENT_GPI1_MAX 9U
/*********************************************************************
* Structure definitions
@ -109,10 +97,7 @@ typedef struct PmNodeOps {
* @typeId Type id, used to distinguish the nodes
* @parent Pointer to power parent node
* @currState Id of the node's current state. Interpretation depends on type
* of the node, bit 0 value is reserved for on/off states where
* 0=off and 1=on, so for any other on-state bit 0 must also be 1
* and any other off-state bit 0 must be 0
* (e.g. 0x2 for off with retention/saved context)
* of the node, bit 0 value is reserved for off states
* @ops Pointer to the operations structure
*/
typedef struct PmNode {

14
lib/sw_apps/zynqmp_pmufw/src/pm_periph.h
View file

@ -40,19 +40,27 @@
* These slaves have no machanisms for controlling their own state, and their
* off state is controlled by the power parent state.
*/
#define PM_STD_SLAVE_STATE_OFF 0U
#define PM_STD_SLAVE_STATE_ON 1U
#define PM_STD_SLAVE_STATE_OFF 0U
#define PM_STD_SLAVE_STATE_ON 1U
/* Always-on slaves, have only one state */
#define PM_AON_SLAVE_STATE 0U
#define PM_AON_SLAVE_STATE 0U
/*********************************************************************
* Structure definitions
********************************************************************/
/**
* PmSlaveTtc - Structure used for timer peripheral
* @slv Base slave structure
*/
typedef struct PmSlaveTtc {
PmSlave slv;
} PmSlaveTtc;
/**
* PmSlaveSata - Structure used for Sata peripheral
* @slv Base slave structure
*/
typedef struct PmSlaveSata {
PmSlave slv;
} PmSlaveSata;

6
lib/sw_apps/zynqmp_pmufw/src/pm_power.h
View file

@ -52,9 +52,9 @@
/**
* PmPower - Structure for power related nodes
* Basically an abstraction of power islands and power domains.
* Not all power entities in the system have this struct. If a node has
* its own power, which does not depend to other nodes, its power is
* controlled within its transition actions. Otherwise, this power
* Not all power entities in the system have this struct. If a node
* has its own power, which does not depend to other nodes, its power
* is controlled within its transition actions. Otherwise, this power
* structure must exist.
* @node Node structure of this power entity
* @children Pointer to the array of children

20
lib/sw_apps/zynqmp_pmufw/src/pm_proc.c
View file

@ -329,13 +329,9 @@ static u32 PmProcTrSleepToActive(PmProc* const proc)
*/
static u32 PmProcTrForcePwrdnToActive(PmProc* const proc)
{
u32 status;
PmDbg("FORCED_PWRDN->ACTIVE %s\n", PmStrNode(proc->node.nodeId));
status = PmProcWake(&proc->node);
return status;
return PmProcWake(&proc->node);
}
/**
@ -356,7 +352,8 @@ u32 PmProcFsm(PmProc* const proc, const PmProcEvent event)
if (PM_PROC_STATE_ACTIVE == currState) {
status = PmProcTrActiveToSuspend(proc);
} else {
PmDbg("illegal state %d for SUSPND event\n", currState);
PmDbg("ERROR: illegal state %d for SUSPEND event\n",
currState);
status = PM_RET_ERROR_INTERNAL;
}
break;
@ -370,7 +367,8 @@ u32 PmProcFsm(PmProc* const proc, const PmProcEvent event)
if (PM_PROC_STATE_SUSPENDING == currState) {
status = PmProcTrSuspendToActive(proc);
} else {
PmDbg("illegal state %d for ABORT event\n", currState);
PmDbg("ERROR: illegal state %d for ABORT event\n",
currState);
status = PM_RET_ERROR_INTERNAL;
}
break;
@ -378,7 +376,8 @@ u32 PmProcFsm(PmProc* const proc, const PmProcEvent event)
if (PM_PROC_STATE_SUSPENDING == currState) {
status = PmProcTrSuspendToSleep(proc);
} else {
PmDbg("illegal state %d for SLEEP event\n", currState);
PmDbg("ERROR: illegal state %d for SLEEP event\n",
currState);
status = PM_RET_ERROR_INTERNAL;
}
break;
@ -388,12 +387,13 @@ u32 PmProcFsm(PmProc* const proc, const PmProcEvent event)
} else if (PM_PROC_STATE_FORCEDOFF == currState) {
status = PmProcTrForcePwrdnToActive(proc);
} else {
PmDbg("illegal state %d for WAKE event\n", currState);
PmDbg("ERROR: illegal state %d for WAKE event\n",
currState);
status = PM_RET_ERROR_INTERNAL;
}
break;
default:
PmDbg("unrecognized event\n", event);
PmDbg("ERROR: unrecognized event %d\n", event);
status = PM_RET_ERROR_INTERNAL;
break;
}

1
lib/sw_apps/zynqmp_pmufw/src/pm_proc.h
View file

@ -105,6 +105,7 @@ typedef u8 PmProcEvent;
* Structure definitions
********************************************************************/
typedef struct PmMaster PmMaster;
/**
* PmProc - Processor node's structure
* @node Processor's node structure

10
lib/sw_apps/zynqmp_pmufw/src/pm_slave.c
View file

@ -99,7 +99,7 @@ bool PmSlaveHasCapRequests(const PmSlave* const slave)
for (i = 0U; i < slave->reqsCnt; i++) {
if ((0U != (PM_MASTER_USING_SLAVE_MASK & slave->reqs[i]->info)) &&
(0U != slave->reqs[i]->currReq)) {
(0U != slave->reqs[i]->currReq)) {
/* Slave is used by this master and has current request for caps */
hasReq = true;
break;
@ -146,7 +146,8 @@ u32 PmCheckCapabilities(PmSlave* const slave, const u32 cap)
for (i = 0; i < slave->slvFsm->statesCnt; i++) {
/* Find the first state that contains all capabilities */
if ((cap & slave->slvFsm->states[i]) == cap) {
return PM_RET_SUCCESS;
status = PM_RET_SUCCESS;
break;
}
}
@ -161,7 +162,7 @@ u32 PmCheckCapabilities(PmSlave* const slave, const u32 cap)
* @return PM_RET_SUCCESS if transition was performed successfully
* error otherwise
*/
u32 PmSlaveChangeState(PmSlave* const slave, const PmStateId state)
static u32 PmSlaveChangeState(PmSlave* const slave, const PmStateId state)
{
u32 t;
u32 status = PM_RET_ERROR_FAILURE;
@ -256,11 +257,10 @@ static void PmSlaveWakeMasters(PmSlave* const slave)
if (slave->reqs[i]->info & PM_MASTER_WAKEUP_REQ_MASK) {
slave->reqs[i]->info &= ~PM_MASTER_WAKEUP_REQ_MASK;
PmDbg("%s->%s\n", PmStrNode(slave->node.nodeId),
PmStrNode(slave->reqs[i]->requestor->procs->node.nodeId));
PmStrNode(slave->reqs[i]->requestor->procs->node.nodeId));
PmProcFsm(slave->reqs[i]->requestor->procs, PM_PROC_EVENT_WAKE);
}
}
PmSlaveWakeDisable(slave);
}

5
lib/sw_apps/zynqmp_pmufw/src/pm_slave.h
View file

@ -128,7 +128,7 @@ typedef struct {
} PmGicProxyProperties;
/**
* PmWakeEvent - Wake-up event
* PmWakeProperties - Wake-up event properties
* @proxyIrqMask As most of the interrupt routes go through FPD GIC Proxy,
* this is the interrupt mask in GIC Proxy registers.
* @proxyGroup Group in FPD GIC Proxy
@ -141,12 +141,11 @@ typedef struct {
/**
* PmSlave - Slave structure used for managing slave's states
* @node Pointer to the node structure of this slave
* @classId Class of the slave. Slaves of the same class have the same state
* definitions
* @instId Index into array of all instances of slave's class
* @reqs Pointer to array of master requirements related to this slave
* @reqsCnt Size of masterReq array
* @wake Wake event this slave can generate
* @slvFsm Slave finite state machine
*/
typedef struct PmSlave {
PmNode node;

2
lib/sw_apps/zynqmp_pmufw/src/xpfw_version.h
View file

@ -1,4 +1,4 @@
#ifndef ZYNQMP_XPFW_VERSION__H_
#define ZYNQMP_XPFW_VERSION__H_
#define ZYNQMP_XPFW_VERSION "2015.1-swbeta2-16-g1a5a1abd8be3"
#define ZYNQMP_XPFW_VERSION "2015.1-swbeta2-17-gf10e9915f4bb"
#endif