Linux电源管理（四）CPUFreq

CPUFreq简介

CPUFreq是一种实时的电压和频率调节技术，也叫DVFS（Dynamic Voltage and Frequency Scaling）动态电压频率调节。

为何需要CPUFreq

随着技术的发展，CPU的频率越来越高，性能越来越好，芯片制造工艺也越来越先进。但高性能的同时也带来高发热。其实移动嵌入式设备并不需要时刻保持高性能。因此，需要一种机制，实现动态地调节频率和电压，以实现性能和功耗的平衡。

CPUFreq软件框架

和一般的linux子系统类似，CPUFreq采用了机制与策略分离的设计架构。分为三个模块：

• cpufreq core： 对cpufreq governors和cpufreq drivers进行了封装和抽象并定义了清晰的接口，从而在设计上完成了对机制和策略的分离。

• cpufreq drivers：位于cpucore的底层，用于设置具体cpu硬件的频率。通过cpufreq driver可以使cpu频率得到调整。cpufreq driver借助Linux Cpufreq标准子系统中的cpufreq_driver结构体，完成cpu调频驱动的注册及实现。

• cpufreq governor：位于cpucore的上层，用于CPU升降频检测，根据系统和负载，决定cpu频率要调节到多少。cpufreq governor借助于linux cpufreq子系统中cpufreq_governor结构体，完成了cpu调频策略的注册和实现。

CPUFreq实现原理

linux cpufreq通过向系统注册实现cpufreq driver和cpufreq governor。cpu governor实现调频的策略，cpu driver实现调频的实际操作，从而完成动态调节频率和电压。一般情况下，优先调节频率，频率无法满足，再调节电压以实现调频。

CPUFreq sys用户态接口

cpufreq相关的节点位于/sys/devices/system/cpu/cpu0/cpufreq目录下：

$ cd /sys/devices/system/cpu/cpu0/cpufreq

可以看到以下节点：

shell@tiny4412:/sys/devices/system/cpu/cpu0/cpufreq # ls
affected_cpus
cpuinfo_cur_freq
cpuinfo_max_freq
cpuinfo_min_freq
cpuinfo_transition_latency
related_cpus
scaling_available_governors
scaling_cur_freq
scaling_driver
scaling_governor
scaling_max_freq
scaling_min_freq
scaling_setspeed
stats

具体含义如下表：

CPUFreq实现分析　

CPUFreq Core层

CPUFreq子系统将一些共同的逻辑代码组织在一起，构成了CPUFreq核心模块。这些公共逻辑模块向CPUFreq和其它内核模块提供了必要的API完成一个完整的CPUFreq子系统。这一节我们分析CPUFreq核心层的一些重要API的实现及使用。

代码位置：

/drivers/cpufreq/cpufreq.c

CPUFreq子系统初始化

static int __init cpufreq_core_init(void)
{
    int cpu;

    if (cpufreq_disabled())
        return -ENODEV;

    for_each_possible_cpu(cpu) {
        per_cpu(cpufreq_policy_cpu, cpu) = -1;
        init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
    }

    cpufreq_global_kobject = kobject_create_and_add("cpufreq", &cpu_subsys.dev_root->kobj);
    BUG_ON(!cpufreq_global_kobject);

#if defined(CONFIG_ARCH_SUNXI) && defined(CONFIG_HOTPLUG_CPU)
    /* register reboot notifier for process cpus when reboot */
    register_reboot_notifier(&reboot_notifier);
#endif

    return 0;
}
core_initcall(cpufreq_core_init);

可见，CPUFreq子系统在系统启动阶段由Initcall机制调用完成核心部分的初始化工作。cpufreq_policy_cpu是一个per_cpu变量，在smp系统下，每个cpu可以有自己独立的policy，也可以与其它cpu共用一个policy。通过kobject_create_and_add函数建立cpufreq节点，这与我们之前看到的sys下的cpufreq节点相吻合。该节点以后会用来放其它一些参数。
参数cpu_subsys是内核的一个全局变量，是由更早期的初始化时初始化的，代码在drivers/base/cpu.c中：

struct bus_type cpu_subsys = {
    .name = "cpu",
    .dev_name = "cpu",
};
EXPORT_SYMBOL_GPL(cpu_subsys);

void __init cpu_dev_init(void)
{
    if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
        panic("Failed to register CPU subsystem");

    cpu_dev_register_generic();
}

这将会建立一根cpu总线，总线下挂着系统中所有的cpu，cpu总线设备的根目录就位于：/sys/devices/system/cpu，同时，/sys/bus下也会出现一个cpu的总线节点。cpu总线设备的根目录下会依次出现cpu0，cpu1，…… cpux节点，每个cpu对应其中的一个设备节点。CPUFreq子系统利用这个cpu_subsys来获取系统中的cpu设备，并在这些cpu设备下面建立相应的cpufreq对象，这个我们在后面再讨论。
这样看来，cpufreq子系统的初始化其实没有做什么重要的事情，只是初始化了几个per_cpu变量和建立了一个cpufreq文件节点。下图是初始化过程的序列图：

注册cpufreq_governor

系统中可以同时存在多个governor策略，一个policy通过cpufreq_policy结构中的governor指针和某个governor相关联。要想一个governor被policy使用，首先要把该governor注册到cpufreq的核心中，我们可以通过核心层提供的API来完成注册：

int cpufreq_register_governor(struct cpufreq_governor *governor)
{
    int err;

    if (!governor)
        return -EINVAL;

    if (cpufreq_disabled())
        return -ENODEV;

    mutex_lock(&cpufreq_governor_mutex);

    governor->initialized = 0;
    err = -EBUSY;
    if (__find_governor(governor->name) == NULL) {
        err = 0;
        list_add(&governor->governor_list, &cpufreq_governor_list);
    }

    mutex_unlock(&cpufreq_governor_mutex);
    return err;
}

核心层定义了一个全局链表变量：cpufreq_governor_list，注册函数首先根据governor的名称，通过__find_governor()函数查找该governor是否已經被注册过，如果没有被注册过，则把代表该governor的结构体添加到cpufreq_governor_list链表中。

注册cpufreq_driver驱动

与governor不同，系统中只会存在一个cpufreq_driver驱动，cpufreq_driver是平台相关的，负责最终实施频率的调整动作，而选择工作频率的策略是由governor完成的。所以，系统中只需要注册一个cpufreq_driver即可，它只负责如何控制该平台的时钟系统，从而设定由governor确定的工作频率。核心提供了一个API：cpufreq_register_driver来完成注册工作。
下面我们分析一下这个函数的工作过程：

int cpufreq_register_driver(struct cpufreq_driver *driver_data)
{
    unsigned long flags;
    int ret;

    if (cpufreq_disabled())
        return -ENODEV;
    // 从代码可以看到，verify和init回调函数必须要实现，而setpolicy和target回调则至少要被实现其中的一个。
    if (!driver_data || !driver_data->verify || !driver_data->init ||
        ((!driver_data->setpolicy) && (!driver_data->target)))
        return -EINVAL;

    pr_debug("trying to register driver %s\n", driver_data->name);

    if (driver_data->setpolicy)
        driver_data->flags |= CPUFREQ_CONST_LOOPS;

    write_lock_irqsave(&cpufreq_driver_lock, flags);
    //检查全局变量cpufreq_driver是否已经被赋值，如果没有，则传入的参数被赋值给全局变量cpufreq_driver，从而保证了系统中只会注册一个cpufreq_driver驱动
    if (cpufreq_driver) {
        write_unlock_irqrestore(&cpufreq_driver_lock, flags);
        return -EBUSY;
    }
    cpufreq_driver = driver_data;
    write_unlock_irqrestore(&cpufreq_driver_lock, flags);
    //通过subsys_interface_register给每一个cpu建立一个cpufreq_policy
    ret = subsys_interface_register(&cpufreq_interface);
    if (ret)
        goto err_null_driver;

    if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
        int i;
        ret = -ENODEV;

        /* check for at least one working CPU */
        for (i = 0; i < nr_cpu_ids; i++)
            if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
                ret = 0;
                break;
            }

        /* if all ->init() calls failed, unregister */
        if (ret) {
            pr_debug("no CPU initialized for driver %s\n",
                            driver_data->name);
            goto err_if_unreg;
        }
    }
    //注册cpu hot plug通知，以便在cpu hot plug的时候，能够动态地处理各个cpu policy之间的关系（比如迁移负责管理的cpu等等）
    register_hotcpu_notifier(&cpufreq_cpu_notifier);
    pr_debug("driver %s up and running\n", driver_data->name);

    return 0;
err_if_unreg:
    subsys_interface_unregister(&cpufreq_interface);
err_null_driver:
    write_lock_irqsave(&cpufreq_driver_lock, flags);
    cpufreq_driver = NULL;
    write_unlock_irqrestore(&cpufreq_driver_lock, flags);
    return ret;
}

cpufreq_interface结构体如下：

 static struct subsys_interface cpufreq_interface = {
    .name       = "cpufreq",
    .subsys     = &cpu_subsys,
    .add_dev    = cpufreq_add_dev,
    .remove_dev = cpufreq_remove_dev,
};

subsys_interface_register遍历子系统下面的每一个子设备，然后用这个子设备作为参数，调用cpufrq_interface结构的add_dev回调函数，这里的回调函数被指向了cpufreq_add_dev。

下图是cpufreq_driver注册过程的序列图：

通过__cpufreq_set_policy函数，最终使得该policy正式生效。到这里，每个cpu的policy已经建立完毕，并正式开始工作。

__cpufreq_set_policy函数时序图如下：

其它API

int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);

以上两个API用于注册和注销cpufreq系统的通知消息，第二个参数可以选择通知的类型，可以有以下两种类型：

• CPUFREQ_TRANSITION_NOTIFIER 收到频率变更通知
• CPUFREQ_POLICY_NOTIFIER 收到policy更新通知

cpufreq_driver_target:用来设置目标频率，实际回调cpufreq的target函数。

int __cpufreq_driver_target(struct cpufreq_policy *policy,
                unsigned int target_freq,
                unsigned int relation)
{
    int retval = -EINVAL;
    unsigned int old_target_freq = target_freq;

    if (cpufreq_disabled())
        return -ENODEV;

    /* Make sure that target_freq is within supported range */
    if (target_freq > policy->max)
        target_freq = policy->max;
    if (target_freq < policy->min)
        target_freq = policy->min;

    pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
            policy->cpu, target_freq, relation, old_target_freq);

    if (target_freq == policy->cur)
        return 0;

    if (cpufreq_driver->target)
        retval = cpufreq_driver->target(policy, target_freq, relation);

    return retval;
}

CPUFreq driver层

通常一个驱动工程师驱动需要实现是大多是cpufreq driver,这部有具体的cpu差异。cpufreq driver主要完成平台相关的CPU频率/电压的控制，它在cpufreq framework中是非常简单的一个模块，主要是定义一个struct cpufreq_driver变量，填充必要的字段，并根据平台的特性，实现其中的回调函数。然后注册到系统中去。
cpufreq_driver 结构体如下所示。

struct cpufreq_driver {
    struct module           *owner;  //一般这THIS_MODULE
    char            name[CPUFREQ_NAME_LEN]; //cpufreq driver名字，如"cpufreq-sunxi"
    u8          flags; //标志：可以设置一些值，如CPUFREQ_STICKY，表示就算所有的init调用都失败了，driver也不被remove。

    bool            have_governor_per_policy;

    /* needed by all drivers */
    int (*init)     (struct cpufreq_policy *policy); //必须实现，用于在cpufreq core在cpu device添加后运行
    int (*verify)   (struct cpufreq_policy *policy); //必须实现，在当上层软件需要设定一个新的policy的时候，会调用driver的verify回调函数，检查该policy是否合法

    /* define one out of two */
    int (*setpolicy)    (struct cpufreq_policy *policy); //一般不实现 
    int (*target)   (struct cpufreq_policy *policy, //实际的调频函数
                 unsigned int target_freq,
                 unsigned int relation);

    /* should be defined, if possible */
    unsigned int    (*get)  (unsigned int cpu); //用于获取指定cpu的频率值

    /* optional */
    unsigned int (*getavg)  (struct cpufreq_policy *policy,
                 unsigned int cpu);
    int (*bios_limit)   (int cpu, unsigned int *limit);

    int (*exit)     (struct cpufreq_policy *policy);
    int (*suspend)  (struct cpufreq_policy *policy);
    int (*resume)   (struct cpufreq_policy *policy);
    struct freq_attr    **attr;
}

下面例子填充并实现cpufreq_driver结构体中这些必要成员。

static struct cpufreq_driver sunxi_cpufreq_driver = {
    .name   = "cpufreq-sunxi",
    .flags  = CPUFREQ_STICKY,
    .init   = sunxi_cpufreq_init,
    .verify = sunxi_cpufreq_verify,
    .target = sunxi_cpufreq_target,
    .get    = sunxi_cpufreq_get,
    .attr   = sunxi_cpufreq_attr,
};

先看一下init函数，init函数主要完成从device tree里获取对应的clock，regulator配置最大最小频率等。
device tree配置如下：

cpu@0 {
    device_type = "cpu";
    compatible = "arm,cortex-a53","arm,armv8";
    reg = <0x0 0x0>;
    enable-method = "psci";
    cpufreq_tbl = < 480000
            648000
            720000
            816000
            912000
            1008000
            1104000
            1152000
            1200000>;
    clock-latency = <2000000>;
    clock-frequency = <1008000000>;
    cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0 &SYS_SLEEP_0>;
};

Init函数如下：

static int __init sunxi_cpufreq_initcall(void)
{
    struct device_node *np;
    const struct property *prop;
    struct cpufreq_frequency_table *freq_tbl;
    const __be32 *val;
    int ret, cnt, i;

    np = of_find_node_by_path("/cpus/cpu@0");
    if (!np) {
        CPUFREQ_ERR("No cpu node found\n");
        return -ENODEV;
    }

    if (of_property_read_u32(np, "clock-latency",
                    &sunxi_cpufreq.transition_latency))
        sunxi_cpufreq.transition_latency = CPUFREQ_ETERNAL;

    prop = of_find_property(np, "cpufreq_tbl", NULL);
    if (!prop || !prop->value) {
        CPUFREQ_ERR("Invalid cpufreq_tbl\n");
        ret = -ENODEV;
        goto out_put_node;
    }

    cnt = prop->length / sizeof(u32);
    val = prop->value;

    freq_tbl = kmalloc(sizeof(*freq_tbl) * (cnt + 1), GFP_KERNEL);
    if (!freq_tbl) {
        ret = -ENOMEM;
        goto out_put_node;
    }

    for (i = 0; i < cnt; i++) {
        freq_tbl[i].index = i;
        freq_tbl[i].frequency = be32_to_cpup(val++);
    }

    freq_tbl[i].index = i;
    freq_tbl[i].frequency = CPUFREQ_TABLE_END;
    sunxi_cpufreq.freq_table = freq_tbl;

#ifdef CONFIG_DEBUG_FS
    sunxi_cpufreq.cpufreq_set_us = 0;
    sunxi_cpufreq.cpufreq_get_us = 0;
#endif

    sunxi_cpufreq.last_freq = ~0;

    sunxi_cpufreq.clk_pll = clk_get(NULL, PLL_CPU_CLK);
    if (IS_ERR_OR_NULL(sunxi_cpufreq.clk_pll)) {
        CPUFREQ_ERR("Unable to get PLL CPU clock\n");
        ret = PTR_ERR(sunxi_cpufreq.clk_pll);
        goto out_err_clk_pll;
    }

    sunxi_cpufreq.clk_cpu = clk_get(NULL, CPU_CLK);
    if (IS_ERR_OR_NULL(sunxi_cpufreq.clk_cpu)) {
        CPUFREQ_ERR("Unable to get CPU clock\n");
        ret = PTR_ERR(sunxi_cpufreq.clk_cpu);
        goto out_err_clk_cpu;
    }

    sunxi_cpufreq.vdd_cpu = regulator_get(NULL, CPU_VDD);
    if (IS_ERR_OR_NULL(sunxi_cpufreq.vdd_cpu)) {
        CPUFREQ_ERR("Unable to get CPU regulator\n");
        ret = PTR_ERR(sunxi_cpufreq.vdd_cpu);
        /* do not return error even if error*/
    }

    /* init cpu frequency from dt */
    ret = __init_freq_dt();
    if (ret == -ENODEV
#ifdef CONFIG_CPU_VOLTAGE_SCALING
        || ret == -EINVAL
#endif
    )
        goto out_err_dt;

    pr_debug("[cpufreq] max: %uMHz, min: %uMHz, ext: %uMHz, boot: %uMHz\n",
                sunxi_cpufreq.max_freq / 1000, sunxi_cpufreq.min_freq / 1000,
                sunxi_cpufreq.ext_freq / 1000, sunxi_cpufreq.boot_freq / 1000);

#ifdef CONFIG_CPU_VOLTAGE_SCALING
    __vftable_show();
    sunxi_cpufreq.last_vdd = sunxi_cpufreq_getvolt();
#endif

    mutex_init(&sunxi_cpufreq.lock);

    ret = cpufreq_register_driver(&sunxi_cpufreq_driver);
    if (ret) {
        CPUFREQ_ERR("failed register driver\n");
        goto out_err_register;
    } else {
        goto out_put_node;
    }

out_err_register:
    mutex_destroy(&sunxi_cpufreq.lock);
out_err_dt:
    if (!IS_ERR_OR_NULL(sunxi_cpufreq.vdd_cpu)) {
        regulator_put(sunxi_cpufreq.vdd_cpu);
    }
    clk_put(sunxi_cpufreq.clk_cpu);
out_err_clk_cpu:
    clk_put(sunxi_cpufreq.clk_pll);
out_err_clk_pll:
    kfree(freq_tbl);
out_put_node:
    of_node_put(np);

    return ret;
}

从上面可以看出，init函数主要的工作是从device tree中获取资源并配置最大最小频率等，然后注册一个cpufreq驱动。

下看看一下cpufreq_frequency_table_verify的实现，该函数主要是确保在policy->min和policy->max之间至少有一个有效
频率，并且所有其他的指标都符合。

static int sunxi_cpufreq_verify(struct cpufreq_policy *policy)
{
    return cpufreq_frequency_table_verify(policy, sunxi_cpufreq.freq_table);
}

get函数主要是获取当前cpu频率。

static unsigned int sunxi_cpufreq_get(unsigned int cpu)
{
    unsigned int current_freq = 0;
#ifdef CONFIG_DEBUG_FS
    ktime_t calltime = ktime_get();
#endif

    clk_get_rate(sunxi_cpufreq.clk_pll);
    current_freq = clk_get_rate(sunxi_cpufreq.clk_cpu) / 1000;

#ifdef CONFIG_DEBUG_FS
    sunxi_cpufreq.cpufreq_get_us = ktime_to_us(ktime_sub(ktime_get(), calltime));
#endif

    return current_freq;
}

target是实现调频调压的操作者。

static int sunxi_cpufreq_target(struct cpufreq_policy *policy,
                    __u32 freq, __u32 relation)
{
    int ret = 0;
    unsigned int            index;
    struct cpufreq_freqs    freqs;
#ifdef CONFIG_DEBUG_FS
    ktime_t calltime;
#endif
#ifdef CONFIG_SMP
    int i;
#endif
#ifdef CONFIG_CPU_VOLTAGE_SCALING
unsigned int new_vdd;
#endif

    mutex_lock(&sunxi_cpufreq.lock);

    /* avoid repeated calls which cause a needless amout of duplicated
     * logging output (and CPU time as the calculation process is
     * done) */
    if (freq == sunxi_cpufreq.last_freq)
        goto out;

    CPUFREQ_DBG(DEBUG_FREQ, "request frequency is %uKHz\n", freq);

    if (unlikely(sunxi_boot_lock))
        freq = freq > sunxi_cpufreq.boot_freq ? sunxi_cpufreq.boot_freq : freq;

    /* try to look for a valid frequency value from cpu frequency table */
    if (cpufreq_frequency_table_target(policy, sunxi_cpufreq.freq_table,
                    freq, relation, &index)) {
        CPUFREQ_ERR("try to look for %uKHz failed!\n", freq);
        ret = -EINVAL;
        goto out;
    }

    /* frequency is same as the value last set, need not adjust */
    if (sunxi_cpufreq.freq_table[index].frequency == sunxi_cpufreq.last_freq)
        goto out;

    freq = sunxi_cpufreq.freq_table[index].frequency;

    CPUFREQ_DBG(DEBUG_FREQ, "target is find: %uKHz, entry %u\n", freq, index);

    /* notify that cpu clock will be adjust if needed */
    if (policy) {
        freqs.cpu = policy->cpu;
        freqs.old = sunxi_cpufreq.last_freq;
        freqs.new = freq;

#ifdef CONFIG_SMP
        /* notifiers */
        for_each_cpu(i, policy->cpus) {
            freqs.cpu = i;
            cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
        }
#else
        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
#endif
    }

#ifdef CONFIG_CPU_VOLTAGE_SCALING
    /* get vdd value for new frequency */
    new_vdd = __get_vdd_value(freq * 1000);
    CPUFREQ_DBG(DEBUG_FREQ, "set cpu vdd to %dmv\n", new_vdd);
    if (!IS_ERR_OR_NULL(sunxi_cpufreq.vdd_cpu) && (new_vdd > sunxi_cpufreq.last_vdd)) {
        CPUFREQ_DBG(DEBUG_FREQ, "set cpu vdd to %dmv\n", new_vdd);
        if (regulator_set_voltage(sunxi_cpufreq.vdd_cpu, new_vdd*1000, new_vdd*1000)) {
            CPUFREQ_ERR("try to set cpu vdd failed!\n");

            /* notify everyone that clock transition finish */
            if (policy) {
                freqs.cpu = policy->cpu;;
                freqs.old = freqs.new;
                freqs.new = sunxi_cpufreq.last_freq;
#ifdef CONFIG_SMP
                /* notifiers */
                for_each_cpu(i, policy->cpus) {
                    freqs.cpu = i;
                    cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
                }
#else
                cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
#endif
            }
            return -EINVAL;
        }
    }
#endif

#ifdef CONFIG_DEBUG_FS
    calltime = ktime_get();
#endif

    /* try to set cpu frequency */
#ifndef CONFIG_SUNXI_ARISC
    if (__set_cpufreq_by_ccu(freq))
#else
    if (arisc_dvfs_set_cpufreq(freq, ARISC_DVFS_PLL1, ARISC_DVFS_SYN, NULL, NULL))
#endif
    {
        CPUFREQ_ERR("set cpu frequency to %uKHz failed!\n", freq);

#ifdef CONFIG_CPU_VOLTAGE_SCALING
        if (!IS_ERR_OR_NULL(sunxi_cpufreq.vdd_cpu) && (new_vdd > sunxi_cpufreq.last_vdd)) {
            if (regulator_set_voltage(sunxi_cpufreq.vdd_cpu,
                    sunxi_cpufreq.last_vdd*1000, sunxi_cpufreq.last_vdd*1000)) {
                CPUFREQ_ERR("try to set voltage failed!\n");
                sunxi_cpufreq.last_vdd = new_vdd;
            }
        }
#endif

        /* set cpu frequency failed */
        if (policy) {
            freqs.cpu = policy->cpu;
            freqs.old = freqs.new;
            freqs.new = sunxi_cpufreq.last_freq;

#ifdef CONFIG_SMP
            /* notifiers */
            for_each_cpu(i, policy->cpus) {
                freqs.cpu = i;
                cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
            }
#else
            cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
#endif
        }

        ret = -EINVAL;
        goto out;
    }

#ifdef CONFIG_DEBUG_FS
    sunxi_cpufreq.cpufreq_set_us = ktime_to_us(ktime_sub(ktime_get(), calltime));
#endif

#ifdef CONFIG_CPU_VOLTAGE_SCALING
    if(sunxi_cpufreq.vdd_cpu && (new_vdd < sunxi_cpufreq.last_vdd)) {
        CPUFREQ_DBG(DEBUG_FREQ, "set cpu vdd to %dmv\n", new_vdd);
        if(regulator_set_voltage(sunxi_cpufreq.vdd_cpu, new_vdd*1000, new_vdd*1000)) {
            CPUFREQ_ERR("try to set voltage failed!\n");
            new_vdd = sunxi_cpufreq.last_vdd;
        }
    }

    sunxi_cpufreq.last_vdd = new_vdd;
#endif

    /* notify that cpu clock will be adjust if needed */
    if (policy) {
#ifdef CONFIG_SMP
        for_each_cpu(i, policy->cpus) {
            freqs.cpu = i;
            cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
        }
#else
        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
#endif
    }

    sunxi_cpufreq.last_freq = freq;

    CPUFREQ_DBG(DEBUG_FREQ, "DVFS done! Freq[%uMHz] Volt[%umv] ok\n", \
            sunxi_cpufreq_get(0) / 1000, sunxi_cpufreq_getvolt());

out:
    mutex_unlock(&sunxi_cpufreq.lock);

    return ret;
}

代码比较较容易理解，这里不再分析，流程图如下：

CPUFreq governor层

上面提到过,governor的作用是根据系统的负载,检测系统的负载状况，然后根据当前的负载，选择出某个可供使用的工作频率，然后把该工作频率传递给cpufreq_driver，完成频率的动态调节。内核默认提供了5种governor供我们使用.
- Performance: 性能优先的governor，直接将cpu频率设置为policy->{min,max}中的最大值。一般会被选做默认的governor以节省系统启动时间,之后再切换.
- Powersave:功耗优先的governor，直接将cpu频率设置为policy->{min,max}中的最小值。
- Userspace: 由用户空间程序通过scaling_setspeed文件修改频率。一般用作调试。
- Ondemand：根据CPU的当前使用率，动态的调节CPU频率。
- interactive: 交互式动态调节CPU频率，与Ondemand类似，由谷歌开发并广泛使用于手机平板等设备上。本文主要讨论该governor。
我们看一下cpufreq_governor结构体：

struct cpufreq_governor {
    char    name[CPUFREQ_NAME_LEN]; //governor的名字，这里被赋值为interactive
    int initialized; //初始化标志位
    int (*governor) (struct cpufreq_policy *policy,
                 unsigned int event);  //这个calback用于控制governor的行为，比较重要，是governor的一个去切入点
    ssize_t (*show_setspeed)    (struct cpufreq_policy *policy,
                     char *buf);
    int (*store_setspeed)   (struct cpufreq_policy *policy,
                     unsigned int freq);
    unsigned int max_transition_latency; /* HW must be able to switch to
            next freq faster than this value in nano secs or we
            will fallback to performance governor */
    struct list_head    governor_list; //所有注册的governor都会被add到这个链表里面
    struct module       *owner;
};

定义一个governor如下：

struct cpufreq_governor cpufreq_gov_interactive = {
    .name = "interactive",
    .governor = cpufreq_governor_interactive,
    .max_transition_latency = 10000000,
    .owner = THIS_MODULE,
};

governor是这个结构的核心字段，cpufreq_governor注册后，cpufreq的核心层通过该字段操纵这个governor的行为，包括：初始化、启动、退出等工作。

• 一个governor如何被初始化的？
  当一个governor被policy选定后，核心层会通过 __ufreq_set_policy函数对该cpu的policy进行设定。如果policy认为这是一个新的governor（和原来使用的旧的governor不相同），policy会通过__cpufreq_governor函数，并传递CPUFREQ_GOV_POLICY_INIT参数，而__cpufreq_governor函数实际上是调用cpufreq_governor结构中的governor回调函数。
  下面是它收到CPUFREQ_GOV_POLICY_INIT参数时的代码片段：

    case CPUFREQ_GOV_POLICY_INIT:
        if (have_governor_per_policy()) {
            WARN_ON(tunables);
        } else if (tunables) {
            tunables->usage_count++;
            policy->governor_data = tunables;
            return 0;
        }

        tunables = kzalloc(sizeof(*tunables), GFP_KERNEL);
        if (!tunables) {
            pr_err("%s: POLICY_INIT: kzalloc failed\n", __func__);
            return -ENOMEM;
        }

        tunables->usage_count = 1;
        tunables->io_is_busy = true;
        tunables->above_hispeed_delay = default_above_hispeed_delay;
        tunables->nabove_hispeed_delay =
            ARRAY_SIZE(default_above_hispeed_delay);
        tunables->go_hispeed_load = DEFAULT_GO_HISPEED_LOAD;
        tunables->target_loads = default_target_loads;
        tunables->ntarget_loads = ARRAY_SIZE(default_target_loads);
        tunables->min_sample_time = DEFAULT_MIN_SAMPLE_TIME;
        tunables->timer_rate = DEFAULT_TIMER_RATE;
        tunables->boostpulse_duration_val = DEFAULT_MIN_SAMPLE_TIME;
        tunables->timer_slack_val = DEFAULT_TIMER_SLACK;

        spin_lock_init(&tunables->target_loads_lock);
        spin_lock_init(&tunables->above_hispeed_delay_lock);

        policy->governor_data = tunables;
        if (!have_governor_per_policy())
            common_tunables = tunables;

        rc = sysfs_create_group(get_governor_parent_kobj(policy),
                get_sysfs_attr());
        if (rc) {
            kfree(tunables);
            policy->governor_data = NULL;
            if (!have_governor_per_policy())
                common_tunables = NULL;
            return rc;
        }

        if (!policy->governor->initialized) {
            idle_notifier_register(&cpufreq_interactive_idle_nb);
            cpufreq_register_notifier(&cpufreq_notifier_block,
                    CPUFREQ_TRANSITION_NOTIFIER);
        }

#ifdef CONFIG_CPU_FREQ_INPUT_EVNT_NOTIFY
        if (!input_handler_register_count) {
            cpumask_clear(&interactive_cpumask);
            rc = input_register_handler(
                    &cpufreq_interactive_input_handler);
            if (rc)
                return rc;
        }

        tunables->input_event_freq = policy->max *
                DEFAULT_INPUT_EVENT_FRFQ_PERCENT / 100;
        tunables->input_dev_monitor = true;
        input_handler_register_count++;
#endif

        break;

时序图如下：

经过sysfs_create_group后在/sys/devices/system/cpu/cpufreq/interactive建立了对应的sys节点，节点主要包括：

boost: interactive对突发任务的处理。
boostpulse：对突发任务的处理频率上升后持续的时间
go_hispeed_load：高频阈值。当系统的负载超过该值，升频，否则降频。
hispeed_freq: 当workload达到 go_hispeed_load时，频率将被拉高到这个值
input_boost：对input事件，如触屏等突发处理
min_sample_time:最小采样时间。每次调频结果必须维持至少这个时间。
timer_rate: 采样定时器的采样率。

当CPU不处于idel状态时，timer_rate作为采样速率来计算CPU的workload. 当CPU处于idel状态，此时使用一个可延时定时器，会导致CPU不能从idel状态苏醒来响应定时器. 定时器的最大的可延时时间用timer_slack表示，默认值80000 uS.
- 一个governor如何被启动的？
类似governor初始化，event CPUFREQ_GOV_START被调用：

    case CPUFREQ_GOV_START:
        mutex_lock(&gov_lock);

        freq_table = cpufreq_frequency_get_table(policy->cpu);
        //如果没有设置hispeed_freq的值的话，就设置hispeed_freq为policy->max
        if (!tunables->hispeed_freq)
            tunables->hispeed_freq = policy->max;
        //遍历所有处于online状态的CPU
        for_each_cpu(j, policy->cpus) {
            pcpu = &per_cpu(cpuinfo, j);
            pcpu->policy = policy;
            pcpu->target_freq = policy->cur;
            pcpu->freq_table = freq_table;
            pcpu->floor_freq = pcpu->target_freq;
            pcpu->floor_validate_time =
                ktime_to_us(ktime_get());
            pcpu->hispeed_validate_time =
                pcpu->floor_validate_time;
            pcpu->max_freq = policy->max;
            down_write(&pcpu->enable_sem);
            del_timer_sync(&pcpu->cpu_timer);
            del_timer_sync(&pcpu->cpu_slack_timer);
            //启动相关的定时器 
            cpufreq_interactive_timer_start(tunables, j);
            //启动定时器以后governor就可以工作了，所以设置pcpu->governor_enabled为1
            pcpu->governor_enabled = 1;
            up_write(&pcpu->enable_sem);
        }

        mutex_unlock(&gov_lock);
        break;

现在，governor 字段被设置为cpufreq_governor_interactive，我们看看它的实现：

static int cpufreq_governor_interactive(struct cpufreq_policy *policy,
        unsigned int event)
{
    int rc;
    unsigned int j;
    struct cpufreq_interactive_cpuinfo *pcpu;
    struct cpufreq_frequency_table *freq_table;
    struct cpufreq_interactive_tunables *tunables;
    unsigned long flags;

    if (have_governor_per_policy())
        tunables = policy->governor_data;
    else
        tunables = common_tunables;

    WARN_ON(!tunables && (event != CPUFREQ_GOV_POLICY_INIT));

    switch (event) {
    case CPUFREQ_GOV_POLICY_INIT:
        if (have_governor_per_policy()) {
            WARN_ON(tunables);
        } else if (tunables) {
            tunables->usage_count++;
            policy->governor_data = tunables;
            return 0;
        }

        tunables = kzalloc(sizeof(*tunables), GFP_KERNEL);
        if (!tunables) {
            pr_err("%s: POLICY_INIT: kzalloc failed\n", __func__);
            return -ENOMEM;
        }

        tunables->usage_count = 1;
        tunables->io_is_busy = true;
        tunables->above_hispeed_delay = default_above_hispeed_delay;
        tunables->nabove_hispeed_delay =
            ARRAY_SIZE(default_above_hispeed_delay);
        tunables->go_hispeed_load = DEFAULT_GO_HISPEED_LOAD;
        tunables->target_loads = default_target_loads;
        tunables->ntarget_loads = ARRAY_SIZE(default_target_loads);
        tunables->min_sample_time = DEFAULT_MIN_SAMPLE_TIME;
        tunables->timer_rate = DEFAULT_TIMER_RATE;
        tunables->boostpulse_duration_val = DEFAULT_MIN_SAMPLE_TIME;
        tunables->timer_slack_val = DEFAULT_TIMER_SLACK;

        spin_lock_init(&tunables->target_loads_lock);
        spin_lock_init(&tunables->above_hispeed_delay_lock);

        policy->governor_data = tunables;
        if (!have_governor_per_policy())
            common_tunables = tunables;

        rc = sysfs_create_group(get_governor_parent_kobj(policy),
                get_sysfs_attr());
        if (rc) {
            kfree(tunables);
            policy->governor_data = NULL;
            if (!have_governor_per_policy())
                common_tunables = NULL;
            return rc;
        }

        if (!policy->governor->initialized) {
            idle_notifier_register(&cpufreq_interactive_idle_nb);
            cpufreq_register_notifier(&cpufreq_notifier_block,
                    CPUFREQ_TRANSITION_NOTIFIER);
        }

#ifdef CONFIG_CPU_FREQ_INPUT_EVNT_NOTIFY
        if (!input_handler_register_count) {
            cpumask_clear(&interactive_cpumask);
            rc = input_register_handler(
                    &cpufreq_interactive_input_handler);
            if (rc)
                return rc;
        }

        tunables->input_event_freq = policy->max *
                DEFAULT_INPUT_EVENT_FRFQ_PERCENT / 100;
        tunables->input_dev_monitor = true;
        input_handler_register_count++;
#endif

        break;

    case CPUFREQ_GOV_POLICY_EXIT:
        if (!--tunables->usage_count) {
            if (policy->governor->initialized == 1) {
                cpufreq_unregister_notifier(&cpufreq_notifier_block,
                        CPUFREQ_TRANSITION_NOTIFIER);
                idle_notifier_unregister(&cpufreq_interactive_idle_nb);
            }

            sysfs_remove_group(get_governor_parent_kobj(policy),
                    get_sysfs_attr());
            kfree(tunables);
            common_tunables = NULL;
        }

#ifdef CONFIG_CPU_FREQ_INPUT_EVNT_NOTIFY
        if (input_handler_register_count > 0)
            input_handler_register_count--;
        if (!input_handler_register_count) {
            cpumask_clear(&interactive_cpumask);
            input_unregister_handler(&cpufreq_interactive_input_handler);
        }
#endif

        policy->governor_data = NULL;
        break;

    case CPUFREQ_GOV_START:
        mutex_lock(&gov_lock);

        freq_table = cpufreq_frequency_get_table(policy->cpu);
        if (!tunables->hispeed_freq)
            tunables->hispeed_freq = policy->max;

        for_each_cpu(j, policy->cpus) {
            pcpu = &per_cpu(cpuinfo, j);
            pcpu->policy = policy;
            pcpu->target_freq = policy->cur;
            pcpu->freq_table = freq_table;
            pcpu->floor_freq = pcpu->target_freq;
            pcpu->floor_validate_time =
                ktime_to_us(ktime_get());
            pcpu->hispeed_validate_time =
                pcpu->floor_validate_time;
            pcpu->max_freq = policy->max;
            down_write(&pcpu->enable_sem);
            del_timer_sync(&pcpu->cpu_timer);
            del_timer_sync(&pcpu->cpu_slack_timer);
            cpufreq_interactive_timer_start(tunables, j);
            pcpu->governor_enabled = 1;
            up_write(&pcpu->enable_sem);
        }

#ifdef CONFIG_CPU_FREQ_INPUT_EVNT_NOTIFY
        cpumask_or(&interactive_cpumask, &interactive_cpumask, policy->cpus);
#endif

        mutex_unlock(&gov_lock);
        break;

    case CPUFREQ_GOV_STOP:
        mutex_lock(&gov_lock);
        for_each_cpu(j, policy->cpus) {
            pcpu = &per_cpu(cpuinfo, j);
            down_write(&pcpu->enable_sem);
            pcpu->governor_enabled = 0;
            del_timer_sync(&pcpu->cpu_timer);
            del_timer_sync(&pcpu->cpu_slack_timer);
            up_write(&pcpu->enable_sem);
        }

#ifdef CONFIG_CPU_FREQ_INPUT_EVNT_NOTIFY
        cpumask_andnot(&interactive_cpumask, &interactive_cpumask, policy->cpus);
#endif

        mutex_unlock(&gov_lock);
        break;

    case CPUFREQ_GOV_LIMITS:
        if (policy->max < policy->cur)
            __cpufreq_driver_target(policy,
                    policy->max, CPUFREQ_RELATION_H);
        else if (policy->min > policy->cur)
            __cpufreq_driver_target(policy,
                    policy->min, CPUFREQ_RELATION_L);
        for_each_cpu(j, policy->cpus) {
            pcpu = &per_cpu(cpuinfo, j);

            down_read(&pcpu->enable_sem);
            if (pcpu->governor_enabled == 0) {
                up_read(&pcpu->enable_sem);
                continue;
            }

            spin_lock_irqsave(&pcpu->target_freq_lock, flags);
            if (policy->max < pcpu->target_freq)
                pcpu->target_freq = policy->max;
            else if (policy->min > pcpu->target_freq)
                pcpu->target_freq = policy->min;

            spin_unlock_irqrestore(&pcpu->target_freq_lock, flags);
            up_read(&pcpu->enable_sem);

            /* Reschedule timer only if policy->max is raised.
             * Delete the timers, else the timer callback may
             * return without re-arm the timer when failed
             * acquire the semaphore. This race may cause timer
             * stopped unexpectedly.
             */

            if (policy->max > pcpu->max_freq) {
                down_write(&pcpu->enable_sem);
                del_timer_sync(&pcpu->cpu_timer);
                del_timer_sync(&pcpu->cpu_slack_timer);
                cpufreq_interactive_timer_start(tunables, j);
                up_write(&pcpu->enable_sem);
            }

            pcpu->max_freq = policy->max;
        }
        break;
    }
    return 0;
}

该函数主要初始化两个定时器，cpufreq_interactive_timer和cpufreq_interactive_nop_timer。
关键在于cpufreq_interactive_timer定时器的实现。