Linux电源管理之Runtime PM

作者简介：Loopers，码龄11年，喜欢研究内核基本原理

前言

Runtime PM (Runtime Power Management)翻译过来就是运行时电源管理。主要的作用是:  每个设备处理好自己的电源管理，在不需要工作时进入低功耗状态。也就是"各人自扫门前雪"。

system suspend需要很长时间完成，其中还可能出现失败。比如freeze task的时候。而suspend设备速度相对system suspend快很对，而且还不需要freeze task。当设备不忙的时候就进入自己的低功耗模式，这样一来每个device(包括CPU) 都做好自己的事，整个系统就达到最大节省能源。这时候突然想起了一句话"只要人人都献出一片爱，世界将变成美好的人间"。

以上这些工作都需要Runtime PM framework的支持，这也都是Runtime PM framework应该操心的事情。

Subsystem and Driver Callbacks

为了实现设备的runtime pm，需要subsystem(PM domains, device types, classes and bus types)和driver提供下面三个回调函数:

struct dev_pm_ops {
        ....
 int (*runtime_suspend)(struct device *dev);
 int (*runtime_resume)(struct device *dev);
 int (*runtime_idle)(struct device *dev);
};

三个回调函数分别用于suspend device，resume device和idle device。通常Runtime PM framework会在合适的时机调用三个函数。

Device States

Runtime PM Framework使用rpm_status枚举类型表示device的状态

enum rpm_status {
 RPM_ACTIVE = 0,
 RPM_RESUMING,
 RPM_SUSPENDED,
 RPM_SUSPENDING,
};

RPM_ACTIVE:                设备处于正常工作状态，处于全速全进状态。runtime_resume的回调执行完毕。

RPM_RESUMING:          设备状态正在从suspend到active转换。 runtime_resume的回调正在执行。

RPM_SUSPENDED:       设备处于低功耗状态，不能处于IO操作。runtime_suspend的回调执行完毕。

RPM_SUSPENDING:     设备状态正从active到suspend状态转换。runtime_suspend回调正在执行。

是的，你没看错，的确是没有调用runtime_idle回调。那runtime_idle回调什么时候调用呢？  idle状态是suspend状态前的一个过渡而已，通常会在runtime_suspend调用之前调用一段时间runtime_idle回调。

Runtime PM请求类型

因为使设备进入suspend或者resume状态，有同步和异步的方式。通常在异步的时候会用到workqueue，这时候就会用到设备的请求类型。

enum rpm_request {
 RPM_REQ_NONE = 0,
 RPM_REQ_IDLE,
 RPM_REQ_SUSPEND,
 RPM_REQ_AUTOSUSPEND,
 RPM_REQ_RESUME,
};

PRM_REQ_NONE:                        Do nothing

PRM_REQ_IDLE:                           运行设备的runtime_idle回调。

PRM_REQ_SUSPEND:                 运行设备的runtime_suspend回调。

RPM_REQ_AUTOSUSPEN:          在一段时间之后运行设备的runtime_suspend回调。

RPM_REQ_RESUME:                   运行设备的runtime_resume回调。

Runtime PM数据段

在每个device结构中都存在dev_pm_info的结构，此结构中通过CONFIG_PM_RUNTIME配置字段代码了Runtime PM的信息。

struct dev_pm_info {
        ....
 struct timer_list suspend_timer; //休眠时候用到的定时器。
 unsigned long  timer_expires; //定时器的超时函数。
 struct work_struct work; //用于workqueue中的工作项。
 wait_queue_head_t wait_queue; //等待队列，用于异步pm操作时候使用。
 atomic_t  usage_count;  //设备的引用计数，通过该字段判断是否有设备使用。
 atomic_t  child_count;  //此设备的"active"子设备的个数。
 unsigned int  disable_depth:3;  //用于禁止Runtime helper function。等于0代表使能，1代表禁止。
 unsigned int  idle_notification:1;  //如果该值被设备，则调用runtime_idle回调函数。
 unsigned int  request_pending:1;  //如果设备，代表工作队列有work请求。
 unsigned int  deferred_resume:1;  //当设备正在执行-> runtime_suspend()的时候，如果->runtime_resume()将要运行，而等待挂起操作完成并不实际，就会设置该值；这里的意思是“一旦你挂起完成，我就开始恢复”。
 unsigned int  run_wake:1;  //如果设备能产生runtime wake-up events事件，就设置该值。
 unsigned int  runtime_auto:1;  //如果设置，则表示用户空间已允许设备驱动程序通过/sys/devices/.../power/control接口在运行时对该设备进行电源管理。
 unsigned int  no_callbacks:1;  //表明该设备不是有Runtime PM callbacks。
 unsigned int  irq_safe:1;  //表示->runtime_suspend()和->runtime_resume()回调函数将在持有自旋锁并禁止中断的情况下被调用。
 unsigned int  use_autosuspend:1;  //表示该设备驱动支持延迟自动休眠功能。
 unsigned int  timer_autosuspends:1;  //表明PM核心应该在定时器到期时尝试进行自动休眠（autosuspend），而不是一个常规的挂起（normal suspend)。
 unsigned int  memalloc_noio:1;  
 enum rpm_request request;  //runtime pm请求类型。
 enum rpm_status  runtime_status;  //runtime pm设备状态。
 int   runtime_error;  //如果该值设备，表明有错误。
 int   autosuspend_delay;  //延迟时间，用于自动休眠。
 unsigned long  last_busy;
 unsigned long  active_jiffies;
 unsigned long  suspended_jiffies;
 unsigned long  accounting_timestamp;

};

Runtime PM运行机制

上面了解了Runtime PM运行时相关的标志之后，可能对runtime已经有了大概的了解，接下来就详细说下runtime的运行机制。

Runtime PM回调约束

Runtime Sys接口

关于runtime sys接口在文件:  /kernel/drivers/base/power/sysfs.c中描述。设备的runtime属性是在dpm_sysfs_add函数中增加的。

 if (pm_runtime_callbacks_present(dev)) {
  rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
  if (rc)
   goto err_out;
 }

runtime的属性如下：

static struct attribute *runtime_attrs[] = {
#ifdef CONFIG_PM_RUNTIME
#ifndef CONFIG_PM_ADVANCED_DEBUG
 &dev_attr_runtime_status.attr,
#endif
 &dev_attr_control.attr,
 &dev_attr_runtime_suspended_time.attr,
 &dev_attr_runtime_active_time.attr,
 &dev_attr_autosuspend_delay_ms.attr,
#endif /* CONFIG_PM_RUNTIME */
 NULL,
};

其中有五个属性。分别为control,  runtime_susupend_time,  runtime_active_time,  autosuspend_delay_ms，runtime_status属性。

/sys/devices/.../power/control

on    -   调用pm_runtime_forbid接口，增加设备的引用计数，然后resume设备。

auto -   调用pm_runtime_allow接口，减少设备的引用计数，如果设备的引用计数为0，则idle设备。

/sys/devices/.../power/runtime_status

active - 设备的状态是正常工作状态。

suspend- 设备的状态是低功耗模式。

suspending-设备的状态正在从active->suspend转化。

resuming-设备的状态正在从suspend->active转化。

error-设备runtime出现错误，此时runtime_error的标志置位。

unsupported-设备的runtime 没有使能，此时disable_depth标志置位。

/sys/devices/.../power/runtime_suspend_time

设备在suspend状态的时间

/sys/devices/.../power/runtime_active_time

设备在active状态的时间

/sys/devices/.../power/autosuspend_delay_ms

设备在idle状态多久之后suspend，设置延迟suspend的延迟时间。

Runtime API

因为Runtime API多达几十个以上，这里列举一些驱动中常用的API供大家参考。

void pm_runtime_enable(struct device *dev)
{
 unsigned long flags;

 spin_lock_irqsave(&dev->power.lock, flags);

 if (dev->power.disable_depth > 0)
  dev->power.disable_depth--;
 else
  dev_warn(dev, "Unbalanced %s!n", __func__);

 spin_unlock_irqrestore(&dev->power.lock, flags);
}

disable_depth在pm_runtime_init会被初始化为1，enabel函数就是将此值减去1而已。当然了在disable函数中会给该值加1。

以上函数接口都比较简单，最终会调用到__pm_runtime_resume/__pm_runtime_suspend/__pm_runtime_idle接口中。

Runtime PM举例

写了一个简单的测试runtime测试例子，如下:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/types.h>
#include <linux/pm_runtime.h>


static int runtime_pm_probe(struct platform_device *pdev)
{
 printk(KERN_EMERG "runtime_pm: runtime_pm_probe!n");
 pm_runtime_set_active(&pdev->dev);
 pm_runtime_enable(&pdev->dev); 
 return 0;
}

static int runtime_pm_remove(struct platform_device *pdev)
{
 printk(KERN_EMERG "runtime_pm: runtime_pm_remove!n");
 pm_runtime_disable(&pdev->dev);
 return 0; 
}

static int runtime_pm_suspend(struct device *dev)
{
 printk(KERN_EMERG "runtime_pm: runtime_pm_suspend!n");
 return 0;
}

static int runtime_pm_resume(struct device *dev)
{
 printk(KERN_EMERG "runtime_pm: runtime_pm_resume!n");
 return 0;
}

static int runtime_pm_idle(struct device *dev)
{
 printk(KERN_EMERG "runtime_pm: runtime_pm_idlen");
 return 0;
}


static const struct dev_pm_ops runtime_pm_ops = {
 SET_RUNTIME_PM_OPS(runtime_pm_suspend,
     runtime_pm_resume,
     runtime_pm_idle)
};

static void runtime_pm_release(struct device * dev)
{
}

static struct platform_device runtime_device = {
 .name  = "runtime_device",
 .id         = -1,
 .dev        = {
         .release = runtime_pm_release,
 },
};

static struct platform_driver runtime_driver = {
 .probe  = runtime_pm_probe,
 .remove  = runtime_pm_remove,
 .driver  = {
  .owner = THIS_MODULE,
  .name = "runtime_device",
  .pm = &runtime_pm_ops,
 },
};

static int runtime_pm_init(void)
{ 
 printk(KERN_EMERG "runtime_pm: runtime_pm_initn");
    platform_device_register(&runtime_device);
 platform_driver_register(&runtime_driver);
 return 0;
}

static void runtime_pm_exit(void)
{
 printk(KERN_EMERG "runtime_pm: runtime_pm_exitn");

 platform_driver_unregister(&runtime_driver);
 platform_device_unregister(&runtime_device);
}

module_init(runtime_pm_init);
module_exit(runtime_pm_exit);
MODULE_LICENSE("GPL");

如下是测试结果：

cat /sys/devices/platform/runtime_device/power/runtime_status

suspend

cat /sys/devices/platform/runtime_device/power/runtime_suspended_time

341028

echo on >  /sys/devices/platform/runtime_device/power/control

echo auto > /sys/devices/platform/runtime_device/power/control

test:/ # dmesg | grep "runtime"                                     
[  451.432602] c7 runtime_pm: runtime_pm_resume!
[  509.842328] c5 runtime_pm: runtime_pm_idle
[  509.846430] c5 runtime_pm: runtime_pm_suspend!