State in Linux

Label

state

ACPI state

#define PM_SUSPEND_ON        ((__force suspend_state_t) 0)

#define PM_SUSPEND_FREEZE    ((__force suspend_state_t) 1)

freeze

Suspend-to-Idle

S0

#define PM_SUSPEND_STANDBY    ((__force suspend_state_t) 2)

standby

Standby/Power-on Suspend

S1

#define PM_SUSPEND_MEM        ((__force suspend_state_t) 3)

mem

Suspend-to-RAM

S3

Phase名稱

ftrace關鍵詞

suspend_prepare

dpm_prepare

suspend

dpm_suspend

suspend_late

dpm_suspend_late

suspend_noirq

dpm_suspend_noirq

suspend_machine

machine_suspend start

resume_machine

machine_suspend end

resume_noirq

dpm_resume_noirq

resume_early

dpm_resume_early

resume

dpm_resume

static const struct platform_suspend_ops psci_suspend_ops = {
    .valid          = suspend_valid_only_mem,  僅支持mem類型的suspend
    .enter          = psci_system_suspend_enter,  睡眠的CPU底層支持
};

static const struct platform_freeze_ops acpi_freeze_ops = {
    .begin = acpi_freeze_begin,
    .prepare = acpi_freeze_prepare,
    .restore = acpi_freeze_restore,
    .end = acpi_freeze_end,
};

static int suspend_prepare(suspend_state_t state)
{
    int error;

驗證suspend狀態
        return -EPERM;

分配一個suspend console

發送PM_SUSPEND_PREPARE通知消息
    if (error)
        goto Finish;

    trace_suspend_resume(TPS("freeze_processes"), 0, true);
    error = suspend_freeze_processes();  凍結進程
    trace_suspend_resume(TPS("freeze_processes"), 0, false);
    if (!error)
        return 0;

    suspend_stats.failed_freeze++;
    dpm_save_failed_step(SUSPEND_FREEZE);
Finish:
    pm_notifier_call_chain(PM_POST_SUSPEND);
    pm_restore_console();
    return error;
}

static inline int suspend_freeze_processes(void)
{
    int error;

觸發用户空間進程進入freeze狀態。當前進程不會被凍結。因為凍結失敗的進程會自動被解凍，所以不需要進行錯誤處理。
    /*
     * freeze_processes() automatically thaws every task if freezing
     * fails. So we need not do anything extra upon error.
     */
    if (error)
        return error;

凍結內核線程
    /*
     * freeze_kernel_threads() thaws only kernel threads upon freezing
     * failure. So we have to thaw the userspace tasks ourselves.
     */
    if (error)  由於freeze_kernel_threads凍結失敗，只會解凍內核線程。所以還需要對用户空間進程進行解凍。
        thaw_processes();

    return error;
}

int suspend_devices_and_enter(suspend_state_t state)
{
    int error;
    bool wakeup = false;

    if (!sleep_state_supported(state))
        return -ENOSYS;

    error = platform_suspend_begin(state);
    if (error)
        goto Close;

關閉console子系統，暫停printk打印
    suspend_test_start();
    error = dpm_suspend_start(PMSG_SUSPEND); suspend_prepare(dpm_prepare)、suspend(dpm_suspend)兩階段
    if (error) {
        pr_err("PM: Some devices failed to suspend, or early wake event detected\n");
        log_suspend_abort_reason("Some devices failed to suspend, or early wake event detected");
        goto Recover_platform;
    }
    suspend_test_finish("suspend devices");
    if (suspend_test(TEST_DEVICES))
        goto Recover_platform;

    do {
        error = suspend_enter(state, &wakeup);  suspend_late(dpm_suspend_late)、suspend_noirq(dpm_suspend_noirq)、suspend_machine、resume_machine、resume_noirq(dpm_resume_noirq)、resume_early(dpm_resume_early)

Resume_devices:
    suspend_test_start();
    dpm_resume_end(PMSG_RESUME);  resume(dpm_resume)、resume_complete(dpm_complete)
    suspend_test_finish("resume devices");
    trace_suspend_resume(TPS("resume_console"), state, true);
    resume_console();  打開console子系統，恢復printk打印。
    trace_suspend_resume(TPS("resume_console"), state, false);

Close:
    platform_resume_end(state);
    return error;

Recover_platform:
    platform_recover(state);
    goto Resume_devices;
}

static int suspend_enter(suspend_state_t state, bool *wakeup)
{
    char suspend_abort[MAX_SUSPEND_ABORT_LEN];
    int error, last_dev;

因為suspend_ops的prepare為空，所以返回0
    if (error)
        goto Platform_finish;

suspend_late
    if (error) {
        last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
        last_dev %= REC_FAILED_NUM;
        printk(KERN_ERR "PM: late suspend of devices failed\n");
        log_suspend_abort_reason("%s device failed to power down",
            suspend_stats.failed_devs[last_dev]);
        goto Platform_finish;
    }
    error = platform_suspend_prepare_late(state);  執行freeze_ops->prepare()
    if (error)
        goto Devices_early_resume;

suspend_noirq
    if (error) {
        last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
        last_dev %= REC_FAILED_NUM;
        printk(KERN_ERR "PM: noirq suspend of devices failed\n");
        log_suspend_abort_reason("noirq suspend of %s device failed",
            suspend_stats.failed_devs[last_dev]);
        goto Platform_early_resume;
    }
    error = platform_suspend_prepare_noirq(state);
    if (error)
        goto Platform_wake;

    if (suspend_test(TEST_PLATFORM))
        goto Platform_wake;

    /*
     * PM_SUSPEND_FREEZE equals
     * frozen processes + suspended devices + idle processors.
     * Thus we should invoke freeze_enter() soon after
     * all the devices are suspended.
     */
    if (state == PM_SUSPEND_FREEZE) {  這裏是freeze和mem/standy差別所在
        trace_suspend_resume(TPS("machine_suspend"), state, true);
        freeze_enter(); 
        trace_suspend_resume(TPS("machine_suspend"), state, false);
        goto Platform_wake;
    }

關閉所有boot-CPU之外的CPU
    if (error || suspend_test(TEST_CPUS)) {
        log_suspend_abort_reason("Disabling non-boot cpus failed");
        goto Enable_cpus;
    }

    arch_suspend_disable_irqs();
    BUG_ON(!irqs_disabled());

執行syscore_ops_list上所有syscore_ops的suspend回調函數
    if (!error) {
        *wakeup = pm_wakeup_pending();  檢查是否需要終止suspend流程？
        if (!(suspend_test(TEST_CORE) || *wakeup)) {
            trace_suspend_resume(TPS("machine_suspend"),
                state, true);
            error = suspend_ops->enter(state);  調用psci_suspend_ops的enter回調函數，關閉machine
            trace_suspend_resume(TPS("machine_suspend"),
                state, false);  !!!!!!!!!!!!!!!!這裏即為喚醒之後的執行路徑了!!!!!!!!!!!!!!!!            events_check_enabled = false;
        } else if (*wakeup) {
            pm_get_active_wakeup_sources(suspend_abort,
                MAX_SUSPEND_ABORT_LEN);
            log_suspend_abort_reason(suspend_abort);
            error = -EBUSY;
        }
        syscore_resume();  執行所有syscore_ops_list的resume回調函數
    }

    arch_suspend_enable_irqs();
    BUG_ON(irqs_disabled());

Enable_cpus:
    enable_nonboot_cpus();  打開所有non-boot CPU

Platform_wake:
    platform_resume_noirq(state);
    dpm_resume_noirq(PMSG_RESUME);  resume_noirq

Platform_early_resume:
    platform_resume_early(state);

Devices_early_resume:
    dpm_resume_early(PMSG_RESUME);  resume_early

Platform_finish:
    platform_resume_finish(state);
    return error;
}

int dpm_prepare(pm_message_t state)
{
    int error = 0;

    trace_suspend_resume(TPS("dpm_prepare"), state.event, true);

    mutex_lock(&dpm_list_mtx);
    while (!list_empty(&dpm_list)) {  遍歷dpm_list
        struct device *dev = to_device(dpm_list.next);

        get_device(dev);
        mutex_unlock(&dpm_list_mtx);

        trace_device_pm_callback_start(dev, "", state.event);
        error = device_prepare(dev, state);  執行->prepare回調函數
        trace_device_pm_callback_end(dev, error);

        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);  移動設備到dpm_prepared_list
        put_device(dev);
    }
    mutex_unlock(&dpm_list_mtx);
    trace_suspend_resume(TPS("dpm_prepare"), state.event, false);
    return error;
}

int dpm_suspend(pm_message_t state)
{
    ktime_t starttime = ktime_get();
    int error = 0;

    trace_suspend_resume(TPS("dpm_suspend"), state.event, true);

    cpufreq_suspend();

    mutex_lock(&dpm_list_mtx);
    pm_transition = state;
    async_error = 0;
    while (!list_empty(&dpm_prepared_list)) { 基於dpm_prepared_list遍歷設備
        struct device *dev = to_device(dpm_prepared_list.prev);

        get_device(dev);
        mutex_unlock(&dpm_list_mtx);

執行設備->suspend回調函數

        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);  移動設備到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);
    trace_suspend_resume(TPS("dpm_suspend"), state.event, false);
    return error;
}

int dpm_suspend_late(pm_message_t state)
{
    ktime_t starttime = ktime_get();
    int error = 0;

    trace_suspend_resume(TPS("dpm_suspend_late"), state.event, true);
    mutex_lock(&dpm_list_mtx);
    pm_transition = state;
    async_error = 0;

遍歷dpm_suspended_list列表
        struct device *dev = to_device(dpm_suspended_list.prev);

        get_device(dev);
        mutex_unlock(&dpm_list_mtx);

執行->suspend_late回調函數

        mutex_lock(&dpm_list_mtx);
        if (!list_empty(&dev->power.entry))
            list_move(&dev->power.entry, &dpm_late_early_list);  移動設備到dpm_late_early_list

        if (error) {
            pm_dev_err(dev, state, " late", error);
            dpm_save_failed_dev(dev_name(dev));
            put_device(dev);
            break;
        }
        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_late++;
        dpm_save_failed_step(SUSPEND_SUSPEND_LATE);
        dpm_resume_early(resume_event(state));
    } else {
        dpm_show_time(starttime, state, "late");
    }
    trace_suspend_resume(TPS("dpm_suspend_late"), state.event, false);
    return error;
}

int dpm_suspend_noirq(pm_message_t state)
{
    ktime_t starttime = ktime_get();
    int error = 0;

    trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true);
    cpuidle_pause();  暫停cpuidle功能，退出idle的CPU
    device_wakeup_arm_wake_irqs();  將具有wakeirq的設備設置成wakeup resource
    suspend_device_irqs();  關閉當前所有能夠關閉的irq，置成IRQS_SUSPENDED。IRQF_NO_SUSPEND類型的wakeup中斷不能被關閉，並且作為wakeup喚醒源的中斷不能被關閉。
    mutex_lock(&dpm_list_mtx);
    pm_transition = state;
    async_error = 0;

    while (!list_empty(&dpm_late_early_list)) {
        struct device *dev = to_device(dpm_late_early_list.prev);

        get_device(dev);
        mutex_unlock(&dpm_list_mtx);

調用->suspend_noirq回調函數

        mutex_lock(&dpm_list_mtx);
        if (error) {
            pm_dev_err(dev, state, " noirq", error);
            dpm_save_failed_dev(dev_name(dev));
            put_device(dev);
            break;
        }
        if (!list_empty(&dev->power.entry))
            list_move(&dev->power.entry, &dpm_noirq_list);  移動設備到dpm_noirq_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_noirq++;
        dpm_save_failed_step(SUSPEND_SUSPEND_NOIRQ);
        dpm_resume_noirq(resume_event(state));
    } else {
        dpm_show_time(starttime, state, "noirq");
    }
    trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, false);
    return error;
}

static void freeze_enter(void)
{
    spin_lock_irq(&suspend_freeze_lock);
    if (pm_wakeup_pending())  檢查是否有wakeup信號在處理，如果有則退出當前流程。
        goto out;

    suspend_freeze_state = FREEZE_STATE_ENTER;
    spin_unlock_irq(&suspend_freeze_lock);

    get_online_cpus();
    cpuidle_resume();  允許使用cpuidle

    /* Push all the CPUs into the idle loop. */
    wake_up_all_idle_cpus();  強制所有CPU退出idle狀態
    pr_debug("PM: suspend-to-idle\n");
    /* Make the current CPU wait so it can enter the idle loop too. */
    wait_event(suspend_freeze_wait_head,
           suspend_freeze_state == FREEZE_STATE_WAKE);  等待FREEZE_STATE_WAKE事件，進入idle loop
    pr_debug("PM: resume from suspend-to-idle\n");  !!!!!!!!!!!!!!!!這裏即為喚醒之後的執行路徑了!!!!!!!!!!!!!!!!    cpuidle_pause();  暫停使用cpuidle
    put_online_cpus();

    spin_lock_irq(&suspend_freeze_lock);

out:
    suspend_freeze_state = FREEZE_STATE_NONE;
    spin_unlock_irq(&suspend_freeze_lock);
}

void dpm_resume_noirq(pm_message_t state)
{
    struct device *dev;
    ktime_t starttime = ktime_get();

    trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, true);
    mutex_lock(&dpm_list_mtx);
    pm_transition = state;

    /*
     * Advanced the async threads upfront,
     * in case the starting of async threads is
     * delayed by non-async resuming devices.
     */
    list_for_each_entry(dev, &dpm_noirq_list, power.entry) {
        reinit_completion(&dev->power.completion);
        if (is_async(dev)) {
            get_device(dev);
            async_schedule(async_resume_noirq, dev);
        }
    }

遍歷dpm_noirq_list
        dev = to_device(dpm_noirq_list.next);
        get_device(dev);
        list_move_tail(&dev->power.entry, &dpm_late_early_list);  移動設備到下一級dpm_late_early_list

        if (!is_async(dev)) {
            int error;

            error = device_resume_noirq(dev, state, false);
            if (error) {
                suspend_stats.failed_resume_noirq++;
                dpm_save_failed_step(SUSPEND_RESUME_NOIRQ);
                dpm_save_failed_dev(dev_name(dev));
                pm_dev_err(dev, state, " noirq", error);
            }
        }

        mutex_lock(&dpm_list_mtx);
        put_device(dev);
    }
    mutex_unlock(&dpm_list_mtx);
    async_synchronize_full();
    dpm_show_time(starttime, state, "noirq");
    resume_device_irqs();
    device_wakeup_disarm_wake_irqs();
    cpuidle_resume();
    trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
}

void dpm_resume_early(pm_message_t state)
{
    struct device *dev;
    ktime_t starttime = ktime_get();

    trace_suspend_resume(TPS("dpm_resume_early"), state.event, true);
    mutex_lock(&dpm_list_mtx);
    pm_transition = state;

    /*
     * Advanced the async threads upfront,
     * in case the starting of async threads is
     * delayed by non-async resuming devices.
     */
    list_for_each_entry(dev, &dpm_late_early_list, power.entry) {
        reinit_completion(&dev->power.completion);
        if (is_async(dev)) {
            get_device(dev);
            async_schedule(async_resume_early, dev);
        }
    }

    while (!list_empty(&dpm_late_early_list)) {
        dev = to_device(dpm_late_early_list.next);
        get_device(dev);
        list_move_tail(&dev->power.entry, &dpm_suspended_list);
        mutex_unlock(&dpm_list_mtx);

        if (!is_async(dev)) {
            int error;

            error = device_resume_early(dev, state, false);
            if (error) {
                suspend_stats.failed_resume_early++;
                dpm_save_failed_step(SUSPEND_RESUME_EARLY);
                dpm_save_failed_dev(dev_name(dev));
                pm_dev_err(dev, state, " early", error);
            }
        }
        mutex_lock(&dpm_list_mtx);
        put_device(dev);
    }
    mutex_unlock(&dpm_list_mtx);
    async_synchronize_full();
    dpm_show_time(starttime, state, "early");
    trace_suspend_resume(TPS("dpm_resume_early"), state.event, false);
}

void dpm_resume(pm_message_t state)
{
    struct device *dev;
    ktime_t starttime = ktime_get();

    trace_suspend_resume(TPS("dpm_resume"), state.event, true);

    mutex_lock(&dpm_list_mtx);
    pm_transition = state;
    async_error = 0;

    list_for_each_entry(dev, &dpm_suspended_list, power.entry) {
        reinit_completion(&dev->power.completion);
        if (is_async(dev)) {
            get_device(dev);
            async_schedule(async_resume, dev);
        }
    }

    while (!list_empty(&dpm_suspended_list)) {
        dev = to_device(dpm_suspended_list.next);
        get_device(dev);
        if (!is_async(dev)) {
            int error;

            mutex_unlock(&dpm_list_mtx);

            error = device_resume(dev, state, false);
            if (error) {
                suspend_stats.failed_resume++;
                dpm_save_failed_step(SUSPEND_RESUME);
                dpm_save_failed_dev(dev_name(dev));
                pm_dev_err(dev, state, "", error);
            }

            mutex_lock(&dpm_list_mtx);
        }
        if (!list_empty(&dev->power.entry))
            list_move_tail(&dev->power.entry, &dpm_prepared_list);
        put_device(dev);
    }
    mutex_unlock(&dpm_list_mtx);
    async_synchronize_full();
    dpm_show_time(starttime, state, NULL);

    cpufreq_resume();
    trace_suspend_resume(TPS("dpm_resume"), state.event, false);
}

void dpm_complete(pm_message_t state)
{
    struct list_head list;

    trace_suspend_resume(TPS("dpm_complete"), state.event, true);
    might_sleep();

    INIT_LIST_HEAD(&list);
    mutex_lock(&dpm_list_mtx);
    while (!list_empty(&dpm_prepared_list)) {
        struct device *dev = to_device(dpm_prepared_list.prev);

        get_device(dev);
        dev->power.is_prepared = false;
        list_move(&dev->power.entry, &list);
        mutex_unlock(&dpm_list_mtx);

        trace_device_pm_callback_start(dev, "", state.event);
        device_complete(dev, state);
        trace_device_pm_callback_end(dev, 0);

        mutex_lock(&dpm_list_mtx);
        put_device(dev);
    }
    list_splice(&list, &dpm_list);
    mutex_unlock(&dpm_list_mtx);
    trace_suspend_resume(TPS("dpm_complete"), state.event, false);
}

adb root && adb remount

adb shell "echo +10 > /sys/class/rtc/rtc0/wakealarm && echo mem > /sys/power/state"

./analyze_suspend.py -adb  /usr/bin/adb -rtcwake 10 -multi 5 20 -f -m mem

./analyze_suspend.py -adb  /usr/bin/adb -rtcwake 10 -multi 5 20 -f -m freeze

sudo ./analyze_suspend.py -rtcwake 10 -multi 5 20 -f -m mem

sudo ./analyze_suspend.py -rtcwake 10 -multi 5 20 -f -m freeze

# ----------------- MAIN --------------------
# exec start (skipped if script is loaded as library)
if __name__ == '__main__':
    cmd = ''
    cmdarg = ''
    multitest = {'run': False, 'count': 0, 'delay': 0}
    # loop through the command line arguments
    args = iter(sys.argv[1:])
    for arg in args:
        …

    # just run a utility command and exit
    if(cmd != ''):
        if(cmd == 'status'):
            statusCheck()
        elif(cmd == 'fpdt'):
            if(sysvals.android):
                doError('cannot read FPDT on android device', False)
            getFPDT(True)
        elif(cmd == 'usbtopo'):
            if(sysvals.android):
                doError('cannot read USB topology '+\
                    'on an android device', False)
            detectUSB(True)
        elif(cmd == 'modes'):
            modes = getModes()
            print modes
        elif(cmd == 'usbauto'):
            setUSBDevicesAuto()
        elif(cmd == 'summary'):
            print("Generating a summary of folder \"%s\"" % cmdarg)
            runSummary(cmdarg, True)
        sys.exit()

    # run test on android device
    if(sysvals.android):  註釋此段代碼可以在Android上支持callgraph
        #if(sysvals.usecallgraph):
        #    doError('ftrace (-f) is not yet supported '+\
        #        'in the android kernel', False)
        if(sysvals.notestrun):
            doError('cannot analyze test files on the '+\
                'android device', False)

    # if instructed, re-analyze existing data files
    if(sysvals.notestrun):  分析已有數據文件，不需要重新測試
        rerunTest()
        sys.exit()

    # verify that we can run a test
    if(not statusCheck()):  檢查測試條件是否滿足
        print('Check FAILED, aborting the test run!')
        sys.exit()

連續多次測試
        # run multiple tests in a separte subdirectory
        s = 'x%d' % multitest['count']
        subdir = datetime.now().strftime('suspend-'+s+'-%m%d%y-%H%M%S')
        os.mkdir(subdir)
        for i in range(multitest['count']):
            if(i != 0):
                print('Waiting %d seconds...' % (multitest['delay']))
                time.sleep(multitest['delay'])
            print('TEST (%d/%d) START' % (i+1, multitest['count']))
            runTest(subdir)  進行單次測試
            print('TEST (%d/%d) COMPLETE' % (i+1, multitest['count']))
        runSummary(subdir, False)  生成summary.html
    else:
        # run the test in the current directory
        runTest(".")

def runTest(subdir):
    global sysvals

    # prepare for the test
    if(not sysvals.android):  針對不同的待測設備，初始化ftrace
        initFtrace()
    else:
        initFtraceAndroid()
    sysvals.initTestOutput(subdir)  生成輸出目錄，輸出文件名等。

    vprint('Output files:\n    %s' % sysvals.dmesgfile)
    if(sysvals.usecallgraph or
        sysvals.usetraceevents or
        sysvals.usetraceeventsonly):
        vprint('    %s' % sysvals.ftracefile)
    vprint('    %s' % sysvals.htmlfile)

執行測試，實際上命令內容基本一致。只是針對Android設備，增加了adb shell '…'。
    if(not sysvals.android):
        executeSuspend()
    else:
        executeAndroidSuspend()

    # analyze the data and create the html output
    print('PROCESSING DATA')
    if(sysvals.usetraceeventsonly):  3.15之後的版本，只需要通過ftrace即可獲取足夠信息。之前的版本的數據都存在dmesg中。
        # data for kernels 3.15 or newer is entirely in ftrace
        testruns = parseTraceLog()
    else:
        # data for kernels older than 3.15 is primarily in dmesg
        testruns = loadKernelLog()
        for data in testruns:
            parseKernelLog(data)
        if(sysvals.usecallgraph or sysvals.usetraceevents):
            appendIncompleteTraceLog(testruns)
    createHTML(testruns)  根據解析的數據生成html矢量圖表

def executeAndroidSuspend():
    global sysvals

    # check to see if the display is currently off
    tp = sysvals.tpath
    out = os.popen(sysvals.adb+\
        ' shell dumpsys power | grep mScreenOn').read().strip()
    # if so we need to turn it on so we can issue a new suspend
    if(out.endswith('false')):
        print('Waking the device up for the test...')
        # send the KEYPAD_POWER keyevent to wake it up
        os.system(sysvals.adb+' shell input keyevent 26')
        # wait a few seconds so the user can see the device wake up
        time.sleep(3)
    # execute however many s/r runs requested
    for count in range(1,sysvals.execcount+1):
        # clear the kernel ring buffer just as we start
        os.system(sysvals.adb+' shell dmesg -c > /dev/null 2>&1')  清空dmesg
        # start ftrace
        if(sysvals.usetraceevents):
            print('START TRACING')
            os.system(sysvals.adb+" shell 'echo 1 > "+tp+"tracing_on'")  開始ftrace抓取
        # initiate suspend
        for count in range(1,sysvals.execcount+1):
            if(sysvals.usetraceevents):
                os.system(sysvals.adb+\
                    " shell 'echo SUSPEND START > "+tp+"trace_marker'")  寫SUSPEND START到ftrace，作為開始標記。後面解析log，會以此為標記。
            if(sysvals.rtcwake):
                print('SUSPEND START')
                print('will autoresume in %d seconds' % sysvals.rtcwaketime)
                os.system(sysvals.adb+" shell 'echo +%d > /sys/class/rtc/rtc0/wakealarm'"%(sysvals.rtcwaketime))  設置wakeup resource
            else:
                print('SUSPEND START (press a key to resume)')

            os.system(sysvals.adb+" shell 'echo "+sysvals.suspendmode+\
                " > "+sysvals.powerfile+"'")  進入suspend，之後就是resume
            # execution will pause here, then adb will exit
            while(True):  輪詢adb shell pwd判斷設備是否被喚醒
                check = os.popen(sysvals.adb+\
                    ' shell pwd 2>/dev/null').read().strip()
                if(len(check) > 0):
                    break
                time.sleep(1)
            if(sysvals.usetraceevents):
                os.system(sysvals.adb+" shell 'echo RESUME COMPLETE > "+tp+\
                    "trace_marker'")  寫RESUME COMPLETE到ftrace，作為結束標記
        # return from suspend
        print('RESUME COMPLETE')
        # stop ftrace
        if(sysvals.usetraceevents):
            os.system(sysvals.adb+" shell 'echo 0 > "+tp+"tracing_on'") 關閉ftrace功能
            print('CAPTURING TRACE')
            os.system('echo "'+sysvals.teststamp+'" > '+sysvals.ftracefile)
            os.system(sysvals.adb+' shell cat '+tp+\
                'trace >> '+sysvals.ftracefile)  將/sys/kernel/debug/tracing/trace內容保存到本地log
        # grab a copy of the dmesg output
        print('CAPTURING DMESG')
        os.system('echo "'+sysvals.teststamp+'" > '+sysvals.dmesgfile)
        os.system(sysvals.adb+' shell dmesg >> '+sysvals.dmesgfile)  將dmesg保存到本地

if(sysvals.usetraceevents):
    os.system(sysvals.adb+\
        " shell 'echo SUSPEND START > "+tp+"trace_marker'")
print('SUSPEND START (press a key on the device to resume)')
os.system(sysvals.adb+" shell 'echo "+sysvals.suspendmode+\
    " > "+sysvals.powerfile+"'")
# execution will pause here, then adb will exit
while(True):
    check = os.popen(sysvals.adb+\
        ' shell pwd 2>/dev/null').read().strip()
    if(len(check) > 0):
        break
    time.sleep(1)
if(sysvals.usetraceevents):
    os.system(sysvals.adb+" shell 'echo RESUME COMPLETE > "+tp+\
        "trace_marker'")

@@ -486,6 +496,7 @@ static int enter_state(suspend_state_t state)
{
        int error;
 
+       trace_suspend_resume(TPS("enter_state"), state, true);
        trace_suspend_resume(TPS("suspend_enter"), state, true);
        if (state == PM_SUSPEND_FREEZE) {
#ifdef CONFIG_PM_DEBUG
@@ -532,6 +543,7 @@ static int enter_state(suspend_state_t state)
        suspend_finish();
  Unlock:
        mutex_unlock(&pm_mutex);
+       trace_suspend_resume(TPS("enter_state"), state, false);
        return error;
}

7    4    1    7

#define console_loglevel (console_printk[0])
#define default_message_loglevel (console_printk[1])
#define minimum_console_loglevel (console_printk[2])
#define default_console_loglevel (console_printk[3])

int console_printk[4] = {
    CONSOLE_LOGLEVEL_DEFAULT,    /* console_loglevel */
    MESSAGE_LOGLEVEL_DEFAULT,    /* default_message_loglevel */
    CONSOLE_LOGLEVEL_MIN,        /* minimum_console_loglevel */
    CONSOLE_LOGLEVEL_DEFAULT,    /* default_console_loglevel */
};

/* We show everything that is MORE important than this.. */
#define CONSOLE_LOGLEVEL_SILENT  0 /* Mum's the word */
#define CONSOLE_LOGLEVEL_MIN     1 /* Minimum loglevel we let people use */
#define CONSOLE_LOGLEVEL_QUIET     4 /* Shhh ..., when booted with "quiet" */
#define CONSOLE_LOGLEVEL_DEFAULT 7 /* anything MORE serious than KERN_DEBUG */
#define CONSOLE_LOGLEVEL_DEBUG    10 /* issue debug messages */
#define CONSOLE_LOGLEVEL_MOTORMOUTH 15    /* You can't shut this one up */

#define KERN_EMERG    KERN_SOH "0"    /* system is unusable */
#define KERN_ALERT    KERN_SOH "1"    /* action must be taken immediately */
#define KERN_CRIT    KERN_SOH "2"    /* critical conditions */
#define KERN_ERR    KERN_SOH "3"    /* error conditions */
#define KERN_WARNING    KERN_SOH "4"    /* warning conditions */
#define KERN_NOTICE    KERN_SOH "5"    /* normal but significant condition */
#define KERN_INFO    KERN_SOH "6"    /* informational */
#define KERN_DEBUG    KERN_SOH "7"    /* debug-level messages */

#define KERN_DEFAULT    KERN_SOH "d"    /* the default kernel loglevel */

diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
old mode 100644
new mode 100755
index e7e586b..b927d67
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -60,7 +60,7 @@ extern void printascii(char *);
#endif
 
int console_printk[4] = {
-       CONSOLE_LOGLEVEL_DEFAULT,       /* console_loglevel */
+       CONSOLE_LOGLEVEL_QUIET, /* console_loglevel */
        MESSAGE_LOGLEVEL_DEFAULT,       /* default_message_loglevel */
        CONSOLE_LOGLEVEL_MIN,           /* minimum_console_loglevel */
        CONSOLE_LOGLEVEL_DEFAULT,       /* default_console_loglevel */

7, mem
    Line 748: resume_complete,resume_console[3],248.54900000002544
    Line 748: resume_complete,resume_console[3],248.6340000000382
    Line 748: resume_complete,resume_console[3],248.26499999994667
    Line 748: resume_complete,resume_console[3],248.3510000000706
    Line 748: resume_complete,resume_console[3],248.42499999999745

7, freeze
    Line 996: resume_complete,resume_console[1],76.18400000001202
    Line 996: resume_complete,resume_console[1],76.19500000009793
    Line 996: resume_complete,resume_console[1],76.3280000001032
    Line 996: resume_complete,resume_console[1],76.1689999999362
    Line 996: resume_complete,resume_console[1],76.19999999997162

4, freeze
    Line 996: resume_complete,resume_console[1],0.1010000000007949
    Line 996: resume_complete,resume_console[1],0.10499999999069587
    Line 996: resume_complete,resume_console[1],0.09799999997994746
    Line 996: resume_complete,resume_console[1],0.1010000000007949
    Line 996: resume_complete,resume_console[1],0.10000000003174137

4, mem
    Line 749: resume_complete,resume_console[3],0.3370000000586515
    Line 749: resume_complete,resume_console[3],0.33800000005612674
    Line 749: resume_complete,resume_console[3],0.37700000007134804
    Line 749: resume_complete,resume_console[3],0.3359999999474894
    Line 749: resume_complete,resume_console[3],0.3429999999298161

4013.868837 |   4)    sh-4511     |               |  /* device_pm_callback_start: mmcblk mmc0:0001, parent: mmc0, [suspend] */
4013.868893 |   4)    sh-4511     |               |  /* device_pm_callback_end: mmcblk mmc0:0001, err=0 */
4013.869000 |   4)    sh-4511     |               |  /* device_pm_callback_start: block mmcblk0, parent: mmc0:0001, [suspend] */
4013.869053 |   4)    sh-4511     |               |  /* device_pm_callback_end: block mmcblk0, err=0 */
4013.889229 |   5)    sh-4511     |               |  /* device_pm_callback_start: mmcblk mmc0:0001, parent: mmc0, bus [suspend] */
4013.914631 |   0)    sh-4511     |               |  /* device_pm_callback_end: mmcblk mmc0:0001, err=0 */
4022.787571 |   0)    sh-4511     |               |  /* device_pm_callback_start: mmcblk mmc0:0001, parent: mmc0, bus [resume] */
4022.886749 |   0)    sh-4511     |               |  /* device_pm_callback_end: mmcblk mmc0:0001, err=0 */
4023.059198 |   0)    sh-4511     |               |  /* device_pm_callback_start: block mmcblk0, parent: mmc0:0001, [resume] */
4023.059270 |   0)    sh-4511     |               |  /* device_pm_callback_end: block mmcblk0, err=0 */
4023.059398 |   0)    sh-4511     |               |  /* device_pm_callback_start: mmcblk mmc0:0001, parent: mmc0, [resume] */
4023.059830 |   0)    sh-4511     |               |  /* device_pm_callback_end: mmcblk mmc0:0001, err=0 */

static struct bus_type mmc_bus_type = {
    .name        = "mmc",
    .dev_groups    = mmc_dev_groups,
    .match        = mmc_bus_match,
    .uevent        = mmc_bus_uevent,
    .probe        = mmc_bus_probe,
    .remove        = mmc_bus_remove,
    .shutdown    = mmc_bus_shutdown,
    .pm        = &mmc_bus_pm_ops,
};

static const struct dev_pm_ops mmc_bus_pm_ops = {
    SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, NULL)
    SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
};

static int mmc_bus_suspend(struct device *dev)
{
    struct mmc_card *card = mmc_dev_to_card(dev);
    struct mmc_host *host = card->host;
    int ret;

對應設備驅動的suspend回調函數。
    if (ret)
        return ret;

這裏的host指的是mmc_host，bus_ops指的是mmc_ops。
    return ret;
}

static int mmc_bus_resume(struct device *dev)
{
    struct mmc_card *card = mmc_dev_to_card(dev);
    struct mmc_host *host = card->host;
    int ret;

這裏的host指的是mmc_host，bus_ops指的是mmc_ops。

    if (ret)
        pr_warn("%s: error %d during resume (card was removed?)\n",
            mmc_hostname(host), ret);

對應設備的驅動的resume回調函數。
    return ret;
}

static int mmc_suspend(struct mmc_host *host)
{
    int err;

    err = _mmc_suspend(host, true);
    if (!err) {
        pm_runtime_disable(&host->card->dev);
        pm_runtime_set_suspended(&host->card->dev);
    }

    return err;
}

static int mmc_resume(struct mmc_host *host)
{
    int err = 0;

MMC_CAP_RUNTIME_RESUME)) {
        err = _mmc_resume(host);
        pm_runtime_set_active(&host->card->dev);
        pm_runtime_mark_last_busy(&host->card->dev);
    }
    pm_runtime_enable(&host->card->dev);

    return err;
}

static int mmc_runtime_suspend(struct mmc_host *host)
{
    int err;

MMC_CAP_AGGRESSIVE_PM))
        return 0;

    err = _mmc_suspend(host, true);
    if (err)
        pr_err("%s: error %d doing aggressive suspend\n",
            mmc_hostname(host), err);

    return err;
}

static int mmc_runtime_resume(struct mmc_host *host)
{
    int err;

MMC_CAP_AGGRESSIVE_PM | MMC_CAP_RUNTIME_RESUME)))
        return 0;

    err = _mmc_resume(host);
    if (err)
        pr_err("%s: error %d doing aggressive resume\n",
            mmc_hostname(host), err);

    return 0;
}

diff --git a/arch/arm64/boot/dts/hisilicon/hi6220.dtsi b/arch/arm64/boot/dts/hisilicon/hi6220.dtsi
old mode 100644
new mode 100755
index 09e2c71..2cec392
--- a/arch/arm64/boot/dts/hisilicon/hi6220.dtsi
+++ b/arch/arm64/boot/dts/hisilicon/hi6220.dtsi
@@ -801,6 +801,7 @@
                        clock-names = "ciu", "biu";
                        resets = <&sys_ctrl PERIPH_RSTDIS0_MMC0>;
                        bus-width = <0x8>;
+                      runtime-suspend;
                        vmmc-supply = <&ldo19>;
                        pinctrl-names = "default";
                        pinctrl-0 = <&emmc_pmx_func &emmc_clk_cfg_func

4013.876306 |   4)    sh-4511     |               |  /* device_pm_callback_start: mmc mmc2:0001, parent: mmc2, [suspend] */
4013.876360 |   4)    sh-4511     |               |  /* device_pm_callback_end: mmc mmc2:0001, err=0 */
4013.876397 |   4)    sh-4511     |               |  /* device_pm_callback_start: sdio mmc2:0001:1, parent: mmc2:0001, [suspend] */
4013.876437 |   4)    sh-4511     |               |  /* device_pm_callback_end: sdio mmc2:0001:1, err=0 */
4013.876470 |   4)    sh-4511     |               |  /* device_pm_callback_start: wl1271_sdio mmc2:0001:2, parent: mmc2:0001, [suspend] */
4013.876525 |   4)    sh-4511     |               |  /* device_pm_callback_end: wl1271_sdio mmc2:0001:2, err=0 */
4013.876556 |   4)    sh-4511     |               |  /* device_pm_callback_start: wl18xx_driver wl18xx.1.auto, parent: mmc2:0001:2, [suspend] */
4013.876596 |   4)    sh-4511     |               |  /* device_pm_callback_end: wl18xx_driver wl18xx.1.auto, err=0 */
4013.881676 |   4)    sh-4511     |               |  /* device_pm_callback_start: wl18xx_driver wl18xx.1.auto, parent: mmc2:0001:2, bus [suspend] */
4013.881698 |   4)    sh-4511     |               |  /* device_pm_callback_end: wl18xx_driver wl18xx.1.auto, err=0 */
4013.881740 |   4)    sh-4511     |               |  /* device_pm_callback_start: wl1271_sdio mmc2:0001:2, parent: mmc2:0001, bus [suspend] */
4013.881765 |   4)    sh-4511     |               |  /* device_pm_callback_end: wl1271_sdio mmc2:0001:2, err=0 */
4013.882582 |   4)    sh-4511     |               |  /* device_pm_callback_start: sdio mmc2:0001:1, parent: mmc2:0001, bus [suspend] */
4013.882603 |   4)    sh-4511     |               |  /* device_pm_callback_end: sdio mmc2:0001:1, err=0 */
4013.882645 |   4)    sh-4511     |               |  /* device_pm_callback_start: mmc mmc2:0001, parent: mmc2, bus [suspend] */
4013.885524 |   4)    sh-4511     |               |  /* device_pm_callback_end: mmc mmc2:0001, err=0 */
4022.888667 |   0)    sh-4511     |               |  /* device_pm_callback_start: mmc mmc2:0001, parent: mmc2, bus [resume] */
4023.042980 |   0)    sh-4511     |               |  /* device_pm_callback_end: mmc mmc2:0001, err=0 */
4023.043021 |   0)    sh-4511     |               |  /* device_pm_callback_start: sdio mmc2:0001:1, parent: mmc2:0001, bus [resume] */
4023.043037 |   0)    sh-4511     |               |  /* device_pm_callback_end: sdio mmc2:0001:1, err=0 */
4023.043067 |   0)    sh-4511     |               |  /* device_pm_callback_start: wl1271_sdio mmc2:0001:2, parent: mmc2:0001, bus [resume] */
4023.043089 |   0)    sh-4511     |               |  /* device_pm_callback_end: wl1271_sdio mmc2:0001:2, err=0 */
4023.043128 |   0)    sh-4511     |               |  /* device_pm_callback_start: wl18xx_driver wl18xx.1.auto, parent: mmc2:0001:2, bus [resume] */
4023.043151 |   0)    sh-4511     |               |  /* device_pm_callback_end: wl18xx_driver wl18xx.1.auto, err=0 */
4023.048824 |   0)    sh-4511     |               |  /* device_pm_callback_start: wl18xx_driver wl18xx.1.auto, parent: mmc2:0001:2, [resume] */
4023.048877 |   0)    sh-4511     |               |  /* device_pm_callback_end: wl18xx_driver wl18xx.1.auto, err=0 */
4023.048916 |   0)    sh-4511     |               |  /* device_pm_callback_start: wl1271_sdio mmc2:0001:2, parent: mmc2:0001, [resume] */
4023.048979 |   0)    sh-4511     |               |  /* device_pm_callback_end: wl1271_sdio mmc2:0001:2, err=0 */
4023.049011 |   0)    sh-4511     |               |  /* device_pm_callback_start: sdio mmc2:0001:1, parent: mmc2:0001, [resume] */
4023.049074 |   0)    sh-4511     |               |  /* device_pm_callback_end: sdio mmc2:0001:1, err=0 */
4023.049113 |   0)    sh-4511     |               |  /* device_pm_callback_start: mmc mmc2:0001, parent: mmc2, [resume] */
4023.049165 |   0)    sh-4511     |               |  /* device_pm_callback_end: mmc mmc2:0001, err=0 */