当我们不用设备的时候，一般需要关机，用的时候再开机，这样有一个问题，开机非常的慢，那么有什么方法即省电又可以快速开机呢？
答案就是休眠唤醒suspend、resume。甚至很多消费者设备例如手机汽车都是假关机，其实还是休眠，这样用户体验好啊，随时用几秒就可以唤醒使用，用户体验才是王道。
休眠唤醒很重要，一般指的是STR（stroe to RAM），其技术涉及范围很广，需求也很多。有电池的设备可以省电，另外就是电源供电的也可以延长设备使用寿命。
1.基本概念和框架
1.1 基本概念
STR
一般的嵌入式产品仅仅只实现了挂起到RAM（也简称为s2ram，或常简称为STR），即将系统的状态保存于内存中，并将SDRAM置于自刷新状态，待用户按键等操作后再重新恢复系统。
STD
少数嵌入式Linux系统会实现挂起到硬盘（简称STD），它与挂起到RAM的不同是s2ram并不关机，STD则把系统的状态保持于磁盘，然后关闭整个系统。
这些休眠方式，可以通过操作设备节点/sys/power/state设置freeze、standyby、STR（suspend to RAM）和STD（suspend to disk）去实现。通过写入”freeze”、”standby”和”mem”，即可触发它们。
休眠后，可以通过唤醒源（按键、RTC、屏幕、USB拔插等）对系统进行唤醒，唤醒源是不休眠的，需要保留下来监听唤醒操作。
1.2 休眠唤醒技术框架
- 上层service通过wakelock的使用，在系统不需要工作的时候经由power manager利用PM core提供的文件节点发起休眠。
- PM core实现power manage的核心逻辑，为上层services提供操作休眠唤醒的相关接口，通过利用底层相关的技术实现休眠唤醒过程中的cpu hotplug、wakup source enable/disable、设备的suspend&resume等。
- 休眠的过程中PM driver会配置、取消唤醒源，调用设备的suspend&resume函数，进行syscore的suspend&resume操作。
Services
Services部分由两类service组成，power manager service及普通的app service。其中，power manager service提供了wakelock锁的create/request/release管理功能，当没有services持有wakelock的话，power manager service会通过往文件节点/sys/power/state写mem发起内核的休眠。
PM core
PM core部分提供了wakelock（决定是否发起休眠）的实现，wakeup_count（用于各services释放wakelock后，到发起内核休眠的期间是否有唤醒源，从而是否进行resume的管理）的实现，suspend的实现。这三个功能分别向上层提供了相应的文件节点，供上层操作。休眠、唤醒的过程中会涉及到进程的freeze&thaw，wakeup source的使能、失能，设备的休眠、唤醒，power domain的关、开，cpu的拔、插等功能或框架。
相关代码如下：
kernel/power/main.c----提供用户空间接口(/sys/power/state)
kernel/power/suspend.c----Suspend功能的主逻辑
kernel/power/suspend_test.c----Suspend功能的测试逻辑
kernel/power/console.c----Suspend过程中对控制台的处理逻辑
kernel/power/process.c----Suspend过程中对进程的处理逻辑
PM driver
PM driver部分主要实现了设备驱动的suspend&resume实现，架构驱动（gpio、irq、timer等）低功耗相关的操作。
//Device PM
drivers/base/power/*
//Platform dependent PM
include/linux/suspend.h----定义platform dependent PM有关的操作函数集
arch/xxx/mach-xxx/xxx.c或者
arch/xxx/plat-xxx/xxx.c----平台相关的电源管理操作
suspend&resume过程概述
2. 核心代码分析
echo mem > /sys/power/state
做如上操作后，整个函数调用流程如下：
其中设置suspend的核心函数为suspend_enter, 如下:
相关功能代码见：kernel/power/main.c和suspend.c等文件。
Linux内核Suspend总体流程如下：
state_store()->
pm_suspend()->
pm_suspend_marker("entry") ## 1、标记进入睡眠
enter_state()-> ## 2、处理睡眠相关工作，重点关注
sys_sync() ## 2.1、同步文件系统
suspend_prepare() ## 2.2、准备进入系统睡眠状态，并冻结用户空间进程和内核线程
suspend_devices_and_enter() ## 2.3、休眠外设并进入系统睡眠状态,该函数在系统唤醒时返回
suspend_finish() ## 2.4、睡眠结束并被唤醒
pm_suspend_marker("exit") ## 3、标记退出睡眠
下面重点介绍suspend_devices_and_enter()函数的流程：
suspend_devices_and_enter()->
## 1、冻结串口，可以在u-boot传入no_console_suspend，释放suspend流程中串口打印
suspend_console()
## 2、外设驱动suspend
dpm_suspend_start()->
dpm_prepare()->
device_prepare() ## 执行设备电源管理函数中的prepare函数
dpm_suspend()->
device_suspend()->
__device_suspend()->
dpm_run_callback()->
initcall_debug_start() ## 显示调用的各suspend()函数名等信息，需要打开pm_print_times
cb() ## 执行各.suspend()函数，包括：外设驱动，电源域，总线等(重点关注****)
initcall_debug_report() ## 显示各suspend()函数返回值和执行时间
## 3、系统进入睡眠状态，该流程同时处理唤醒操作
suspend_enter()->
platform_suspend_prepare()
dpm_suspend_late(PMSG_SUSPEND)->
device_suspend_late()->
__device_suspend_late()->
dpm_run_callback()->
initcall_debug_start() ## 显示调用的各suspend()函数名等信息，需要打开pm_print_times
cb() ## 执行各.suspend_late()函数 (重点关注****)
initcall_debug_report() ## 显示各.suspend_late()函数返回值和执行时间
dpm_suspend_noirq(PMSG_SUSPEND)->
device_suspend_noirq()->
__device_suspend_noirq()->
dpm_run_callback()->
initcall_debug_start() ## 显示调用的各suspend()函数名等信息，需要打开pm_print_times
cb() ## 执行各.suspend_noirq()函数 (重点关注****)
initcall_debug_report() ## 显示各.suspend_noirq()函数返回值和执行时间
disable_nonboot_cpus() ## 冻结非启动cpu
arch_suspend_disable_irqs() ## 关中断
syscore_suspend() ## 执行注册在syscore_ops_list上的syscore_ops的suspend
##################################### 开始唤醒,流程和suspend相反 #######################
syscore_resume()
arch_suspend_enable_irqs()
enable_nonboot_cpus()
dpm_resume_noirq(PMSG_RESUME)
dpm_resume_early()
platform_resume_finish()
dpm_resume_end(PMSG_RESUME)
resume_console()
3. 详细分析
3.1 suspend sys节点入口
在用户空间执行如下操作：
echo "freeze" > /sys/power/state
echo "standby" > /sys/power/state
echo "mem" > /sys/power/state
系统初始化时候调用pm_init函数，在kernel/power/main.c中
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;
根据sys节点的属性命令规则，sysfs接口实现此节点的实现代码为: state_store
static struct attribute_group attr_group = {
.attrs = g,
};
static struct attribute * g[] = {
&state_attr.attr,
。。。
}
power_attr(state);
#define power_attr(_name)
static struct kobj_attribute _name##_attr = {
.attr = {
.name = __stringify(_name),
.mode = 0644,
},
.show = _name##_show,
.store = _name##_store,
}
3.2 state_store&pm_suspend
这样操作state的时候就会执行state_store（）函数
static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
const char *buf, size_t n)
{
suspend_state_t state;
int error;
//给autosleep功能加锁
error = pm_autosleep_lock();
if (error)
return error;
//autosleep_state值大于0，已经工作在suspend了则停止
if (pm_autosleep_state() > PM_SUSPEND_ON) {
error = -EBUSY;
goto out;
}
//解析用户命令中的buf，例如mem
state = decode_state(buf, n);
if (state < PM_SUSPEND_MAX)
error = pm_suspend(state);
else if (state == PM_SUSPEND_MAX)
error = hibernate();
else
error = -EINVAL;
out:
pm_autosleep_unlock();
return error ? error : n;
}
power_attr(state);
power_attr定义了一个名称为state的attribute文件，该文件的store接口为state_store，该接口在lock住autosleep功能后，解析用户传入的buffer（freeze、standby or mem），转换成state参数。
state参数的类型为suspend_state_t，在includelinuxsuspend.h中定义，为电源管理状态在内核中的表示
typedef int __bitwise suspend_state_t;
#define PM_SUSPEND_ON ((__force suspend_state_t) 0)
#define PM_SUSPEND_FREEZE ((__force suspend_state_t) 1)
#define PM_SUSPEND_STANDBY ((__force suspend_state_t) 2)
#define PM_SUSPEND_MEM ((__force suspend_state_t) 3)
#define PM_SUSPEND_MIN PM_SUSPEND_FREEZE
#define PM_SUSPEND_MAX ((__force suspend_state_t) 4)
pm_suspend在kernel/power/suspend.c定义，处理所有的suspend过程。
int pm_suspend(suspend_state_t state)
{
int error;
if (state = PM_SUSPEND_MAX)
return -EINVAL;
error = enter_state(state);
if (error) {
suspend_stats.fail++;
dpm_save_failed_errno(error);
} else {
suspend_stats.success++;
}
return error;
}
EXPORT_SYMBOL(pm_suspend);
3.3 enter_state
enter_state（）函数中：
static int enter_state(suspend_state_t state)
{
int error;
//确保没有人试图将系统置于睡眠状态
trace_suspend_resume(TPS("suspend_enter"), state, true);
if (state == PM_SUSPEND_FREEZE) {
#ifdef CONFIG_PM_DEBUG
if (pm_test_level != TEST_NONE && pm_test_level valid && suspend_ops->valid(state);
}
对于standby和mem，则需要调用suspend_ops的valid回调，由底层平台代码判断是否支持。
suspend_ops->valid(state)对应：
static int imx6q_pm_valid(suspend_state_t state)
{
return (state == PM_SUSPEND_STANDBY || state == PM_SUSPEND_MEM);
}
static const struct platform_suspend_ops imx6q_pm_ops = {
.enter = imx6q_pm_enter,
.valid = imx6q_pm_valid,
};
//赋值流程如下，系统启动的时候会match machtne执行init
DT_MACHINE_START(IMX6Q, "Freescale i.MX6 Quad/DualLite (Device Tree)")
.l2c_aux_val = 0,
.l2c_aux_mask = ~0,
.smp = smp_ops(imx_smp_ops),
.map_io = imx6q_map_io,
.init_irq = imx6q_init_irq,
.init_machine = imx6q_init_machine,
.init_late = imx6q_init_late,
.dt_compat = imx6q_dt_compat,
MACHINE_END
imx6q_init_machine
--》cpu_is_imx6q() ? imx6q_pm_init() : imx6dl_pm_init();
--》imx6_pm_common_init(&imx6q_pm_data);
--》ret = imx6q_suspend_init(socdata);
--》suspend_set_ops(&imx6q_pm_ops);
3.3.2 suspend_prepare
调用suspend_prepare，进行suspend前的准备，主要包括switch console和process&thread freezing。如果失败，则终止suspend过程。
suspend_prepare（）函数如下：
static int suspend_prepare(suspend_state_t state)
{
int error, nr_calls = 0;
if (!sleep_state_supported(state))
return -EPERM;
//将当前console切换到一个虚拟console并重定向内核的kmsg（需要的话）
pm_prepare_console();
//发送suspend开始的消息
error = __pm_notifier_call_chain(PM_SUSPEND_PREPARE, -1, &nr_calls);
if (error) {
nr_calls--;
goto Finish;
}
trace_suspend_resume(TPS("freeze_processes"), 0, true);
//freeze用户空间进程和一些内核线程
error = suspend_freeze_processes();
trace_suspend_resume(TPS("freeze_processes"), 0, false);
if (!error)
return 0;
//如果freezing-of-tasks失败，调用pm_restore_console，将console切换回原来的console，
//并返回错误，以便能终止suspend。
suspend_stats.failed_freeze++;
dpm_save_failed_step(SUSPEND_FREEZE);
Finish:
__pm_notifier_call_chain(PM_POST_SUSPEND, nr_calls, NULL);
pm_restore_console();
return error;
}
void pm_prepare_console(void)
{
if (!pm_vt_switch())
return;
orig_fgconsole = vt_move_to_console(SUSPEND_CONSOLE, 1);
if (orig_fgconsole < 0)
return;
orig_kmsg = vt_kmsg_redirect(SUSPEND_CONSOLE);
return;
}
3.3.3 suspend_devices_and_enter
suspend_freeze_processes冻结进程的主要流程
suspend_freeze_processes
——> freeze_processes() -> pm_freezing = true
->try_to_freeze_tasks -> freeze_task -> fake_signal_wake_up(p); 冻结用户进程
->freeze_kernel_threads() ->pm_nosig_freezing = true
->try_to_freeze_tasks -> freeze_task -> freeze_workqueues_begin(); 冻结workqueue;
wake_up_state(p, task_interruptible); 冻结内核线程
冻结的对象：可以被调度执行的实体，包括用户进程，内核线程和workqueue.
前半部分，suspend console、suspend device、关中断、调用平台相关的suspend_ops使系统进入低功耗状态。
后半部分，在系统被事件唤醒后，处理相关动作，调用平台相关的suspend_ops恢复系统、开中断、resume device、resume console。
int suspend_devices_and_enter(suspend_state_t state)
{
int error;
bool wakeup = false;
//检查平台代码是否需要提供以及是否提供了suspend_ops
if (!sleep_state_supported(state))
return -ENOSYS;
//调用suspend_ops的begin回调（有的话），通知平台代码，以便让其作相应的处理（需要的话）
error = platform_suspend_begin(state);
if (error)
goto Close;
//挂起console
suspend_console();
suspend_test_start();
//调用所有设备的->prepare和->suspend回调函数
error = dpm_suspend_start(PMSG_SUSPEND);
if (error) {
pr_err("PM: Some devices failed to suspend, or early wake event detectedn");
goto Recover_platform;
}
suspend_test_finish("suspend devices");
if (suspend_test(TEST_DEVICES))
goto Recover_platform;
do {
error = suspend_enter(state, &wakeup);
} while (!error && !wakeup && platform_suspend_again(state));
Resume_devices:
suspend_test_start();
dpm_resume_end(PMSG_RESUME);
suspend_test_finish("resume devices");
trace_suspend_resume(TPS("resume_console"), state, true);
resume_console();
trace_suspend_resume(TPS("resume_console"), state, false);
Close:
platform_resume_end(state);
return error;
Recover_platform:
platform_recover(state);
goto Resume_devices;
}
- 再次检查平台代码是否需要提供以及是否提供了suspend_ops。
- 调用suspend_ops的begin回调（有的话），通知平台代码，以便让其作相应的处理（需要的话）。可能失败，需要跳至Close处执行恢复操作（suspend_ops->end）。
- 调用suspend_console，挂起console。该接口由"kernelprintk.c"实现，主要是hold住一个lock，该lock会阻止其它代码访问console。
- 调用ftrace_stop，停止ftrace功能。ftrace是一个很有意思的功能，后面再介绍。
- 调用dpm_suspend_start，调用所有设备的->prepare和->suspend回调函数，suspend需要正常suspend的设备。suspend device可能失败，需要跳至 Recover_platform，执行recover操作（suspend_ops->recover）。
- 以上都是suspend前的准备工作，此时，调用suspend_enter接口。
3.3.4 dpm_suspend_start
调用所有设备的->prepare和->suspend回调函数，suspend需要正常suspend的设备。suspend device可能失败，需要跳至 Recover_platform，执行recover操作（suspend_ops->recover）。
3.3.5 suspend_enter
suspend_enter接口使系统进入指定的电源状态。该接口的内容如下：
//该接口处理完后，会通过返回值告知是否enter成功，同时通过wakeup指针，告知调用者，是否有wakeup事件发生，导致电源状态切换失败。
static int suspend_enter(suspend_state_t state, bool *wakeup)
{
int error;
//通知平台代码，以便让其在即将进行状态切换之时，再做一些处理（需要的话
error = platform_suspend_prepare(state);
if (error)
goto Platform_finish;
//调用所有设备的->suspend_late和->suspend_noirq回调函数
error = dpm_suspend_late(PMSG_SUSPEND);
if (error) {
pr_err("PM: late suspend of devices failedn");
goto Platform_finish;
}
//通知平台代码，以便让其在最后关头，再做一些处理（需要的话）
error = platform_suspend_prepare_late(state);
if (error)
goto Devices_early_resume;
error = dpm_suspend_noirq(PMSG_SUSPEND);
if (error) {
pr_err("PM: noirq suspend of devices failedn");
goto Platform_early_resume;
}
error = platform_suspend_prepare_noirq(state);
if (error)
goto Platform_wake;
if (suspend_test(TEST_PLATFORM))
goto Platform_wake;
//如果是suspend to freeze，执行相应的操作，包括冻结进程、suspended devices（参数为PM_SUSPEND_FREEZE）、cpu进入idle。如果有任何事件使CPU从idle状态退出，跳至Platform_wake处，执行wake操作。
if (state == PM_SUSPEND_FREEZE) {
trace_suspend_resume(TPS("machine_suspend"), state, true);
freeze_enter();
trace_suspend_resume(TPS("machine_suspend"), state, false);
goto Platform_wake;
}
//禁止所有的非boot cpu
error = disable_nonboot_cpus();
if (error || suspend_test(TEST_CPUS))
goto Enable_cpus;
//关全局中断
arch_suspend_disable_irqs();
BUG_ON(!irqs_disabled());
//suspend system core
error = syscore_suspend();
if (!error) {
//调用pm_wakeup_pending检查一下，这段时间内，是否有唤醒事件发生，如果有就要终止suspend。
*wakeup = pm_wakeup_pending();
if (!(suspend_test(TEST_CORE) || *wakeup)) {
trace_suspend_resume(TPS("machine_suspend"),
state, true);
//调用suspend_ops的enter回调，进行状态切换
error = suspend_ops->enter(state);
trace_suspend_resume(TPS("machine_suspend"),
state, false);
events_check_enabled = false;
} else if (*wakeup) {
error = -EBUSY;
}
syscore_resume();
}
arch_suspend_enable_irqs();
BUG_ON(irqs_disabled());
Enable_cpus:
enable_nonboot_cpus();
Platform_wake:
platform_resume_noirq(state);
dpm_resume_noirq(PMSG_RESUME);
Platform_early_resume:
platform_resume_early(state);
Devices_early_resume:
dpm_resume_early(PMSG_RESUME);
Platform_finish:
platform_resume_finish(state);
return error;
}
- f1）该接口处理完后，会通过返回值告知是否enter成功，同时通过wakeup指针，告知调用者，是否有wakeup事件发生，导致电源状态切换失败。
- f2）调用suspend_ops的prepare回调（有的话），通知平台代码，以便让其在即将进行状态切换之时，再做一些处理（需要的话）。该回调可能失败（平台代码出现意外），失败的话，需要跳至Platform_finish处，调用suspend_ops的finish回调，执行恢复操作。
- f3）调用dpm_suspend_end，调用所有设备的->suspend_late和->suspend_noirq回调函数（具体可参考“Linux电源管理(4)_Power Management Interface”的描述），suspend late suspend设备和需要在关中断下suspend的设备。需要说明的是，这里的noirq，是通过禁止所有的中断线的形式，而不是通过关全局中断的方式。同样，该操作可能会失败，失败的话，跳至Platform_finish处，执行恢复动作。
- f4）调用suspend_ops的prepare_late回调（有的话），通知平台代码，以便让其在最后关头，再做一些处理（需要的话）。该回调可能失败（平台代码出现意外），失败的话，需要跳至Platform_wake处，调用suspend_ops的wake回调，执行device的resume、调用suspend_ops的finish回调，执行恢复操作。
- f5）如果是suspend to freeze，执行相应的操作，包括冻结进程、suspended devices（参数为PM_SUSPEND_FREEZE）、cpu进入idle。如果有任何事件使CPU从idle状态退出，跳至Platform_wake处，执行wake操作。
- f6）调用disable_nonboot_cpus，禁止所有的非boot cpu。也会失败，执行恢复操作即可。
- f7）调用arch_suspend_disable_irqs，关全局中断。如果无法关闭，则为bug。
- f8）调用syscore_suspend，suspend system core。同样会失败，执行恢复操作即可。system core为系统的一些核心功能，如timer、irq、clk等。
- f9）如果很幸运，以上操作都成功了，那么，切换吧。不过，别高兴太早，还得调用pm_wakeup_pending检查一下，这段时间内，是否有唤醒事件发生，如果有就要终止suspend。
- f10）如果一切顺利，调用suspend_ops的enter回调，进行状态切换。这时，系统应该已经suspend了……
- f11）suspend过程中，唤醒事件发生，系统唤醒，该函数接着执行resume动作，并最终返回。resume动作基本上是suspend的反动作，就不再继续分析了。
- f12）或者，由于意外，suspend终止，该函数也会返回。
3.3.6 suspend_finish
最后，调用suspend_finish，恢复（或等待恢复）process&thread，还原console。
static void suspend_finish(void)
{
suspend_thaw_processes();
pm_notifier_call_chain(PM_POST_SUSPEND);
pm_restore_console();
}
- 恢复所有的用户空间进程和内核线程。
- 发送suspend结束的通知。
- 将console切换回原来的。
3.4 唤醒源设置
int suspend_enter(suspend_state_t state, bool *wakeup)
-->int dpm_suspend_noirq(pm_message_t state)
-->void dpm_noirq_begin(void)
-->void device_wakeup_arm_wake_irqs(void)
-->void dev_pm_arm_wake_irq(struct wake_irq *wirq)
-->enable_irq_wake()
首先dpm_suspend_noirq会禁止所有的中断
然后enable_irq_wake设置唤醒源中断，调用途径有两种：
一是先在driver的probe函数中调用dev_pm_set_wake_irq()和device_init_wakeup()，将irq标记为wakeup irq， 这样在如下流程中将标记为wakeup irq的irq为唤醒源：
二是在driver的suspend函数中主动调用调用；即当系统将要进入suspend模式时，会先调用设备的设置suspend接口进入suspend模式，在该过程中会先判断如果该设备被设置为 wakeup source（通过调用device_may_wakeup()判断），则调用enable_irq_wake()将设备对应的irq设置为wakeup 功能的irq。
例如一个GPIO按键，在DTB中，设置属性”wakeup-source“为1，在GPIO驱动中
static struct platform_driver egpio_driver = {
.driver = {
.name = "htc-egpio",
.suppress_bind_attrs = true,
},
.suspend = egpio_suspend,
.resume = egpio_resume,
};
static int egpio_suspend(struct platform_device *pdev, pm_message_t state)
{
struct egpio_info *ei = platform_get_drvdata(pdev);
if (ei->chained_irq && device_may_wakeup(&pdev->dev))
enable_irq_wake(ei->chained_irq);
return 0;
}
一般其他驱动例如USB、Ethnet、触摸屏等都会触发唤醒。就是感觉到有人要使用了就会触发。
int suspend_enter(suspend_state_t state, bool *wakeup)
-->int dpm_suspend_noirq(pm_message_t state)
-->suspend_device_irqs();
-->__disable_irq(desc);
为设备中断处理函数，会对每个设备中断执行关闭操作
3.5 struct platform_suspend_ops
这个由平台实现，见代码里面只有enter和valid，不全面
static const struct platform_suspend_ops imx6q_pm_ops = {
.enter = imx6q_pm_enter,
.valid = imx6q_pm_valid,
};
正常的操作接口可以操作psci
一般suspend设计power domain，是按域进行实际硬件操作的，这就需要系统支持power domain的驱动，例如
drivers/soc/rockchip/pm_domains.c
static const struct rockchip_domain_info rk3399_pm_domains[] = {
[RK3399_PD_TCPD0] = DOMAIN_RK3399("tcpd0", BIT(8), BIT(8), 0, false),
[RK3399_PD_TCPD1] = DOMAIN_RK3399("tcpd1", BIT(9), BIT(9), 0, false),
[RK3399_PD_CCI] = DOMAIN_RK3399("cci", BIT(10), BIT(10), 0, true),
[RK3399_PD_CCI0] = DOMAIN_RK3399("cci0", 0, 0, BIT(15), true),
[RK3399_PD_CCI1] = DOMAIN_RK3399("cci1", 0, 0, BIT(16), true),
[RK3399_PD_PERILP] = DOMAIN_RK3399("perilp", BIT(11), BIT(11), BIT(1), true),
[RK3399_PD_PERIHP] = DOMAIN_RK3399("perihp", BIT(12), BIT(12), BIT(2), true),
[RK3399_PD_CENTER] = DOMAIN_RK3399("center", BIT(13), BIT(13), BIT(14), true),
[RK3399_PD_VIO] = DOMAIN_RK3399("vio", BIT(14), BIT(14), BIT(17), false),
[RK3399_PD_GPU] = DOMAIN_RK3399("gpu", BIT(15), BIT(15), BIT(0), false),
[RK3399_PD_VCODEC] = DOMAIN_RK3399("vcodec", BIT(16), BIT(16), BIT(3), false),
[RK3399_PD_VDU] = DOMAIN_RK3399("vdu", BIT(17), BIT(17), BIT(4), false),
[RK3399_PD_RGA] = DOMAIN_RK3399("rga", BIT(18), BIT(18), BIT(5), false),
[RK3399_PD_IEP] = DOMAIN_RK3399("iep", BIT(19), BIT(19), BIT(6), false),
[RK3399_PD_VO] = DOMAIN_RK3399("vo", BIT(20), BIT(20), 0, false),
[RK3399_PD_VOPB] = DOMAIN_RK3399("vopb", 0, 0, BIT(7), false),
[RK3399_PD_VOPL] = DOMAIN_RK3399("vopl", 0, 0, BIT(8), false),
[RK3399_PD_ISP0] = DOMAIN_RK3399("isp0", BIT(22), BIT(22), BIT(9), false),
[RK3399_PD_ISP1] = DOMAIN_RK3399("isp1", BIT(23), BIT(23), BIT(10), false),
[RK3399_PD_HDCP] = DOMAIN_RK3399("hdcp", BIT(24), BIT(24), BIT(11), false),
[RK3399_PD_GMAC] = DOMAIN_RK3399("gmac", BIT(25), BIT(25), BIT(23), true),
[RK3399_PD_EMMC] = DOMAIN_RK3399("emmc", BIT(26), BIT(26), BIT(24), true),
[RK3399_PD_USB3] = DOMAIN_RK3399("usb3", BIT(27), BIT(27), BIT(12), true),
[RK3399_PD_EDP] = DOMAIN_RK3399("edp", BIT(28), BIT(28), BIT(22), false),
[RK3399_PD_GIC] = DOMAIN_RK3399("gic", BIT(29), BIT(29), BIT(27), true),
[RK3399_PD_SD] = DOMAIN_RK3399("sd", BIT(30), BIT(30), BIT(28), true),
[RK3399_PD_SDIOAUDIO] = DOMAIN_RK3399("sdioaudio", BIT(31), BIT(31), BIT(29), true),
};
这个驱动在probe的时候会添加这些domain并赋值回调函数
pd->genpd.power_off = rockchip_pd_power_off;
pd->genpd.power_on = rockchip_pd_power_on;
3.6 ATF中处理
在ATF代码中，处理smc为
#define PSCI_CPU_SUSPEND_AARCH64 U(0xc4000001)
std_svc_smc_handler
--》psci_smc_handler
-->psci_cpu_suspend
#define PSCI_SYSTEM_SUSPEND_AARCH64 U(0xc400000E)
int psci_system_suspend(uintptr_t entrypoint, u_register_t context_id)
{
if (!psci_is_last_on_cpu()) //必须是最后一个on的cpu
rc = psci_validate_entry_point(&ep, entrypoint, context_id); //判断entrypoint有效性
psci_query_sys_suspend_pwrstate(&state_info);//对state进行校验
if (psci_find_target_suspend_lvl(&state_info) < PLAT_MAX_PWR_LVL)
return PSCI_E_DENIED;
assert(psci_validate_suspend_req(&state_info, PSTATE_TYPE_POWERDOWN)
== PSCI_E_SUCCESS);
assert(is_local_state_off(
state_info.pwr_domain_state[PLAT_MAX_PWR_LVL]) != 0);
//设置cpu进入suspend
rc = psci_cpu_suspend_start(&ep,
PLAT_MAX_PWR_LVL,
&state_info,
PSTATE_TYPE_POWERDOWN);
return rc;
}
psci_cpu_suspend_start函数里面可以自己看下，最后执行了wfi指令使cpu down
后记
休眠唤醒流程的确很复杂，直接看代码不同平台实现差异很大，看懂也比较难，我们能做的就是知道大致原理，最后还是要通过PMU或者SCP去实现，都是要区分power domain。然后在需求开发的时候，我们调研几个平台的实现就可以自己攒一个实现了。
“啥都懂一点，啥都不精通，
干啥都能干，干啥啥不是，
专业入门劝退，堪称程序员杂家”。
后续会继续更新，纯干货分析，欢迎分享给朋友，欢迎评论交流！
