android suspend/resume

一、应用层当系统未处于 Suspend 状态下用户按下Power键时会在产生一个信号，上层的 WindowManager? 会收到这个上节点的变化而得知当前应该进入休眠状态, 通知PowerManagerService, 它会做如下调用,

路径：./frameworks/base/services/java/com/android/server/PowerManagerService.java" line 1452

 private int setScreenStateLocked(boolean on) {
        int err = Power.setScreenState(on); ------------------------------------------>在这里调用setScreenState（）
        if (err == 0) {
            mLastScreenOnTime = (on ? SystemClock.elapsedRealtime() : 0);
            if (mUseSoftwareAutoBrightness) {
                enableLightSensor(on);
                if (!on) {
                    // make sure button and key backlights are off too
                    mButtonLight.turnOff();
                    mKeyboardLight.turnOff();
                    // clear current value so we will update based on the new conditions
                    // when the sensor is reenabled.
                    mLightSensorValue = -1;
                    // reset our highest light sensor value when the screen turns off
                    mHighestLightSensorValue = -1;
                }
            }
        }
        return err;
    }

setScreenState最终会调到hardware/libhardware_legacy/power/power.c 中的set_screen_state

const char * const NEW_PATHS[] = {
    "/sys/power/wake_lock",
    "/sys/power/wake_unlock",
    "/sys/power/state"
};

static const char *off_state = "mem";
static const char *on_state = "on";

下边这个函数打开NEW_PATHS[]中的三个描述符
static int
open_file_descriptors(const char * const paths[])
{
    int i;
    for (i=0; i<OUR_FD_COUNT; i++) {
        int fd = open(paths[i], O_RDWR);
        if (fd < 0) {
            fprintf(stderr, "fatal error opening \"%s\"\n", paths[i]);
            g_error = errno;
            return -1;
        }
        g_fds[i] = fd;
    }

    g_error = 0;
    return 0;
}


int
set_screen_state(int on)
{
    QEMU_FALLBACK(set_screen_state(on));

    LOGI("*** set_screen_state %d", on);

    initialize_fds();

    //LOGI("go_to_sleep eventTime=%lld now=%lld g_error=%s\n", eventTime,
      //      systemTime(), strerror(g_error));

    if (g_error) return g_error;

    char buf[32];
    int len;
    if(on)
    {
        len = sprintf(buf, on_state);
        len = write(g_fds[REQUEST_STATE], buf, len);

        sys_file = fopen(FILENAME_SYS_3G_RESTART, "w");
        if(sys_file)
        {
            fputc(2, sys_file);
            fclose(sys_file);
        }
    }
    else
    {
        len = sprintf(buf, off_state);
        len = write(g_fds[REQUEST_STATE], buf, len);  ===> echo mem > /sys/power/state

        sys_file = fopen(FILENAME_SYS_3G_RESTART, "w");
        if(sys_file)
        {
            fputc(0, sys_file);
            fclose(sys_file);
        }

        write_resume_state(1);
    }
    if(len < 0) {
        LOGE("Failed setting last user activity: g_error=%d\n", g_error);
    }
    return 0;
}

到些完成了从按下power键到 echo mem > /sys/power/state 的过程，接下来就是进入内核中

二、内核中的休眠过程分析1、创建 /sys/power/state节点在内核中 kernel/power/main.cpower_attr(state);这是一个宏（定义在kernel/power/power.h），它实现在/sys/power/ 下创建对应节点state，对这个结点进行读写对应的函数为

//写结点时调用的函数
static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
                           const char *buf, size_t n)
//读结点时调用的函数
static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
                          char *buf)

接上边echo mem > /sys/power/state后state_store被调用

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;                                                          |->android 添加的部分，如果定义了
                        request_suspend_state(state);                                       |->earlysuspend则调用request_suspend_state(state); (定义在kernel/power/earlysuspend.c)
                }                                                                           |
#else ---------------------------------------------------------------------------------------
                error = enter_state(state);   ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝>标准linux进入休眠的路径                  
#endif
#endif

 Exit:
        return error ? error : n;
}

request_suspend_state 位于： kernel/power/earlysuspend.c

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;
                queue_work(suspend_work_queue, &early_suspend_work);------------- >这个是把工作early_suspend_work添加到工作队列suspend_work_queue中
                requested_suspend_state = new_state;
                spin_unlock_irqrestore(&state_lock, irqflags);
        } 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);
                mdelay(300);
        }
        else {
                requested_suspend_state = new_state;
                spin_unlock_irqrestore(&state_lock, irqflags);
        }
}

工作队列suspend_work_queue定义在kernel/power/wakelock.c中在wakelocks_init（）函数中对这个工作队列初始化

static int __init wakelocks_init(void)
{
        。。。。
        suspend_work_queue = create_singlethread_workqueue("suspend");  创建一个单线程休眠工作队列
        if (suspend_work_queue == NULL) {
                ret = -ENOMEM;
                goto err_suspend_work_queue;
        }

       。。。。。

        return ret;
}