linux驱动程序之电源管理之Run-time PM 详解（4）

Run-time PM.

每个device或者bus都会向run-time PM core注册3个callback

 

struct dev_pm_ops {

...

int (*runtime_suspend)(struct device *dev);

int (*runtime_resume)(struct device *dev);

int (*runtime_idle)(struct device *dev);

...

};

 

每个device或者bus都会有2个计数器，一个是device的usage counter,一个是device的active状态的children个数。

当这个device的两个counter都减少为0的时候。

run-time PM core就会去调用runtime_idle函数，但是这里的idle函数可不是当前device的idle函数。

代码如下：

if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_idle) {

spin_unlock_irq(&dev->power.lock);

 

dev->bus->pm->runtime_idle(dev);

 

spin_lock_irq(&dev->power.lock);

} else if (dev->type && dev->type->pm && dev->type->pm->runtime_idle) {

spin_unlock_irq(&dev->power.lock);

 

dev->type->pm->runtime_idle(dev);

 

spin_lock_irq(&dev->power.lock);

} else if (dev->class && dev->class->pm

   && dev->class->pm->runtime_idle) {

spin_unlock_irq(&dev->power.lock);

 

dev->class->pm->runtime_idle(dev);

 

spin_lock_irq(&dev->power.lock);

}

按照dev->bus, dev->type, dev->class的顺序去调用。

大家会问了，那runtime_suspend函数什么时候调用？

runtime_suspend函数不会被RPM core主动去调用，一般情况下是在bus，或者class的idle函数里去调用。

例如：

static int xxx_runtime_idle(struct device *dev)

{

return pm_schedule_suspend(dev, 50);

}

 

pm_schedule_suspend函数会去调用device里的suspend函数，调用顺序代码如下：

if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend) {

spin_unlock_irq(&dev->power.lock);

 

retval = dev->bus->pm->runtime_suspend(dev);

 

spin_lock_irq(&dev->power.lock);

dev->power.runtime_error = retval;

} else if (dev->type && dev->type->pm

   && dev->type->pm->runtime_suspend) {

spin_unlock_irq(&dev->power.lock);

 

retval = dev->type->pm->runtime_suspend(dev);

 

spin_lock_irq(&dev->power.lock);

dev->power.runtime_error = retval;

} else if (dev->class && dev->class->pm

   && dev->class->pm->runtime_suspend) {

spin_unlock_irq(&dev->power.lock);

 

retval = dev->class->pm->runtime_suspend(dev);

 

spin_lock_irq(&dev->power.lock);

dev->power.runtime_error = retval;

} else {

retval = -ENOSYS;

}

发现了吧，和idle顺序是一模一样哒。当然肯定也会有不一样了，否则runtime_suspend函数没存在意义了。在跑完此dev的bus or type or class的suspend函数以后。紧接着会做一个巨艰巨的任务，就是

if (parent && !parent->power.ignore_children) {

spin_unlock_irq(&dev->power.lock);

 

pm_request_idle(parent);

 

spin_lock_irq(&dev->power.lock);

}

会去调用当前这个device的parent device的idle函数！！！

之后会去递归的往上层调用。为啥会这么做呢？？？

其实RPM机制总体来说就是管理总线结构和主次设备结构的电源。

假如一个bus上有2个device。这个bus首先会有一个bus_type，其次还会有一个代表bus的device（谁说bus不是device了！）首先命名以下，bus device叫做Bdev, 两个bus上的子device是dev1, dev2。dev1,dev2是Bdev的子设备，也就是说dev1,dev2的parent是Bdev。

其中bus_type里会有一套runtime_pm的三个callback，Bdev自身还有另一套runtime_pm的三个callback。

当dev1的两个counter都为零了，就会调用bus_type里的runtime_idle，一般情况下这个idle会调用pm_runtime_suspend，仅按照上面的介绍，就会调用这个bus_type里的runtime_suspend call back。之后是不是就该是最重要的那一步了？pm_request_idle(parent);pm_request_idle里的一系列操作会首先判断parent的两个counter是否为零了，因为dev2还活着呢，所以条件不满足，返回！

当dev2也来这么一套之后，再调用pm_request_idle(parent);的时候，Bdev里的runtime_idle就能跑啦。

总结一下，bus_type的runtime_系列回调函数是用来处理bus上的device函数的。而bus自己的device的函数是用来处理自己的。

因为体系结构的因素，bus套bus的情况，最后就会形成一个device大树。runtime这套机制就可以从根到树顶都能管理得到。比如：I2C device挂在I2C bus上，I2C bus controller是PCI的一个设备，因为挂在PCI上。这个PCI bus一般还是在南桥上，然后再通过南桥在跑到北桥PCI上。。。。是不是块疯了。。。。但是有这么个递归电源管理。一切搞定。

 

说完了睡流程了。还有醒流程。

当device调用完suspend函数后，这个device就处于了一个suspended状态。当某个device被唤醒后，就会调用pm_runtime_get_sync类似的函数。这个函数做了啥捏？通过上述的睡过程，有点脑子的人就能想出醒流程，反着来呗！！！必须从大树顶往下跑，才能最后让根伸出来。代码如下：

 

if (!parent && dev->parent) {

/*

* Increment the parent's resume counter and resume it if

* necessary.

*/

parent = dev->parent;

spin_unlock(&dev->power.lock);

 

pm_runtime_get_noresume(parent);

 

spin_lock(&parent->power.lock);

/*

* We can resume if the parent's run-time PM is disabled or it

* is set to ignore children.

*/

if (!parent->power.disable_depth

   && !parent->power.ignore_children) {

__pm_runtime_resume(parent, false);

if (parent->power.runtime_status != RPM_ACTIVE)

retval = -EBUSY;

}

spin_unlock(&parent->power.lock);

 

spin_lock(&dev->power.lock);

if (retval)

goto out;

goto repeat;

}

首先跑这个device的parent的resume函数。之后

if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume) {

spin_unlock_irq(&dev->power.lock);

 

retval = dev->bus->pm->runtime_resume(dev);

 

spin_lock_irq(&dev->power.lock);

dev->power.runtime_error = retval;

} else if (dev->type && dev->type->pm

   && dev->type->pm->runtime_resume) {

spin_unlock_irq(&dev->power.lock);

 

retval = dev->type->pm->runtime_resume(dev);

 

spin_lock_irq(&dev->power.lock);

dev->power.runtime_error = retval;

} else if (dev->class && dev->class->pm

   && dev->class->pm->runtime_resume) {

spin_unlock_irq(&dev->power.lock);

 

retval = dev->class->pm->runtime_resume(dev);

 

spin_lock_irq(&dev->power.lock);

dev->power.runtime_error = retval;

} else {

retval = -ENOSYS;

}

跑的是bus的resume函数。通过这个函数进行递归，直到递归到树顶后,树顶的resume就开始run了，run完一个往下面继续传，直到我们的这一连串device的resume函数都跑完，我们的device就算醒了。

RPM常用接口如下：

 void pm_runtime_init(struct device *dev);

    - initialize the device run-time PM fields in 'struct dev_pm_info'

 

  void pm_runtime_remove(struct device *dev);

    - make sure that the run-time PM of the device will be disabled after

      removing the device from device hierarchy

 

  int pm_runtime_idle(struct device *dev);

    - execute the subsystem-level idle callback for the device; returns 0 on

      success or error code on failure, where -EINPROGRESS means that

      ->runtime_idle() is already being executed

 

  int pm_runtime_suspend(struct device *dev);

    - execute the subsystem-level suspend callback for the device; returns 0 on

      success, 1 if the device's run-time PM status was already 'suspended', or

      error code on failure, where -EAGAIN or -EBUSY means it is safe to attempt

      to suspend the device again in future

 

  int pm_runtime_resume(struct device *dev);

    - execute the subsystem-level resume callback for the device; returns 0 on

      success, 1 if the device's run-time PM status was already 'active' or

      error code on failure, where -EAGAIN means it may be safe to attempt to

      resume the device again in future, but 'power.runtime_error' should be

      checked additionally

 

  int pm_request_idle(struct device *dev);

    - submit a request to execute the subsystem-level idle callback for the

      device (the request is represented by a work item in pm_wq); returns 0 on

      success or error code if the request has not been queued up

 

  int pm_schedule_suspend(struct device *dev, unsigned int delay);

    - schedule the execution of the subsystem-level suspend callback for the

      device in future, where 'delay' is the time to wait before queuing up a

      suspend work item in pm_wq, in milliseconds (if 'delay' is zero, the work

      item is queued up immediately); returns 0 on success, 1 if the device's PM

      run-time status was already 'suspended', or error code if the request

      hasn't been scheduled (or queued up if 'delay' is 0); if the execution of

      ->runtime_suspend() is already scheduled and not yet expired, the new

      value of 'delay' will be used as the time to wait

 

  int pm_request_resume(struct device *dev);

    - submit a request to execute the subsystem-level resume callback for the

      device (the request is represented by a work item in pm_wq); returns 0 on

      success, 1 if the device's run-time PM status was already 'active', or

      error code if the request hasn't been queued up

 

  void pm_runtime_get_noresume(struct device *dev);

    - increment the device's usage counter

 

  int pm_runtime_get(struct device *dev);

    - increment the device's usage counter, run pm_request_resume(dev) and

      return its result

 

  int pm_runtime_get_sync(struct device *dev);

    - increment the device's usage counter, run pm_runtime_resume(dev) and

      return its result

 

  void pm_runtime_put_noidle(struct device *dev);

    - decrement the device's usage counter

 

  int pm_runtime_put(struct device *dev);

    - decrement the device's usage counter, run pm_request_idle(dev) and return

      its result

 

  int pm_runtime_put_sync(struct device *dev);

    - decrement the device's usage counter, run pm_runtime_idle(dev) and return

      its result

 

  void pm_runtime_enable(struct device *dev);

    - enable the run-time PM helper functions to run the device bus type's

      run-time PM callbacks described in Section 2

 

  int pm_runtime_disable(struct device *dev);

    - prevent the run-time PM helper functions from running subsystem-level

      run-time PM callbacks for the device, make sure that all of the pending

      run-time PM operations on the device are either completed or canceled;

      returns 1 if there was a resume request pending and it was necessary to

      execute the subsystem-level resume callback for the device to satisfy that

      request, otherwise 0 is returned

 

  void pm_suspend_ignore_children(struct device *dev, bool enable);

    - set/unset the power.ignore_children flag of the device

 

  int pm_runtime_set_active(struct device *dev);

    - clear the device's 'power.runtime_error' flag, set the device's run-time

      PM status to 'active' and update its parent's counter of 'active'

      children as appropriate (it is only valid to use this function if

      'power.runtime_error' is set or 'power.disable_depth' is greater than

      zero); it will fail and return error code if the device has a parent

      which is not active and the 'power.ignore_children' flag of which is unset

 

  void pm_runtime_set_suspended(struct device *dev);

    - clear the device's 'power.runtime_error' flag, set the device's run-time

      PM status to 'suspended' and update its parent's counter of 'active'

      children as appropriate (it is only valid to use this function if

      'power.runtime_error' is set or 'power.disable_depth' is greater than

      zero)

 

  bool pm_runtime_suspended(struct device *dev);

    - return true if the device's runtime PM status is 'suspended', or false

      otherwise

 

  void pm_runtime_allow(struct device *dev);

    - set the power.runtime_auto flag for the device and decrease its usage

      counter (used by the /sys/devices/.../power/control interface to

      effectively allow the device to be power managed at run time)

 

  void pm_runtime_forbid(struct device *dev);

    - unset the power.runtime_auto flag for the device and increase its usage

      counter (used by the /sys/devices/.../power/control interface to

      effectively prevent the device from being power managed at run time)

可以中断里跑的接口：

pm_request_idle()

pm_schedule_suspend()

pm_request_resume()

pm_runtime_get_noresume()

pm_runtime_get()

pm_runtime_put_noidle()

pm_runtime_put()

pm_suspend_ignore_children()

pm_runtime_set_active()

pm_runtime_set_suspended()

pm_runtime_enable()