linux pm runtime

来源：互联网发布：linux移动文件到桌面编辑：程序博客网时间：2024/06/05 10:51

pm runtime核心只提供机制（功能），什么的时候上电/掉电等策略应由driver去实现。 driver里实现的pm runtime的call back函数被runtime 核心封装了起来，会暴露一些API接口来间接的调用这么Call back函数。

pm runtime利用了一个工作队列pm_wq来负责具体的电源事务，上电和下电有同步和异步之分：

设备状态在PM runtime中的表示

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

用于电源请求的类型，当工作队列执行一个work时，会判断请求的类型，从而执行不同的函数(rpm_idle, rpm_suspend, rpm_resume)

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

device_register->device_init->deviec_pm_init->pm_runtime_init

void pm_runtime_init(struct device *dev) {

dev->power.runtime_status = RPM_SUSPENDED; //设备默认是SUSPEND状态，和设备的实际状态可能不一样
dev->power.idle_notification = false;

dev->power.disable_depth = 1; //设备的PM runtime 默认是禁止的
atomic_set(&dev->power.usage_count, 0);

dev->power.runtime_error = 0;

atomic_set(&dev->power.child_count, 0);
pm_suspend_ignore_children(dev, false);
dev->power.runtime_auto = true; //这里的auto指得是是否开启runtime

dev->power.request_pending = false;
dev->power.request = RPM_REQ_NONE;
dev->power.deferred_resume = false;
dev->power.accounting_timestamp = jiffies;
INIT_WORK(&dev->power.work, pm_runtime_work); //当向pm_wq工作队列提交一个工作时，将会执行pm_runtime_work函数

dev->power.timer_expires = 0;
setup_timer(&dev->power.suspend_timer, pm_suspend_timer_fn, //延时提交一个电源事件的定时器函数
(unsigned long)dev);

init_waitqueue_head(&dev->power.wait_queue);

}

static void pm_runtime_work(struct work_struct *work)
{
struct device *dev = container_of(work, struct device, power.work);
enum rpm_request req;

spin_lock_irq(&dev->power.lock);

if (!dev->power.request_pending)
goto out;

req = dev->power.request;
dev->power.request = RPM_REQ_NONE;
dev->power.request_pending = false;

switch (req) { //根据请求的类型，执行不同的核心函数， rpm_idle, rpm_suspend, rpm_resume应该是PM runtime的三个核心函数，其它的外部API都是基于这三个

函数实现的 + 定时器 + 其它的逻辑判断，而三个核心函数的实现则是基于工作队列pm_wq来实现异步操作的
case RPM_REQ_NONE:
break;
case RPM_REQ_IDLE:
rpm_idle(dev, RPM_NOWAIT);
break;
case RPM_REQ_SUSPEND:
rpm_suspend(dev, RPM_NOWAIT);    //注意，这里的函数都是同步的，也就是直接调用相应的Call back函数的,如果这里也是异步调用的话，那Call back函数应该不会被执行到
break;
case RPM_REQ_AUTOSUSPEND:
rpm_suspend(dev, RPM_NOWAIT | RPM_AUTO);
break;
case RPM_REQ_RESUME:
rpm_resume(dev, RPM_NOWAIT);
break;
}

out:
spin_unlock_irq(&dev->power.lock);
}

static void pm_suspend_timer_fn(unsigned long data) //auto-suspend的定时器函数
{
struct device *dev = (struct device *)data;
unsigned long flags;
unsigned long expires;

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

expires = dev->power.timer_expires;
/* If 'expire' is after 'jiffies' we've been called too early. */
if (expires > 0 && !time_after(expires, jiffies)) {
dev->power.timer_expires = 0;
rpm_suspend(dev, dev->power.timer_autosuspends ? //向pm_wq工作队列提交一个异步的suspend工作.
(RPM_ASYNC | RPM_AUTO) : RPM_ASYNC);
}

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

pm_runtime_put_sync_suspend(dev)

-->__pm_runtime_suspend(dev, RPM_GET_PUT) //没有指定RPM_ASYNC标志，默认是同步

-->rpm_suspend

static int rpm_suspend(struct device *dev, int rpmflags) {

...

repeat:
retval = rpm_check_suspend_allowed(dev); //会检查一下是否允许设备suspend.

if (retval < 0)
; /* Conditions are wrong. */
/* Synchronous suspends are not allowed in the RPM_RESUMING state. */
else if (dev->power.runtime_status == RPM_RESUMING &&
!(rpmflags & RPM_ASYNC))
retval = -EAGAIN;
if (retval)
goto out

...

/* Carry out an asynchronous or a synchronous suspend. */
if (rpmflags & RPM_ASYNC) { //异步
dev->power.request = (rpmflags & RPM_AUTO) ?
RPM_REQ_AUTOSUSPEND : RPM_REQ_SUSPEND;
if (!dev->power.request_pending) {
dev->power.request_pending = true;
queue_work(pm_wq, &dev->power.work); //向工作队列提交一个work
}
goto out; //异步的话就直接退出了
}

if (dev->pm_domain) // 回调函数的选择： domain->type->class->bus.
callback = dev->pm_domain->ops.runtime_suspend;
else if (dev->type && dev->type->pm)
callback = dev->type->pm->runtime_suspend;
else if (dev->class && dev->class->pm)
callback = dev->class->pm->runtime_suspend;
else if (dev->bus && dev->bus->pm) /*以platform_bus为例，它的dev_pm_ops为platform_dev_pm_ops, 定义为

static const struct dev_pm_ops platform_dev_pm_ops = {
.runtime_suspend = pm_generic_runtime_suspend, //该函数会判断driver里的dev_pm_ops有没有被实现，如果有的话，调用driver的回调函数
.runtime_resume = pm_generic_runtime_resume,
.runtime_idle = pm_generic_runtime_idle, //如果设备的driver定义了相应的runtime_idle函数，调用之，如果没有出错的话，在调用pm_runtime_suspend(同步版本)
USE_PLATFORM_PM_SLEEP_OPS
};

*/
callback = dev->bus->pm->runtime_suspend;
else
callback = NULL;

if (!callback && dev->driver && dev->driver->pm) //driver的pm runtime回调
callback = dev->driver->pm->runtime_suspend;

retval = rpm_callback(callback, dev); //执行回调函数
if (retval)
goto fail;

no_callback:
__update_runtime_status(dev, RPM_SUSPENDED);
pm_runtime_deactivate_timer(dev);

if (dev->parent) {
parent = dev->parent;
atomic_add_unless(&parent->power.child_count, -1, 0); //子设备已经下电，减少父设备的child_count计数器，每个设备有自己的使用计数器和子设备的active计数

...

/* Maybe the parent is now able to suspend. */
if (parent && !parent->power.ignore_children && !dev->power.irq_safe) { //如果父设备的子设备都已经suspend，尝试关掉父设备，一直递归上去
spin_unlock(&dev->power.lock);

spin_lock(&parent->power.lock);
rpm_idle(parent, RPM_ASYNC);
spin_unlock(&parent->power.lock);

spin_lock(&dev->power.lock);
}

}

static int rpm_check_suspend_allowed(struct device *dev)
{
int retval = 0;

if (dev->power.runtime_error)
retval = -EINVAL;
else if (dev->power.disable_depth > 0) //通过__pm_runtime_disable来暂时禁用runtime
retval = -EACCES;
else if (atomic_read(&dev->power.usage_count) > 0) //设备正在使用中
retval = -EAGAIN;
else if (!pm_children_suspended(dev)) //子设备还在使用中，父设备不能suspend，除非父设备自身设定了ignore_children标志
retval = -EBUSY;

/* Pending resume requests take precedence over suspends. */ //resume过程的优先级高点。。。
else if ((dev->power.deferred_resume
&& dev->power.runtime_status == RPM_SUSPENDING)
|| (dev->power.request_pending
&& dev->power.request == RPM_REQ_RESUME))
retval = -EAGAIN;
else if (__dev_pm_qos_read_value(dev) < 0)
retval = -EPERM;
else if (dev->power.runtime_status == RPM_SUSPENDED) //设备已经suspend过了
retval = 1;

return retval;
}

一个API的调用，会引发一连串的函数调用和影响。。。