Linux cpufreq framework(2)_cpufreq driver

最新推荐文章于 2024-12-11 00:08:51 发布

转载最新推荐文章于 2024-12-11 00:08:51 发布 · 927 阅读

文章标签：

#内核 #cpu

Linux内核转载专栏收录该内容

57 篇文章

订阅专栏

本文从平台驱动工程师的角度出发，详细介绍了如何为特定平台编写cpufreq驱动。内容覆盖了驱动的编写步骤、关键API及功能分析，包括频率表的定义、cpufreq_driver结构体的解析及其回调函数的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 前言

本文从平台驱动工程师的角度，介绍怎么编写cpufreq驱动。

注1：本文基于linux-3.18-rc4内核，其它版本内核可能会稍有不同。

2. cpufreq driver的编写步骤

cpufreq driver主要完成平台相关的CPU频率/电压的控制，它在cpufreq framework中是非常简单的一个模块，编写步骤包括：

1）平台相关的初始化动作，包括CPU core的clock/regulator获取、初始化等。

2）生成frequency table，即CPU core所支持的频率/电压列表。并在初始化时将该table保存在policy中。

3）定义一个struct cpufreq_driver变量，填充必要的字段，并根据平台的特性，实现其中的回调函数。

4）调用cpufreq_register_driver将driver注册到cpufreq framework中。

5）cpufreq core会在CPU设备添加时，调用driver的init接口。driver需要在该接口中初始化struct cpufreq_policy变量。

6）系统运行过程中，cpufreq core会根据实际情况，调用driver的setpolicy或者target/target_index等接口，设置CPU的调频策略或者频率值。

7）系统suspend的时中，会将CPU的频率设置为指定的值，或者调用driver的suspend回调函数；系统resume时，调用driver的resume回调函数。

具体请参考后面的分析。

3. cpufreq driver有关的API即功能分析

3.1 frequency table

frequency table是CPU core可以正确运行的一组频率/电压组合，一般情况下，会在项目启动的初期，通过“try频点”的方法，确定出稳定性、通用性都符合要求的频点。

frequency table之所以存在的一个思考点是：table是频率和电压之间的一个一一对应的组合，因此cpufreq framework只需要关心频率，所有的策略都称做“调频”策略。而cpufreq driver可以在“调频”的同时，通过table取出和频率对应的电压，进行修改CPU core电压，实现“调压”的功能。这简化了设计。

cpufreq framework以cpufreq_frequency_table抽象frequency table，如下：

 
/* Special Values of .frequency field */ 
#define CPUFREQ_ENTRY_INVALID   ~0u 
#define CPUFREQ_TABLE_END       ~1u 
/* Special Values of .flags field */ 
#define CPUFREQ_BOOST_FREQ      (1 << 0) 
   
struct cpufreq_frequency_table { 
        unsigned int    flags; 
        unsigned int    driver_data; /* driver specific data, not used by core */ 
        unsigned int    frequency; /* kHz - doesn't need to be in ascending 
                                    * order */ 
}; 
 

frequency，频率值，单位为kHz，不需要特别的排序。这里定义了两个特殊的频率值：CPUFREQ_ENTRY_INVALID，用来表示table中的一个无效频率值；CPUFREQ_TABLE_END，用于表示table的结束。

driver_data，由名字就可以知道，这个字段由driver使用，具体意义由driver定义，可以是电压，也可以是其它（如OPP index，后续文章会详细描述）。

flags，现在只有一个----CPUFREQ_BOOST_FREQ，表示这个频率值是一个boost频率。

注2：Boost表示智能超频技术，是一个在x86平台上的功能，具体可参考“turbo-boost-technology.html”，本文不做过多描述。

假设CPU device的OPP 列表已经由cpu subsystem driver调用of_init_opp_table解析出来了，cpufreq driver可以借助dev_pm_opp_init_cpufreq_table将OPP列表转换为frequency table。

of_init_opp_table接口请参考“Linux电源管理(15)_PM OPP Interface”，dev_pm_opp_init_cpufreq_table接口的声明如下：

 
/* include/linux/cpufreq.h */ 
int dev_pm_opp_init_cpufreq_table(struct device *dev, 
                                  struct cpufreq_frequency_table **table); 
 

该接口的逻辑很简单，根据传入的设备指针，遍历OPP列表，转换为frequency table，并通过table返回给调用者。具体请参考后面的文章。

3.2 struct cpufreq_driver

struct cpufreq_driver是cpufreq driver的核心数据结构，我们在“linux cpufreq framework(1)_概述”中有简单介绍过，这里再详细分析一下：

 
struct cpufreq_driver { 
    char            name[CPUFREQ_NAME_LEN]; 
    u8            flags; 
    void            *driver_data; 
   
    /* needed by all drivers */ 
    int    (*init)        (struct cpufreq_policy *policy); 
    int    (*verify)    (struct cpufreq_policy *policy); 
   
    /* define one out of two */ 
    int    (*setpolicy)    (struct cpufreq_policy *policy); 
   
    /* 
     * On failure, should always restore frequency to policy->restore_freq 
     * (i.e. old freq). 
     */ 
    int    (*target)    (struct cpufreq_policy *policy,    /* Deprecated */ 
                 unsigned int target_freq, 
                 unsigned int relation); 
    int    (*target_index)    (struct cpufreq_policy *policy, 
                 unsigned int index); 
    /* 
     * Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION 
     * unset. 
     * 
     * get_intermediate should return a stable intermediate frequency 
     * platform wants to switch to and target_intermediate() should set CPU 
     * to to that frequency, before jumping to the frequency corresponding 
     * to 'index'. Core will take care of sending notifications and driver 
     * doesn't have to handle them in target_intermediate() or 
     * target_index(). 
     * 
     * Drivers can return '0' from get_intermediate() in case they don't 
     * wish to switch to intermediate frequency for some target frequency. 
     * In that case core will directly call ->target_index(). 
     */ 
    unsigned int (*get_intermediate)(struct cpufreq_policy *policy, 
                     unsigned int index); 
    int    (*target_intermediate)(struct cpufreq_policy *policy, 
                       unsigned int index); 
   
    /* should be defined, if possible */ 
    unsigned int    (*get)    (unsigned int cpu); 
   
    /* optional */ 
    int    (*bios_limit)    (int cpu, unsigned int *limit); 
   
    int    (*exit)        (struct cpufreq_policy *policy); 
    void    (*stop_cpu)    (struct cpufreq_policy *policy); 
    int    (*suspend)    (struct cpufreq_policy *policy); 
    int    (*resume)    (struct cpufreq_policy *policy); 
    struct freq_attr    **attr; 
   
    /* platform specific boost support code */ 
    bool                    boost_supported; 
    bool                    boost_enabled; 
    int     (*set_boost)    (int state); 
}; 
 

1）init回调函数

init回调函数是cpufreq driver的入口，由cpufreq core在CPU device添加之后调用，其主要功能就是初始化policy变量（把它想象成cpufreq device）。

对driver而言，不需要太关心struct cpufreq_policy的内部实现（其实cpufreq framework也在努力实现这个目标，包括将相应的初始化过程封装成一个API等），为了分析方便，我们再把这个结构贴一次：

 
struct cpufreq_cpuinfo { 
    unsigned int        max_freq; 
    unsigned int        min_freq; 
   
    /* in 10^(-9) s = nanoseconds */ 
    unsigned int        transition_latency; 
}; 
   
struct cpufreq_real_policy { 
    unsigned int        min;    /* in kHz */ 
    unsigned int        max;    /* in kHz */ 
    unsigned int        policy; /* see above */ 
    struct cpufreq_governor    *governor; /* see below */ 
}; 
   
struct cpufreq_policy { 
    /* CPUs sharing clock, require sw coordination */ 
    cpumask_var_t        cpus;    /* Online CPUs only */ 
    cpumask_var_t        related_cpus; /* Online + Offline CPUs */ 
   
    unsigned int        shared_type; /* ACPI: ANY or ALL affected CPUs 
                        should set cpufreq */ 
    unsigned int        cpu;    /* cpu nr of CPU managing this policy */ 
    unsigned int        last_cpu; /* cpu nr of previous CPU that managed 
                       * this policy */ 
    struct clk        *clk; 
    struct cpufreq_cpuinfo    cpuinfo;/* see above */ 
   
    unsigned int        min;    /* in kHz */ 
    unsigned int        max;    /* in kHz */ 
    unsigned int        cur;    /* in kHz, only needed if cpufreq 
                     * governors are used */ 
    unsigned int        restore_freq; /* = policy->cur before transition */ 
    unsigned int        suspend_freq; /* freq to set during suspend */ 
   
    unsigned int        policy; /* see above */ 
    struct cpufreq_governor    *governor; /* see below */ 
    void            *governor_data; 
    bool            governor_enabled; /* governor start/stop flag */ 
   
    struct work_struct    update; /* if update_policy() needs to be 
                     * called, but you're in IRQ context */ 
   
    struct cpufreq_real_policy    user_policy; 
    struct cpufreq_frequency_table    *freq_table; 
   
    struct list_head        policy_list; 
    struct kobject        kobj; 
    struct completion    kobj_unregister; 
   
    /* 
     * The rules for this semaphore: 
     * - Any routine that wants to read from the policy structure will 
     *   do a down_read on this semaphore. 
     * - Any routine that will write to the policy structure and/or may take away 
     *   the policy altogether (eg. CPU hotplug), will hold this lock in write 
     *   mode before doing so. 
     * 
     * Additional rules: 
     * - Lock should not be held across 
     *     __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT); 
     */ 
    struct rw_semaphore    rwsem; 
   
    /* Synchronization for frequency transitions */ 
    bool            transition_ongoing; /* Tracks transition status */ 
    spinlock_t        transition_lock; 
    wait_queue_head_t    transition_wait; 
    struct task_struct    *transition_task; /* Task which is doing the transition */ 
   
    /* For cpufreq driver's internal use */ 
    void            *driver_data; 
}; 
 

对driver而言，需要在init中初始化policy的如下内容：

cpus，告诉cpufreq core，该policy适用于哪些cpu。大多数情况下，系统中所有的cpu core都由相同的硬件逻辑，统一控制cpu frequency，因此只需要一个policy，就可以管理所有的cpu core。“linux cpufreq framework(3)_cpufreq core”中会重点介绍。

clk，clock指针，cpufreq core可以利用该指针，获取当前实际的frequency值。

cpuinfo，该cpu调频相关的固定信息，包括最大频率、最小频率、切换延迟，其中最大频率、最小频率可以通过frequency table推导得出。

min、max，调频策略所对应的最小频率、最大频率，初始化时，可以和上面的cpuinfo中的min、max相同。

freq_table，所对应的frequency table。

除了clk指针外，cpuinfo、min、max、freq_table等都可以通过cpufreq_generic_init接口初始化：

 
int cpufreq_generic_init(struct cpufreq_policy *policy, 
                struct cpufreq_frequency_table *table, 
                unsigned int transition_latency); 
 

该接口以需要初始化的policy、frequency table以及切换延迟为参数，从table中解析policy初始化所需的信息，初始化该policy。

一般情况下，该接口是enough的，因此在init中调用它即可。

2）verify回调函数

当上层软件需要设定一个新的policy的时候，会调用driver的verify回调函数，检查该policy是否合法。cpufreq core封装了下面两个接口，辅助完成这个功能：

 
int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, 
                                   struct cpufreq_frequency_table *table); 
int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy); 
 

cpufreq_frequency_table_verify根据指定的frequency table，检查policy是否合法，检查逻辑很简单：policy的频率范围{min,max}，是否超出policy->cpuinfo的频率范围，是否超出frequency table中的频率范围。

cpufreq_generic_frequency_table_verify更简单，它以policy中保存的frequency table为参数（policy->freq_table），调用cpufreq_frequency_table_verify接口。

注3：在这里先提一下cpufreq framework中“频率”的几个层次。
最底层，是frequency table中定义的频率，有限的离散频率，代表了cpu的调频能力。
往上，是policy->cpuinfo中的频率范围，它对cpu调频进行的简单的限制，该限制可以和frequency table一致，也可以小于table中的范围。必须在driver初始化时给定，之后不能再修改。
再往上，是policy的频率范围，代表调频策略。对于可以自动调频的CPU，只需要把这个范围告知CPU即可，此时它是调频的基本单位。对于不可以自动调频的CPU，它是软件层面的一个限制。该范围也可以通过sysfs修改。
最上面，是policy中的频率值，对那些不可以调频的CPU，该值就是CPU的运行频率。

3）setpolicy回调函数

对于可以自动调频的CPU，driver需要提供该接口，通过该接口，将调频范围告知CPU。

4）target回调函数，不建议使用了，就不讲了。

5）target_index回调函数

对于不可以自动调频的CPU，该接口用于指定CPU的运行频率。index表示frequency table中的index。

driver需要通过index，将频率值取出，通过clock framework提供的API，将CPU的频率设置为对应的值。

同时，driver可以调用OPP interface，获取该频率对应的电压值，通过regulator framework提供的API，将CPU的电压设置为对应的值。

6）get_intermediate、target_intermediate，在没有提供target接口的时候使用，希望看这篇文章对的工程师不要使用。不详细介绍了。

7）get回调函数

用于获取指定cpu的频率值，如果可以的话，driver应尽可能提供。如果在init接口中给policy->clk赋值的话，则可以使用cpufreq framework提供的通用接口：

 
unsigned int cpufreq_generic_get(unsigned int cpu); 
 

该接口会直接调用clock framework API，从policy->clk中获取频率值。

8）exit，和init对应，在CPU device被remove时调用。

9）stop_cpu，在CPU被stop时调用。

10）suspend、resume回调函数

系统给suspend的时候，clock、regulator等driver有可能被suspend，因此需要在这之前将CPU设置为一个确定的频率值。driver可以通过suspend回调设置，也可以通过policy中的suspend_freq字段设置（cpufreq core会自动切换）。

同理，系统resume后，CPU的运行频率是什么，可以通过resume回调设置，也可以通过policy中的restore_freq字段设置。

11）freq_attr

如果cpufreq driver需要提供一些额外的sysfs attribute，可以通过如下的attribute宏设置，然后保存在cpufreq_driver的attr数组中：

 
struct freq_attr { 
        struct attribute attr; 
        ssize_t (*show)(struct cpufreq_policy *, char *); 
        ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count); 
}; 
   
#define cpufreq_freq_attr_ro(_name)             \ 
static struct freq_attr _name =                 \ 
__ATTR(_name, 0444, show_##_name, NULL) 
   
#define cpufreq_freq_attr_ro_perm(_name, _perm) \ 
static struct freq_attr _name =                 \ 
__ATTR(_name, _perm, show_##_name, NULL) 
   
#define cpufreq_freq_attr_rw(_name)             \ 
static struct freq_attr _name =                 \ 
__ATTR(_name, 0644, show_##_name, store_##_name) 
 

3.3 cpufreq_driver flags

注册cpufreq driver时，可以通过flag字段指定一些特性，包括：

 
/* flags */ 
#define CPUFREQ_STICKY          (1 << 0)        /* driver isn't removed even if 
                                                   all ->init() calls failed */ 
#define CPUFREQ_CONST_LOOPS     (1 << 1)        /* loops_per_jiffy or other 
                                                   kernel "constants" aren't 
                                                   affected by frequency 
                                                   transitions */ 
#define CPUFREQ_PM_NO_WARN      (1 << 2)        /* don't warn on suspend/resume 
                                                   speed mismatches */ 
   
/* 
 * This should be set by platforms having multiple clock-domains, i.e. 
 * supporting multiple policies. With this sysfs directories of governor would 
 * be created in cpu/cpu/cpufreq/ directory and so they can use the same 
 * governor with different tunables for different clusters. 
 */ 
#define CPUFREQ_HAVE_GOVERNOR_PER_POLICY (1 << 3) 
   
/* 
 * Driver will do POSTCHANGE notifications from outside of their ->target() 
 * routine and so must set cpufreq_driver->flags with this flag, so that core 
 * can handle them specially. 
 */ 
#define CPUFREQ_ASYNC_NOTIFICATION  (1 << 4) 
   
/* 
 * Set by drivers which want cpufreq core to check if CPU is running at a 
 * frequency present in freq-table exposed by the driver. For these drivers if 
 * CPU is found running at an out of table freq, we will try to set it to a freq 
 * from the table. And if that fails, we will stop further boot process by 
 * issuing a BUG_ON(). 
 */ 
#define CPUFREQ_NEED_INITIAL_FREQ_CHECK (1 << 5) 
 

CPUFREQ_STICKY，表示就算所有的init调用都失败了，driver也不被remove。具体应用场景不明。

CPUFREQ_CONST_LOOPS，表示频率的调整，不影响loops_per_jiffy等kernel常来的计算。

CPUFREQ_PM_NO_WARN，suspend/resume过程相关的flag，后面文章如果分析相应的功能的话，再详细描述。

CPUFREQ_HAVE_GOVERNOR_PER_POLICY，表示不同的CPU，有不同的频率控制方式，因此cpufreq core会为每一个CPU创建一个cpufreq调频接口。否则（也是正常情况下），一个调频接口可以调整所有CPU的频率。

其它flag用到时再分析。

3.4 cpufreq_register_driver

driver的注册接口比较简单，进行一些必要的检查后，将driver保存在一个全局指针（cpufreq_driver）中，如果该指针不为空，则说明已经有driver注册过了，返回错误（-EEXIST）。

最后，会调用subsys_interface_register接口，注册一个subsystem interface（struct subsys_interface cpufreq_interface），有关subsystem interface的介绍，可参考“Linux设备模型(6)_Bus”中的描述。cpufreq与此有关的逻辑，会在下一篇文章详细说明（linux cpufreq framework(3)_cpufreq core）。

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