cpuidle子系统之（三）：driver层

    cpus {

        #address-cells = <1>;

        #size-cells = <0>;

        CPU0: cpu@0 {

            device_type = "cpu";

            compatible = "arm,cortex-a53";

            reg = <0x0>;

            next-level-cache = <&L2_0>;

            enable-method = "psci";

            clocks = <&apcs>;

            operating-points-v2 = <&cpu_opp_table>;

            #cooling-cells = <2>;

            power-domains = <&CPU_PD0>;                    //指定这个cpu所属的电源域

            power-domain-names = "psci";

        };

        CPU1: cpu@1 {

            device_type = "cpu";

            compatible = "arm,cortex-a53";

            reg = <0x1>;

            next-level-cache = <&L2_0>;

            enable-method = "psci";

            clocks = <&apcs>;

            operating-points-v2 = <&cpu_opp_table>;

            #cooling-cells = <2>;

            power-domains = <&CPU_PD1>;

            power-domain-names = "psci";

        };

        CPU2: cpu@2 {

            device_type = "cpu";

            compatible = "arm,cortex-a53";

            reg = <0x2>;

            next-level-cache = <&L2_0>;

            enable-method = "psci";

            clocks = <&apcs>;

            operating-points-v2 = <&cpu_opp_table>;

            #cooling-cells = <2>;

            power-domains = <&CPU_PD2>;

            power-domain-names = "psci";

        };

        CPU3: cpu@3 {

            device_type = "cpu";

            compatible = "arm,cortex-a53";

            reg = <0x3>;

            next-level-cache = <&L2_0>;

            enable-method = "psci";

            clocks = <&apcs>;

            operating-points-v2 = <&cpu_opp_table>;

            #cooling-cells = <2>;

            power-domains = <&CPU_PD3>;

            power-domain-names = "psci";

        };

        L2_0: l2-cache {

            compatible = "cache";

            cache-level = <2>;

        };

        # 描述不同等级的C state，本例只有一个等级

        idle-states {

            entry-method = "psci";

            # 下面描述一个C state

            CPU_SLEEP_0: cpu-sleep-0 {

                compatible = "arm,idle-state";

                idle-state-name = "standalone-power-collapse";

                arm,psci-suspend-param = <0x40000002>;

                entry-latency-us = <130>;                #进入该状态延迟

                exit-latency-us = <150>;                #退出该状态延迟

                min-residency-us = <2000>;            #最小滞留时间

                local-timer-stop;                        #在该状态下，local timer是否需要关闭

            };

        };

        # 对不同的电源域的进入/退出延迟、最小滞留时间进行描述

        domain-idle-states {

            CLUSTER_RET: cluster-retention {

                compatible = "domain-idle-state";

                arm,psci-suspend-param = <0x41000012>;

                entry-latency-us = <500>;                #进入该状态延时

                exit-latency-us = <500>;                #退出该状态延迟

                min-residency-us = <2000>;            #最小滞留时间

            };

            CLUSTER_PWRDN: cluster-gdhs {

                compatible = "domain-idle-state";

                arm,psci-suspend-param = <0x41000032>;

                entry-latency-us = <2000>;            #进入该状态延时

                exit-latency-us = <2000>;                #退出该状态延迟

                min-residency-us = <6000>;            #最小滞留时间

            };

        };

    };

    #下面描述电源域

    psci {

        compatible = "arm,psci-1.0";

        method = "smc";

        CPU_PD0: power-domain-cpu0 {

            #power-domain-cells = <0>;

            power-domains = <&CLUSTER_PD>;

            domain-idle-states = <&CPU_SLEEP_0>;            #描述这个电源域的C state

        };

        CPU_PD1: power-domain-cpu1 {

            #power-domain-cells = <0>;

            power-domains = <&CLUSTER_PD>;

            domain-idle-states = <&CPU_SLEEP_0>;

        };

        CPU_PD2: power-domain-cpu2 {

            #power-domain-cells = <0>;

            power-domains = <&CLUSTER_PD>;

            domain-idle-states = <&CPU_SLEEP_0>;

        };

        CPU_PD3: power-domain-cpu3 {

            #power-domain-cells = <0>;

            power-domains = <&CLUSTER_PD>;

            domain-idle-states = <&CPU_SLEEP_0>;

        };

        CLUSTER_PD: power-domain-cluster {

            #power-domain-cells = <0>;

            domain-idle-states = <&CLUSTER_RET>, <&CLUSTER_PWRDN>;

        };

    };

    cpus {

        #address-cells = <2>;

        #size-cells = <0>;

        CPU0: cpu@0 {

            device_type = "cpu";

            compatible = "qcom,kryo280";

            reg = <0x0 0x0>;

            enable-method = "psci";

            #这个cpu支持的idle等级，这里表示有两级idle

            cpu-idle-states = <&LITTLE_CPU_SLEEP_0 &LITTLE_CPU_SLEEP_1>;

            next-level-cache = <&L2_0>;

            L2_0: l2-cache {

                compatible = "arm,arch-cache";

                cache-level = <2>;

            };

            L1_I_0: l1-icache {

                compatible = "arm,arch-cache";

            };

            L1_D_0: l1-dcache {

                compatible = "arm,arch-cache";

            };

        };

        CPU1: cpu@1 {

            device_type = "cpu";

            compatible = "qcom,kryo280";

            reg = <0x0 0x1>;

            enable-method = "psci";

            cpu-idle-states = <&LITTLE_CPU_SLEEP_0 &LITTLE_CPU_SLEEP_1>;

            next-level-cache = <&L2_0>;

            L1_I_1: l1-icache {

                compatible = "arm,arch-cache";

            };

            L1_D_1: l1-dcache {

                compatible = "arm,arch-cache";

            };

        };

        CPU2: cpu@2 {

            device_type = "cpu";

            compatible = "qcom,kryo280";

            reg = <0x0 0x2>;

            enable-method = "psci";

            cpu-idle-states = <&LITTLE_CPU_SLEEP_0 &LITTLE_CPU_SLEEP_1>;

            next-level-cache = <&L2_0>;

            L1_I_2: l1-icache {

                compatible = "arm,arch-cache";

            };

            L1_D_2: l1-dcache {

                compatible = "arm,arch-cache";

            };

        };

        CPU3: cpu@3 {

            device_type = "cpu";

            compatible = "qcom,kryo280";

            reg = <0x0 0x3>;

            enable-method = "psci";

            cpu-idle-states = <&LITTLE_CPU_SLEEP_0 &LITTLE_CPU_SLEEP_1>;

            next-level-cache = <&L2_0>;

            L1_I_3: l1-icache {

                compatible = "arm,arch-cache";

            };

            L1_D_3: l1-dcache {

                compatible = "arm,arch-cache";

            };

        };

        CPU4: cpu@100 {

            device_type = "cpu";

            compatible = "qcom,kryo280";

            reg = <0x0 0x100>;

            enable-method = "psci";

            cpu-idle-states = <&BIG_CPU_SLEEP_0 &BIG_CPU_SLEEP_1>;        #大核的C state

            next-level-cache = <&L2_1>;

            L2_1: l2-cache {

                compatible = "arm,arch-cache";

                cache-level = <2>;

            };

            L1_I_100: l1-icache {

                compatible = "arm,arch-cache";

            };

            L1_D_100: l1-dcache {

                compatible = "arm,arch-cache";

            };

        };

        CPU5: cpu@101 {

            device_type = "cpu";

            compatible = "qcom,kryo280";

            reg = <0x0 0x101>;

            enable-method = "psci";

            cpu-idle-states = <&BIG_CPU_SLEEP_0 &BIG_CPU_SLEEP_1>;

            next-level-cache = <&L2_1>;

            L1_I_101: l1-icache {

                compatible = "arm,arch-cache";

            };

            L1_D_101: l1-dcache {

                compatible = "arm,arch-cache";

            };

        };

        CPU6: cpu@102 {

            device_type = "cpu";

            compatible = "qcom,kryo280";

            reg = <0x0 0x102>;

            enable-method = "psci";

            cpu-idle-states = <&BIG_CPU_SLEEP_0 &BIG_CPU_SLEEP_1>;

            next-level-cache = <&L2_1>;

            L1_I_102: l1-icache {

                compatible = "arm,arch-cache";

            };

            L1_D_102: l1-dcache {

                compatible = "arm,arch-cache";

            };

        };

        CPU7: cpu@103 {

            device_type = "cpu";

            compatible = "qcom,kryo280";

            reg = <0x0 0x103>;

            enable-method = "psci";

            cpu-idle-states = <&BIG_CPU_SLEEP_0 &BIG_CPU_SLEEP_1>;

            next-level-cache = <&L2_1>;

            L1_I_103: l1-icache {

                compatible = "arm,arch-cache";

            };

            L1_D_103: l1-dcache {

                compatible = "arm,arch-cache";

            };

        };

        cpu-map {

            cluster0 {

                core0 {

                    cpu = <&CPU0>;

                };

                core1 {

                    cpu = <&CPU1>;

                };

                core2 {

                    cpu = <&CPU2>;

                };

                core3 {

                    cpu = <&CPU3>;

                };

            };

            cluster1 {

                core0 {

                    cpu = <&CPU4>;

                };

                core1 {

                    cpu = <&CPU5>;

                };

                core2 {

                    cpu = <&CPU6>;

                };

                core3 {

                    cpu = <&CPU7>;

                };

            };

        };

        # 不同的C state的信息

        idle-states {

            entry-method = "psci";

            LITTLE_CPU_SLEEP_0: cpu-sleep-0-0 {

                compatible = "arm,idle-state";

                idle-state-name = "little-retention";

                arm,psci-suspend-param = <0x00000002>;

                entry-latency-us = <81>;                    #进入该C state的延迟

                exit-latency-us = <86>;                    #退出该C state的延迟

                min-residency-us = <200>;                    #最小滞留时间

            };

            LITTLE_CPU_SLEEP_1: cpu-sleep-0-1 {

                compatible = "arm,idle-state";

                idle-state-name = "little-power-collapse";

                arm,psci-suspend-param = <0x40000003>;

                entry-latency-us = <273>;

                exit-latency-us = <612>;

                min-residency-us = <1000>;

                local-timer-stop;                            #在该C state下，local timer关闭

            };

            BIG_CPU_SLEEP_0: cpu-sleep-1-0 {

                compatible = "arm,idle-state";

                idle-state-name = "big-retention";

                arm,psci-suspend-param = <0x00000002>;

                entry-latency-us = <79>;

                exit-latency-us = <82>;

                min-residency-us = <200>;

            };

            BIG_CPU_SLEEP_1: cpu-sleep-1-1 {

                compatible = "arm,idle-state";

                idle-state-name = "big-power-collapse";

                arm,psci-suspend-param = <0x40000003>;

                entry-latency-us = <336>;

                exit-latency-us = <525>;

                min-residency-us = <1000>;

                local-timer-stop;

            };

        };

    };

/**

* 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,                //为哪个driver解析C state

            const struct of_device_id *matches,        //match表中记录着进入idle的函数

            unsigned int start_idx)                    //要初始化的第一个C state

{

    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;

    //1.最多允许支持10个C state

    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.

     */

    //2.获取这个driver控制的cpu，未指定的话就是所有可能的cpu

    cpumask = drv->cpumask ? : cpu_possible_mask;

    //3.获取设备树中的cpu的节点

    cpu_node = of_cpu_device_node_get(cpumask_first(cpumask));

    //4.遍历每一级C state

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

        //4.获取这个cpu的idle等级对应的设备树节点

        state_node = of_get_cpu_state_node(cpu_node, i);

        if (!state_node)

            break;

        //5.通过match表找到对应的节点，假设match表为"arm,idle-state"

        match_id = of_match_node(matches, state_node);

        if (!match_id) {

            err = -ENODEV;

            break;

        }

        //6.判断节点是否有效

        if (!of_device_is_available(state_node)) {

            of_node_put(state_node);

            continue;

        }

        //7.校验cpumask中的所有cpu，在第i级的idle状态是不是一样的

        // 也就是说：同一个driver中的所有的cpu的所有idle层级都应该是一样的

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

            pr_warn("%pOF idle state not valid, bailing out\n",

                state_node);

            err = -EINVAL;

            break;

        }

        //8.最多遍历10级C state

        if (state_idx == CPUIDLE_STATE_MAX) {

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

            break;

        }

        //9.获取该层级对应的cpuidle_state结构的空间，

        // 下面要从设备树中解析参数来填充这个空间了

        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 i;

}

/**

* of_get_cpu_state_node - Get CPU's idle state node at the given index

*

* @cpu_node: The device node for the CPU

* @index: The index in the list of the idle states

*

* Two generic methods can be used to describe a CPU's idle states, either via

* a flattened description through the "cpu-idle-states" binding or via the

* hierarchical layout, using the "power-domains" and the "domain-idle-states"

* bindings. This function check for both and returns the idle state node for

* the requested index.

*

* In case an idle state node is found at @index, the refcount is incremented

* for it, so call of_node_put() on it when done. Returns NULL if not found.

*/

struct device_node *of_get_cpu_state_node(

            struct device_node *cpu_node,        //哪个cpu

            int index)                            //idx表示idle等级

{

    struct of_phandle_args args;

    int err;

    //1.第一种格式：msm8916

    // 获取到CPU_PDx对应的设备树节点，赋值给args

    err = of_parse_phandle_with_args(cpu_node, "power-domains",

                    "#power-domain-cells", 0, &args);

    if (!err) {

        //2.找到指定的idle等级对应的设备树

        struct device_node *state_node =

            of_parse_phandle(args.np, "domain-idle-states", index);

        of_node_put(args.np);

        if (state_node)

            return state_node;

    }

    //2.第二种格式：msm8998

    return of_parse_phandle(cpu_node, "cpu-idle-states", index);

}

/*

* Check that the idle state is uniform across all CPUs in the CPUidle driver

* cpumask

*/

static bool idle_state_valid(

            struct device_node *state_node,        //idle等级对应的设备树节点

            unsigned int idx,                        //idx表示idle的等级

            const cpumask_t *cpumask)

{

    int cpu;

    struct device_node *cpu_node, *curr_state_node;

    bool valid = true;

    /*

     * Compare idle state phandles for index idx on all CPUs in the

     * CPUidle driver cpumask. Start from next logical cpu following

     * cpumask_first(cpumask) since that's the CPU state_node was

     * retrieved from. If a mismatch is found bail out straight

     * away since we certainly hit a firmware misconfiguration.

     */

    //1.遍历cpumask中的所有cpu

    for (cpu = cpumask_next(cpumask_first(cpumask), cpumask);

     cpu < nr_cpu_ids; cpu = cpumask_next(cpu, cpumask)) {

        //2.通过下面两步，找到这个cpu的第idx对应的idle等级对应的设备树节点

        cpu_node = of_cpu_device_node_get(cpu);

        curr_state_node = of_get_cpu_state_node(cpu_node, idx);

        //3.如果这两个值不一样，则说明这个cpu的第idx级idle状态，并不是state_node

        if (state_node != curr_state_node)

            valid = false;

        of_node_put(curr_state_node);

        of_node_put(cpu_node);

        if (!valid)

            break;

    }

    return valid;

}

static int init_state_node(

            struct cpuidle_state *idle_state,            //解析后存放在哪

            const struct of_device_id *match_id,            //match表

            struct device_node *state_node)                //要解析哪一级的C state

{

    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.

     */

    //1.进入该C state的回调函数

    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;

    //2.从设备树中解析从该C state退出时的延迟

    // 如果存在"wakeup-latency-us"，of_property_read_u32函数返回0，

    // 不存在该属性时，进入if分支，通过其他属性解析

    err = of_property_read_u32(state_node, "wakeup-latency-us", &idle_state->exit_latency);

    if (err) {

        u32 entry_latency, exit_latency;

        //2.1 依次读出"entry-latency-us"和"exit-latency-us"属性

        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

         */

        //2.2 两者的和表示从该级C state退出的耗时

        idle_state->exit_latency = entry_latency + exit_latency;

    }

    //3.解析"min-residency-us"，该属性表示该C state的"最小滞留时间"

    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;

    }

    //4.解析这个C state的名称，若没有指定该属性，则直接使用C state的名称

    err = of_property_read_string(state_node, "idle-state-name", &desc);

    if (err)

        desc = state_node->name;

    //5.从设备树中解析flags信息，表示进入该C state是否需要关闭时钟

    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

     */

    //6.解析该C state的name和desc信息

    strncpy(idle_state->name, state_node->name, CPUIDLE_NAME_LEN - 1);

    strncpy(idle_state->desc, desc, CPUIDLE_DESC_LEN - 1);

    return 0;

}

struct cpuidle_ops {

    int (*suspend)(unsigned long arg);                //指定这个cpu如何进入指定级别的C state

    int (*init)(struct device_node *, int cpu);        //初始化指定的cpu

};

static struct cpuidle_ops cpuidle_ops[NR_CPUS] __ro_after_init;

static struct cpuidle_ops amx3_cpuidle_ops __initdata = {

    .init = amx3_idle_init,

    .suspend = amx3_idle_enter,

};

CPUIDLE_METHOD_OF_DECLARE(pm33xx_idle, "ti,am3352", &amx3_cpuidle_ops);

CPUIDLE_METHOD_OF_DECLARE(pm43xx_idle, "ti,am4372", &amx3_cpuidle_ops);

#define CPUIDLE_METHOD_OF_DECLARE(name, _method, _ops)            \

    static const struct of_cpuidle_method __cpuidle_method_of_table_##name \

    __cpuidle_method_section = { .method = _method, .ops = _ops }

其中：

#define __cpuidle_method_section __used __section("__cpuidle_method_of_table")

...

. = ALIGN(8);

__cpuidle_method_of_table = .;

KEEP(*(__cpuidle_method_of_table))

KEEP(*(__cpuidle_method_of_table_end))

...

extern struct of_cpuidle_method __cpuidle_method_of_table[];

/**

* arm_cpuidle_get_ops() - find a registered cpuidle_ops by name

* @method: the method name

*

* Search in the __cpuidle_method_of_table array the cpuidle ops matching the

* method name.

*

* Returns a struct cpuidle_ops pointer, NULL if not found.

*/

static const struct cpuidle_ops *__init arm_cpuidle_get_ops(const char *method)

{

    struct of_cpuidle_method *m = __cpuidle_method_of_table;

    //遍历段中的所有cpuidle_ops，直到找到method指定的那个cpuidle_ops

    for (; m->method; m++)

        if (!strcmp(m->method, method))

            return m->ops;

    return NULL;

}

/**

* arm_cpuidle_read_ops() - Initialize the cpuidle ops with the device tree

* @dn: a pointer to a struct device node corresponding to a cpu node

* @cpu: the cpu identifier

*

* Get the method name defined in the 'enable-method' property, retrieve the

* associated cpuidle_ops and do a struct copy. This copy is needed because all

* cpuidle_ops are tagged __initconst and will be unloaded after the init

* process.

*

* Return 0 on sucess, -ENOENT if no 'enable-method' is defined, -EOPNOTSUPP if

* no cpuidle_ops is registered for the 'enable-method', or if either init or

* suspend callback isn't defined.

*/

static int __init arm_cpuidle_read_ops(

            struct device_node *dn,                //这个cpu对于的设备树节点

            int cpu)

{

    const char *enable_method;

    const struct cpuidle_ops *ops;

    //1.先从设备树中获取enable-method属性，以便后面从段中取出对于的cpuidle_ops结构

    enable_method = of_get_property(dn, "enable-method", NULL);

    if (!enable_method)

        return -ENOENT;

    //2.根据上面获取到的enable-method属性，从段中取出对于的cpuidle_ops结构

    // 实际上大部分ARM32平台都在这里返回了-EOPNOTSUPP，目前只有omap的一个

    // 平台设置了这个ops，所以大部分的arm32平台因为找不到ops导致cpuidle-arm初始化失败

    ops = arm_cpuidle_get_ops(enable_method);

    if (!ops) {

        pr_warn("%pOF: unsupported enable-method property: %s\n",

            dn, enable_method);

        return -EOPNOTSUPP;

    }

    //3.在ARM32平台中，要求cpuidle_ops必须设置了这两个回调函数

    if (!ops->init || !ops->suspend) {

        pr_warn("cpuidle_ops '%s': no init or suspend callback\n",

            enable_method);

        return -EOPNOTSUPP;

    }

    //4.赋值给全局变量，以便后期使用

    cpuidle_ops[cpu] = *ops; /* structure copy */

    pr_notice("cpuidle: enable-method property '%s'"

         " found operations\n", enable_method);

    return 0;

}

/*

* arm_idle_init - Initializes arm cpuidle driver

*

* Initializes arm cpuidle driver for all CPUs, if any CPU fails

* to register cpuidle driver then rollback to cancel all CPUs

* registeration.

*/

static int __init arm_idle_init(void)

{

    int cpu, ret;

    struct cpuidle_driver *drv;

    struct cpuidle_device *dev;

    //遍历系统中每一个可能的cpu

    for_each_possible_cpu(cpu) {

        ret = arm_idle_init_cpu(cpu);

        if (ret)

            goto out_fail;

    }

    return 0;

out_fail:

    while (--cpu >= 0) {

        dev = per_cpu(cpuidle_devices, cpu);

        drv = cpuidle_get_cpu_driver(dev);

        cpuidle_unregister(drv);

        kfree(drv);

    }

    return ret;

}

device_initcall(arm_idle_init);            //cpuidle_arm驱动初始化的时候调用

/*

* arm_idle_init_cpu

*

* Registers the arm specific cpuidle driver with the cpuidle

* framework. It relies on core code to parse the idle states

* and initialize them using driver data structures accordingly.

*/

static int __init arm_idle_init_cpu(int cpu)

{

    int ret;

    struct cpuidle_driver *drv;

    //1.因为每个cpu都有自己的driver，首先copy一份模版

    drv = kmemdup(&arm_idle_driver, sizeof(*drv), GFP_KERNEL);

    if (!drv)

        return -ENOMEM;

    //2.这个mask中仅包含一个cpu，可见每个cpu对应一个driver

    drv->cpumask = (struct cpumask *)cpumask_of(cpu);

    /*

     * Initialize idle states data, starting at index 1. This

     * driver is DT only, 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.

     */

    //3.从设备树中提取C state信息，state1及其之后的C state必须从设备树中传进来

    // 注意，下面传入的参数为1，表示从设备树中获取除了state0之外的所有state，

    // state0默认为wfi state，具体可参见下面静态定义的arm_idle_driver

    ret = dt_init_idle_driver(drv, arm_idle_state_match, 1);

    if (ret <= 0) {

        ret = ret ? : -ENODEV;

        goto out_kfree_drv;

    }

    /*

     * Call arch CPU operations in order to initialize

     * idle states suspend back-end specific data

     */

    //4.给个机会给平台端，让平台在设备树中读取自定义的C state信息

    // 注意：对于ARM64平台，该函数返回-EOPNOTSUPP

    ret = arm_cpuidle_init(cpu);

    /*

     * Allow the initialization to continue for other CPUs, if the

     * reported failure is a HW misconfiguration/breakage (-ENXIO).

     *

     * Some platforms do not support idle operations

     * (arm_cpuidle_init() returning -EOPNOTSUPP), we should

     * not flag this case as an error, it is a valid

     * configuration.

     */

    //5.注意：对于ARM64在这里就返回了，没有执行下面的驱动注册，

    // ARM64平台真正的注册的地方是在psci驱动初始化的地方，具

    // 体参见psci_idle_init_cpu

    if (ret) {

        if (ret != -EOPNOTSUPP)

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

        ret = ret == -ENXIO ? 0 : ret;

        goto out_kfree_drv;

    }

    //6.只有ARM32平台才会走到这里，ARM64在上面退出了

    // 注册这个driver

    ret = cpuidle_register(drv, NULL);

    if (ret)

        goto out_kfree_drv;

    //7.暂不分析

    cpuidle_cooling_register(drv);

    return 0;

out_kfree_drv:

    kfree(drv);

    return ret;

}

static struct cpuidle_driver arm_idle_driver __initdata = {

    .name = "arm_idle",

    .owner = THIS_MODULE,

    /*

     * State at index 0 is standby wfi and considered standard

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

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

     * to work around this issue and allow installing a special

     * handler for idle state index 0.

     */

    .states[0] = {

        .enter = arm_enter_idle_state,        //进入该C state的方法

        .exit_latency = 1,                            //退出延迟

        .target_residency = 1,                            //最小滞留时间

        .power_usage = UINT_MAX,                    //功耗

        .name = "WFI",

        .desc = "ARM WFI",

    }

};

static const struct of_device_id arm_idle_state_match[] __initconst = {

    { .compatible = "arm,idle-state",

     .data = arm_enter_idle_state },            //data中指定进入指定C state的函数

    { },

};

/*

* arm_enter_idle_state - Programs CPU to enter the specified state

*

* dev: cpuidle device

* drv: cpuidle driver

* idx: state index

*

* Called from the CPUidle framework to program the device to the

* specified target state selected by the governor.

*/

static int arm_enter_idle_state(

            struct cpuidle_device *dev,            //要进入idle的cpu

            struct cpuidle_driver *drv,            //进入idle所使用的驱动

            int idx)                                //要进入idle的级别

{

    /*

     * Pass idle state index to arm_cpuidle_suspend which in turn

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

     * parameter.

     */

    //arm_cpuidle_suspend方法的具体实现在下一章讲解

    return CPU_PM_CPU_IDLE_ENTER(arm_cpuidle_suspend, idx);

}

#define __CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter,    \    //回调函数

                idx,                    \                        //要进入的C state级别

                state,                    \                        //平台自定义的C state对应的数据

                is_retention)                \

({                                    \

    int __ret = 0;                            \

                                    \

    if (!idx) {                            \                //如果指定的等级为0，则执行这个函数

        cpu_do_idle();                        \

        return idx;                        \

    }                                \

                                    \

    if (!is_retention)                        \

        __ret = cpu_pm_enter();                \

    if (!__ret) {                            \

        __ret = low_level_idle_enter(state);    \            //调用回调函数进入直接级别的idle

        if (!is_retention)                    \

            cpu_pm_exit();                    \

    }                                \

                                    \

    __ret ? -1 : idx;                        \

})

#define CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter, idx)    \

    __CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter, idx, idx, 0)

int arm_cpuidle_init(unsigned int cpu)

{

    const struct cpu_operations *ops = get_cpu_ops(cpu);

    int ret = -EOPNOTSUPP;

    //注意:

    // 在ARM64平台，上面获取到的ops为cpu_psci_ops，这个ops没有

    // 定义cpu_suspend和cpu_init_idle，该函数直接返回EOPNOTSUPP

    if (ops && ops->cpu_suspend && ops->cpu_init_idle)

        ret = ops->cpu_init_idle(cpu);

    return ret;

}

/**

* arm_cpuidle_init() - Initialize cpuidle_ops for a specific cpu

* @cpu: the cpu to be initialized

*

* Initialize the cpuidle ops with the device for the cpu and then call

* the cpu's idle initialization callback. This may fail if the underlying HW

* is not operational.

*

* Returns:

* 0 on success,

* -ENODEV if it fails to find the cpu node in the device tree,

* -EOPNOTSUPP if it does not find a registered and valid cpuidle_ops for

* this cpu,

* -ENOENT if it fails to find an 'enable-method' property,

* -ENXIO if the HW reports a failure or a misconfiguration,

* -ENOMEM if the HW report an memory allocation failure

*/

int __init arm_cpuidle_init(int cpu)

{

    //1.获取这个cpu对应的设备树节点

    struct device_node *cpu_node = of_cpu_device_node_get(cpu);

    int ret;

    if (!cpu_node)

        return -ENODEV;

    //2.读出这个cpu对应的cpuidle_ops，并赋值给全局数组cpuidle_ops[]

    // 如果平台端没有注册了ops的话，这里会返回-EOPNOTSUPP

    ret = arm_cpuidle_read_ops(cpu_node, cpu);

    //3.调用cpuidle_ops对应的init函数，完成平台自己关心的初始化工作

    // 例如在omap2平台中，会在这个init中继续从设备树中获取自定义的

    // C state信息，实际上omap2的这个平台就是通过这些信息，决定在执

    // 行wfi命令之前需要关闭哪些外设，进而区分不同等级的C state

    if (!ret)

        ret = cpuidle_ops[cpu].init(cpu_node, cpu);

    of_node_put(cpu_node);

    return ret;

}

static int __init amx3_idle_init(struct device_node *cpu_node, int cpu)

{

    struct device_node *state_node;

    struct amx3_idle_state states[CPUIDLE_STATE_MAX];

    int i;

    int state_count = 1;

    //1.查看设备树中国是否有指定的属性，并初始化wfi_flags

    // wfi_flags用于指导：在执行wfi之前要执行哪些操作，

    // 例如刷cache，关闭片上外设等操作

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

        //2.通过for循环，获取这个cpu支持的所有C state对应的节点

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

        if (!state_node)

            break;

        if (!of_device_is_available(state_node))

            continue;

        if (i == CPUIDLE_STATE_MAX) {

            pr_warn("%s: cpuidle states reached max possible\n",

                __func__);

            break;

        }

        states[state_count].wfi_flags = 0;

        //3.里从设备树中读取C state自定义的信息

        if (of_property_read_bool(state_node, "ti,idle-wkup-m3"))

            states[state_count].wfi_flags |= WFI_FLAG_WAKE_M3 | WFI_FLAG_FLUSH_CACHE;

        state_count++;

    }

    //4.为全局的idle_states[]数组申请空间，该变量中保存了在idle状态下的一些特性

    idle_states = kcalloc(state_count, sizeof(*idle_states), GFP_KERNEL);

    if (!idle_states)

        return -ENOMEM;

    for (i = 1; i < state_count; i++)

        idle_states[i].wfi_flags = states[i].wfi_flags;

    return 0;

}

    cpus {

        #address-cells = <1>;

        #size-cells = <0>;

        cpu@0 {

            compatible = "arm,cortex-a8";

            enable-method = "ti,am3352";

            device_type = "cpu";

            reg = <0>;

            operating-points-v2 = <&cpu0_opp_table>;

            clocks = <&dpll_mpu_ck>;

            clock-names = "cpu";

            clock-latency = <300000>; /* From omap-cpufreq driver */

            cpu-idle-states = <&mpu_gate>;            //只支持一个C state

        };

        idle-states {

            mpu_gate: mpu_gate {

                compatible = "arm,idle-state";

                entry-latency-us = <40>;

                exit-latency-us = <90>;

                min-residency-us = <300>;

                ti,idle-wkup-m3;

            };

        };

    };

#ifdef CONFIG_CPU_V7M

# ifdef CPU_NAME

# undef MULTI_CPU

# define MULTI_CPU

# else

# define CPU_NAME cpu_v7m

# endif

#endif

#define cpu_do_idle            __glue(CPU_NAME,_do_idle)

/*

*    cpu_v7m_do_idle()

*

*    Idle the processor (eg, wait for interrupt).

*

*    IRQs are already disabled.

*/

ENTRY(cpu_v7m_do_idle)

    wfi                                //wfi指令进入0级C state

    ret lr                            //返回到睡眠位置继续执行

ENDPROC(cpu_v7m_do_idle)

/**

* arm_cpuidle_suspend() - function to enter a low-power idle state

* @arg: argument to pass to CPU suspend operations

*

* Return: 0 on success, -EOPNOTSUPP if CPU suspend hook not initialized, CPU

* operations back-end error code otherwise.

*/

int arm_cpuidle_suspend(int index)

{

    int cpu = smp_processor_id();

    const struct cpu_operations *ops = get_cpu_ops(cpu);

    //进入指定的睡眠等级

    return ops->cpu_suspend(index);

}

/**

* arm_cpuidle_suspend() - function to enter low power idle states

* @index: an integer used as an identifier for the low level PM callbacks

*

* This function calls the underlying arch specific low level PM code as

* registered at the init time.

*

* Returns the result of the suspend callback.

*/

int arm_cpuidle_suspend(int index)

{

    int cpu = smp_processor_id();

    return cpuidle_ops[cpu].suspend(index);

}

static struct cpuidle_ops amx3_cpuidle_ops __initdata = {

    .init = amx3_idle_init,

    .suspend = amx3_idle_enter,

};

CPUIDLE_METHOD_OF_DECLARE(pm33xx_idle, "ti,am3352", &amx3_cpuidle_ops);

CPUIDLE_METHOD_OF_DECLARE(pm43xx_idle, "ti,am4372", &amx3_cpuidle_ops);

static int amx3_idle_enter(

            unsigned long index)                //要进入的C state

{

    //1.根据index，找到指定级别的C state对应的数据结构

    struct amx3_idle_state *idle_state = &idle_states[index];

    if (!idle_state)

        return -EINVAL;

    //2.idle_fn完成进入idle函数，这个函数在哪赋值呢

    if (idle_fn)

        idle_fn(idle_state->wfi_flags);

    return 0;

}

static int am33xx_pm_probe(struct platform_device *pdev)

{

    struct device *dev = &pdev->dev;

    int ret;

    if (!of_machine_is_compatible("ti,am33xx") &&

     !of_machine_is_compatible("ti,am43"))

        return -ENODEV;

    pm_ops = dev->platform_data;

    ...

    //1.获取可执行代码放在哪里

    pm_sram = pm_ops->get_sram_addrs();

    ...

    //2.拷贝回调函数对应的二进制代码段

    ret = am33xx_push_sram_idle();

    ...

    //3.初始化

    ret = pm_ops->init(am33xx_do_sram_idle);

    if (ret) {

        dev_err(dev, "Unable to call core pm init!\n");

        ret = -ENODEV;

        goto err_put_wkup_m3_ipc;

    }

    return 0;

}

static struct am33xx_pm_platform_data am33xx_ops = {

    .init = am33xx_suspend_init,

    .deinit = amx3_suspend_deinit,

    .soc_suspend = am33xx_suspend,

    .cpu_suspend = am33xx_cpu_suspend,

    .begin_suspend = amx3_begin_suspend,

    .finish_suspend = amx3_finish_suspend,

    .get_sram_addrs = amx3_get_sram_addrs,

    .save_context = am33xx_save_context,

    .restore_context = am33xx_restore_context,

    .check_off_mode_enable = am33xx_check_off_mode_enable,

};

static int am33xx_do_sram_idle(u32 wfi_flags)

{

    int ret = 0;

    if (!m3_ipc || !pm_ops)

        return 0;

    if (wfi_flags & WFI_FLAG_WAKE_M3)

        ret = m3_ipc->ops->prepare_low_power(m3_ipc, WKUP_M3_IDLE);

    return pm_ops->cpu_suspend(am33xx_do_wfi_sram, wfi_flags);

}

static int am33xx_cpu_suspend(

            int (*fn)(unsigned long),            //进入指定C state时的回调函数

            unsigned long args)                //这里传入的是wfi_flags

{

    int ret = 0;

    if (omap_irq_pending() || need_resched())

        return ret;

    //1.cpu_suspend函数中实际是调用了传递的fn回调函数，完成进入指定等级的C state

    // 注意：这里传入的参数args为wfi_flags，该参数用于指示在执行wfi指令之前需要

    // 关闭哪些外设，用这个方法区分不同等级的C state

    ret = cpu_suspend(args, fn);

    return ret;

}

#ifdef CONFIG_MMU

int cpu_suspend(unsigned long arg, int (*fn)(unsigned long))

{

    struct mm_struct *mm = current->active_mm;

    u32 __mpidr = cpu_logical_map(smp_processor_id());

    int ret;

    if (!idmap_pgd)

        return -EINVAL;

    /*

     * Function graph tracer state gets incosistent when the kernel

     * calls functions that never return (aka suspend finishers) hence

     * disable graph tracing during their execution.

     */

    pause_graph_tracing();

    /*

     * Provide a temporary page table with an identity mapping for

     * the MMU-enable code, required for resuming. On successful

     * resume (indicated by a zero return code), we need to switch

     * back to the correct page tables.

     */

    //调用__cpu_suspend函数进入idle睡眠

    ret = __cpu_suspend(arg, fn, __mpidr);

    unpause_graph_tracing();

    if (ret == 0) {

        cpu_switch_mm(mm->pgd, mm);

        local_flush_bp_all();

        local_flush_tlb_all();

        check_other_bugs();

    }

    return ret;

}

#else

int cpu_suspend(unsigned long arg, int (*fn)(unsigned long))

{

    u32 __mpidr = cpu_logical_map(smp_processor_id());

    int ret;

    pause_graph_tracing();

    //调用__cpu_suspend函数进入idle睡眠

    ret = __cpu_suspend(arg, fn, __mpidr);

    unpause_graph_tracing();

    return ret;

}

#define    idmap_pgd    NULL

#endif

/*

* Save CPU state for a suspend. This saves the CPU general purpose

* registers, and allocates space on the kernel stack to save the CPU

* specific registers and some other data for resume.

* r0 = suspend function arg0

* r1 = suspend function

* r2 = MPIDR value the resuming CPU will use

*/

ENTRY(__cpu_suspend)

    stmfd sp!, {r4 - r11, lr}

#ifdef MULTI_CPU

    ldr r10, =processor

    ldr r4, [r10, #CPU_SLEEP_SIZE]        @ size of CPU sleep state

#else

    ldr r4, =cpu_suspend_size

#endif

    mov r5, sp                                @ current virtual SP

    add r4, r4, #12                        @ Space for pgd, virt sp, phys resume fn

    sub sp, sp, r4                            @ allocate CPU state on stack

    ldr r3, =sleep_save_sp

    stmfd sp!, {r0, r1}                    @ save suspend func arg and pointer

    ldr r3, [r3, #SLEEP_SAVE_SP_VIRT]

    ALT_SMP(ldr r0, =mpidr_hash)

    ALT_UP_B(1f)

    /* This ldmia relies on the memory layout of the mpidr_hash struct */

    ldmia r0, {r1, r6-r8}                    @ r1 = mpidr mask (r6,r7,r8) = l[0,1,2] shifts

    compute_mpidr_hash r0, r6, r7, r8, r2, r1

    add r3, r3, r0, lsl #2

1:    mov r2, r5                                @ virtual SP

    mov r1, r4                                @ size of save block

    add r0, sp, #8                            @ pointer to save block

    bl __cpu_suspend_save

    badr lr, cpu_suspend_abort

    ldmfd sp!, {r0, pc}                    @ call suspend fn

ENDPROC(__cpu_suspend)

static int (*am33xx_do_wfi_sram)(unsigned long unused);

static int am33xx_push_sram_idle(void)

{

    ...

    am33xx_do_wfi_sram = sram_exec_copy(sram_pool, (void *)ocmcram_location,

                     pm_sram->do_wfi,

                     *pm_sram->do_wfi_sz);

    if (!am33xx_do_wfi_sram) {

        dev_err(pm33xx_dev,

            "PM: %s: am33xx_do_wfi copy to sram failed\n",

            __func__);

        return -ENODEV;

    }

    ...

}

void *sram_exec_copy(struct gen_pool *pool, void *dst, void *src, size_t size);

pm_sram = pm_ops->get_sram_addrs();

static struct am33xx_pm_sram_addr *amx3_get_sram_addrs(void)

{

    if (soc_is_am33xx())

        return &am33xx_pm_sram;

    else if (soc_is_am437x())

        return &am43xx_pm_sram;

    else

        return NULL;

}

extern struct am33xx_pm_sram_addr am33xx_pm_sram;

ENTRY(am33xx_pm_sram)

    .word am33xx_do_wfi

    .word am33xx_do_wfi_sz

    .word am33xx_resume_offset

    .word am33xx_emif_sram_table

    .word am33xx_pm_ro_sram_data

resume_addr:

.word cpu_resume - PAGE_OFFSET + 0x80000000

struct am33xx_pm_sram_addr {

    void (*do_wfi)(void);

    unsigned long *do_wfi_sz;

    unsigned long *resume_offset;

    unsigned long *emif_sram_table;

    unsigned long *ro_sram_data;

    unsigned long resume_address;

};

/*

* WFI Flags for sleep code control

*

* These flags allow PM code to exclude certain operations from happening

* in the low level ASM code found in sleep33xx.S and sleep43xx.S

*

* WFI_FLAG_FLUSH_CACHE: Flush the ARM caches and disable caching. Only

*             needed when MPU will lose context.

* WFI_FLAG_SELF_REFRESH: Let EMIF place DDR memory into self-refresh and

*             disable EMIF.

* WFI_FLAG_SAVE_EMIF: Save context of all EMIF registers and restore in

*         resume path. Only needed if PER domain loses context

*         and must also have WFI_FLAG_SELF_REFRESH set.

* WFI_FLAG_WAKE_M3: Disable MPU clock or clockdomain to cause wkup_m3 to

*         execute when WFI instruction executes.

* WFI_FLAG_RTC_ONLY: Configure the RTC to enter RTC+DDR mode.

*/

#define WFI_FLAG_FLUSH_CACHE        BIT(0)

#define WFI_FLAG_SELF_REFRESH        BIT(1)

#define WFI_FLAG_SAVE_EMIF        BIT(2)

#define WFI_FLAG_WAKE_M3            BIT(3)

#define WFI_FLAG_RTC_ONLY            BIT(4)

ENTRY(am33xx_do_wfi)

    stmfd sp!, {r4 - r11, lr}    @ save registers on stack

    /* Save wfi_flags arg to data space */

    //1.首先将wfi_flags参数保存在r4中

    mov r4, r0

    //2.下面的操作只是为了保存wfi_flags，因为后面调用的一些操作可能或破坏r4

    //2.1 am33xx_pm_ro_sram_data是在汇编中预留的一段空间

    adr r3, am33xx_pm_ro_sram_data

    //2.2 从am33xx_pm_ro_sram_data中读出amx3_pm_sram_data_virt

    // amx3_pm_sram_data_virt指向的是一个am33xx_pm_sram_data类型的结构

    ldr r2, [r3, #AMX3_PM_RO_SRAM_DATA_VIRT_OFFSET]

    //2.3 将上面传进来的wfi_flags存入am33xx_pm_sram_data->wfi_flags中去

    str r4, [r2, #AMX3_PM_WFI_FLAGS_OFFSET]

    /* Only flush cache is we know we are losing MPU context */

    //3.下面根据wfi_flags，执行不同的操作

    tst r4, #WFI_FLAG_FLUSH_CACHE

    beq cache_skip_flush

    /*

     * Flush all data from the L1 and L2 data cache before disabling

     * SCTLR.C bit.

     */

    ldr r1, kernel_flush

    blx r1

    /*

     * Clear the SCTLR.C bit to prevent further data cache

     * allocation. Clearing SCTLR.C would make all the data accesses

     * strongly ordered and would not hit the cache.

     */

    mrc p15, 0, r0, c1, c0, 0

    bic r0, r0, #(1 << 2)    @ Disable the C bit

    mcr p15, 0, r0, c1, c0, 0

    isb

    /*

     * Invalidate L1 and L2 data cache.

     */

    ldr r1, kernel_flush

    blx r1

    //4.下面的操作时恢复上面保存的wfi_flags参数

    adr r3, am33xx_pm_ro_sram_data

    ldr r2, [r3, #AMX3_PM_RO_SRAM_DATA_VIRT_OFFSET]

    ldr r4, [r2, #AMX3_PM_WFI_FLAGS_OFFSET]

cache_skip_flush:

    /* Check if we want self refresh */

    //5.继续根据wfi_flags，执行相应的操作

    tst r4, #WFI_FLAG_SELF_REFRESH

    beq emif_skip_enter_sr

    adr r9, am33xx_emif_sram_table

    ldr r3, [r9, #EMIF_PM_ENTER_SR_OFFSET]

    blx r3

emif_skip_enter_sr:

    /* Only necessary if PER is losing context */

    //6.继续根据wfi_flags，执行相应的操作

    tst r4, #WFI_FLAG_SAVE_EMIF

    beq emif_skip_save

    ldr r3, [r9, #EMIF_PM_SAVE_CONTEXT_OFFSET]

    blx r3

emif_skip_save:

    /* Only can disable EMIF if we have entered self refresh */

    //7.继续根据wfi_flags，执行相应的操作

    tst r4, #WFI_FLAG_SELF_REFRESH

    beq emif_skip_disable

    /* Disable EMIF */

    ldr r1, virt_emif_clkctrl

    ldr r2, [r1]

    bic r2, r2, #AM33XX_CM_CLKCTRL_MODULEMODE_DISABLE

    str r2, [r1]

    ldr r1, virt_emif_clkctrl

wait_emif_disable:

    ldr r2, [r1]

    mov r3, #AM33XX_CM_CLKCTRL_MODULESTATE_DISABLED

    cmp r2, r3

    bne wait_emif_disable

emif_skip_disable:

    //8.继续根据wfi_flags，执行相应的操作

    tst r4, #WFI_FLAG_WAKE_M3

    beq wkup_m3_skip

    /*

     * For the MPU WFI to be registered as an interrupt

     * to WKUP_M3, MPU_CLKCTRL.MODULEMODE needs to be set

     * to DISABLED

     */

    ldr r1, virt_mpu_clkctrl

    ldr r2, [r1]

    bic r2, r2, #AM33XX_CM_CLKCTRL_MODULEMODE_DISABLE

    str r2, [r1]

wkup_m3_skip:

    /*

     * Execute an ISB instruction to ensure that all of the

     * CP15 register changes have been committed.

     */

    isb

    /*

     * Execute a barrier instruction to ensure that all cache,

     * TLB and branch predictor maintenance operations issued

     * have completed.

     */

    dsb

    dmb

    /*

     * Execute a WFI instruction and wait until the

     * STANDBYWFI output is asserted to indicate that the

     * CPU is in idle and low power state. CPU can specualatively

     * prefetch the instructions so add NOPs after WFI. Thirteen

     * NOPs as per Cortex-A8 pipeline.

     */

    //9.执行wfi指令，进入idle

    wfi

    nop

    nop

    nop

    nop

    nop

    nop

    nop

    nop

    nop

    nop

    nop

    nop

    nop

    /* We come here in case of an abort due to a late interrupt */

    /* Set MPU_CLKCTRL.MODULEMODE back to ENABLE */

    ldr r1, virt_mpu_clkctrl

    mov r2, #AM33XX_CM_CLKCTRL_MODULEMODE_ENABLE

    str r2, [r1]

    /* Re-enable EMIF */

    ldr r1, virt_emif_clkctrl

    mov r2, #AM33XX_CM_CLKCTRL_MODULEMODE_ENABLE

    str r2, [r1]

wait_emif_enable:

    ldr r3, [r1]

    cmp r2, r3

    bne wait_emif_enable

    /* Only necessary if PER is losing context */

    //10.下面根据wfi_flags，恢复相应的操作

    tst r4, #WFI_FLAG_SELF_REFRESH

    beq emif_skip_exit_sr_abt

    adr r9, am33xx_emif_sram_table

    ldr r1, [r9, #EMIF_PM_ABORT_SR_OFFSET]

    blx r1

emif_skip_exit_sr_abt:

    //11.继续根据wfi_flags，恢复相应的操作

    tst r4, #WFI_FLAG_FLUSH_CACHE

    beq cache_skip_restore

    /*

     * Set SCTLR.C bit to allow data cache allocation

     */

    mrc p15, 0, r0, c1, c0, 0

    orr r0, r0, #(1 << 2)    @ Enable the C bit

    mcr p15, 0, r0, c1, c0, 0

    isb

cache_skip_restore:

    /* Let the suspend code know about the abort */

    //12.执行成功返回1，也就是从idle中退出后返回1

    mov r0, #1

    ldmfd sp!, {r4 - r11, pc}    @ restore regs and return

ENDPROC(am33xx_do_wfi)

.align 3

ENTRY(am33xx_pm_ro_sram_data)

    .space AMX3_PM_RO_SRAM_DATA_SIZE

int main(void)

{

    ti_emif_asm_offsets();

    DEFINE(AMX3_PM_WFI_FLAGS_OFFSET,

     offsetof(struct am33xx_pm_sram_data, wfi_flags));

    DEFINE(AMX3_PM_L2_AUX_CTRL_VAL_OFFSET,

     offsetof(struct am33xx_pm_sram_data, l2_aux_ctrl_val));

    DEFINE(AMX3_PM_L2_PREFETCH_CTRL_VAL_OFFSET,

     offsetof(struct am33xx_pm_sram_data, l2_prefetch_ctrl_val));

    DEFINE(AMX3_PM_SRAM_DATA_SIZE, sizeof(struct am33xx_pm_sram_data));

    BLANK();

    DEFINE(AMX3_PM_RO_SRAM_DATA_VIRT_OFFSET,

     offsetof(struct am33xx_pm_ro_sram_data, amx3_pm_sram_data_virt));

    DEFINE(AMX3_PM_RO_SRAM_DATA_PHYS_OFFSET,

     offsetof(struct am33xx_pm_ro_sram_data, amx3_pm_sram_data_phys));

    DEFINE(AMX3_PM_RTC_BASE_VIRT_OFFSET,

     offsetof(struct am33xx_pm_ro_sram_data, rtc_base_virt));

    DEFINE(AMX3_PM_RO_SRAM_DATA_SIZE,

     sizeof(struct am33xx_pm_ro_sram_data));

    return 0;

}

struct am33xx_pm_ro_sram_data {

    u32 amx3_pm_sram_data_virt;

    u32 amx3_pm_sram_data_phys;

    void __iomem *rtc_base_virt;

} __packed __aligned(8);

struct am33xx_pm_sram_data {

    u32 wfi_flags;

    u32 l2_aux_ctrl_val;

    u32 l2_prefetch_ctrl_val;

} __packed __aligned(8);

$(obj)/pm-asm-offsets.h: $(obj)/pm-asm-offsets.s FORCE

    $(call filechk,offsets,__TI_PM_ASM_OFFSETS_H__)

$(obj)/sleep33xx.o $(obj)/sleep43xx.o: $(obj)/pm-asm-offsets.h

targets += pm-asm-offsets.s

clean-files += pm-asm-offsets.h

/*

* NB: Owing to current menu governor behaviour big and LITTLE

* index 1 states have to define exit_latency and target_residency for

* cluster state since, when all CPUs in a cluster hit it, the cluster

* can be shutdown. This means that when a single CPU enters this state

* the exit_latency and target_residency values are somewhat overkill.

* There is no notion of cluster states in the menu governor, so CPUs

* have to define CPU states where possibly the cluster will be shutdown

* depending on the state of other CPUs. idle states entry and exit happen

* at random times; however the cluster state provides target_residency

* values as if all CPUs in a cluster enter the state at once; this is

* somewhat optimistic and behaviour should be fixed either in the governor

* or in the MCPM back-ends.

* To make this driver 100% generic the number of states and the exit_latency

* target_residency values must be obtained from device tree bindings.

*

* exit_latency: refers to the TC2 vexpress test chip and depends on the

* current cluster operating point. It is the time it takes to get the CPU

* up and running when the CPU is powered up on cluster wake-up from shutdown.

* Current values for big and LITTLE clusters are provided for clusters

* running at default operating points.

*

* target_residency: it is the minimum amount of time the cluster has

* to be down to break even in terms of power consumption. cluster

* shutdown has inherent dynamic power costs (L2 writebacks to DRAM

* being the main factor) that depend on the current operating points.

* The current values for both clusters are provided for a CPU whose half

* of L2 lines are dirty and require cleaning to DRAM, and takes into

* account leakage static power values related to the vexpress TC2 testchip.

*/

static struct cpuidle_driver bl_idle_little_driver = {

    .name = "little_idle",

    .owner = THIS_MODULE,

    .states[0] = ARM_CPUIDLE_WFI_STATE,                //进入idle0的方法

    .states[1] = {

        .enter            = bl_enter_powerdown,            //进入idle1的方法

        .exit_latency        = 700,

        .target_residency    = 2500,

        .flags            = CPUIDLE_FLAG_TIMER_STOP,

        .name            = "C1",

        .desc            = "ARM little-cluster power down",

    },

    .state_count = 2,

};

/* Common ARM WFI state */

#define ARM_CPUIDLE_WFI_STATE_PWR(p) {\

    .enter = arm_cpuidle_simple_enter,\        //进入该idle0的方法

    .exit_latency = 1,\

    .target_residency = 1,\

    .power_usage = p,\

    .name = "WFI",\

    .desc = "ARM WFI",\

}

/*

* in case power_specified == 1, give a default WFI power value needed

* by some governors

*/

#define ARM_CPUIDLE_WFI_STATE            ARM_CPUIDLE_WFI_STATE_PWR(UINT_MAX)

static struct cpuidle_driver bl_idle_big_driver = {

    .name = "big_idle",

    .owner = THIS_MODULE,

    .states[0] = ARM_CPUIDLE_WFI_STATE,                    //进入idle0的方法

    .states[1] = {

        .enter            = bl_enter_powerdown,                //进入idle1的方法

        .exit_latency        = 500,

        .target_residency    = 2000,

        .flags            = CPUIDLE_FLAG_TIMER_STOP,

        .name            = "C1",

        .desc            = "ARM big-cluster power down",

    },

    .state_count = 2,

};

static int __init bl_idle_init(void)

{

    int ret;

    //1.找到设备树的根节点

    struct device_node *root = of_find_node_by_path("/");

    const struct of_device_id *match_id;

    if (!root)

        return -ENODEV;

    /*

     * Initialize the driver just for a compliant set of machines

     */

    //2.只有match匹配上才允许使用bl模块

    match_id = of_match_node(compatible_machine_match, root);

    of_node_put(root);

    if (!match_id)

        return -ENODEV;

    if (!mcpm_is_available())

        return -EUNATCH;

    /*

     * For now the differentiation between little and big cores

     * is based on the part number. A7 cores are considered little

     * cores, A15 are considered big cores. This distinction may

     * evolve in the future with a more generic matching approach.

     */

    //3.初始化driver，设置driver->cpumask

    // 小核A7，大核A15

    ret = bl_idle_driver_init(&bl_idle_little_driver, ARM_CPU_PART_CORTEX_A7);

    if (ret)

        return ret;

    ret = bl_idle_driver_init(&bl_idle_big_driver, ARM_CPU_PART_CORTEX_A15);

    if (ret)

        goto out_uninit_little;

    /* Start at index 1, index 0 standard WFI */

    //4.解析设备树中的C state信息

    // 这里传入的参数为1，由上面注释可知，从设备树解析出来的

    // C state信息是给idx>=1使用的，idx=0是wfi预留的

    ret = dt_init_idle_driver(&bl_idle_big_driver, bl_idle_state_match, 1);

    if (ret < 0)

        goto out_uninit_big;

    /* Start at index 1, index 0 standard WFI */

    ret = dt_init_idle_driver(&bl_idle_little_driver, bl_idle_state_match, 1);

    if (ret < 0)

        goto out_uninit_big;

    //5.注册driver

    ret = cpuidle_register(&bl_idle_little_driver, NULL);

    if (ret)

        goto out_uninit_big;

    ret = cpuidle_register(&bl_idle_big_driver, NULL);

    if (ret)

        goto out_unregister_little;

    return 0;

out_unregister_little:

    cpuidle_unregister(&bl_idle_little_driver);

out_uninit_big:

    kfree(bl_idle_big_driver.cpumask);

out_uninit_little:

    kfree(bl_idle_little_driver.cpumask);

    return ret;

}

device_initcall(bl_idle_init);

static const struct of_device_id compatible_machine_match[] = {

    { .compatible = "arm,vexpress,v2p-ca15_a7" },

    { .compatible = "samsung,exynos5420" },

    { .compatible = "samsung,exynos5800" },

    {},

};

static const struct of_device_id bl_idle_state_match[] __initconst = {

    { .compatible = "arm,idle-state",

     .data = bl_enter_powerdown },

    { },

};

static int __init bl_idle_driver_init(struct cpuidle_driver *drv, int part_id)

{

    struct cpumask *cpumask;

    int cpu;

    cpumask = kzalloc(cpumask_size(), GFP_KERNEL);

    if (!cpumask)

        return -ENOMEM;

    for_each_possible_cpu(cpu)

        if (smp_cpuid_part(cpu) == part_id)

            cpumask_set_cpu(cpu, cpumask);

    drv->cpumask = cpumask;

    return 0;

}

/**

* arm_cpuidle_simple_enter() - a wrapper to cpu_do_idle()

* @dev: not used

* @drv: not used

* @index: not used

*

* A trivial wrapper to allow the cpu_do_idle function to be assigned as a

* cpuidle callback by matching the function signature.

*

* Returns the index passed as parameter

*/

int arm_cpuidle_simple_enter(

            struct cpuidle_device *dev,

            struct cpuidle_driver *drv,

            int index)                            //wfi不关注等级，该参数被忽略

{

    cpu_do_idle();

    return index;

}

#define cpu_do_idle            __glue(CPU_NAME,_do_idle)

#ifdef CONFIG_CPU_V7M

# ifdef CPU_NAME

# undef MULTI_CPU

# define MULTI_CPU

# else

# define CPU_NAME cpu_v7m

# endif

#endif

/*

*    cpu_v7m_do_idle()

*

*    Idle the processor (eg, wait for interrupt).

*

*    IRQs are already disabled.

*/

ENTRY(cpu_v7m_do_idle)

    wfi                            //直接执行wfi进入睡眠

    ret lr                        //醒来后，返回原来的位置继续执行

ENDPROC(cpu_v7m_do_idle)

/**

* bl_enter_powerdown - Programs CPU to enter the specified state

* @dev: cpuidle device

* @drv: The target state to be programmed

* @idx: state index

*

* Called from the CPUidle framework to program the device to the

* specified target state selected by the governor.

*/

static int bl_enter_powerdown(

            struct cpuidle_device *dev,

            struct cpuidle_driver *drv,

            int idx)                            //要进入的idle级别，但是在这个函数中并没有用

{

    cpu_pm_enter();

    //调用bl_powerdown_finisher函数进入指定的idle等级

    //注意：下面传入的0在bl_powerdown_finisher也是没有使用的，因为固定进入idle1

    cpu_suspend(0, bl_powerdown_finisher);

    /* signals the MCPM core that CPU is out of low power state */

    mcpm_cpu_powered_up();

    cpu_pm_exit();

    return idx;

}

/*

* notrace prevents trace shims from getting inserted where they

* should not. Global jumps and ldrex/strex must not be inserted

* in power down sequences where caches and MMU may be turned off.

*/

static int notrace bl_powerdown_finisher(

            unsigned long arg)                    //传入的参数并没有使用

{

    /* MCPM works with HW CPU identifiers */

    unsigned int mpidr = read_cpuid_mpidr();

    unsigned int cluster = MPIDR_AFFINITY_LEVEL(mpidr, 1);

    unsigned int cpu = MPIDR_AFFINITY_LEVEL(mpidr, 0);

    //1.设置cpu从idle退出后，从哪开始执行

    mcpm_set_entry_vector(cpu, cluster, cpu_resume);

    //2.进入idle1

    mcpm_cpu_suspend();

    /* return value != 0 means failure */

    return 1;

}

void mcpm_cpu_suspend(void)

{

    if (WARN_ON_ONCE(!platform_ops))

        return;

    /* Some platforms might have to enable special resume modes, etc. */

    //1.一些平台可能需要执行一些准备工作

    if (platform_ops->cpu_suspend_prepare) {

        unsigned int mpidr = read_cpuid_mpidr();

        unsigned int cpu = MPIDR_AFFINITY_LEVEL(mpidr, 0);

        unsigned int cluster = MPIDR_AFFINITY_LEVEL(mpidr, 1);

        arch_spin_lock(&mcpm_lock);

        platform_ops->cpu_suspend_prepare(cpu, cluster);

        arch_spin_unlock(&mcpm_lock);

    }

    //2.进入idle

    mcpm_cpu_power_down();

}

static void tc2_pm_cpu_suspend_prepare(unsigned int cpu, unsigned int cluster)

{

    ve_spc_set_resume_addr(cluster, cpu, __pa_symbol(mcpm_entry_point));

}

/**

* ve_spc_set_resume_addr() - set the jump address used for warm boot

*

* @cluster: mpidr[15:8] bitfield describing cluster affinity level

* @cpu: mpidr[7:0] bitfield describing cpu affinity level

* @addr: physical resume address

*/

void ve_spc_set_resume_addr(u32 cluster, u32 cpu, u32 addr)

{

    void __iomem *baseaddr;

    if (cluster >= MAX_CLUSTERS)

        return;

    //不同的cpu架构，读取的寄存器不一样