Linux电源管理——CPUidle Framework

目录

前言

一、CPU idle

二、cpuidle framework 相关概念

三、cpuidle core 数据结构

3.1、cpuidle_state

3.2、cpuidle_driver

3.3、cpuidle_device

3.4、cpuidle_governor

四、cpuidle driver初始化流程

 4.1、cpuidle driver 初始化方式

 4.2、drv->states[0]的初始化

 4.3、其它drv->states的初始化

 4.4 register cpuidle driver/device

 4.5、psci_enter_idle_state

五、cpuidle governor

5.1、governor 的分类和作用

5.2、代码分析

5.2.1、menu_enable_device

5.2.2、menu_select

5.2.3、menu_reflect

References

---

Linux Version：linux-6.1

前言

        随着现在操作系统和芯片设计越来越复杂，产品的应用场景不同对cpu idle的要求也会不一样，有的产品可能要求 cpu idle时的功耗要低，但对退出 idle 时的延迟要求并不高，反之有的产品可能对系统恢复的时间(idle退出延迟)有很高的要求，但对功耗并没有要求，为了更好的平衡idle的功耗和延迟，所以就有了cpuidle framework，cpuidle framework 会根据系统的不同应用场景而选择不同 idle state，即本文主要就是针对 cpuidle framework 中相关的数据结构和相关函数进行分析，为后面分析 suspend to idle 打下基础。

一、CPU idle

        在Linux系统中，CPU主要处理两类程序：一类是进程/线程，另一类是各种中断/异常的处理程序。为了节省电量，当系统中的 CPU 在处理完中断程序或没有进程任务需要运行时，该CPU就会进入一种空闲状态(idle state)，即让 CPU 停止从内存获取指令。在空闲状态下，系统将消耗非常少的电量。

        在ARM64架构中，当CPU Idle会调用WFI指令(wait for interrupt)让 CPU 进入低功耗状态，当有中断触发时，CPU又会恢复回来。

二、cpuidle framework 相关概念

        一般情况下，在 CPU 进入空闲状态之前可能会有多种不同的空闲状态可以使用，所以此时需要找到当前系统最合适的一种，并让 CPU 进入该特定的空闲状态。而idle状态又会根据不同的省电程度而分成不同的idle等级，等级越深则省电越优，但是系统恢复越慢，反之如果想要系统恢复得比较快，则省电效果可能不太理想，因此需要结合用户的实际需求，选择进入哪个等级的idle状态。但是这些 idle 状态是怎样初始化的？系统中有哪些 idle 状态？是通过什么方式进行选择最合适一种 idle 状态的？这就是 cpuidle framework 的作用了。

    cpuidle framework通过向上给Scheduler/Sysfs提供调用的接口，向下对应不同架构的CPU，屏蔽硬件层并抽象出调用接口，这也是 linux 系统常用的一种方法了。

下面是 cpuidle framework 的一张整体框架图，如下：

cpuidle core：cpuidle framework 框架的核心，向上层用户空间和 idle task 提供调用接口，如cpuidle_idle_call、call_cpuidle 等函数，向下层 cpuidle drivers/governors 提供统一的注册接口，比如 cpuidle_register_driver/cpuidle_unregister_driver，cpuidle_register_governor、cpuidle_switch_governor 函数等。

cpuidle drivers：负责每一种 idle state 的具体实现，向上为 cpuidle core 提供调用接口，向 cpuidle_governor 提供每一个 idle state 的一些基本信息，比如该 idle 的 “退出延迟“， “idle 功耗“ 等。不同的平台 cpuidle drivers 的实现方式不同，arm 架构中是在 cpuidle-arm.c，而 arm64 则是在 cpuidle-psci.c 文件中实现。

cpuidle governors：在之前就提到了，为了适应系统的不同使用场景会为CPU设置多种不同层级的idle state，这些idle state的主要区别主要有两点，一是idle时的功耗，这会体现出该idle state 是否真正达到了节省电量的目的，二是idle退出延迟，这会体现出该idle state resume 时的时间长短。在 cpuidle driver 中初始化每种idle state之后，它会把这些信息告诉 cpuidle governor，由governor根据系统具体的应用场景，决定要选用哪种idle状态。

        简单的说就是当调度器发现没有Task在运行状态时，就会切换到Idle进程，此时通过cpuidle_idle_call接口调到cpuidle framework，cpuidle framework会根据当前系统的情况选择合适的策略来决定进入哪种idle状态，最终回调到底层的平台实现。

三、cpuidle core 数据结构

    cpuidle core抽象出了三个数据结构：cpuidle device 用于描述CPU核，cpuidle driver是针对CPU核的驱动而cpuidle governor则主要根据cpuidle的device和driver状态来选择策略。

3.1、cpuidle_state

cpuidle core使用struct cpuidle_state结构体抽象cpu idle 的层级，如下：

//  include/linux/cpuidle.h
struct cpuidle_state {char		name[CPUIDLE_NAME_LEN];char		desc[CPUIDLE_DESC_LEN];s64		exit_latency_ns;s64		target_residency_ns;unsigned int	flags;unsigned int	exit_latency; /* in US */int		power_usage; /* in mW */unsigned int	target_residency; /* in US */int (*enter)	(struct cpuidle_device *dev,struct cpuidle_driver *drv,int index);int (*enter_dead) (struct cpuidle_device *dev, int index);/** CPUs execute ->enter_s2idle with the local tick or entire timekeeping* suspended, so it must not re-enable interrupts at any point (even* temporarily) or attempt to change states of clock event devices.** This callback may point to the same function as ->enter if all of* the above requirements are met by it.*/int (*enter_s2idle)(struct cpuidle_device *dev,struct cpuidle_driver *drv,int index);
};

name / desc：该idle state 的名字和描述

exit_latency_ns：退出该idle state 所需的延迟时间，单位是 ns。该变量决定了CPU从 idle 状态切换到运行状态的效率

target_residency_ns：期望CPU在该 idle 状态下停留的时间，单位是 ns

flags：idle state的特性标志

exit_latency：退出该 idle 状态所需的延迟时间，单位是 us

power_usage：CPU在该 idle 状态下的功耗，单位是 mW

target_residency：目标驻留时间，单位是 us

enter：CPU进入该idle状态的入口

enter_dead：通常用于深度休眠或关闭电源的场景

enter_s2idle：用于将CPU进入s2idle状态。如果 enter 函数满足和 enter_s2idle 函数一样的 idle 要求，则 enter_s2idle 可以指向和 enter 相同的函数。

        cpuidle state的主要功能为定义一些关于 idle 的功耗、退出延迟等相关变量，并提供了进入该 idle state的回调函数。

3.2、cpuidle_driver

cpuidle core使用struct cpuidle_driver抽象cpuidle驱动，如下：

//  include/linux/cpuidle.h
struct cpuidle_driver {const char		*name;struct module 		*owner;/* used by the cpuidle framework to setup the broadcast timer */unsigned int            bctimer:1;/* states array must be ordered in decreasing power consumption */struct cpuidle_state	states[CPUIDLE_STATE_MAX];int			state_count;int			safe_state_index;/* the driver handles the cpus in cpumask */struct cpumask		*cpumask;/* preferred governor to switch at register time */const char		*governor;ANDROID_KABI_RESERVE(1);
};

name / owner：驱动名称和 驱动所有者

bctimer:1：广播计时器（broadcast timer），允许CPU在空闲状态下同步唤醒，以减少功耗

states：idle state 数组，包含了CPU idle driver支持的所有空闲状态

state_count：states 数组元素个数，即该 CPU 所支持的所有 idle state 个数

cpumask： 一个struct cpumask结构体类型的bit map指针，说明该driver支持哪些cpu core

governor：指定了在注册时首选的 governor

cpuidle_driver 结构体最主要是定义CPU所支持的cpuidle state

cpuidle_driver 的注册，销毁相关的函数如下：

//  drivers/cpuidle/driver.c
int cpuidle_register_driver(struct cpuidle_driver *drv)  //注册一个 cpuidle_driver
void cpuidle_unregister_driver(struct cpuidle_driver *drv) //注销一个 cpuidle_driver
struct cpuidle_driver *cpuidle_get_driver(void)    //获取一个和当前 CPU 绑定的 cpuidle_driver

3.3、cpuidle_device

cpuidle device是一个虚拟设备，负责描述CPU和实现cpuidle相关的逻辑，linux kernel 使用struct cpuidle_device抽象cpuidle device

//  include/linux/cpuidle.h
struct cpuidle_device {unsigned int		registered:1;unsigned int		enabled:1;unsigned int		poll_time_limit:1;unsigned int		cpu;ktime_t			next_hrtimer;int			last_state_idx;u64			last_residency_ns;u64			poll_limit_ns;u64			forced_idle_latency_limit_ns;struct cpuidle_state_usage	states_usage[CPUIDLE_STATE_MAX];struct cpuidle_state_kobj *kobjs[CPUIDLE_STATE_MAX];struct cpuidle_driver_kobj *kobj_driver;struct cpuidle_device_kobj *kobj_dev;struct list_head 	device_list;#ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLEDcpumask_t		coupled_cpus;struct cpuidle_coupled	*coupled;
#endifANDROID_KABI_RESERVE(1);
};

registered:1：表示该idle devices 是否已经被注册

enabled:1：表示该idle devices 是否已经被启动

poll_time_limit:1：指示是否有限制轮询时间

cpu：表示这个cpuidle_device结构体关联的CPU编号

last_state_idx：上一次进入的CPU idle state 的索引

last_residency_ns：上一次在该CPU idle state 下停留的时间，单位为ns

poll_limit_ns：轮询限制时间

forced_idle_latency_limit_ns：强制空闲延迟限制时间

states_usage：记录了该设备的每个idle state的统计信息

kobjs/kobj_driver/kobj_dev：为用户空间创建 sysfs 接口

device_list：将cpuidle_device结构体添加到一个全局链表中

cpuidle_device 的注册，销毁相关的函数如下：

//  drivers/cpuidle/cpuidle.c
int cpuidle_register_device(struct cpuidle_device *dev)  //注册一个 cpuidle_device
void cpuidle_unregister_device(struct cpuidle_device *dev)//注销一个 cpuidle_device
void cpuidle_disable_device(struct cpuidle_device *dev)  //禁用 cpuidle_device
int cpuidle_enable_device(struct cpuidle_device *dev)  //开启 cpuidle_device

3.4、cpuidle_governor

cpuidle core使用struct cpuidle_governor结构抽象cpuidle governor，如下：

//  include/linux/cpuidle.h
struct cpuidle_governor {char			name[CPUIDLE_NAME_LEN];struct list_head 	governor_list;unsigned int		rating;int  (*enable)		(struct cpuidle_driver *drv,struct cpuidle_device *dev);void (*disable)		(struct cpuidle_driver *drv,struct cpuidle_device *dev);int  (*select)		(struct cpuidle_driver *drv,struct cpuidle_device *dev,bool *stop_tick);void (*reflect)		(struct cpuidle_device *dev, int index);
};

name：governor的名字

governor_list：将该governor添加到一个全局的governors链表中

rating：该 CPU idle governor 的等级或评分，一般内核会根据rating来选择最合适的策略。

enable/disable：governor的enable/disable回调函数

select：结合当前系统的运行状况和各个idle state的特点，选择一个合适的 state，会返回该 state 的 idx 索引

reflect：更新governor，系统上一次的idle state是哪个，即 dev->last_state_idx = index

cpuidle_governor 的注册，销毁相关的函数如下：

//  drivers/cpuidle/governor.c
int cpuidle_register_governor(struct cpuidle_governor *gov)  //注册一个 governor
int cpuidle_switch_governor(struct cpuidle_governor *gov)  //更改 governor
struct cpuidle_governor *cpuidle_find_governor(const char *str) //通过指定名称查找 governor

四、cpuidle driver初始化流程

 4.1、cpuidle driver 初始化方式

        本小节主要是对ARM64平台下的cpuidle driver进行分析，包括 cpuidle_state中的 idle state 初始化流程，因为 arm64 架构的 cpuidle _driver 是通过 psci 实现的，所以 cpuidle driver 文件在cpuidle-psci.c 文件中，如下：

//  drivers/cpuidle/cpuidle-psci.c
static int __init psci_idle_init(void)
{struct platform_device *pdev;int ret;
//  注册驱动ret = platform_driver_register(&psci_cpuidle_driver);if (ret)return ret;pdev = platform_device_register_simple("psci-cpuidle", -1, NULL, 0);if (IS_ERR(pdev)) {platform_driver_unregister(&psci_cpuidle_driver);return PTR_ERR(pdev);}return 0;
}
device_initcall(psci_idle_init);

psci_cpuidle_driver 结构体：

static struct platform_driver psci_cpuidle_driver = {.probe = psci_cpuidle_probe,.driver = {.name = "psci-cpuidle",},
};

        通过 psci_idle_init 函数可以看出在 arm64 架构中 cpuidle driver 中的初始化其实是通过平台总线进行匹配并开始初始化的，psci_cpuidle_probe 如下： 

/** psci_idle_probe - Initializes PSCI cpuidle driver** Initializes PSCI cpuidle driver for all CPUs, if any CPU fails* to register cpuidle driver then rollback to cancel all CPUs* registration.*/
static int psci_cpuidle_probe(struct platform_device *pdev)
{int cpu, ret;struct cpuidle_driver *drv;struct cpuidle_device *dev;
//  遍历每一个可用的CPUfor_each_possible_cpu(cpu) {//  为每一个CPU初始化 cpuidle_driverret = psci_idle_init_cpu(&pdev->dev, cpu);if (ret)goto out_fail;}psci_idle_init_cpuhp();return 0;out_fail:while (--cpu >= 0) {dev = per_cpu(cpuidle_devices, cpu);drv = cpuidle_get_cpu_driver(dev);cpuidle_unregister(drv);psci_cpu_deinit_idle(cpu);}return ret;
}

psci_idle_init_cpu 函数如下：

static int psci_idle_init_cpu(struct device *dev, int cpu)
{struct cpuidle_driver *drv;struct device_node *cpu_node;const char *enable_method;int ret = 0;cpu_node = of_cpu_device_node_get(cpu);if (!cpu_node)return -ENODEV;/** Check whether the enable-method for the cpu is PSCI, fail* if it is not.*/enable_method = of_get_property(cpu_node, "enable-method", NULL);if (!enable_method || (strcmp(enable_method, "psci")))ret = -ENODEV;of_node_put(cpu_node);if (ret)return ret;drv = devm_kzalloc(dev, sizeof(*drv), GFP_KERNEL);if (!drv)return -ENOMEM;drv->name = "psci_idle";drv->owner = THIS_MODULE;drv->cpumask = (struct cpumask *)cpumask_of(cpu);/** PSCI idle states relies on architectural WFI to be represented as* state index 0.*/drv->states[0].enter = psci_enter_idle_state;drv->states[0].exit_latency = 1;drv->states[0].target_residency = 1;drv->states[0].power_usage = UINT_MAX;strcpy(drv->states[0].name, "WFI");strcpy(drv->states[0].desc, "ARM WFI");/** If no DT idle states are detected (ret == 0) let the driver* initialization fail accordingly since there is no reason to* initialize the idle driver if only wfi is supported, the* default archictectural back-end already executes wfi* on idle entry.*/ret = dt_init_idle_driver(drv, psci_idle_state_match, 1);if (ret <= 0)return ret ? : -ENODEV;/** Initialize PSCI idle states.*/ret = psci_cpu_init_idle(dev, drv, cpu, ret);if (ret) {pr_err("CPU %d failed to PSCI idle\n", cpu);return ret;}ret = cpuidle_register(drv, NULL);if (ret)goto deinit;cpuidle_cooling_register(drv);return 0;
deinit:psci_cpu_deinit_idle(cpu);return ret;
}

        psci_idle_init_cpu 函数首先会将设备树中的 cpu 节点通过 of_cpu_device_node_get 函数读取到 device_node *cpu_node 变量中，并通过 of_get_property 函数获取该 CPU 的启动方式，看是否为 PSCI，如果不是则返回错误。

        然后对 cpuidle_driver 分配空间并初始化一些基本的变量，初始化 cpuidle_driver drv->name = “psci_idle”，这将以 sysfs 的形式体现在 /sys/devices/system/cpu/cpuidle/current_driver 文件中如下所示，然后还提供了默认的 WFI 状态，即 idle state[0]，如果有其它 idle state，则需要通过DTS进行配置。

# cat /sys/devices/system/cpu/cpuidle/current_driver
psci_idle

 4.2、drv->states[0]的初始化

        在初始化完 cpuidle driver 的一些基本信息之后，会对 idle state 进行初始化，cpuidle state[0] 初始化如下：

/*
* PSCI idle states relies on architectural WFI to be represented as
* state index 0.
*/
drv->states[0].enter = psci_enter_idle_state;
drv->states[0].exit_latency = 1;
drv->states[0].target_residency = 1;
drv->states[0].power_usage = UINT_MAX;
strcpy(drv->states[0].name, "WFI");
strcpy(drv->states[0].desc, "ARM WFI");

        这里将states[0].enter 回调初始化为 psci_enter_idle_state 函数，将 idle state[0].exit_latency 和 states[0].target_residency 都初始化为 1 (us)，states[0].power_usage 初始化为 uint 类型的最大值 UINT_MAX，但这些值都只是一个相对值，因为对于其它的所有 idle state 的 power_usage 都不应该比 UINT_MAX 还要大了，其它 idle state 的 exit_latency 和 target_residency 都不应该比 1 还小了，因为 exit_latency 和 target_residency 是 unsigned int 类型的，这也是为了适应系统中各种 idle state 而设计，因为cpuidle_driver 不可能知道每一种 arm64 平台的 idle state 所有信息， 在实际应用中，这些值应该根据具体的硬件和系统需求进行调整和优化。

 4.3、其它drv->states的初始化

        初始化完 idle state[0]之后如果还有 idle state 需要初始化则从 state[1]开始需要通过 DTS 进行配置，如下：

	/** If no DT idle states are detected (ret == 0) let the driver* initialization fail accordingly since there is no reason to* initialize the idle driver if only wfi is supported, the* default archictectural back-end already executes wfi* on idle entry.*/ret = dt_init_idle_driver(drv, psci_idle_state_match, 1);if (ret <= 0)return ret ? : -ENODEV;

        通过注释可以看出如果没有在 DT 中检测到 idle state 即 (ret == 0)，则驱动程序初始化将应该失败，因为如果仅支持 wfi，则没有理由初始化 idle driver 程序，因为架构已经有了默认的在空闲执行的 WFI。也就是说使用 cpuidle framework 时必须要通过 DTS 配置 idle state，否则 cpuidle_driver 会初始化失败。

        dt_init_idle_driver 函数第二个参数 psci_idle_state_match 就是用来匹配 DTS 中的 state 节点的，三个参数表示 state的第几项，1表示从 DTS 初始化的 idle state 从 state[1]开始。psci_idle_state_match 如下：

static const struct of_device_id psci_idle_state_match[] = {{ .compatible = "arm,idle-state",.data = psci_enter_idle_state },{ },
};

        在分析 dt_init_idle_driver 函数之前先了解一下 cpuidle state 的 DTS 节点长什么样，如下是以 rockchip 平台的 rk3399平台为例进行分析：

#arch/arm64/boot/dts/rockchip/rk3399.dtsi
cpus {#address-cells = <2>;#size-cells = <0>;cpu-map {cluster0 {core0 {cpu = <&cpu_l0>;};......};......};cpu_l0: cpu@0 {device_type = "cpu";compatible = "arm,cortex-a53";reg = <0x0 0x0>;enable-method = "psci";......cpu-idle-states = <&CPU_SLEEP &CLUSTER_SLEEP>;};......idle-states {entry-method = "psci";CPU_SLEEP: cpu-sleep {compatible = "arm,idle-state";local-timer-stop;arm,psci-suspend-param = <0x0010000>;entry-latency-us = <120>;exit-latency-us = <250>;min-residency-us = <900>;};......};
};

        通过上面的设备树文件可以看出该 CPU 的启动方式(enable-method)为 PSCI，在每个cpu 节点中，通过 cpu-idle-states 字段，指定该CPU所支持的idle states，比如这个CPU支持的 idle state 为 CPU_SLEEP 和 CLUSTER_SLEEP 两种，下面主要对 CPU_SLEEP state 进行分析，如下：

CPU_SLEEP: cpu-sleep {compatible = "arm,idle-state";local-timer-stop;arm,psci-suspend-param = <0x0010000>;entry-latency-us = <120>;exit-latency-us = <250>;min-residency-us = <900>;
};

        idle state 的 compatible 属性都是 "arm,idle-state" ，这其实是为了个 psci_idle_state_match 结构体进行匹配，因为该结构体中的 compatible = "arm,idle-state" ，当想使用该 DTS node 时，compatible 需要相互匹配，具体细节后面再分析，entry-latency-us、exit-latency-us、min-residency-us 定义了该 idle state 的几个重要信息，后续会通过 dt_init_idle_driver 函数进行解析，并将数据保存到 cpuidle_state 的 idle_state 数组中。

结合上面对 DTS 的分析，下面对 dt_init_idle_driver函数进行简要分析，dt_init_idle_driver 函数如下：

//  drivers/cpuidle/dt_idle_states.c
/*** dt_init_idle_driver() - Parse the DT idle states and initialize the*			   idle driver states array* @drv:	  Pointer to CPU idle driver to be initialized* @matches:	  Array of of_device_id match structures to search in for*		  compatible idle state nodes. The data pointer for each valid*		  struct of_device_id entry in the matches array must point to*		  a function with the following signature, that corresponds to*		  the CPUidle state enter function signature:**		  int (*)(struct cpuidle_device *dev,*			  struct cpuidle_driver *drv,*			  int index);** @start_idx:    First idle state index to be initialized** If DT idle states are detected and are valid the state count and states* array entries in the cpuidle driver are initialized accordingly starting* from index start_idx.** Return: number of valid DT idle states parsed, <0 on failure*/
int dt_init_idle_driver(struct cpuidle_driver *drv,const struct of_device_id *matches,unsigned int start_idx)
{struct cpuidle_state *idle_state;struct device_node *state_node, *cpu_node;const struct of_device_id *match_id;int i, err = 0;const cpumask_t *cpumask;unsigned int state_idx = start_idx;if (state_idx >= CPUIDLE_STATE_MAX)return -EINVAL;/** We get the idle states for the first logical cpu in the* driver mask (or cpu_possible_mask if the driver cpumask is not set)* and we check through idle_state_valid() if they are uniform* across CPUs, otherwise we hit a firmware misconfiguration.*/cpumask = drv->cpumask ? : cpu_possible_mask;cpu_node = of_cpu_device_node_get(cpumask_first(cpumask));for (i = 0; ; i++) {state_node = of_get_cpu_state_node(cpu_node, i);if (!state_node)break;
//  检查一个设备节点state_node是否与给定的 matches 节点匹配，即 .compatible 是否相同match_id = of_match_node(matches, state_node);if (!match_id) {err = -ENODEV;break;}if (!of_device_is_available(state_node)) {of_node_put(state_node);continue;}if (!idle_state_valid(state_node, i, cpumask)) {pr_warn("%pOF idle state not valid, bailing out\n",state_node);err = -EINVAL;break;}if (state_idx == CPUIDLE_STATE_MAX) {   // state_index 最大值pr_warn("State index reached static CPU idle driver states array size\n");break;}idle_state = &drv->states[state_idx++];err = init_state_node(idle_state, match_id, state_node);if (err) {pr_err("Parsing idle state node %pOF failed with err %d\n",state_node, err);err = -EINVAL;break;}of_node_put(state_node);}of_node_put(state_node);of_node_put(cpu_node);if (err)return err;/** Update the driver state count only if some valid DT idle states* were detected*/if (i)drv->state_count = state_idx;/** Return the number of present and valid DT idle states, which can* also be 0 on platforms with missing DT idle states or legacy DT* configuration predating the DT idle states bindings.*/return state_idx - start_idx;
}
EXPORT_SYMBOL_GPL(dt_init_idle_driver);

        函数首先会将 start_idx 赋值给 state_idx ，作为 idle state 的索引，然后通过 of_cpu_device_node_get 和 of_get_cpu_state_node 函数获取该 CPU 的idle state node ，并调用 of_match_node 函数进行匹配，of_match_node 函数第一个参数为 matches 即传递进来的 psci_idle_state_match 结构体，第二个参数为 CPU 的idle state node，即看该结构体中的 compatible 成员和 DTS 中CPU 的idle state 节点的 compatible 属性是否匹配（compatible = "arm,idle-state"），如果匹配则继续往下。

idle_state = &drv->states[state_idx++];

这一段代码是在初始化 idle state 数组，state_idx = 1，所以是从 state[1] 开始初始化。

        现在 DTS 中的 idle state node 已经找到了，现在就需要解析 node 中的数据，并初始化 idle_state 了，init_state_node 函数就是解析 DTS 并初始化 idle_state 的如下：

static int init_state_node(struct cpuidle_state *idle_state,const struct of_device_id *match_id,struct device_node *state_node)
{int err;const char *desc;/** CPUidle drivers are expected to initialize the const void *data* pointer of the passed in struct of_device_id array to the idle* state enter function.*/idle_state->enter = match_id->data;/** Since this is not a "coupled" state, it's safe to assume interrupts* won't be enabled when it exits allowing the tick to be frozen* safely. So enter() can be also enter_s2idle() callback.*/idle_state->enter_s2idle = match_id->data;err = of_property_read_u32(state_node, "wakeup-latency-us",&idle_state->exit_latency);if (err) {u32 entry_latency, exit_latency;err = of_property_read_u32(state_node, "entry-latency-us",&entry_latency);if (err) {pr_debug(" * %pOF missing entry-latency-us property\n",state_node);return -EINVAL;}err = of_property_read_u32(state_node, "exit-latency-us",&exit_latency);if (err) {pr_debug(" * %pOF missing exit-latency-us property\n",state_node);return -EINVAL;}/** If wakeup-latency-us is missing, default to entry+exit* latencies as defined in idle states bindings*/idle_state->exit_latency = entry_latency + exit_latency;}err = of_property_read_u32(state_node, "min-residency-us",&idle_state->target_residency);if (err) {pr_debug(" * %pOF missing min-residency-us property\n",state_node);return -EINVAL;}err = of_property_read_string(state_node, "idle-state-name", &desc);if (err)desc = state_node->name;idle_state->flags = 0;if (of_property_read_bool(state_node, "local-timer-stop"))idle_state->flags |= CPUIDLE_FLAG_TIMER_STOP;/** TODO:*	replace with kstrdup and pointer assignment when name*	and desc become string pointers*/strncpy(idle_state->name, state_node->name, CPUIDLE_NAME_LEN - 1);strncpy(idle_state->desc, desc, CPUIDLE_DESC_LEN - 1);return 0;
}

初始化 idle_state 的 enter 和 enter_s2idle 回调:

idle_state->enter = match_id->data;
idle_state->enter_s2idle = match_id->data;

        这里 enter 和 enter_s2idle 指向的函数都是 match_id->data，也就是 psci_idle_state_match 中的 data 成员，即 psci_enter_idle_state 函数，和 state[0].enter 指向的函数相同。

        然后就是解析 DTS 中关于 idle state 的各种信息，包括 entry-latency-us、exit-latency-us、min-residency-us等，并初始化 idle_state->exit_latency = entry_latency + exit_latency。

        最后再将初始化 idle_state 的其它参数，包括 idle_state->flags、idle_state->name、idle_state->desc，如果一切顺利，init_state_node 函数将返回 0 。

        当 init_state_node 成功返回 0 时，回到 dt_init_idle_driver 函数中还会更新 drv->state_count ，并返回通过 DTS 初始化了多少个 cpu idle state 如下：

/** Update the driver state count only if some valid DT idle states* were detected*/
if (i)drv->state_count = state_idx;
/** Return the number of present and valid DT idle states, which can* also be 0 on platforms with missing DT idle states or legacy DT* configuration predating the DT idle states bindings.*/
return state_idx - start_idx;  // 如果 DTS 只初始化了一个 idle state 则 state_idx - start_idx = 2 - 1

 4.4 register cpuidle driver/device

        回到 psci_idle_init_cpu 函数中 dt_init_idle_driver 函数返回的就是通过 DTS 初始化的 idle state 的个数，当通过 DTS 初始化了一个 idle state 时，返回 1，当没有通过 DTS 初始化idle state或者初始化失败时， idle state 返回 0 ， psci_idle_init_cpu 函数直接返回，cpuidle_driver 会初始化失败，这也就对前面的注释做了验证，如下代码段：

ret = dt_init_idle_driver(drv, psci_idle_state_match, 1);
if (ret <= 0)return ret ? : -ENODEV;

        当 dt_init_idle_driver 函数成功返回时，最后会调用 cpuidle_register 对 cpuidle_driver 进行注册，并且还会在 cpuidle_register 函数中对 cpuidle_device 进行相应初始化和注册，如下：

cpuidle_register-> struct cpuidle_device *device;-> cpuidle_register_driver  // 注册 cpuidle_driver-> device = &per_cpu(cpuidle_dev, cpu);-> device->cpu = cpu;...-> cpuidle_register_device  // 注册 cpuidle_device

 4.5、psci_enter_idle_state

        psci_enter_idle_state 函数是进入cpuidle状态的入口函数，即 idle_state->enter，如下：

psci_enter_idle_state-> CPU_PM_CPU_IDLE_ENTER_PARAM(psci_cpu_suspend_enter, idx, state);-> __CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter, idx, state, 0)

__CPU_PM_CPU_IDLE_ENTER 宏定义如下：

#define __CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter,			\idx,					\state,					\is_retention)				\
({									\int __ret = 0;							\\if (!idx) {							\cpu_do_idle();						\return idx;						\}								\\if (!is_retention)						\__ret =  cpu_pm_enter();				\if (!__ret) {							\__ret = low_level_idle_enter(state);			\if (!is_retention)					\cpu_pm_exit();					\}								\\__ret ? -1 : idx;						\
})

        可以看到当 idx = 0 ，即cpuidle_state states[0]时，会调用默认的 idle 函数 cpu_do_idle，然后直接返回了，cpu_do_idle 函数如下：

//  arch/arm64/kernel/idle.c
/**	cpu_do_idle()**	Idle the processor (wait for interrupt).**	If the CPU supports priority masking we must do additional work to*	ensure that interrupts are not masked at the PMR (because the core will*	not wake up if we block the wake up signal in the interrupt controller).*/
void noinstr cpu_do_idle(void)
{struct arm_cpuidle_irq_context context;arm_cpuidle_save_irq_context(&context);dsb(sy);wfi();   // 直接调用 wfi()函数等待中断arm_cpuidle_restore_irq_context(&context);
}

当 idx 不等于 0 时就会调用到 psci_cpu_suspend_enter 函数，如下:

int psci_cpu_suspend_enter(u32 state)
{int ret;if (!psci_power_state_loses_context(state)) {struct arm_cpuidle_irq_context context;arm_cpuidle_save_irq_context(&context);ret = psci_ops.cpu_suspend(state, 0);arm_cpuidle_restore_irq_context(&context);} else {ret = cpu_suspend(state, psci_suspend_finisher);}return ret;
}

cpu_suspend函数：

/** cpu_suspend** arg: argument to pass to the finisher function* fn: finisher function pointer**/
int cpu_suspend(unsigned long arg, int (*fn)(unsigned long))
{int ret = 0;unsigned long flags;struct sleep_stack_data state;struct arm_cpuidle_irq_context context;/* Report any MTE async fault before going to suspend */mte_suspend_enter();/** From this point debug exceptions are disabled to prevent* updates to mdscr register (saved and restored along with* general purpose registers) from kernel debuggers.*/flags = local_daif_save();/** Function graph tracer state gets inconsistent when the kernel* calls functions that never return (aka suspend finishers) hence* disable graph tracing during their execution.*/pause_graph_tracing();/** Switch to using DAIF.IF instead of PMR in order to reliably* resume if we're using pseudo-NMIs.*/arm_cpuidle_save_irq_context(&context);if (__cpu_suspend_enter(&state)) {/* Call the suspend finisher */ret = fn(arg);/** Never gets here, unless the suspend finisher fails.* Successful cpu_suspend() should return from cpu_resume(),* returning through this code path is considered an error* If the return value is set to 0 force ret = -EOPNOTSUPP* to make sure a proper error condition is propagated*/if (!ret)ret = -EOPNOTSUPP;} else {RCU_NONIDLE(__cpu_suspend_exit());}arm_cpuidle_restore_irq_context(&context);unpause_graph_tracing();/** Restore pstate flags. OS lock and mdscr have been already* restored, so from this point onwards, debugging is fully* reenabled if it was enabled when core started shutdown.*/local_daif_restore(flags);return ret;
}

        在 cpu_suspend 函数中首先会通过__cpu_suspend_enter函数保存当前系统的状态，然后会回调 psci_suspend_finisher 函数，如下：

static noinstr int psci_suspend_finisher(unsigned long state)
{u32 power_state = state;phys_addr_t pa_cpu_resume;pa_cpu_resume = __pa_symbol_nodebug((unsigned long)cpu_resume);return psci_ops.cpu_suspend(power_state, pa_cpu_resume);
}

        psci_suspend_finisher 函数中会调用底层的 psci_ops中的cpu_suspend回调，然后通过 smc 陷入 ATF 进行后续的工作 。

五、cpuidle governor

5.1、governor 的分类和作用

        本文以menu governor为例，简单介绍cpuidle framework中的governor，在 linux-6.1 版本中有3 个 governor 分别为 ladder、menu、teo ，并且当前使用的 menu 如下：

# cat /sys/devices/system/cpu/cpuidle/available_governors
ladder menu teo
# cat /sys/devices/system/cpu/cpuidle/current_governor
menu

        通过前面的简单了解，知道 governor 的主要作用是根据系统目前的运行情况，根据具体的算法选择一个合适idle state，在选择时一般有两点需要考虑，一是要考虑切换到 idle state 停留的时间所节省的功耗需要大于状态切换时所产生的功耗，通过 cpuidle_state 中的 target_residency 来体现，即该进入该 idle state 所停留的时间应该是大于 target_residency 的，不然并不能达到节省的效果。二是要考虑退出时的延迟大小，当idle state 在满足系统功耗之后会尽量选择延迟低的 idle state。

5.2、代码分析

//  drivers/cpuidle/governors/menu.c
static struct cpuidle_governor menu_governor = {.name =		"menu",.rating =	20,.enable =	menu_enable_device,.select =	menu_select,.reflect =	menu_reflect,
};/*** init_menu - initializes the governor*/
static int __init init_menu(void)
{return cpuidle_register_governor(&menu_governor);
}

        governor name 可以通过 /sys/devices/system/cpu/cpuidle 文件夹下的相关governor文件体现，并初始化了 enable、select、reflect 三个回调函数。

5.2.1、menu_enable_device

menu_enable_device 函数主要是做启动的前期工作

/*** menu_enable_device - scans a CPU's states and does setup* @drv: cpuidle driver* @dev: the CPU*/
static int menu_enable_device(struct cpuidle_driver *drv,struct cpuidle_device *dev)
{struct menu_device *data = &per_cpu(menu_devices, dev->cpu);int i;memset(data, 0, sizeof(struct menu_device));/** if the correction factor is 0 (eg first time init or cpu hotplug* etc), we actually want to start out with a unity factor.*/for(i = 0; i < BUCKETS; i++)data->correction_factor[i] = RESOLUTION * DECAY;return 0;
}

5.2.2、menu_select

/*** menu_update - attempts to guess what happened after entry* @drv: cpuidle driver containing state data* @dev: the CPU*/
static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
{struct menu_device *data = this_cpu_ptr(&menu_devices);int last_idx = dev->last_state_idx;struct cpuidle_state *target = &drv->states[last_idx];u64 measured_ns;unsigned int new_factor;/** Try to figure out how much time passed between entry to low* power state and occurrence of the wakeup event.** If the entered idle state didn't support residency measurements,* we use them anyway if they are short, and if long,* truncate to the whole expected time.** Any measured amount of time will include the exit latency.* Since we are interested in when the wakeup begun, not when it* was completed, we must subtract the exit latency. However, if* the measured amount of time is less than the exit latency,* assume the state was never reached and the exit latency is 0.*/if (data->tick_wakeup && data->next_timer_ns > TICK_NSEC) {/** The nohz code said that there wouldn't be any events within* the tick boundary (if the tick was stopped), but the idle* duration predictor had a differing opinion.  Since the CPU* was woken up by a tick (that wasn't stopped after all), the* predictor was not quite right, so assume that the CPU could* have been idle long (but not forever) to help the idle* duration predictor do a better job next time.*/measured_ns = 9 * MAX_INTERESTING / 10;} else if ((drv->states[last_idx].flags & CPUIDLE_FLAG_POLLING) &&dev->poll_time_limit) {/** The CPU exited the "polling" state due to a time limit, so* the idle duration prediction leading to the selection of that* state was inaccurate.  If a better prediction had been made,* the CPU might have been woken up from idle by the next timer.* Assume that to be the case.*/measured_ns = data->next_timer_ns;} else {/* measured value */measured_ns = dev->last_residency_ns;/* Deduct exit latency */if (measured_ns > 2 * target->exit_latency_ns)measured_ns -= target->exit_latency_ns;elsemeasured_ns /= 2;}/* Make sure our coefficients do not exceed unity */if (measured_ns > data->next_timer_ns)measured_ns = data->next_timer_ns;/* Update our correction ratio */new_factor = data->correction_factor[data->bucket];new_factor -= new_factor / DECAY;if (data->next_timer_ns > 0 && measured_ns < MAX_INTERESTING)new_factor += div64_u64(RESOLUTION * measured_ns,data->next_timer_ns);else/** we were idle so long that we count it as a perfect* prediction*/new_factor += RESOLUTION;/** We don't want 0 as factor; we always want at least* a tiny bit of estimated time. Fortunately, due to rounding,* new_factor will stay nonzero regardless of measured_us values* and the compiler can eliminate this test as long as DECAY > 1.*/if (DECAY == 1 && unlikely(new_factor == 0))new_factor = 1;data->correction_factor[data->bucket] = new_factor;/* update the repeating-pattern data */data->intervals[data->interval_ptr++] = ktime_to_us(measured_ns);if (data->interval_ptr >= INTERVALS)data->interval_ptr = 0;
}/*** menu_select - selects the next idle state to enter* @drv: cpuidle driver containing state data* @dev: the CPU* @stop_tick: indication on whether or not to stop the tick*/
static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev,bool *stop_tick)
{struct menu_device *data = this_cpu_ptr(&menu_devices);s64 latency_req = cpuidle_governor_latency_req(dev->cpu);......if (data->needs_update) {menu_update(drv, dev);  // 更新 munu governordata->needs_update = 0; // 该标志位会在 menu_reflect 函数中置位}....../** Don't stop the tick if the selected state is a polling one or if the* expected idle duration is shorter than the tick period length.*/if (((drv->states[idx].flags & CPUIDLE_FLAG_POLLING) ||predicted_ns < TICK_NSEC) && !tick_nohz_tick_stopped()) {*stop_tick = false;if (idx > 0 && drv->states[idx].target_residency_ns > delta_tick) {/** The tick is not going to be stopped and the target* residency of the state to be returned is not within* the time until the next timer event including the* tick, so try to correct that.*/for (i = idx - 1; i >= 0; i--) {if (dev->states_usage[i].disable)continue;idx = i;if (drv->states[i].target_residency_ns <= delta_tick)break;}}}return idx;
}

        menu_select 会根据系统当前的运行情况，选择一个合适的 idle state，并返回相应 state 的 idx，并且更新 governor 也是在该函数中通过 menu_update 函数实现的，但为什么从 idle state 返回时需要更新 munu governor 呢？ 其主要原因是为了下一次选择 idle state 的准确性，它根据CPU 进入和退出 idle state 的时间，来更新校正因子(correction_factor)，以改进CPU idle 时间的预测准确性，提高电源管理效率。这里具体是怎么选择 idle state 的将不再具体分析。

5.2.3、menu_reflect

/*** menu_reflect - records that data structures need update* @dev: the CPU* @index: the index of actual entered state** NOTE: it's important to be fast here because this operation will add to*       the overall exit latency.*/
static void menu_reflect(struct cpuidle_device *dev, int index)
{struct menu_device *data = this_cpu_ptr(&menu_devices);dev->last_state_idx = index;data->needs_update = 1;data->tick_wakeup = tick_nohz_idle_got_tick();
}

        menu_reflect 主要是通过 data->last_state_idx记录了上次进入 idle state 的 idx 索引值，和置位data->needs_update，实现具体更新状态的代码是放到 menu_select 函数中去了，因为该函数的调用是在退出 idle state 之前调用的，所以这里速度很重要，要尽量的快，不然会增加 idle 整体的 exit latency。

References

[1] CPU Idle Time Management — The Linux Kernel documentation

[2] http://www.wowotech.net/pm_subsystem/cpuidle_overview.html

[3] http://www.wowotech.net/pm_subsystem/cpuidle_arm64.html

[4] https://blog.csdn.net/weixin_48185168/article/details/133576463

[5] https://zhuanlan.zhihu.com/p/539722367

[6] https://blog.csdn.net/youthcowboy/article/details/135348079

[7] https://m.elecfans.com/article/2313635.html

[8] https://zhuanlan.zhihu.com/p/572644843

[9] https://www.cnblogs.com/LoyenWang/p/11379937.html