標準linux休眠過程：
l power management notifiers are executed with PM_SUSPEND_PREPARE
l tasks are frozen
l target system sleep state is announced to the platform-handling code
l devices are suspended
l platform-specific global suspend preparation methods are executed
l non-boot CPUs are taken off-line
l interrupts are disabled on the remaining (main) CPU
l late suspend of devices is carried out (一般有一些BUS driver的動作進行)
l platform-specific global methods are invoked to put the system to sleep
標準linux喚醒過程：
l the main CPU is switched to the appropriate mode, if necessary
l early resume of devices is carried out (一般有
l platform-specific global resume preparation methods are invoked
l devices are woken up
l tasks are thawed
l power management notifiers are executed with PM_POST_SUSPEND
用戶可以通過sys文件系統控制系統進入休眠一些BUS driver的動作進行)
l interrupts are enabled on the main CPU
l non-boot CPUs are enabled ：
查看系統支持的休眠方式：
#cat /sys/power/state
常見有standby(suspend to RAM)、mem(suspend to RAM)和disk(suspend to disk)，只是standby耗電更多，返回到正常工作狀態的時間更短。
通過 #echo mem > /sys/power/state 讓系統進入休眠。
#echo on> /sys/power/state 使系統喚醒。
Android休眠與喚醒
android是在傳統的linux內核電源管理設計的基礎上，結合手機設計的實際需求而進化出的一套電源管理系統，其核心內容有：wakelock 、early_suspend與late_resume。
wakelock在Android的電源管理系統中扮演一個核心的角色。wakelock是一種鎖的機制， 只要有人拿着這個鎖，系統就無法進入休眠，可以被用戶態程序和內核獲得。這個鎖可以是有超時的或者是沒有超時的，超時的鎖會在時間過去以後自動解鎖。如果沒有鎖了或者超時了，內核就會啓動休眠的那套機制來進入休眠。
當系統在啓動完畢後，會自己去加一把名爲“main“的鎖，而當系統有意願去睡眠時則會先去釋放這把“main”鎖，在android中，在early_suspend的最後一步會去釋放“main”鎖（wake_unlock: main）。釋放完後則會去檢查是否還有其他存在的鎖，如果沒有則直接進入睡眠過程。
它的缺點是，如果有某一應用獲鎖而不釋放或者因一直在執行某種操作而沒時間來釋放的話，則會導致系統一直進入不了睡眠狀態，功耗過大。
early_suspend：先與linux內核的睡眠過程被調用。一般在手機系統的設計中對背光的操作等採用此類方法，因爲背光需要的能耗過大。當然此操作與late_resume是配套使用的。一些在內核中要預先進行處理的事件可以先註冊上early_suspend函數，當系統要進入睡眠之前會首先調用這些註冊的函數。
本文中，linux kernel版本爲 linux-2.6.29，android版本爲 android 2.1
與android休眠喚醒主要相關的文件主要有：
l linux_source/kernel/power/main.c
l linux_source/kernel/power/earlysuspend.c
l linux_source/kernel/power/wakelock.c
l linux_source/kernel/power/process.c
l linux_source/driver/base/power/main.c
l linux_source/arch/xxx/mach-xxx/pm.c或linux_source/arch/xxx/plat-xxx/pm.c
Android 休眠過程如下：
當用戶讀寫/sys/power/state時，linux_source/kernel/power/main.c中的state_store()函數會被調用。其中，android的early_suspend會執行request_suspend_state(state); 而標準的linux休眠則執行error = enter_state(state);
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;
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);
}
#else
#endif
#endif
Exit:
return error ? error : n;
}
在request_suspend_state(state)函數中，會調用early_suspend_work的工作隊列，從而進入early_suspend()函數中。
static DECLARE_WORK(early_suspend_work, early_suspend);
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-d-d d:d:d.lu 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;
queue_work(suspend_work_queue, &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);
}
requested_suspend_state = new_state;
spin_unlock_irqrestore(&state_lock, irqflags);
}
在early_suspend()函數中，首先要判斷當前請求的狀態是否還是suspend，若不是，則直接退出了；若是，函數會調用已經註冊的early_suspend的函數。然後同步文件系統，最後釋放main_wake_lock。
static void early_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;
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) {
if (pos->suspend != NULL)
pos->suspend(pos);
}
mutex_unlock(&early_suspend_lock);
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: sync\n");
sys_sync();
abort:
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPEND_REQUESTED_AND_SUSPENDED)
wake_unlock(&main_wake_lock);
spin_unlock_irqrestore(&state_lock, irqflags);
}
在wake_unlock()中，刪除鏈表中wake_lock節點，判斷當前是否存在wake_lock，若wake_lock的數目爲0，則調用工作隊列suspend_work，進入suspend狀態。
static DECLARE_WORK(suspend_work, suspend);
void wake_unlock(struct wake_lock *lock)
{
int type;
unsigned long irqflags;
spin_lock_irqsave(&list_lock, irqflags);
type = lock->flags & WAKE_LOCK_TYPE_MASK;
#ifdef CONFIG_WAKELOCK_STAT
wake_unlock_stat_locked(lock, 0);
#endif
if (debug_mask & DEBUG_WAKE_LOCK)
pr_info("wake_unlock: %s\n", lock->name);
lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);
list_del(&lock->link);
list_add(&lock->link, &inactive_locks);
if (type == WAKE_LOCK_SUSPEND) {
long has_lock = has_wake_lock_locked(type);
if (has_lock > 0) {
if (debug_mask & DEBUG_EXPIRE)
pr_info("wake_unlock: %s, start expire timer, "
"%ld\n", lock->name, has_lock);
mod_timer(&expire_timer, jiffies + has_lock);
} else {
if (del_timer(&expire_timer))
if (debug_mask & DEBUG_EXPIRE)
pr_info("wake_unlock: %s, stop expire "
"timer\n", lock->name);
if (has_lock == 0)
queue_work(suspend_work_queue, &suspend_work);
}
if (lock == &main_wake_lock) {
if (debug_mask & DEBUG_SUSPEND)
print_active_locks(WAKE_LOCK_SUSPEND);
#ifdef CONFIG_WAKELOCK_STAT
update_sleep_wait_stats_locked(0);
#endif
}
}
spin_unlock_irqrestore(&list_lock, irqflags);
}
在suspend()函數中，先判斷當前是否有wake_lock，若有，則退出；然後同步文件系統，最後調用pm_suspend()函數。
static void suspend(struct work_struct *work)
{
int ret;
int entry_event_num;
if (has_wake_lock(WAKE_LOCK_SUSPEND)) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("suspend: abort suspend\n");
return;
}
entry_event_num = current_event_num;
sys_sync();
if (debug_mask & DEBUG_SUSPEND)
pr_info("suspend: enter suspend\n");
ret = pm_suspend(requested_suspend_state);
if (debug_mask & DEBUG_EXIT_SUSPEND) {
struct timespec ts;
struct rtc_time tm;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
pr_info("suspend: exit suspend, ret = %d "
"(%d-d-d d:d:d.lu UTC)\n", ret,
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
}
if (current_event_num == entry_event_num) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("suspend: pm_suspend returned with no event\n");
wake_lock_timeout(&unknown_wakeup, HZ / 2);
}
}
在pm_suspend()函數中，enter_state()函數被調用，從而進入標準linux休眠過程。
int pm_suspend(suspend_state_t state)
{
if (state > PM_SUSPEND_ON && state <= PM_SUSPEND_MAX)
return enter_state(state);
return -EINVAL;
}
在enter_state()函數中，首先檢查一些狀態參數，再同步文件系統，然後調用suspend_prepare()來凍結進程，最後調用suspend_devices_and_enter()讓外設進入休眠。
static 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]);
error = suspend_devices_and_enter(state);
Finish:
pr_debug("PM: Finishing wakeup.\n");
suspend_finish();
Unlock:
mutex_unlock(&pm_mutex);
return error;
}
在suspend_prepare()函數中，先通過pm_prepare_console();給suspend分配一個虛擬終端來輸出信息，再廣播一個系統進入suspend的通報，關閉用戶態的helper進程，然後調用suspend_freeze_processes()來凍結進程，最後會嘗試釋放一些內存。
static int suspend_prepare(void)
{
int error;
unsigned int free_pages;
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();
if (error)
goto Finish;
if (suspend_freeze_processes()) {
error = -EAGAIN;
goto Thaw;
}
free_pages = global_page_state(NR_FREE_PAGES);
if (free_pages < FREE_PAGE_NUMBER) {
pr_debug("PM: free some memory\n");
shrink_all_memory(FREE_PAGE_NUMBER - free_pages);
if (nr_free_pages() < FREE_PAGE_NUMBER) {
error = -ENOMEM;
printk(KERN_ERR "PM: No enough memory\n");
}
}
if (!error)
return 0;
Thaw:
suspend_thaw_processes();
usermodehelper_enable();
Finish:
pm_notifier_call_chain(PM_POST_SUSPEND);
pm_restore_console();
return error;
}