devfreq 内核框架介绍【转】

转自:https://blog.csdn.net/weixin_39059738/article/details/104260671

目录

一 应用背景

二 软件框架介绍

三 API和用户接口

3.1 device注册接口介绍

3.2 governor使用接口介绍

3.2.1 governor注册接口

3.2.2 governor调频接口

3.2.3 monitor机制接口

3.3 用户层接口

四 编程模板

4.1 dts配置

4.1.1 定义工作性能表:

4.1.2 引用工作性能表:

4.2 底层driver实现

4.2.1 底层driver需要实现的回调函数

4.2.2 probe时注册devfreq框架

4.3 governor的注册

4.3.1 governor需要实现的回调函数

4.3.2 governor向devfreq的注册

五 框架分析

5.1 devfreq框架初始化

5.2 对device的管理

一 应用背景
对于可以调频的设备,我们可以通过在不同场景和需求下调节设备的频率,可以达到节省功耗的目的。CPU有单独的cpufreq框架来控制和管理其频率,但是不兼容普通的设备。对于普通设备,我们可以通过devfreq 框架来方便地实现调频操作。

二 软件框架介绍
devfreq框架存在的意义,是为了将调频逻辑的公共部分,比如数据结构,调频方法等抽象出来,减少重复代码的产生,方便驱动工程师实现设备的调频操作。

我们这里将有调频需求的设备称为device_freq,以便后续的讨论。有了devfreq框架,驱动工程师只需要按照devfreq框架提供的函数原型,实现具体设备的具体调频操作,同时选取合适的governor,并将device_freq和底层调频方法一同注册进devfreq框架,就能够实现调频。

这里的governor ,其实指的是不同的调频策略。所谓的调频策略,包括什么时候对设备进行调频,以及将设备的频率调整到多大。不同的设备,有不同的调频策略,因此devfreq将设备的调频策略抽象出来,以供设备选择。具体的设备也可以根据自己的需求,实现自己的governor,并注册进devfreq框架。以内核提供的最简单的userspace_governor为例 ,其调频策略就很简单——调频的时机是当用户通过给定的文件节点输入目标频率F时,就执行调频操作;且将设备的频率调整为F。

以上提到的两个概念,device_freq和 governor,是devfreq框架的两个核心主题,这里做一个总结:

1. device_freq,是需要调频的设备,需要通过devfreq框架提供的接口进行注册;

2. governor,是具体的调频策略,也需要通过devfreq框架提供的接口进行注册;governor可由用户自己实现,也可以选用内核已有的governor。

整体上,devfreq的软件框架如下所示:

 

 

 

上图中,devfreq框架内部维护了两个链表,一个链表Governor_list是用于管理系统中所有注册进来的governor,还有一个devfreq_list 是用于管理系统中所有的可调频的设备device_freq。

一个拥有opp_table的可调频设备,需要实现自己的调频函数(图中的xxx_devfreq_profile),再通过devfreq提供的接口(devm_devfreq_add_device)来注册进devfreq框架。在注册时,device_freq会指定自己的governor,devfreq框架负责将device_freq和governor进行匹配 。

用户可以实现自己的governor,并通过接口(devfreq_add_governor)注册进devfreq框架。

三 API和用户接口
3.1 device注册接口介绍
device_freq通过接口devm_devfreq_add_device注册进devfreq框架:该接口的定义如下所示:

struct devfreq *devm_devfreq_add_device(struct device *dev,
struct devfreq_dev_profile *profile,
const char *governor_name,
void *data);
设备在调用该函数时,device_freq需要传递四个参数:

1. @dev:设备的device结构体

2. @governor_name:调频设备必须指定一个governor,因为没有governor就无法实现调频。device_freq注册时,devfreq框架会根据该字段自动寻找匹配的governor ,将二者关联。

3. @data:该字段用于governor和device_freq之间传递信息,由用户自己定义,框架并不关心这个数据。

4. @profile: 该profile是一个结构体,类似于去银行注册银行卡时填写的信息表,定义如下(讲解见注释):

struct devfreq_dev_profile {
/* 在注册时,设备初始的工作频率,必须 */
unsigned long initial_freq;
/*
* 当governor启动monitor机制时,monitor会每隔一定的时间更新设备的频率,这个位段就指定了该
* 时间间隔。当该值为0时,表示不启用monitor机制。
*/
unsigned int polling_ms;
/* 底层设备的调频函数,设备必须自己实现该函数,并在注册时通过该结构体提供给框架 */
int (*target)(struct device *dev, unsigned long *freq, u32 flags);
/* 该函数目前很少被用到,可以不实现 */
int (*get_dev_status)(struct device *dev,
¦ ¦ struct devfreq_dev_status *stat);
/* 底层设备的获取当前设备频率的函数,设备必须自己实现该函数,并提供给框架 */
int (*get_cur_freq)(struct device *dev, unsigned long *freq);
/* 可选的退出函数,当devfreq设备发生错误时,框架会回调该函数。一般不需要实现。 */
void (*exit)(struct device *dev);
/*
* 设备支持的频点表。如果已经在dts中引用了opp_table,并通过dev_pm_opp_of_add_table
* 关联到opp_table,以下两个字段会由devfreq自动填入。
*/
unsigned long *freq_table;
/* 该设备最多支持的频点数 */
unsigned int max_state;
};

可见,该profile结构体包含了device_freq设备在注册进devfreq框架时需要填写的所有信息,其中必须提供的信息包括:

初始频率initial_freq;
设备调频函数target
设备当前频率的获取函数get_cur_freq
另外,devfreq框架需要知道设备支持的所有频点。因此可以在profile中将freq_table和max_state填写,注册的时候由devfreq框架读取;但是更加规范的方法是在dts中引用一个opp_table,然后在设备注册进devfreq框架前,调用dev_pm_opp_of_add_table将设备和opp_table相关联;这样,devfreq框架会自动读取设备的opp_table,将信息整合,代替freq_table和 max_state字段。

3.2 governor使用接口介绍
3.2.1 governor注册接口
governor的注册接口比较简单:

int devfreq_add_governor(struct devfreq_governor *governor);
这里,重点关注传参类型struct devfreq_governor:

struct devfreq_governor {
struct list_head node;

const char name[DEVFREQ_NAME_LEN];
const unsigned int immutable;
int (*get_target_freq)(struct devfreq *this, unsigned long *freq);
int (*event_handler)(struct devfreq *devfreq,
unsigned int event, void *data);
};
governor结构体由以下几个部分组成:

节点node,用于加入全局链表governor_list
governor的名字,用于在device注册进来时进行匹配
immutable 标志位,当置为1时,表示使用该governor的设备不可以动态更换其他的governor
get_target_freq回调函数,是具体的调频策略实现,用于给出某个时间点设备的目标调节频率,也是整个governor的核心操作之一。
event_handler回调函数,用于处理框架发送给governor的事件。典型的事件包括:DEVFREQ_GOV_START,DEVFREQ_GOV_STOP等。例如,当有设备注册进框架,并匹配到该governor时,devfreq框架调用该函数,并传递DEVFREQ_GOV_START事件类型。
3.2.2 governor调频接口
前面提到,governor负责具体的调频策略,也就是说,何时进行调频也是governor决定的。比如,userspace_governor的策略,就是当用户通过文件节点输入设备频率时,开始进行调频操作。governor可通过调用以下接口进行调频:

int update_devfreq(struct devfreq *devfreq);
第一眼看到这个函数或许会有疑惑,为什么传参里面没有出现目标频率这个参数?调用完这个函数,设备的频率会变成多少?事实上,该函数内部会先调用governor->get_target_freq 回调函数获取governor推荐的目标频率,然后再调用设备的target回调函数,实现一次具体的调频操作。

3.2.3 monitor机制接口
devfreq为governor实现了一种基本的调频策略,就是每隔一段时间就调用 update_devfreq函数更新设备的频率,称之为monitor机制。monitor机制的相关API包括:

extern void devfreq_monitor_start(struct devfreq *devfreq);
extern void devfreq_monitor_stop(struct devfreq *devfreq);
extern void devfreq_monitor_suspend(struct devfreq *devfreq);
extern void devfreq_monitor_resume(struct devfreq *devfreq);
start接口用于开启monitor模式,可以在devfreq向governor 发送DEVFREQ_GOV_START事件时调用该函数;

stop接口用于开关闭monitor模式,可以在devfreq向governor 发送DEVFREQ_GOV_STOP事件时调用该函数;

suspend接口用于暂停monitor模式,可以在devfreq向governor 发送DEVFREQ_GOV_SUSPEND事件时调用该函数;

resume接口用于暂停monitor模式,可以在devfreq向governor 发送DEVFREQ_GOV_RESUME事件时调用该函数;

3.3 用户层接口
所有注册进devfreq框架的设备,都会在/sys/class/devfreq/xxxx-device/下生成以下文件节点:

节点名称 读操作 写操作
governor 返回device的governor名称 写入目标governorB的名字,可以替换当前governorA
available governors 获取所有支持的governor名字 不支持
cur_freq 获取设备当前的频率 不支持
target_freq 获取上一个使用的频点 不支持
polling_interval 获取当前值 修改当前值
min_freq 获取设备支持的最小值 修改设备支持的最小值
max_freq 获取设备支持的最大值 修改设备支持的最大值
available frequencies 获取设备支持的所有频点信息 不支持
trans_state 获取设备的调频历史纪录 不支持
四 编程模板
4.1 dts配置
4.1.1 定义工作性能表:
对于使用devfreq框架的设备,都需要在dts中预先定义一个工作性能表。例如,对于可以工作在三个频点上的设备,可以在dts中预先定义以下的性能工作表:

xxx_opp_table: xxx_opp_table {
compatible = "operating-points-v2";

opp@800000000 {
opp-hz = /bits/ 64 <800000000>;
};
opp@3200000000 {
opp-hz = /bits/ 64 <3200000000>;
};
opp@3800000000 {
opp-hz = /bits/ 64 <3800000000>;
};
};
内核在初始化的过程中,会通过opp框架,将以上的性能表添加至一个全局的链表中。

 

4.1.2 引用工作性能表:
定义好性能表后,在device对应的dts中引用对应的性能表:

xxx: xxx_dev {
...;
operating-points-v2 = <&xxx_opp_table>;
}
4.2 底层driver实现
4.2.1 底层driver需要实现的回调函数
底层driver必须实现两个回调函数:

1. 调频动作的具体实现,target函数;

2. 当前device的工作频率的获取,get_cur_freq函数;

例程如下所示:

static int xxx_freq_target(struct device *dev, unsigned int *freq, u32 flags)
{
struct dev_pm_opp *opp;
unsigned long rate;
rcu_read_lock();
/* 根据参数freq,遍历device引用的性能表,匹配最接近的性能点opp */
opp = devfreq_recommended_opp(dev, freq, flags);
if (IS_ERR(opp)) {
rcu_read_unlock();
printk(KERN_ERR "failed to find opp for %lu hz\n", *freq);
return PTR_ERR(opp);
}
/* 获取性能点opp中的频率信息 */
rate = dev_pm_opp_get_freq(opp);
rcu_read_unlock();

/* 根据具体调频的方法,进行调频操作 */
return xxx_change_rate(rate);
}

static int xxx_get_cur_freq(struct device *dev, unsigned long *freq)
{
unsigned long rate;

/* 根据device具体的方法,获得当前device的工作频率 */
rate = xxx_get_freq(...);
*freq = rate;
return 0
}

static struct devfreq_dev_profile xxx_devfreq_profile = {
.polling_ms = 0,
.target = xxx_freq_target,
.get_cur_freq = xxx_get_cur_freq,
}

4.2.2 probe时注册devfreq框架
注册包含两步:

1.将device添加至opp框架;

2.将device和其实现的回调函数添加至devfreq框架,并指定governor。

例程代码如下所示:(这里governor使用的是userspace)

static int xxx_probe(struct platform_device *pdev)

{
struct device *dev = &pdev->dev;
int ret;

...;
/* 1. 将device和dts中引用的opp表相关联 */
ret = dev_pm_opp_of_add_table(dev);
if (ret)
printk(KERN_ERR, "cannot add opp table!\n");

xxx_devfreq_profile.initial_freq = xxxx;
/* 2. 将device注册到devfreq框架, governer设置为userspace */
ret = devm_devfreq_add_device(dev, &xxx_devfreq_profile, "userspace", NULL);
if (ret)
printk(KERN_ERR, "cannot add device to devfreq!\n");
...;

}

4.3 governor的注册
对于一个支持dvfs的设备,若想通过devfreq框架管理该设备的调频调压,必须同时实现该设备的governor ,因为核心的调频操作,需要governor的调频策略,给出目标频率。

下面以governor_userspace为例,说明governor的注册方法。

4.3.1 governor需要实现的回调函数
governor在向框架注册时,需要提前准备好两个回调函数:

1.get_target_freq:该函数用于实现具体的调频策略,给出governor建议的目标调节频率。对于userspace_governor来说,其调频策略很简单,目标频率就是用户通过文件节点输入的频率。

2.event_handler:该函数用于处理devfreq框架向governor发送的事件。典型的事件包括:

当有设备注册进devfreq框架,且该设备的governor设定为该governor时,框架向governor发送DEVFREQ_GOV_START事件。
当有设备从devfreq框架注销,且该设备的governor设定为该governor时,框架向governor发送DEVFREQ_GOV_STOP事件。
...
以上两个回调函数,governor_userspace的实现代码如下所示:

struct userspace_data {
unsigned long user_frequency;
bool valid;
};

/* userspace_governor给出的目标频率来自用户层的输入 */
static int devfreq_userspace_func(struct devfreq *df, unsigned long *freq)
{
struct userspace_data *data = df->data;

/* 每次当用户通过文件节点设置目标频率时,data将被更新 */
if (data->valid)
*freq = data->user_frequency;
else
*freq = df->previous_freq; /* No user freq specified yet */

return 0;
}

/* userspace_governor只处理START和STOP两个事件 */
static int devfreq_userspace_handler(struct devfreq *devfreq,
unsigned int event, void *data)
{
int ret = 0;

switch (event) {
case DEVFREQ_GOV_START:
ret = userspace_init(devfreq);
break;
case DEVFREQ_GOV_STOP:
userspace_exit(devfreq);
break;
default:
break;
}

return ret;
}

static struct devfreq_governor devfreq_userspace = {
.name = "userspace",
.get_target_freq = devfreq_userspace_func,
.event_handler = devfreq_userspace_handler,
};

其中,我们重点关注userspace_init函数。使用该governor的设备注册进devfreq框架时,会调用该函数:

static struct attribute *dev_entries[] = {
&dev_attr_set_freq.attr,
NULL,
};
static const struct attribute_group dev_attr_group = {
.name = DEVFREQ_GOV_USERSPACE, //"userspace"
.attrs = dev_entries,
};
static int userspace_init(struct devfreq *devfreq)
{
int err = 0;
struct userspace_data *data = kzalloc(sizeof(struct userspace_data),
¦ ¦ GFP_KERNEL);

if (!data) {
err = -ENOMEM;
goto out;
}
data->valid = false;
devfreq->data = data;

err = sysfs_create_group(&devfreq->dev.kobj, &dev_attr_group);
out:
return err;
}

可以看出,userspace_init函数为使用该governor的设备在/sys文件系统下添加了名为"userspace"文件夹,并且该文件夹下有一个名为"set_freq"的节点。通过该节点,我们可以进行调频操作和读取当前设备频率的操作。 相关代码如下所示:

static ssize_t store_freq(struct device *dev, struct device_attribute *attr,
¦ const char *buf, size_t count)
{
struct devfreq *devfreq = to_devfreq(dev);
struct userspace_data *data;
unsigned long wanted;
int err = 0;

mutex_lock(&devfreq->lock);
data = devfreq->data;
/* 读取用户输入的目标频率 */
sscanf(buf, "%lu", &wanted);
data->user_frequency = wanted;
data->valid = true;
/* 调用核心的调频函数,对该设备进行调频 */
err = update_devfreq(devfreq);
if (err == 0)
err = count;
mutex_unlock(&devfreq->lock);
return err;
}

static ssize_t show_freq(struct device *dev, struct device_attribute *attr,
¦char *buf)
{
struct devfreq *devfreq = to_devfreq(dev);
struct userspace_data *data;
int err = 0;

mutex_lock(&devfreq->lock);
data = devfreq->data;

if (data->valid)
err = sprintf(buf, "%lu\n", data->user_frequency);
else
err = sprintf(buf, "undefined\n");
mutex_unlock(&devfreq->lock);
return err;
}

static DEVICE_ATTR(set_freq, 0644, show_freq, store_freq);
4.3.2 governor向devfreq的注册
当准备好以上回调函数后,就可以将通过devfreq提供的接口devfreq_add_governor,将governor注册进devfreq框架。以governor_userspace为例,governor的注册方法如下:

static int __init devfreq_userspace_init(void)
{
return devfreq_add_governor(&devfreq_userspace);
}
subsys_initcall(devfreq_userspace_init);
五 框架分析
5.1 devfreq框架初始化
devfreq框架的初始化很简单,只是在sys/class/目录下创建了名为devfreq的类,并指定了该类下面的所有device所具备的文件属性。具体代码如下所示:

static int __init devfreq_init(void)
{
/* 创建devfreq类 */
devfreq_class = class_create(THIS_MODULE, "devfreq");
if (IS_ERR(devfreq_class)) {
pr_err("%s: couldn't create class\n", __FILE__);
return PTR_ERR(devfreq_class);
}
/* 创建工作队列 */
devfreq_wq = create_freezable_workqueue("devfreq_wq");
if (!devfreq_wq) {
class_destroy(devfreq_class);
pr_err("%s: couldn't create workqueue\n", __FILE__);
return -ENOMEM;
}
devfreq_class->dev_groups = devfreq_groups;

return 0;
}
subsys_initcall(devfreq_init);
这样,所有注册进devfreq框架的device,在其目录下都会自动创建以下文件节点:

static struct attribute *devfreq_attrs[] = {
&dev_attr_governor.attr,
&dev_attr_available_governors.attr,
&dev_attr_cur_freq.attr,
&dev_attr_available_frequencies.attr,
&dev_attr_target_freq.attr,
&dev_attr_polling_interval.attr,
&dev_attr_min_freq.attr,
&dev_attr_max_freq.attr,
&dev_attr_trans_stat.attr,
NULL,
};
ATTRIBUTE_GROUPS(devfreq);
5.2 对device的管理
devfreq框架很大一部分代码是对注册进来的device的管理。我们可以从3.2.2小节中device向devfreq注册的接口devm_devfreq_add_device入手,对相关代码进行分析。

devm_devfreq_add_device函数内部主要调用了函数devfreq_add_device,该函数较长,我们节选核心的部分进行分析:

1. 首先在全局链表devfreq_list中,查看该设备是否已经注册,如果已经注册,直接返回错误:

struct devfreq *devfreq_add_device(struct device *dev,
¦ struct devfreq_dev_profile *profile,
¦ const char *governor_name,
/ ¦ void *data)
{
struct devfreq *devfreq;
struct devfreq_governor *governor;
static atomic_t devfreq_no = ATOMIC_INIT(-1);
int err = 0;

...;
mutex_lock(&devfreq_list_lock);
devfreq = find_device_devfreq(dev);
mutex_unlock(&devfreq_list_lock);
if (!IS_ERR(devfreq)) {
dev_err(dev, "%s: Unable to create devfreq for the device.\n",
__func__);
err = -EINVAL;
goto err_out;
}
...;
2. 然后,为内部使用的devfreq类型的特殊设备分配内存,并对其进行初始化。这里,特别注意,注册进来的设备,成为内部的devfreq设备的父设备,而且,注册时 profile必须提供设备的初始频率 initial_freq:

/* devfreq内部使用结构体struct devfreq来管理设备 */
devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL);
if (!devfreq) {
err = -ENOMEM;
goto err_out;
}

mutex_init(&devfreq->lock);
mutex_lock(&devfreq->lock);
/* 其父设备为注册进来的device,这样,内部维护的devfreq设备就和原注册设备相关联起来 */
devfreq->dev.parent = dev;
devfreq->dev.class = devfreq_class;
devfreq->dev.release = devfreq_dev_release;
devfreq->profile = profile;
strncpy(devfreq->governor_name, governor_name, DEVFREQ_NAME_LEN);
devfreq->previous_freq = profile->initial_freq;
devfreq->last_status.current_frequency = profile->initial_freq;
devfreq->data = data;
....
3. devfreq框架是如何知道该设备支持哪些频点的呢?一种方式是device在注册进来的时候,通过profile结构体,预先设填好freq_table和max_state字段,显然这种方式比较笨,一般不会使用;还有一种方式,就是由devfreq框架通过设备注册时的传参device,使用opp框架的帮助函数来读取该设备支持的opp_table。相关代码如下所示:

if (!devfreq->profile->max_state && !devfreq->profile->freq_table) {
mutex_unlock(&devfreq->lock);
err = set_freq_table(devfreq);
if (err < 0)
goto err_dev;
mutex_lock(&devfreq->lock);
}
其中核心的处理函数set_freq_table,首先通过dev_pm_opp_get_opp_count获取设备的频点数,将该频点数设置为max_state的值。再动态分配freq_table,使用dev_pm_opp_find_freq_ceil依次读取与设备关联的opp_table中的频率值,填充进freq_table中。相关代码如下:

static int set_freq_table(struct devfreq *devfreq)
{
struct devfreq_dev_profile *profile = devfreq->profile;
struct dev_pm_opp *opp;
unsigned long freq;
int i, count;
/* Initialize the freq_table from OPP table */
count = dev_pm_opp_get_opp_count(devfreq->dev.parent);
if (count <= 0)
return -EINVAL;

profile->max_state = count;
profile->freq_table = devm_kcalloc(devfreq->dev.parent,
profile->max_state,
sizeof(*profile->freq_table),
GFP_KERNEL);
if (!profile->freq_table) {
profile->max_state = 0;
return -ENOMEM;
}

for (i = 0, freq = 0; i < profile->max_state; i++, freq++) {
opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &freq);
if (IS_ERR(opp)) {
devm_kfree(devfreq->dev.parent, profile->freq_table);
profile->max_state = 0;
return PTR_ERR(opp);
}
dev_pm_opp_put(opp);
profile->freq_table[i] = freq;
}

return 0;
}
4. 根据device的opp_table读取最大值和最小值:

devfreq->scaling_min_freq = find_available_min_freq(devfreq);
if (!devfreq->scaling_min_freq) {
mutex_unlock(&devfreq->lock);
err = -EINVAL;
goto err_dev;
}
devfreq->min_freq = devfreq->scaling_min_freq;

devfreq->scaling_max_freq = find_available_max_freq(devfreq);
if (!devfreq->scaling_max_freq) {
mutex_unlock(&devfreq->lock);
err = -EINVAL;
goto err_dev;
}
devfreq->max_freq = devfreq->scaling_max_freq;
5. 根据profile指定的名字绑定具体的governor,并将新创建的devfreq添加至全局的链表统一管理:

governor = try_then_request_governor(devfreq->governor_name);
if (IS_ERR(governor)) {
dev_err(dev, "%s: Unable to find governor for the device\n",
__func__);
err = PTR_ERR(governor);
goto err_init;
}

devfreq->governor = governor;
err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START,
NULL);
if (err) {
dev_err(dev, "%s: Unable to start governor for the device\n",
__func__);
goto err_init;
}

list_add(&devfreq->node, &devfreq_list);
//TODO增加对governor管理的文档;增加统一文件节点的介绍
————————————————
版权声明:本文为CSDN博主「华华要好好学真正的技术啦」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/weixin_39059738/article/details/104260671

posted @ 2022-09-19 18:12  Sky&Zhang  阅读(915)  评论(0编辑  收藏  举报