---
title: "Android在标准linux基础上对休眠唤醒的实现(一)"
author: "mmdev"
date: "2011-12-08T16:29:00Z"
tags: []
slug: "android-linux"
draft: false
lastmod: "2011-12-10T16:03:39Z"
id: 1301202
url: "https://mmdev.iteye.com/blog/1301202"
---

看到了一些好文章，作者写得非常好，放进来自己仔细研究下。

转自：[http://blog.csdn.net/lizhiguo0532/article/details/6453581](http://blog.csdn.net/lizhiguo0532/article/details/6453581)

说明：

1.Based on linux 2.6.32 and android 2.2，only support SDR(mem).

2.参考文章：

[http://2695477.blog.51cto.com/blog/2685477/484751](http://2695477.blog.51cto.com/blog/2685477/484751)

[http://www.docin.com/p-115475680.html](http://www.docin.com/p-115475680.html)

[http://blogold.chinaunix.net/u3/113927/showart\_2447111.html](http://blogold.chinaunix.net/u3/113927/showart_2447111.html)

[http://www.cnmsdn.com/html/201003/1269407632ID2530.html](http://www.cnmsdn.com/html/201003/1269407632ID2530.html)

**一、新增特性介绍**

实际上，android仍然是利用了标准linux的休眠唤醒系统，只不过添加了一些使用上的新特性，early suspend、late resume、wake lock。

Early suspend-这个机制定义了在suspend的早期，关闭显示屏的时候，一些和显示屏相关的设备，比如背光、重力感应器和触摸屏等设备都应该被关掉，但是此时系统可能还有持有wake lock的任务在运行，如音乐播放，电话，或者扫描sd卡上的文件等，这个时候整个系统还不能进入真正睡眠，直到所有的wake lock都没释放。在嵌入式设备中，悲观是一个很大的电源消耗，所有android加入了这种机制。

Late resume-这个机制定义了在resume的后期，也就是唤醒源已经将处理器唤醒，标准linux的唤醒流程已经走完了，在android上层系统识别出这个物理上的唤醒源是上层定义的，那么上层将会发出late resume的命令给下层，这个时候将会调用相关设备注册的late resume回调函数。

Wake lock- wakelock在android的电源管理系统中扮演一个核心的角色，wakelock是一种锁的机制,只要有task拿着这个锁,系统就无法进入休眠,可以被用户态进程和内核线程获得。这个锁可以是有超时的或者是没有超时的,超时的锁会在时间过去以后自动解锁。如果没有锁了或者超时了,内核就会启动标准linux的那套休眠机制机制来进入休眠。

**二、kernel层源码解析- early suspend和late resume实现**

相关源码：

kernel/kernel/power/main.c

kernel/kernel/power/earlysuspend.c

kernel/kernel/power/wakelock.c

kernel/kernel/power/userwakelock.c

kernel/kernel/power/suspend.c

之前标准的linux的sysfs的接口只需要一个state就够了，现在至少需要3个接口文件：state、wake\_lock、wake\_unlock。现在为了配合android为休眠唤醒添加的几种新特性，可以填入文件state的模式又多了一种：on,标准android系统中只支持state的on和mem模式，其余的暂不支持。wake\_lock和wake\_unlock接口对应的读写函数在文件userwakelock.c中，对wakelock.c中的create wakelock或者release wakelock进行了封装，供用户空间来使用。

如果上层用户执行:echo xxx(on or mem) &gt; sys/power/state的话，将会调用到如下函数：

static ssize\_tstate\_store(struct kobject \*kobj, struct kobj\_attribute \*attr,

const char \*buf, size\_t n)

{

#ifdef CONFIG\_SUSPEND// set

#ifdefCONFIG\_EARLYSUSPEND//set

suspend\_state\_t state = PM\_SUSPEND\_ON;// for early suspend and late resume

#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();//检查是否要求进入disk省电模式，暂时不支持

goto Exit;

}

#ifdef CONFIG\_SUSPEND// def

for (s = &pm\_states\[state]; state &lt; PM\_SUSPEND\_MAX; s++, state++) {

if (\*s && len == strlen(\*s) && !strncmp(buf, \*s, len))

break;

}

if (state &lt; PM\_SUSPEND\_MAX && \*s)

#ifdefCONFIG\_EARLYSUSPEND

if (state == PM\_SUSPEND\_ON || valid\_state(state)) {

//需要经过平台pm.c文件定义的模式支持检查函数，mtk只支持mem，同时如果是android发送出来的late resume命令(on)，这里也会放行，往下执行

error = 0;

request\_suspend\_state(state);// android休眠唤醒的路线

}

#else

error =enter\_state(state);//标准linux休眠唤醒的路线

#endif

#endif

Exit:

return error ? error : n;

}

@ kernel/kernel/power/earlysuspend.c

enum {

DEBUG\_USER\_STATE = 1U &lt;&lt; 0,

DEBUG\_SUSPEND = 1U &lt;&lt; 2,

};

int Earlysuspend\_debug\_mask = DEBUG\_USER\_STATE;

module\_param\_named(Earlysuspend\_debug\_mask, Earlysuspend\_debug\_mask, int, S\_IRUGO | S\_IWUSR | S\_IWGRP);

static DEFINE\_MUTEX(early\_suspend\_lock);

static LIST\_HEAD(early\_suspend\_handlers);

static void early\_sys\_sync(struct work\_struct \*work);

static void early\_suspend(struct work\_struct \*work);

static void late\_resume(struct work\_struct \*work);

static DECLARE\_WORK(early\_sys\_sync\_work, early\_sys\_sync);

static DECLARE\_WORK(early\_suspend\_work, early\_suspend);

static DECLARE\_WORK(late\_resume\_work, late\_resume);

static DEFINE\_SPINLOCK(state\_lock);

enum {

SUSPEND\_REQUESTED = 0x1,

SUSPENDED = 0x2,

SUSPEND\_REQUESTED\_AND\_SUSPENDED = SUSPEND\_REQUESTED | SUSPENDED,

};

static int state;//初始化为0

static DECLARE\_COMPLETION(fb\_drv\_ready);

voidrequest\_suspend\_state(suspend\_state\_t new\_state)

{

unsigned long irqflags;

int old\_sleep;

spin\_lock\_irqsave(&state\_lock, irqflags);

old\_sleep = state & SUSPEND\_REQUESTED;// state = 1 or 3

// state的值会在0-&gt;1-&gt;3-&gt;2-&gt;0循环变化，后面分析代码都可以看出这些值代表系统目前处于什么阶段，简单得说就是：正常-&gt;准备进early suspend-&gt;开始early suspend并且对名为mian的wakelock解锁，如果此时没有其余wakelock处于lock状态，那么系统就走linux的休眠唤醒路线让整个系统真正休眠，直到唤醒源发生，然后将处理器和linux层唤醒。之后android层判断本次底层醒来是由于我所定义的唤醒源引起的吗？如果不是，android将不予理会，过段时间没有wakelock锁，系统会再次走linux的休眠路线进入休眠。如果是，那么android上层就会写一个on的指令到state接口中，同样是会调用到函数request\_suspend\_state()-&gt;准备执行late resume-&gt;开始执行late resume，之后整个系统就这样被唤醒了。

if (Earlysuspend\_debug\_mask & DEBUG\_USER\_STATE) {

struct timespec ts;//打印出debug信息

struct rtc\_time tm;

getnstimeofday(&ts);

rtc\_time\_to\_tm(ts.tv\_sec, &tm);

pr\_info("\[request\_suspend\_state]: %s (%d-&gt;%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);

}

// eg: \[request\_suspend\_state]: sleep (0-&gt;3) at 97985478409 (2010-01-03 09:52:59.637902305 UTC)，这里对时间的获取和处理，在其他地方可以参考

// ready to enter earlysuspend

if (!old\_sleep && new\_state != PM\_SUSPEND\_ON) {// susepnd会进入这里

state |= SUSPEND\_REQUESTED;// state = 1

pr\_info("\[request\_suspend\_state]:

sys\_sync\_work\_queue early\_sys\_sync\_work/n");

queue\_work(sys\_sync\_work\_queue, &early\_sys\_sync\_work);

pr\_info("\[request\_suspend\_state]: suspend\_work\_queue early\_suspend\_work/n");

queue\_work(suspend\_work\_queue, &early\_suspend\_work);

//在wakelocks\_init()函数(wakelock.c)中会创建这两个工作队列和工作者线程来专门负责处理sys\_sync和early suspend的工作。关于工作队列的详情参考我工作队列的文章

}

// ready to enter lateresume

else if (old\_sleep && new\_state == PM\_SUSPEND\_ON) {

state &= ~SUSPEND\_REQUESTED;// state = 2

wake\_lock(&main\_wake\_lock);//对main wakelock上锁

pr\_info("\[request\_suspend\_state]: suspend\_work\_queue late\_resume\_work/n" );

if (queue\_work(suspend\_work\_queue, &late\_resume\_work)) {

//提交late resume的工作项

//

//In order to synchronize the backlight turn on timing,

//block the thread and wait for fb driver late\_resume()

//callback function is completed

//

wait\_for\_completion(&fb\_drv\_ready);

//等待完成量fb\_drv\_ready，他会在late resume结束之后完成

}

}

requested\_suspend\_state = new\_state;

//存储本次休眠或者是唤醒的状态，供下次休眠或者唤醒使用

spin\_unlock\_irqrestore(&state\_lock, irqflags);

}

在系统suspend的时候提交的两个工作项会陆续被执行到，那么下面就来看一下执行early suspend的关键函数。

static voidearly\_sys\_sync(struct work\_struct \*work)

{

wake\_lock(&sys\_sync\_wake\_lock);

printk("\[sys\_sync work] start/n");

sys\_sync();//同步文件系统

printk("\[sys\_sync wrok] done/n");

wake\_unlock(&sys\_sync\_wake\_lock);

}

static voidearly\_suspend(struct work\_struct \*work)

{

struct early\_suspend \*pos;

unsigned long irqflags;

int abort = 0;

mutex\_lock(&early\_suspend\_lock);

spin\_lock\_irqsave(&state\_lock, irqflags);

if (state == SUSPEND\_REQUESTED)

state |= SUSPENDED;// state = 3

else

abort = 1;

spin\_unlock\_irqrestore(&state\_lock, irqflags);

if (abort) {// suspend中止退出

if (Earlysuspend\_debug\_mask & DEBUG\_SUSPEND)

pr\_info("\[early\_suspend]: abort, state %d/n", state);

mutex\_unlock(&early\_suspend\_lock);

goto abort;

}

if (Earlysuspend\_debug\_mask & DEBUG\_SUSPEND)

pr\_info("\[early\_suspend]: call handlers/n");

list\_for\_each\_entry(pos, &early\_suspend\_handlers, link) {

if (pos-&gt;suspend != NULL)

pos-&gt;suspend(pos);

}

//函数register\_early\_suspend()会将每一个early suspend项以优先级大小注册到链表early\_suspend\_handlers中，这里就是一次取出，然后执行对应的early suspend回调函数

mutex\_unlock(&early\_suspend\_lock);

// Remove sys\_sync from early\_suspend,

// and use work queue to complete sys\_sync

abort:

spin\_lock\_irqsave(&state\_lock, irqflags);

if (state == SUSPEND\_REQUESTED\_AND\_SUSPENDED)

{

pr\_info("\[early\_suspend]: wake\_unlock(main)/n");

wake\_unlock(&main\_wake\_lock);

// main wakelock解锁。看到这里，好像系统执行了early suspend之后就没有往下执行标准linux的suspend流程了，其实不是，android的做法是，不是你执行完了early suspend的回调就可以马上走标准linux的suspend流程，而是会检查还有没有wakelock被持有，如果所有wakelock全是解锁状态，那么就会执行标准linux的suspend步骤。

}

spin\_unlock\_irqrestore(&state\_lock, irqflags);

}

static voidlate\_resume(struct work\_struct \*work)

{

struct early\_suspend \*pos;

unsigned long irqflags;

int abort = 0;

int completed = 0;

mutex\_lock(&early\_suspend\_lock);

spin\_lock\_irqsave(&state\_lock, irqflags);

// return back from suspend

if (state == SUSPENDED)

state &= ~SUSPENDED;// state = 0

else

abort = 1;

spin\_unlock\_irqrestore(&state\_lock, irqflags);

if (abort) {

if (Earlysuspend\_debug\_mask & DEBUG\_SUSPEND)

pr\_info("\[late\_resume]: abort, state %d/n", state);

goto abort;

}

if (Earlysuspend\_debug\_mask & DEBUG\_SUSPEND)

pr\_info("\[late\_resume]: call handlers/n");

list\_for\_each\_entry\_reverse(pos, &early\_suspend\_handlers, link)

{

if (!completed && pos-&gt;level &lt; EARLY\_SUSPEND\_LEVEL\_DISABLE\_FB) {

complete(&fb\_drv\_ready);

completed = 1;

}

if (pos-&gt;resume != NULL)

pos-&gt;resume(pos);

}

//以和early suspend的逆序执行链表early\_suspend\_handlers上的late resume回调函数

if (Earlysuspend\_debug\_mask & DEBUG\_SUSPEND)

pr\_info("\[late\_resume]: done/n");

abort:

if (!completed)

complete(&fb\_drv\_ready);//设置完成量ok

mutex\_unlock(&early\_suspend\_lock);

}