A subsystem sends the
requests the PLM to finalize the subsystem configuration and power down unused nodes to
maintain optimum power consumption.
For bare-metal application, an application developer needs to call
XPm_InitFinalize(void) from the application.
For Linux applications, the platform management driver calls
A subsystem that is incapable of PM never sends this request. Therefore, its platform management devices remain powered up at all times, or until the PM subsystem itself is powered down.
XPm_InitFinalize() is not called, the PLM
does not power down any device. The objective of
XPm_InitFinalize() is to make the firmware aware that the caller subsystem
XPm_InitFinalize() is platform management capable
(uses platform management APIs if it needs any device).
XPm_RequestNode() will power up devices even if
XPm_InitFinalize() is not invoked. Nodes will also be released through
XPm_ReleaseNode() even if
XPmInitFinalize() is not invoked
XPm_ReleaseNode() also passes. However in this case, only the use count is
decremented, and no power down operation is performed.
Pre-requisites for Power Management
XPm_InitFinalize() for proper
power management and to obtain desired power values. The PLM power downs all unused
nodes when you call
XPm_InitFinalize() from each
subsystem. The PLM also allows you to power down any device when you call the
XPm_ReleaseNode() API. A PM-capable subsystem
XPm_InitFinalize() request after
initializing the sub-system. The PLM then begins to power down the PM devices in
this subsystem whenever they are not being used.
In a default subsystem (id = 0x1C000000), APU or RPUs can exist in
same subsystem (id = 0x1C000000). In such a case, if any of master calls
XPmInitFinalize(), all unused nodes are powered down by
the PLM. For example, if the APU is running Linux and it calls
XPmInitFinalize() during the Linux boot from the Linux
Power Management driver, unused devices will be powered down. If this default
subsystem has any other processors, for example an RPU application, they must
request device using
XPm_RequestNode(). This is
done to avoid powering down required nodes or request for nodes which are already
powered down during initial boot sequence. For more details, see Requesting and Releasing a Device From a Standalone Application.
Consider an APU subsystem that is PM capable (uses PM APIs), and a RPU subsystem that is PM incapable (does not use PM API). Assume that both subsystems use TCM.
As the APU subsystem is PM-capable, it calls both
XPm_InitFinalize(). The PLM then knows that the APU subsystem is PM
capable, and calls
XPm_RequestNode() when it
requires a device.
In contrast, because the RPU is PM unaware, applications might be
using devices without requesting the PM API, as AMD allows applications to run without using the XilPM library.
The PLM is aware that the RPU subsystem is running, but remains unaware about the
devices that are used by the RPU. Therefore, the PLM does not power down any device
until each subsystem has called