基于MTK android电源管理：early_suspend分析

Android共支持3种suspend的模式：
early_suspend、suspned、hibernation
1，earlysuspend是一种低功耗的状态,某些设备可以选择进入某种功耗较低的状态,比如LCD可以降低亮度或灭掉;

2，suspend是指除电源管理以外的其他外围模块以及cpu均不工作,只有内存保持自刷新的状态;

3，hibernation是指所有内存镜像都被写入磁盘中,然后系统关机,恢复后系统将能恢复到“关机”之前的状态.

power manager的suspend状态有4种，可从suspend.h中查看
typedef int __bitwise suspend_state_t;

#define PM_SUSPEND_ON        ((__force suspend_state_t) 0)
#define PM_SUSPEND_STANDBY    ((__force suspend_state_t) 1)
#define PM_SUSPEND_MEM        ((__force suspend_state_t) 3)

#define PM_SUSPEND_MAX        ((__force suspend_state_t) 4)

其中在suspend.c中只为前三种定义了可操作的宏：
const char *const pm_states[PM_SUSPEND_MAX] = {
#ifdef CONFIG_EARLYSUSPEND
    [PM_SUSPEND_ON]        = "on",
#endif
    [PM_SUSPEND_STANDBY]    = "standby",
    [PM_SUSPEND_MEM]    = "mem",

};

至于第四种应该就是hibernation功能，目前所知道的android设备支持的很少；

#define power_attr(_name) \
static struct kobj_attribute _name##_attr = {    \
    .attr    = {                \
        .name = __stringify(_name),    \
        .mode = 0644,            \
    },                    \
    .show    = _name##_show,            \
    .store    = _name##_store,        \

}

power_attr(state);
在power maneger 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);
    if (!power_kobj)
        return -ENOMEM;
    error = sysfs_create_group(power_kobj, &attr_group);
    if (error)
        return error;
    return pm_autosleep_init();
}

将该属性文件注册到/sys下面，之后用户层可以通过/sys/power/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;

#ifdef CONFIG_MTK_HIBERNATION
    state = decode_state(buf, n);
    hib_log("entry (%d)\n", state);
#endif
    if (no_suspend && len == 3 && !strncmp(buf, "mem", len))
    {
        printk("suspend disabled\n");
        goto Exit;
    }

#ifdef CONFIG_MTK_HIBERNATION
    if (len == 8 && !strncmp(buf, "hibabort", len)) {
        hib_log("abort hibernation...\n");
        error = mtk_hibernate_abort();
        goto Exit;
    }
#endif

    /* First, check if we are requested to hibernate */
    if (len == 4 && !strncmp(buf, "disk", len)) {
#ifdef CONFIG_MTK_HIBERNATION
        hib_log("trigger hibernation...\n");
#ifdef CONFIG_EARLYSUSPEND
        if (PM_SUSPEND_ON == get_suspend_state()) {
            hib_warn("\"on\" to \"disk\" (i.e., 0->4) is not supported !!!\n");
            error = -EINVAL;
            goto Exit;
        }
#endif
        if (!pre_hibernate()) {
            error = 0;
            error = mtk_hibernate();
        }
#else // !CONFIG_MTK_HIBERNATION
        error = hibernate();
#endif
        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
            error = -EINVAL;
#else
        error = enter_state(state);
#endif
    }
#endif

 Exit:
    return error ? error : n;

}

CONFIG_MTK_HIBERNATION用来判断是否有开启hibernation状态

    for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {
        if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
            break;
    }
用来侦测目前powwer manager的状态，是on还是mem，还是suspened.
valid_state(state)：用来判断该android的power manager是否支持该state，之后再进入request_suspend_state.
如果是标准的linux内核就会走enter_state(state)


void request_suspend_state(suspend_state_t new_state)
{
    unsigned long irqflags;
    int old_sleep;
    int wait_flag = 0;

    spin_lock_irqsave(&state_lock, irqflags);
    old_sleep = state & SUSPEND_REQUESTED;
    if (earlysuspend_debug_mask & DEBUG_USER_STATE) {
        struct timespec ts;
        struct rtc_time tm;
        getnstimeofday(&ts);
        rtc_time_to_tm(ts.tv_sec, &tm);
        pm_warn("%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;
        pm_warn("sys_sync_work_queue early_sys_sync_work\n");
        queue_work(sys_sync_work_queue, &early_sys_sync_work);
        pm_warn("suspend_work_queue early_suspend_work\n");
        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);
        ///cun
        if (queue_work(suspend_work_queue, &late_resume_work)) {
            /*
             * In order to synchronize the backlight turn on timing,egou
             * block the thread and wait for fb driver late_resume()
             * callback function is completed
             */
            wait_flag = 1;
        }
    }
    requested_suspend_state = new_state;
    spin_unlock_irqrestore(&state_lock, irqflags);
    if (wait_flag == 1) {
        wait_for_completion(&fb_drv_ready);
        pr_warn("wait done\n");
    }
}
通过上面的两条判断语句根据不同的power manager状态将对应的suspend、resume操作函数加入对应的工作队列中去；
先来看看suspend的操作函数：
queue_work(suspend_work_queue, &early_suspend_work):调度执行指定的工作对列suspend_work_queue中的任务，early_suspend_work是指定的任务指针
DECLARE_WORK(early_suspend_work, early_suspend)静态的创建工作对列结构，其中early_suspend是队列中的任务所对应的function;
suspend_work_queue是在什么时候创建的呢？

static int __init org_wakelocks_init(void)
{
    int ret;
   
    wake_lock_init(&sys_sync_wake_lock, WAKE_LOCK_SUSPEND, "sys_sync");

    sys_sync_work_queue = create_singlethread_workqueue("fs_sync");
    if (sys_sync_work_queue == NULL) {
        pr_err("[wakelocks_init] fs_sync workqueue create failed\n");
    }

    suspend_work_queue = create_singlethread_workqueue("suspend");
    if (suspend_work_queue == NULL) {
        ret = -ENOMEM;
        goto err_suspend_work_queue;
    }
    return 0;

err_suspend_work_queue:

    return ret;
}
整个suspend的核心就是在创建suspend_work_queue的工作队列中完成

static void early_suspend(struct work_struct *work)
{
    struct early_suspend *pos;
    unsigned long irqflags;
    int abort = 0, count = 0;

    pr_warn("@@@@@@@@@@@@@@@@@@@@@@@\n@@@__early_suspend__@@@\n@@@@@@@@@@@@@@@@@@@@@@@\n");

    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 (earlysuspend_debug_mask & DEBUG_SUSPEND)
            pm_warn("abort, state %d\n", state);
        mutex_unlock(&early_suspend_lock);
        goto abort;
    }

    pr_warn("early_suspend_count = %d, forbid_id = 0x%x\n", early_suspend_count, forbid_id);
    if (earlysuspend_debug_mask & DEBUG_SUSPEND)
        pm_warn("call handlers\n");
    list_for_each_entry(pos, &early_suspend_handlers, link) {
        if (pos->suspend != NULL) {
            if (!(forbid_id & (0x1 << count))) {
                //if (earlysuspend_debug_mask & DEBUG_VERBOSE)
                    pr_warn("ES handlers %d: [%pf], level: %d\n", count, pos->suspend, pos->level);
                pos->suspend(pos);
            }
            count++;
        }
    }
    mutex_unlock(&early_suspend_lock);

    /* Remove sys_sync from early_suspend, and use work queue to complete sys_sync */

abort:
    if (state == SUSPEND_REQUESTED_AND_SUSPENDED) {
        //wake_unlock(&main_wake_lock);
#ifdef CONFIG_MTK_HIBERNATION
        suspend_state_t susp_state = get_suspend_state();
        pm_warn("calling pm_autosleep_set_state() with parameter: %d\n", susp_state);
        pm_autosleep_set_state(susp_state);
#else
        pm_autosleep_set_state(PM_SUSPEND_MEM);
#endif
    }
}
关键性的函数： list_for_each_entry(pos, &early_suspend_handlers, link),会遍历early_suspend_handlers
链表中的所有handler，然后回调所有加入该链表中的模块的suspend handle函数，最后会释放main lock，到此early_suspend结束，每个模块又是如何加入到该early_suspend_handlers链表中的呢

每个模块如果需要进入suspend，就需要将对应的处理函数加入到handles的链表中，register_early_suspend(&obj->early_drv)，该函数就是用来将处理函数注册到handles链表中
    obj->early_drv.level    = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1,
    obj->early_drv.suspend  = bma220_early_suspend,
    其中level是表示该结构在handlers链表中的位置，suspend时该level值越小那么在回调函数中执行的就越早,resume则反过来
    android在earlysuspened.h中先定义了如下几个level值：
    enum {
    EARLY_SUSPEND_LEVEL_BLANK_SCREEN = 50,
    EARLY_SUSPEND_LEVEL_STOP_DRAWING = 100,
    EARLY_SUSPEND_LEVEL_DISABLE_FB = 150,
};

    struct early_suspend {
    #ifdef CONFIG_HAS_EARLYSUSPEND
        struct list_head link;
        int level;
        void (*suspend)(struct early_suspend *h);
        void (*resume)(struct early_suspend *h);
    #endif
    };
    如果需要将suspend的顺序调到这其中之前的话，只需将level值改成比这个小就可以了
    下面看看register_early_suspend这个函数的处理过程：
    
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);
    early_suspend_count++;
    if ((state & SUSPENDED) && handler->suspend)
        handler->suspend(handler);
    mutex_unlock(&early_suspend_lock);
}

    可以到source code详细查看这段函数体的实现过程，大意如下;
    
    通过扫描链表中的每一项来与将要注册的handle的level进行比较，将level小的这项加入到与之对比的链表项的后面
    
    下面看看有关suspend的hal层代码;
    
    const char * const NEW_PATHS[] = {
    "/sys/power/wake_lock",
    "/sys/power/wake_unlock",
    "/sys/power/state"
};
    首先定义了操作的接口，这些接口在kernel起来后就已注册好，任何一个要操作的接口，首先就需先打开：
    static int
open_file_descriptors(const char * const paths[])
{
    int i;
    for (i=0; 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;
}

用户空间的电源管理系统会通过调用set_screen_state来触发底层的suspend流程
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 = snprintf(buf, sizeof(buf), "%s", on_state);
    else
        len = snprintf(buf, sizeof(buf), "%s", off_state);

    buf[sizeof(buf) - 1] = '\0';
    len = write(g_fds[REQUEST_STATE], buf, len);
    if(len < 0) {
        LOGE("Failed setting last user activity: g_error=%d\n", g_error);
    }
    return 0;
}
该函数实质上是往接口中写men或on等字符串命令