从电源模块的初始化函数(pm_init)开始分析:
/kernel/power/main.c
static int __init pm_init(void)
{
int error = pm_start_workqueue();
if (error)
return error;
hibernate_image_size_init();
hibernate_reserved_size_init();
power_kobj = kobject_create_and_add("power", NULL);//创建一个power的kobject
if (!power_kobj)
return -ENOMEM;
return sysfs_create_group(power_kobj, &attr_group);//生成power的sys文件并返回
}
core_initcall(pm_init);
调用sysfs_create_group在指定目录下生成sysfs文件。
static struct attribute_group attr_group = {
.attrs = g,
};static struct attribute * g[] = {
&state_attr.attr,
#ifdef CONFIG_PM_TRACE
&pm_trace_attr.attr,
&pm_trace_dev_match_attr.attr,
#endif
#ifdef CONFIG_PM_SLEEP
&pm_async_attr.attr,
&wakeup_count_attr.attr,
#ifdef CONFIG_PM_DEBUG
&pm_test_attr.attr,
#endif
#ifdef CONFIG_USER_WAKELOCK
&wake_lock_attr.attr,
&wake_unlock_attr.attr,
#endif
#endif
&phone_actived_attr.attr,
NULL,
};至此，电源管理模块的初始化函数就已经完成，用户可以通过/sys/power/state来实现控制系统的电源状态。这里的sys文件操作使用了power_attr函数来声明。
#define power_attr(_name) \
static struct kobj_attribute _name##_attr = { \
.attr = { \
.name = __stringify(_name), \
.mode = 0644, \
}, \
.show = _name##_show, \
.store = _name##_store, \
}/* If set, devices may be suspended and resumed asynchronously. */
int pm_async_enabled = 1;
static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
char *buf)
{
return sprintf(buf, "%d\n", pm_async_enabled); //通过sprintf函数直接输出其内容
}
static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
const char *buf, size_t n)
{
unsigned long val;
if (strict_strtoul(buf, 10, &val))
return -EINVAL;
if (val > 1)
return -EINVAL;
pm_async_enabled = val;
return n;
}
power_attr(pm_async);我们暂且看一下strict_strtoul这个函数 ./linux-3.3/include/linux/kernel.h
#define strict_strtoul kstrtoul
static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res)
{
/*
* We want to shortcut function call, but
* __builtin_types_compatible_p(unsigned long, unsigned long long) = 0.
*/
if (sizeof(unsigned long) == sizeof(unsigned long long) &&
__alignof__(unsigned long) == __alignof__(unsigned long long))
return kstrtoull(s, base, (unsigned long long *)res);
else
return _kstrtoul(s, base, res);
}
/* Internal, do not use. */
int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
{
unsigned long long tmp;
int rv;
rv = kstrtoull(s, base, &tmp);
if (rv < 0)
return rv;
if (tmp != (unsigned long long)(unsigned long)tmp)
return -ERANGE;
*res = tmp;
return 0;
}
EXPORT_SYMBOL(_kstrtoul); change a module parameter in the following way:
echo 1024 > /sys/module/e1000/parameters/copybreak
echo will append a newline to the tail.
It returns 0 if conversion is successful and *res is set to the converted value, otherwise it returns -EINVAL and *res is set to 0.
现在来看电源管理状态操作的核心部分——power_attr(state)操作
struct kobject *power_kobj;
/**
* state - control system power state.
*
* show() returns what states are supported, which is hard-coded to
* 'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and
* 'disk' (Suspend-to-Disk).
*
* store() accepts one of those strings, translates it into the
* proper enumerated value, and initiates a suspend transition.
*/
static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
char *buf)
{
char *s = buf;
#ifdef CONFIG_SUSPEND
int i;
for (i = 0; i < PM_SUSPEND_MAX; i++) {
if (pm_states[i] && valid_state(i))
s += sprintf(s,"%s ", pm_states[i]);
}
#endif
#ifdef CONFIG_HIBERNATION
s += sprintf(s, "%s\n", "disk");
#else
if (s != buf)
/* convert the last space to a newline */
*(s-1) = '\n';
#endif
return (s - buf);
}
static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
const char *buf, size_t n)
{
#ifdef CONFIG_SUSPEND
#ifdef CONFIG_EARLYSUSPEND
suspend_state_t state = PM_SUSPEND_ON;
#else
suspend_state_t state = PM_SUSPEND_STANDBY;
#endif
const char * const *s;
#endif
char *p;
int len;
int error = -EINVAL;
p = memchr(buf, '\n', n);
len = p ? p - buf : n;
/* First, check if we are requested to hibernate */
if (len == 4 && !strncmp(buf, "disk", len)) {
error = hibernate();
goto Exit;
}
#ifdef CONFIG_SUSPEND
for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {
if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
break;
}
if (state < PM_SUSPEND_MAX && *s) {
#ifdef CONFIG_EARLYSUSPEND
if (state == PM_SUSPEND_ON || valid_state(state)) { //请求中断状态
error = 0;
request_suspend_state(state); //============Android系统从这个地方进入
}
#else
error = enter_state(state);
if (error) {
suspend_stats.fail++;
dpm_save_failed_errno(error);
} else
suspend_stats.success++;
#endif
}
#endif
Exit:
return error ? error : n;
}
power_attr(state);const char *const pm_states[PM_SUSPEND_MAX] = {
#ifdef CONFIG_EARLYSUSPEND
[PM_SUSPEND_ON] = "on",
#endif
[PM_SUSPEND_STANDBY] = "standby",
[PM_SUSPEND_MEM] = "mem",
[PM_SUSPEND_BOOTFAST] = "bootfast",
};static struct platform_driver axp_battery_driver = {
.driver = {
.name = "axp22-supplyer",
.owner = THIS_MODULE,
},
.probe = axp_battery_probe,
.remove = axp_battery_remove,
.suspend = axp22_suspend,
.resume = axp22_resume,
.shutdown = axp22_shutdown,
};
static int axp_battery_init(void)
{
int ret =0;
ret = platform_driver_register(&axp_battery_driver);
return ret;
}
static void axp_battery_exit(void)
{
platform_driver_unregister(&axp_battery_driver);
}
subsys_initcall(axp_battery_init);
module_exit(axp_battery_exit);void request_suspend_state(suspend_state_t new_state)
{
unsigned long irqflags;
int old_sleep;
spin_lock_irqsave(&state_lock, irqflags);//保存本地中断状态并关闭，获取自旋锁
old_sleep = state & SUSPEND_REQUESTED;
if (debug_mask & DEBUG_USER_STATE) {
struct timespec ts;
struct rtc_time tm;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
pr_info("request_suspend_state: %s (%d->%d) at %lld "
"(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",
new_state != PM_SUSPEND_ON ? "sleep" : "wakeup",
requested_suspend_state, new_state,
ktime_to_ns(ktime_get()),
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
}
if (!old_sleep && new_state != PM_SUSPEND_ON) {
state |= SUSPEND_REQUESTED;
#ifdef CONFIG_EARLYSUSPEND_DELAY
/* delay 5 seconds to enter suspend */
wake_unlock(&ealysuspend_delay_work);
wake_lock_timeout(&ealysuspend_delay_work, HZ * 5);
#endif
queue_work(suspend_work_queue, &early_suspend_work);//请求中断，则将early_suspend_work加入到队列排队,
//调用early_suspend_work完成一级休眠工作
} else if (old_sleep && new_state == PM_SUSPEND_ON) { //中断之后的恢复
state &= ~SUSPEND_REQUESTED;
wake_lock(&main_wake_lock);
queue_work(suspend_work_queue, &late_resume_work); //late_resume_work加入到队列
}
requested_suspend_state = new_state;
spin_unlock_irqrestore(&state_lock, irqflags);//完成释放锁、恢复本地中断到之前的状态
}static DECLARE_WORK(early_suspend_work, early_suspend);
static DECLARE_WORK(late_resume_work, late_resume);void register_early_suspend(struct early_suspend *handler)
{
struct list_head *pos;
mutex_lock(&early_suspend_lock);
list_for_each(pos, &early_suspend_handlers) {
struct early_suspend *e;
e = list_entry(pos, struct early_suspend, link);
if (e->level > handler->level)
break;
}
list_add_tail(&handler->link, pos);
if ((state & SUSPENDED) && handler->suspend)
handler->suspend(handler);
mutex_unlock(&early_suspend_lock);
}
EXPORT_SYMBOL(register_early_suspend);
void unregister_early_suspend(struct early_suspend *handler)
{
mutex_lock(&early_suspend_lock);
list_del(&handler->link);
mutex_unlock(&early_suspend_lock);
}
EXPORT_SYMBOL(unregister_early_suspend);
在注册函数中将支持中断设备的early_suspend的handler添加到early_suspend_handlers链表。然后在注销函数中将early_suspend_handlers链表清除即可。
=====early_suspend=====完成一级休眠工作
static void early_suspend(struct work_struct *work)
{
struct early_suspend *pos;
unsigned long irqflags;
int abort = 0;
ktime_t calltime;
u64 usecs64;
int usecs;
ktime_t starttime;
mutex_lock(&early_suspend_lock);
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPEND_REQUESTED)//检查请求状态是否是suspend
state |= SUSPENDED;
else
abort = 1;
spin_unlock_irqrestore(&state_lock, irqflags);
if (abort) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: abort, state %d\n", state);
mutex_unlock(&early_suspend_lock);
goto abort;
}
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: call handlers\n");
list_for_each_entry(pos, &early_suspend_handlers, link) {//遍历链表依次调用每个驱动的handler
if (pos->suspend != NULL) {
if (debug_mask & DEBUG_VERBOSE){
pr_info("early_suspend: calling %pf\n", pos->suspend);
starttime = ktime_get();
}
pos->suspend(pos);//中断,调用二级休眠入口函数suspend
if (debug_mask & DEBUG_VERBOSE){
calltime = ktime_get();
usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
do_div(usecs64, NSEC_PER_USEC);
usecs = usecs64;
if (usecs == 0)
usecs = 1;
pr_info("early_suspend: %pf complete after %ld.%03ld msecs\n",
pos->suspend, usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
}
}
}
standby_level = STANDBY_WITH_POWER;
mutex_unlock(&early_suspend_lock);
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: sync\n");
queue_work(sync_work_queue, &sync_system_work);//同步文件系统sync_system
abort:
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPEND_REQUESTED_AND_SUSPENDED)
wake_unlock(&main_wake_lock);//释放main_wake_lock,这是个没有超时的锁，若不释放系统无法进入休眠
spin_unlock_irqrestore(&state_lock, irqflags);
}suspend调用pm_suspend，再调用enter_state（这里才是真正的二级待机入口）
唤醒恢复
唤醒通常有以下几种原因：
1):来电。如果是来电，那么Modem会通过RILD守护进程主动上报给Android系统，并通知WindowManager有来电响应，这样就会远程调用PowerManagerService将"on"写入到//sys/power/state中，从而启用late resume的设。
2):用户按键。用户按键事件会发送到WindowManager中，WindowManager会处理这些按键事件。按键分为几种情况，如果按键不是唤醒键，那么WindowManager会主动放弃WakeLock来使用系统进入再次休眠状态；如果是唤醒键，那么WindowManager就会调用PowerManagerService中的接口来执行Late Resume.
static void late_resume(struct work_struct *work)
{
struct early_suspend *pos;
unsigned long irqflags;
int abort = 0;
ktime_t calltime;
u64 usecs64;
int usecs;
ktime_t starttime;
mutex_lock(&early_suspend_lock);
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPENDED)
state &= ~SUSPENDED;
else
abort = 1;
spin_unlock_irqrestore(&state_lock, irqflags);
if (abort) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("late_resume: abort, state %d\n", state);
goto abort;
}
if (debug_mask & DEBUG_SUSPEND)
pr_info("late_resume: call handlers\n");
list_for_each_entry_reverse(pos, &early_suspend_handlers, link) {//遍历链表
if (pos->resume != NULL) {
if (debug_mask & DEBUG_VERBOSE){
pr_info("late_resume: calling %pf\n", pos->resume);
starttime = ktime_get();
}
pos->resume(pos);//恢复
if (debug_mask & DEBUG_VERBOSE){
calltime = ktime_get();
usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
do_div(usecs64, NSEC_PER_USEC);
usecs = usecs64;
if (usecs == 0)
usecs = 1;
pr_info("late_resume: %pf complete after %ld.%03ld msecs\n",
pos->resume, usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
}
}
}
if (debug_mask & DEBUG_SUSPEND)
pr_info("late_resume: done\n");
standby_level = STANDBY_INITIAL;
abort:
mutex_unlock(&early_suspend_lock);
}下面来分析从非中断状态直接进入enter_state函数所执行的操作，该函数的定义如下:
/**
* enter_state - Do common work of entering low-power state.
* @state: pm_state structure for state we're entering.
*
* Make sure we're the only ones trying to enter a sleep state. Fail
* if someone has beat us to it, since we don't want anything weird to
* happen when we wake up.
* Then, do the setup for suspend, enter the state, and cleaup (after
* we've woken up).
*/
int enter_state(suspend_state_t state)
{
int error;
if (!valid_state(state)) //检测状态是否有效
return -ENODEV;
if (!mutex_trylock(&pm_mutex)) //加锁
return -EBUSY;
printk(KERN_INFO "PM: Syncing filesystems ... ");
sys_sync(); //同步更新文件系统
printk("done.\n");
pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
error = suspend_prepare(); //中断准备
if (error)
goto Unlock;
if (suspend_test(TEST_FREEZER)) //中断检测
goto Finish;
pr_debug("PM: Entering %s sleep\n", pm_states[state]);
pm_restrict_gfp_mask();
error = suspend_devices_and_enter(state); //中断外部设备
pm_restore_gfp_mask();
Finish:
pr_debug("PM: Finishing wakeup.\n");
suspend_finish(); //中断完成
Unlock:
mutex_unlock(&pm_mutex);
return error;
}/**
* suspend_prepare - Do prep work before entering low-power state.
*
* This is common code that is called for each state that we're entering.
* Run suspend notifiers, allocate a console and stop all processes.
*/
static int suspend_prepare(void)
{
int error;
if (!suspend_ops || !suspend_ops->enter)
return -EPERM;
pm_prepare_console();//分配一个虚拟终端来输出信息
error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);//运行暂停、中断通知器
if (error)
goto Finish;
error = usermodehelper_disable();//关闭用户态的helper进程
if (error)
goto Finish;
error = suspend_freeze_processes();//进程冻结，并保存所有进程的当前状态
if (!error)
return 0;
suspend_stats.failed_freeze++; //冻结进程失败
dpm_save_failed_step(SUSPEND_FREEZE);
usermodehelper_enable();
Finish:
pm_notifier_call_chain(PM_POST_SUSPEND);//发送中断请求
pm_restore_console();//重置控制台
return error;
}/**
* suspend_devices_and_enter - suspend devices and enter the desired system
* sleep state.
* @state: state to enter
*/
int suspend_devices_and_enter(suspend_state_t state)
{
int error;
bool wakeup = false;
if (!suspend_ops)
return -ENOSYS;
trace_machine_suspend(state);
if (suspend_ops->begin) {//开始
error = suspend_ops->begin(state);
if (error)
goto Close;
}
suspend_console(); //控制台子系统进入休眠
suspend_test_start(); //中断测试开始
error = dpm_suspend_start(PMSG_SUSPEND);//Device suspend
if (error) {
printk(KERN_ERR "PM: Some devices failed to suspend\n");
goto Recover_platform;
}
suspend_test_finish("suspend devices");//中断测试结束
if (suspend_test(TEST_DEVICES))//测试要中断的设备
goto Recover_platform;
do {
error = suspend_enter(state, &wakeup);//中断处理
} while (!error && !wakeup
&& suspend_ops->suspend_again && suspend_ops->suspend_again());
Resume_devices:
suspend_test_start();
dpm_resume_end(PMSG_RESUME);
suspend_test_finish("resume devices");
resume_console();
Close:
if (suspend_ops->end)
suspend_ops->end();
trace_machine_suspend(PWR_EVENT_EXIT);
return error;
Recover_platform:
if (suspend_ops->recover)
suspend_ops->recover();
goto Resume_devices;
}/**
* dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
* @state: PM transition of the system being carried out.
*/
int dpm_suspend(pm_message_t state)//遍历链表调用设备的prepare函数
{
ktime_t starttime = ktime_get();
int error = 0;
might_sleep();
mutex_lock(&dpm_list_mtx);
pm_transition = state;
async_error = 0;
while (!list_empty(&dpm_prepared_list)) {
struct device *dev = to_device(dpm_prepared_list.prev);
get_device(dev);
mutex_unlock(&dpm_list_mtx);
error = device_suspend(dev);
mutex_lock(&dpm_list_mtx);
if (error) {
pm_dev_err(dev, state, "", error);
dpm_save_failed_dev(dev_name(dev));
put_device(dev);
break;
}
if (!list_empty(&dev->power.entry))
list_move(&dev->power.entry, &dpm_suspended_list);
put_device(dev);
if (async_error)
break;
}
mutex_unlock(&dpm_list_mtx);
async_synchronize_full();
if (!error)
error = async_error;
if (error) {
suspend_stats.failed_suspend++;
dpm_save_failed_step(SUSPEND_SUSPEND);
} else
dpm_show_time(starttime, state, NULL);
return error;
}
/**
* dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
* @state: PM transition of the system being carried out.
*
* Execute the ->prepare() callback(s) for all devices.
*/
int dpm_prepare(pm_message_t state)//遍历链表调用设备的prepare函数
{
int error = 0;
might_sleep();
mutex_lock(&dpm_list_mtx);
while (!list_empty(&dpm_list)) {
struct device *dev = to_device(dpm_list.next);
get_device(dev);
mutex_unlock(&dpm_list_mtx);
error = device_prepare(dev, state);
mutex_lock(&dpm_list_mtx);
if (error) {
if (error == -EAGAIN) {
put_device(dev);
error = 0;
continue;
}
printk(KERN_INFO "PM: Device %s not prepared "
"for power transition: code %d\n",
dev_name(dev), error);
put_device(dev);
break;
}
dev->power.is_prepared = true;
if (!list_empty(&dev->power.entry))
list_move_tail(&dev->power.entry, &dpm_prepared_list);
put_device(dev);
}
mutex_unlock(&dpm_list_mtx);
return error;
}
/**
* dpm_suspend_start - Prepare devices for PM transition and suspend them.
* @state: PM transition of the system being carried out.
*
* Prepare all non-sysdev devices for system PM transition and execute "suspend"
* callbacks for them.
*/
int dpm_suspend_start(pm_message_t state)
{
int error;
error = dpm_prepare(state);
if (error) {
suspend_stats.failed_prepare++;
dpm_save_failed_step(SUSPEND_PREPARE);
} else
error = dpm_suspend(state);
return error;
}
EXPORT_SYMBOL_GPL(dpm_suspend_start);
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
