Difference between revisions of "OMAP Power Management"

From eLinux.org
Jump to: navigation, search
(Debug info)
(Add category)
Line 481: Line 481:
  # Print test summary
  # Print test summary
  echo -e "$NR"
  echo -e "$NR"

Revision as of 14:46, 27 October 2011

PM branch

The PM branch is a developement branch of the linux-omap kernel for the purposes of developing and stabilizing the PM infrastructure for OMAP and submitting it upstream.

The maintainer of the PM branch is Kevin Hilman.


  • full-chip retention in idle and suspend
  • full-chip OFF in idle and suspend
  • idle PM via CPUidle
  • [dropped for re-architecture] active PM via DVFS using CPUfreq
  • support for multiple OMAP3 boards

The latest, tested PM branch is available as a branch named 'pm' from the linux-omap-pm repository. This branch is also sync'd daily as the 'pm' branch of the main linux-omap repository.

OMAP PM today.png

Current version

Supported platforms (OMAP3 only)

Tested on the following platforms using omap3_pm_defconfig with busybox-based initramfs, and tested full-chip RET and OFF in idle and suspend:

  • 3430SDP
  • Beagle
  • Overo (Water + Tobi)
  • Nokia N900 (a.k.a RX51)
  • Zoom2
  • KwikByte KBOC

What makes up the PM branch?

The PM branch is actually a collection of sub branches for the various features that are being worked on.


The pm-core branch contains features/patches that are "ready", meaning they have been either already merged, awaiting merge, or basically done, but awaiting final approval.

  • pm-backports: backports from already merged or queued upstream development needed for PM (Kevin)
  • pm-fixes: PM relates fixes queued for the next -rc series; (Kevin: queued for Tony)
  • pm-misc: misc. PM patches being queued for next merge window (Kevin: queued for Tony)

Work-in-Progress (WIP)

  • pm-cpufreq: base CPUfreq driver for OMAP (Kevin)
  • pm-gpio: GPIO off-mode support: needs rework on top of GPIO hwmod conversion (Kevin, obsoleted)
  • pm-t2: T2/PMIC board support: needs rework after voltage layter (Kevin, obsoleted)
  • pm-debug: misc. PM debug patches (Kevin)

Using the PM branch


By default, the OMAP is configured to hit full-chip retention in suspend.

# echo mem > /sys/power/state

Serial console activity or other configured wakeup sources (keypad, touchscreen) will trigger resume.

Optionally you can use a wake-up timer:

# echo 4 > /debug/pm_debug/wakeup_timer_seconds

Upon resume, you can use the powerdomain state statistics to check whether all states hit the desired state, cf. 'Debug info'

# cat /debug/pm_debug/count

In addition, if any powerdomains did not hit the desired state, you will see a message on the console.

Enabling system for hitting retention during idle

By default, the kernel will not try to hit retention or off while idle. To enable idle path to attempt deeper sleep states:

# echo 1 > /debug/pm_debug/sleep_while_idle

Then, wait for any inactivity timers to expire (such as the 5 second UART timer) and check the powerdomain transition statistics to see that transitions are happening

 # cat /debug/pm_debug/count
Enabling system for hitting OFF

By default, retention is the deepest sleep state attempted. To enable powerdomain transitions to off mode

# echo 1 > /debug/pm_debug/enable_off_mode

Once again, after a suspend or after some idle time, use the powerdomain transition stats to check that transitions to off-mode are happening

 # cat /debug/pm_debug/count

Known Problems

  • Zoom2/3: serial console wakeups not working
    • Problem: on suspend, by default the serial driver will disable serial interrupts, thus disabling the GPIO IRQ needed for wakeup.
    • Fix: enable the wakeup feature for the tty used as console:
 # echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup 
  • Root filesystem on MMC leads to crash when using off-mode.
    • There is currently no support for off-mode in the MMC driver.
  • GPIO module-level wakeups not always working
    • Background: GPIO wakeups can happen either via the GPIO module itself (module-level wakeups) or via IO pad wakeups if the CORE powerdomain is inactive, in retention or off.
    • If the IO pad wakeups are not enabled (either because CORE remains on, or because IO pad is not armed) GPIO wakeups may not happen unless the GPIO module-level wakeups are programmed correctly.
    • To ensure GPIO module wakeups are programmed correctly:
      • Enable GPIO IRQ for wakeup GPIO, including ISR. Use request_irq()
      • Ensure GPIO is edge-triggered. Only edge triggered GPIOs are wakeup capable (c.f. omap34xx TRM Sec.
        • the flags argument of request_irq() should have either IRQF_TRIGGER_FALLING, IRQF_TRIGGER_RISING or both.
      • Enable GPIO IRQ as wakeup source using enable_irq_wake(gpio_to_irq(<gpio>))
    • NOTE: It is very important that an interrupt handler be configured for the GPIO IRQ, even if it does nothing but return IRQ_HANDLED. This is because without an interrupt handler, the GPIO IRQ event will never be properly cleared and this can prevent the GPIO module from hitting retention or off on the next idle request (c.f. omap34xx TRM Sec.
  • GPIO wakeup works once, but prevents future retention
    • See NOTE just above

Advanced features for PM developers and power users

Debug info

First, mount the debug filesystem (debugfs)

# mount -t debugfs debugfs /debug

Show powerdomain state statistics and clockdomain active clocks

# cat /debug/pm_debug/count

This will look something like this:

 # cat /debug/pm_debug/count
 cefuse_pwrdm (OFF),OFF:1,RET:0,INA:0,ON:0,RET-LOGIC-OFF:0
 always_on_core_pwrdm (OFF),OFF:1,RET:0,INA:0,ON:0,RET-LOGIC-OFF:0
 l3init_pwrdm (RET),OFF:0,RET:1,INA:0,ON:1,RET-LOGIC-OFF:0,RET-MEMBANK1-OFF:0
 cpu1_pwrdm (ON),OFF:0,RET:0,INA:0,ON:1,RET-LOGIC-OFF:0,RET-MEMBANK1-OFF:0
 cpu0_pwrdm (ON),OFF:0,RET:0,INA:0,ON:1,RET-LOGIC-OFF:0,RET-MEMBANK1-OFF:0

If you see each power domain has counters specified. OFF, RET, INA and so on...The count basically keeps incrementing every time it hits low power state. In the above example, cam_pwrdm (camera power domain) has hit OFF state once. GFX power domain has hit OFF state twice and like wise.

Dump current PRCM registers

# cat /debug/pm_debug/registers/current

Dump PRCM register snapshot taken just before suspend (just before jump into SRAM idle code)

# cat /debug/pm_debug/registers/1

Dump PRCM register snapshot taken immediately after resume

# cat /debug/pm_debug/registers/2

UART wakeup and timeout options

By default, each of the on-chip OMAP UARTs are enabled as wakeup sources. In addition, they are configured with a configurable inactivity timer (default 5 seconds) after which the UART clocks are allowed to be gated during idle or suspend.

For example, to disable the wakeup capability of a UART1 (a.k.a ttyO0)

 # echo disabled > /sys/devices/platform/omap/omap-hsuart.0/power/wakeup

And to change the inactivity timer to 10 seconds, instead of the default 5:

 # echo 10 > /sys/devices/platform/omap/omap-hsuart.0/sleep_timeout

Note that you can cat these files under /sys as well to see the current values.

UART PM Debugging Techniques

Debugging problems with the OMAP UART driver wakeup and data transfer when Power Management is enabled can be quite tedious, if one does not have a proper HW setup. An example of a setup (including both HW and SW changes) can be found in the OMAP_UART_pm_debugging page.

Misc. options

OMAP PM future.png

Future directions

What's next is to get the remaining functionality of the PM branch into mainline. As pointed out above in the 'what's left in PM branch' secion, those parts are not yet ready for mainline. To that end, the goal of this section is to lay out a rough plan of how to get those features done in a way that can be submitted upstream.

  • 3630, OMAP4 support
  • new OPP layer
  • device PM control

Device PM control via omap_device + omap_hwmod

Currently, we have a rather ad-hoc way for device drivers to do power management. Currently this is done in drivers by directly using the clock framework API in combination with manually setting device specific PM registers (e.g. SYSCONFIG for various idle setting bits etc.)

The goal of new device PM control is to have a standard, common, portable interface for device drivers to control PM. From a driver API point of view, there is a new single API: the Run-time PM API. Internally to the OMAP PM core, the implementation of the runtime PM API will use the new omap_device and omap_hwmod layers to implement device PM.

omap_hwmod, omap_device conversion

An important buidling block to converting to a common framework (runtime PM) for device PM is a common framework for all on-chip hardware blocks. This is available as the omap_device and omap_hwmod layers. These layers provide an abstraction so that all hardware IP blocks can be controlled using the same API. The runtime PM layer is then implemented as a think layer on top of the omap_device API.

This implies that in order to have runtime PM support for a device, the underlying HW IP must be represented by an omap_hwmod and have a correspdonding omap_device built for it. Then, using the runtime PM API from the driver will result in omap_device API calls to control the IP.

Run-time PM

Run-time PM is a recent development in the upstream kernel community. It provides an architecture independent framework for doing runtime power management of IO devices. It also extends the platform_bus/platform_device infrastructure to allow arch-specific extentions of the platform_device.

  • Key features
    • architecture independent
    • only a framework, does nothing without platform specific hooks
  • Plans for use in linux-omap
    • OMAP-specific extention of platform_device: contains an omap_device
    • implement platform specific runtime PM hooks for OMAP
    • runtime PM API used by all OMAP drivers
  • Current status

Public Power management test framework

Some commonly used power management utilities are listed here which make sense from an OMAP perspective

Cpufreq utils

cpufreq utils for testing dynamic voltage and frequency scaling.

Maemo pm_test

pm-test plugin for Maemo says

 utility which tests that kernel and kernel modules works power management wise

This utility could be used to sanity test the powermanagement impact to a system for suspend/restore and basic power features.

Quick verification of suspend-idle functionality

the following script may be used with userspace supporting something simple as busybox:

# Quick script to verify SUSPEND Resume behavior without human intervention
# Refer: http://elinux.org/OMAP_Power_Management for details

# Some params that might change based on the environment

kver=`uname -r`
if [ $kver > "2.6.36" ]; then

# Setup cpu idle
	echo -n "$1" > $PMDEBUG/sleep_while_idle

# setup off mode
	echo -n "$1" > $PMDEBUG/enable_off_mode

# Do a suspend
	echo -n "mem" > $SYS/power/state

# get my core data (This is the last domain to hit lowest power state)
	cat $PMDEBUG/count |grep "^core_pwrdm"

# get my retention counter
	core_count|cut -d ',' -f3|cut -d ':' -f2

# get my off counter
	core_count|cut -d ',' -f2|cut -d ':' -f2

# setup wakeup timer - automated testing
	echo -n "$1" > $PMDEBUG/wakeup_timer_seconds
	echo -n "$2" > $PMDEBUG/wakeup_timer_milliseconds

# Setup our uart to be inactivity timer
setup_tty_sleep_timeout() {
	if [ -f $UART1 ]; then
		echo -n "$1" > $UART1
	if [ -f $UART2 ]; then
		echo -n "$1" > $UART1
	if [ -f $UART3 ]; then
		echo -n "$1" > $UART3


# Measurement Start
	TIME_START=`date "+%s"`
# Measurement End
	TIME_END=`date "+%s"`
# Common formatted print
	echo "$1 | $2 | OFF: $OFF_START->$OFF_END| RET:$RET_START->$RET_END ($DUR sec)"

# verify function
	if [ $OFF_START -lt $OFF_END ]; then
	if [ $RET_START -lt $RET_END ]; then

# Disable everything
	# disable voltage off
	if [ -f $VOLTAGE_OFF ]; then
		echo -n "0" >$VOLTAGE_OFF
	setup_tty_sleep_timeout 0
	wakeup_timer 0 0
	off_mode 0
	cpu_idle 0

# test idle - core ret
test_idle_ret() {
	setup_tty_sleep_timeout 5
	cpu_idle 1
	sleep 20
	sleep 1;sync
	measure_print "IDLE:RET test" $RESULT

# test idle - core off
test_idle_off() {
	setup_tty_sleep_timeout 5
	off_mode 1
	cpu_idle 1
	sleep 20
	sleep 1;sync
	measure_print "IDLE:OFF test" $RESULT

# test suspend - core ret
test_suspend_ret() {
	wakeup_timer 5 0
	sleep 1;sync
	measure_print "SUSPEND:RET test" $RESULT

# test suspend - core off
test_suspend_off() {
	off_mode 1
	wakeup_timer 5 0
	sleep 1;sync
	measure_print "SUSPEND:OFF test" $RESULT

# mount up the basic fs
already_mntd=`mount|grep $PROC`
if [ x == x"$already_mntd" ]; then
	mount -t proc none $PROC

already_mntd=`mount|grep $SYS`
if [ x == x"$already_mntd" ]; then
	mount -t sysfs none $SYS
already_mntd=`mount|grep $DEBUG`
if [ x == x"$already_mntd" ]; then
	mount -t debugfs none $DEBUG
# Lets run the tests one by one..
echo $R
echo $R
echo $R
echo $R
# Print End result summary
cat $PMDEBUG/count

# Print test summary
echo -e "$NR"