Linux功耗管理(20)_Linux cpuidle framework(3)_ARM64 generic CPU idle driver

1. 前言

本文以ARM64平台下的cpuidle driver为例，说明怎样在cpuidle framework的框架下，编写cpuidle driver。另外，本文在描述cpuidle driver的同时，会涉及到CPU hotplug的概念，因此也可作为CPU hotplug的引子。

2. arm64_idle_init

ARM64 generic CPU idle driver的代码位于“drivers/cpuidle/cpuidle-arm64.c”中，它的入口函数是arm64_idle_init，如下：

1: static int __init arm64_idle_init(void)

2: {

3:         int cpu, ret;

4:         struct cpuidle_driver *drv = &arm64_idle_driver;

5: 

6:         /*

7:          * Initialize idle states data, starting at index 1.

8:          * This driver is DT only, if no DT idle states are detected (ret == 0)

9:          * let the driver initialization fail accordingly since there is no

10:          * reason to initialize the idle driver if only wfi is supported.

11:          */

12:         ret = dt_init_idle_driver(drv, arm64_idle_state_match, 1);

13:         if (ret <= 0) {

14:                 if (ret)

15:                         pr_err("failed to initialize idle states\n");

16:                 return ret ? : -ENODEV;

17:         }

18: 

19:         /*

20:          * Call arch CPU operations in order to initialize

21:          * idle states suspend back-end specific data

22:          */

23:         for_each_possible_cpu(cpu) {

24:                 ret = cpu_init_idle(cpu);

25:                 if (ret) {

26:                         pr_err("CPU %d failed to init idle CPU ops\n", cpu);

27:                         return ret;

28:                 }

29:         }

30: 

31:         ret = cpuidle_register(drv, NULL);

32:         if (ret) {

33:                 pr_err("failed to register cpuidle driver\n");

34:                 return ret;

35:         }

36: 

37:         return 0;

38: }

39: device_initcall(arm64_idle_init);

由该函数的执行过程，可以看出cpuidle driver的实现过程，包括：

1）静态定义一个struct cpuidle_driver变量（这里为arm64_idle_driver）并填充必要的字段，如下

1: static struct cpuidle_driver arm64_idle_driver = {

2:         .name = "arm64_idle",

3:         .owner = THIS_MODULE,

4:         /*

5:          * State at index 0 is standby wfi and considered standard

6:          * on all ARM platforms. If in some platforms simple wfi

7:          * can't be used as "state 0", DT bindings must be implemented

8:          * to work around this issue and allow installing a special

9:          * handler for idle state index 0.

10:          */

11:         .states[0] = {

12:                 .enter                  = arm64_enter_idle_state,

13:                 .exit_latency           = 1,

14:                 .target_residency       = 1,

15:                 .power_usage            = UINT_MAX,

16:                 .flags                  = CPUIDLE_FLAG_TIME_VALID,

17:                 .name                   = "WFI",

18:                 .desc                   = "ARM64 WFI",

19:         }

20: };

该driver的名称为“arm64_idle”，会体现在sysfs（如/sys/devices/system/cpu/cpuidle/current_driver）中；

稍微留意一下上面的注释，所有的ARM平台，都应提供默认的WFI standby状态，作为idle state 0，如果有例外，则需要在DTS中另行处理；

对于state0，driver将其初始化为：exit latency和target residency均为1（最小值），power usage为整数中的最大值。由此可以看出，这些信息不是实际信息（因为driver不可能知道所有ARM平台的WFI相关的信息），而是相对信息，其中的含义是：所有其它的state，exit latency和target residency都会比state0大，power usage都会比state0小，够用了！多么巧妙地设计！

2）初始化其它的idle states（从state1开始），必须通过DTS操作，否则返回失败。具体可参考后续的描述。

3）对每一个cpu，调用cpu_init_idle接口，初始化用于支持cpuidle的、和cpu suspend有关的后端数据。后面会详细介绍。

4）调用cpuidle_register，将cpuidle driver注册到cpuidle core中（具体可参考“Linux cpuidle framework(2)_cpuidle core”）。

3. dt_init_idle_driver

dt_init_idle_driver函数用于从DTS中解析出cpuidle states的信息，并初始化arm64_idle_driver中的states数组。在分析这个函数之前，我们先来看一下cpuidle相关的DTS源文件是怎么写的：

注：写这篇文章所参考的kernel（3.18-rc4）中，没有ARM64平台使用了cpuidle功能，因此这里给不出ARM64平台下的参考文件。好在ARM和ARM64在cpuidle dts解析上面的流程是一样的，我们可以借用ARM中的例子。

1: /* arch/arm/boot/dts/vexpress-v2p-ca15_a7.dts */

2: cpus {

3:         #address-cells = <1>;

4:         #size-cells = <0>;

5: 

6:         cpu0: cpu@0 {

7:                 device_type = "cpu";

8:                 compatible = "arm,cortex-a15";

9:                 reg = <0>;

10:                 cci-control-port = <&cci_control1>;

11:                 cpu-idle-states = <&CLUSTER_SLEEP_BIG>;

12:         };

13: 

14:         cpu1: cpu@1 {

15:                 device_type = "cpu";

16:                 compatible = "arm,cortex-a15";

17:                 reg = <1>;

18:                 cci-control-port = <&cci_control1>;

19:                 cpu-idle-states = <&CLUSTER_SLEEP_BIG>;

20:         };

21: 

22:         cpu2: cpu@2 {

23:                 device_type = "cpu";

24:                 compatible = "arm,cortex-a7";

25:                 reg = <0x100>;

26:                 cci-control-port = <&cci_control2>;

27:                 cpu-idle-states = <&CLUSTER_SLEEP_LITTLE>;

28:         };

29: 

30:         cpu3: cpu@3 {

31:                 device_type = "cpu";

32:                 compatible = "arm,cortex-a7";

33:                 reg = <0x101>;

34:                 cci-control-port = <&cci_control2>;

35:                 cpu-idle-states = <&CLUSTER_SLEEP_LITTLE>;

36:         };

37: 

38:         cpu4: cpu@4 {

39:                 device_type = "cpu";

40:                 compatible = "arm,cortex-a7";

41:                 reg = <0x102>;

42:                 cci-control-port = <&cci_control2>;

43:                 cpu-idle-states = <&CLUSTER_SLEEP_LITTLE>;

44:         };

45:         idle-states {

46:             CLUSTER_SLEEP_BIG: cluster-sleep-big {

47:                 compatible = "arm,idle-state";

48:                 local-timer-stop;

49:                 entry-latency-us = <1000>;

50:                 exit-latency-us = <700>;

51:                 min-residency-us = <2000>;

52:             };

53: 

54:             CLUSTER_SLEEP_LITTLE: cluster-sleep-little {

55:                 compatible = "arm,idle-state";

56:                 local-timer-stop;

57:                 entry-latency-us = <1000>;

58:                 exit-latency-us = <500>;

59:                 min-residency-us = <2500>;

60:             };

61: };

cpuidle有关的DTS信息，从属于cpus node中，先看最后面的idle-states node，它负责定义该ARM平台支持的所有的idle states，每个子node就是一个state： 

        各个state定义都以“arm,idle-state”标识； 

        entry-latency-us、exit-latency-us、min-residency-us分别定义了改idle state的几个重要参数，local-timer-stop对应CPUIDLE_FLAG_TIMER_STOP flag（具体含义可参考“Linux
cpuidle framework(2)_cpuidle core”中的描述）； 

        这些信息会被dt_init_idle_driver解析出来，并保存在arm64_idle_driver的state数组中。 

在每个cpu的node中，通过cpu-idle-states字段，指明该CPU支持的idle states，可以有多个。         

结合上面的DTS信息，dt_init_idle_driver函数的执行过程如下。

1: /* drivers/cpuidle/dt_idle_states.c */

2: int dt_init_idle_driver(struct cpuidle_driver *drv,

3:             const struct of_device_id *matches,

4:             unsigned int start_idx)

5: {

6:     struct cpuidle_state *idle_state;

7:     struct device_node *state_node, *cpu_node;

8:     int i, err = 0;

9:     const cpumask_t *cpumask;

10:     unsigned int state_idx = start_idx;

11: 

12:     if (state_idx >= CPUIDLE_STATE_MAX)

13:         return -EINVAL;

14:     /*

15:      * We get the idle states for the first logical cpu in the

16:      * driver mask (or cpu_possible_mask if the driver cpumask is not set)

17:      * and we check through idle_state_valid() if they are uniform

18:      * across CPUs, otherwise we hit a firmware misconfiguration.

19:      */

20:     cpumask = drv->cpumask ? : cpu_possible_mask;

21:     cpu_node = of_cpu_device_node_get(cpumask_first(cpumask));

22: 

23:     for (i = 0; ; i++) {

24:         state_node = of_parse_phandle(cpu_node, "cpu-idle-states", i);

25:         if (!state_node)

26:             break;

27: 

28:         if (!idle_state_valid(state_node, i, cpumask)) {

29:             pr_warn("%s idle state not valid, bailing out\n",

30:                 state_node->full_name);

31:             err = -EINVAL;

32:             break;

33:         }

34: 

35:         if (state_idx == CPUIDLE_STATE_MAX) {

36:             pr_warn("State index reached static CPU idle driver states array size\n");

37:             break;

38:         }

39: 

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

41:         err = init_state_node(idle_state, matches, state_node);

42:         if (err) {

43:             pr_err("Parsing idle state node %s failed with err %d\n",

44:                    state_node->full_name, err);

45:             err = -EINVAL;

46:             break;

47:         }

48:         of_node_put(state_node);

49:     }

50: 

51:     of_node_put(state_node);

52:     of_node_put(cpu_node);

53:     if (err)

54:         return err;

55:     /*

56:      * Update the driver state count only if some valid DT idle states

57:      * were detected

58:      */

59:     if (i)

60:         drv->state_count = state_idx;

61: 

62:     /*

63:      * Return the number of present and valid DT idle states, which can

64:      * also be 0 on platforms with missing DT idle states or legacy DT

65:      * configuration predating the DT idle states bindings.

66:      */

67:     return i;

68: }

69: EXPORT_SYMBOL_GPL(dt_init_idle_driver);

1）14~21、28~33行，获取第一个cpu的node，通过其中的“cpu-idle-states”字段，解析出该cpu支持的cpuidle states。同时通过idle_state_valid接口，检查其它CPU是否同样支持这些states，如果不支持，返回错误。也就是说，ARM64 generic CPU idle driver，只支持那些所有cpuidle state都相同的ARM64平台。

2）40~47行，针对每一个支持的state，调用init_state_node接口，解析cpuidle state相关的信息，并保存在drv->state数组的指定index中。解析的过程中，会为每个state指定enter回调函数，对ARM64而言，统一使用arm64_enter_idle_state接口。其它的解析过程，比较简单，不再详细说明了。

4. cpu_init_idle

cpuidle功能的支持，需要依赖CPU的、和电源管理有关的底层代码实现。对ARM64来说，kernel将这些底层代码抽象为一系列的操作函数集（struct cpu_operations，具体可参考arch/arm64/kernel/cpu_ops.c）。对同一个ARM平台，可能有多种类型的操作函数集，设计者可以根据需要选择一种使用（具体可参考本站后续的文档）。

以ARM64为例，ARM document规定了一种PSCI（Power State Coordination Interface）接口，它由firmware实现，用于电源管理有关的操作，如IDLE相关的、SMP相关的、Hotplug相关的、等等。

对cpuidle来说，需要在cpuidle driver注册之前，调用cpu_init_idle，该函数会根据当前使用的操作函数集，调用其中的cpu_init_idle回调函数，进行idle相关的初始化操作。具体的内容，蜗蜗会在其它文章中说明，这里就暂停了。

5. arm64_enter_idle_state

idle state的enter函数用于使CPU进入指定的idle state，如下：

1: static int arm64_enter_idle_state(struct cpuidle_device *dev,

2:                                   struct cpuidle_driver *drv, int idx)

3: {

4:         int ret;

5: 

6:         if (!idx) {

7:                 cpu_do_idle();

8:                 return idx;

9:         }

10: 

11:         ret = cpu_pm_enter();

12:         if (!ret) {

13:                 /*

14:                  * Pass idle state index to cpu_suspend which in turn will

15:                  * call the CPU ops suspend protocol with idle index as a

16:                  * parameter.

17:                  */

18:                 ret = cpu_suspend(idx);

19: 

20:                 cpu_pm_exit();

21:         }

22: 

23:         return ret ? -1 : idx;

24: }

如果是idle state0（即WFI），调用传统cpu_do_idle接口，该接口的实现，可参照“Linux cpuidle framework(1)_概述和软件架构”中第2章ARM9的例子，在kernel source code中跟踪；

对于其它的state，首先调用cpu_pm_enter，发出CPU即将进入low power state的通知。如果成功，则调用cpu_suspend接口，让cpu进入指定的idle状态。最后，从idle返回时，发送退出low power state的通知；

cpu_pm_enter/cpu_pm_exit位于kernel/cpu_pm.c中，会在其它文章介绍；

cpu_suspend位于arch/arm64/kernel/suspend.c中，直接调用操作函数集（struct cpu_operations，如PSCI）中的cpu_suspend回调函数。具体会在其它文章中描述。

原创文章，转发请注明出处。蜗窝科技，www.wowotech.net。