RK3576 CPUFreq驱动深度剖析：从原理到实战

域垚达人保险理财 2026-04-10 2352 0

嵌入式Linux性能调优核心战场，从代码层面彻底吃透DVFS机制

作为嵌入式Linux开发者，你是否只停留在echo performance > scaling_governor的表层操作？当遇到频率切换延迟高、电压调节失败、多核异构频率协同等问题时，是否束手无策？

今天这篇文章，将逐行剖析RK3576平台的cpufreq实现，从源码层面拆解Linux内核DVFS（动态电压频率调节）的每一个细节，带你从“会用”到“精通”，解决实际开发中的核心痛点。

一、为什么要深入cpufreq源码？

嵌入式Linux开发中，cpufreq是性能与功耗平衡的核心，但这些问题往往让开发者卡壳：

•频率切换延迟过高，如何优化？

•电压调节失败，如何定位？

•多核异构场景下，频率如何协同？

•自定义调速器，如何接入框架？

只有深入源码，才能真正掌握DVFS的底层逻辑，而非停留在“调参数”的表面操作。

二、整体架构：代码视角的分层设计

2.1文件组织与模块依赖

cpufreq驱动的代码分布清晰，核心文件各司其职：

drivers/cpufreq/├── cpufreq.c # 核心框架：策略管理、通知链、sysfs├── cpufreq-dt.c # DT 通用驱动：OPP 解析、时钟操作├── cpufreq-dt.h # DT 驱动接口定义├── rockchip-cpufreq.c # RK 平台驱动：SoC 特性、DVFS 锁、监控├── rockchip-cpufreq.h # RK 驱动导出接口├── cpufreq_governor.c # 调速器公共框架├── cpufreq_governor.h # 调速器数据结构├── cpufreq_interactive.c # Interactive 调速器实现├── cpufreq_ondemand.c # Ondemand 调速器实现├── freq_table.c # 频率表辅助函数└── cpufreq_stats.c # 统计信息模块

2.2核心结构体关系（代码定义）

cpufreq的核心逻辑围绕两个结构体展开，是理解整个框架的关键：

// include/linux/cpufreq.hstructcpufreq_policy{ cpumask_var_t cpus; // 本策略管理的 CPU 掩码 cpumask_var_t related_cpus; // 硬件相关的 CPU（共享时钟） unsignedint min; // 用户设置的最小频率 unsignedint max; // 用户设置的最大频率 unsignedint cur; // 当前频率（kHz） structcpufreq_governor*governor; // 当前调速器 void *governor_data;// 调速器私有数据 structcpufreq_frequency_table*freq_table;// 频率表 structcpufreq_stats *stats; // 统计信息 structkobject kobj; // sysfs 对象 void *driver_data; // 驱动私有数据 // ... 更多字段};structcpufreq_driver{ char name[CPUFREQ_NAME_LEN]; unsignedint flags;
 /* 必须实现的回调 */ int(*target_index)(structcpufreq_policy *policy,unsignedintindex); unsignedint(*get)(unsignedintcpu);
 /* 可选回调 */ int(*init)(structcpufreq_policy *policy); int(*exit)(structcpufreq_policy *policy); int(*online)(structcpufreq_policy *policy); int(*offline)(structcpufreq_policy *policy); // ...};

脑图：RK3576 CPUFreq核心架构

三、初始化流程：从模块加载到频率就绪

RK3576的cpufreq初始化是“先集群初始化，再注册驱动”的逻辑，核心分为三步：

3.1驱动入口：rockchip_cpufreq_driver_init

这是整个RK平台cpufreq的入口函数，核心逻辑是遍历CPU集群、初始化集群信息、注册通知链和平台设备：

// drivers/cpufreq/rockchip-cpufreq.cstaticint__initrockchip_cpufreq_driver_init(void){ structcluster_info *cluster, *pos; structcpufreq_dt_platform_data pdata = {0}; intcpu, ret; boolis_opp_shared_cpu_bus =false; /* 遍历所有可能的 CPU，为每个 cluster 初始化 */ for_each_possible_cpu(cpu) { cluster = rockchip_cluster_info_lookup(cpu); if(cluster) continue; // 已初始化过 cluster = kzalloc(sizeof(*cluster), GFP_KERNEL); if(!cluster) { ret = -ENOMEM; gotorelease_cluster_info; } /* 核心初始化：解析 OPP、获取 regulator、设置 SoC 信息 */ ret = rockchip_cpufreq_cluster_init(cpu, cluster); if(ret) { pr_err("Failed to initialize dvfs info cpu%dn", cpu); gotorelease_cluster_info; }
 list_add(&cluster->list_head, &cluster_info_list); if(cluster->is_opp_shared_cpu_bus) is_opp_shared_cpu_bus =true; } /* 设置平台数据 */ pdata.have_governor_per_policy =true; pdata.suspend = rockchip_cpufreq_suspend; /* 注册 cpufreq 通知链 */ ret = cpufreq_register_notifier(&rockchip_cpufreq_notifier_block, CPUFREQ_POLICY_NOTIFIER); if(ret) { pr_err("failed to register cpufreq notifiern"); gotorelease_cluster_info; } /* 如果存在 OPP 共享总线，注册 transition 通知器 */ if(is_opp_shared_cpu_bus) { ret = cpufreq_register_notifier(&rockchip_cpufreq_transition_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); // ... } /* 注册 panic 通知器，用于调试 */ ret = atomic_notifier_chain_register(&panic_notifier_list, &rockchip_cpufreq_panic_notifier_block); /* 注册 platform_device，触发 cpufreq-dt 驱动 probe */ returnPTR_ERR_OR_ZERO(platform_device_register_data(NULL,"cpufreq-dt", -1, (void*)&pdata,sizeof(structcpufreq_dt_platform_data)));}module_init(rockchip_cpufreq_driver_init);// drivers/cpufreq/rockchip-cpufreq.cstaticint__initrockchip_cpufreq_driver_init(void){ structcluster_info *cluster, *pos; structcpufreq_dt_platform_data pdata = {0}; intcpu, ret; boolis_opp_shared_cpu_bus =false; /* 遍历所有可能的 CPU，为每个 cluster 初始化 */ for_each_possible_cpu(cpu) { cluster = rockchip_cluster_info_lookup(cpu); if(cluster) continue; // 已初始化过 cluster = kzalloc(sizeof(*cluster), GFP_KERNEL); if(!cluster) { ret = -ENOMEM; gotorelease_cluster_info; } /* 核心初始化：解析 OPP、获取 regulator、设置 SoC 信息 */ ret = rockchip_cpufreq_cluster_init(cpu, cluster); if(ret) { pr_err("Failed to initialize dvfs info cpu%dn", cpu); gotorelease_cluster_info; }
 list_add(&cluster->list_head, &cluster_info_list); if(cluster->is_opp_shared_cpu_bus) is_opp_shared_cpu_bus =true; } /* 设置平台数据 */ pdata.have_governor_per_policy =true; pdata.suspend = rockchip_cpufreq_suspend; /* 注册 cpufreq 通知链 */ ret = cpufreq_register_notifier(&rockchip_cpufreq_notifier_block, CPUFREQ_POLICY_NOTIFIER); if(ret) { pr_err("failed to register cpufreq notifiern"); gotorelease_cluster_info; } /* 如果存在 OPP 共享总线，注册 transition 通知器 */ if(is_opp_shared_cpu_bus) { ret = cpufreq_register_notifier(&rockchip_cpufreq_transition_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); // ... } /* 注册 panic 通知器，用于调试 */ ret = atomic_notifier_chain_register(&panic_notifier_list, &rockchip_cpufreq_panic_notifier_block); /* 注册 platform_device，触发 cpufreq-dt 驱动 probe */ returnPTR_ERR_OR_ZERO(platform_device_register_data(NULL,"cpufreq-dt", -1, (void*)&pdata,sizeof(structcpufreq_dt_platform_data)));}module_init(rockchip_cpufreq_driver_init);

3.2 Cluster初始化：rockchip_cpufreq_cluster_init

每个CPU集群（大核/小核）的初始化核心是解析OPP表、获取电压调节器、读取SoC特有信息：

Cstaticintrockchip_cpufreq_cluster_init(intcpu,structcluster_info *cluster){ structrockchip_opp_info*opp_info = &cluster->opp_info; structdevice_node*np; structdevice*dev; char*reg_name; intret =0; u32 freq =0; dev =get_cpu_device(cpu); if(!dev) return-ENODEV; /* 从 CPU 节点获取 operating-points-v2 phandle */ np =of_parse_phandle(dev->of_node,"operating-points-v2",0); if(!np) { dev_warn(dev,"OPP-v2 not supportedn"); return-ENOENT; } /* 获取共享 OPP 的 CPU 掩码（大核/小核 cluster） */ ret =dev_pm_opp_of_get_sharing_cpus(dev, &cluster->cpus); if(ret) { dev_err(dev,"Failed to get sharing cpusn"); of_node_put(np); returnret; } /* 检查是否共享 DSU/CCI 总线 OPP */ if(of_property_read_bool(np,"rockchip,opp-shared-dsu") || of_property_read_bool(np,"rockchip,opp-shared-cci")) cluster->is_opp_shared_cpu_bus =true; /* 读取 CPU 到总线频率的百分比 */ of_property_read_u32(np,"rockchip,cpu-freq-percent", &cluster->cpu_freq_percent); /* 读取空闲阈值频率 */ if(!of_property_read_u32(np,"rockchip,idle-threshold-freq", &freq)) cluster->idle_threshold_freq = freq; of_node_put(np); /* 确定 regulator 名称 */ if(of_find_property(dev->of_node,"cpu-supply",NULL)) reg_name ="cpu"; elseif(of_find_property(dev->of_node,"cpu0-supply",NULL)) reg_name ="cpu0"; else return-ENOENT; /* 获取 SoC 特定的 OPP 数据处理函数 */ rockchip_get_opp_data(rockchip_cpufreq_of_match, opp_info); /* 初始化 OPP 信息：读取 nvmem、设置 supported_hw */ ret =rockchip_init_opp_info(dev, opp_info,NULL, reg_name); if(ret) dev_err(dev,"failed to init opp infon"); returnret;}

3.3 RK3576特有的SoC信息读取

RK3576不同版本（M/J/S）的频率/电压支持不同，核心是从nvmem读取芯片规格：

staticintrk3576_cpu_get_soc_info(structdevice *dev,structdevice_node *np, int*bin,int*process){ intret =0; u8 spec =0, test_version =0; if(!bin) return0; /* 从 nvmem 读取芯片规格序列号 */ if(of_property_match_string(np,"nvmem-cell-names", "specification_serial_number") >=0) { ret = rockchip_nvmem_cell_read_u8(np, "specification_serial_number", &spec); if(ret) { dev_err(dev,"Failed to get specification_serial_numbern"); returnret; } } /* 读取测试版本 */ if(of_property_match_string(np,"nvmem-cell-names","test_version") >=0) { ret = rockchip_nvmem_cell_read_u8(np,"test_version", &test_version); if(ret) { dev_err(dev,"Failed to get test_versionn"); returnret; } } /* 根据 spec 值判断芯片型号 */ if(spec ==0xd) { *bin =1; /* RK3576M */ }elseif(spec ==0xa) { *bin =2; /* RK3576J */ }elseif(spec ==0x13) { if(test_version ==0) { *bin =3; /* RK3576S */ }else{ *bin =0; dev_info(dev,"bin=%d (3)n", *bin); return0; } } if(*bin < 0) *bin =0; dev_info(dev,"bin=%dn", *bin); returnret;}

流程图：RK3576 CPUFreq初始化流程

st=>start: 模块加载(rockchip_cpufreq_driver_init)op1=>operation: 遍历所有CPUop2=>operation: 查找/创建cluster_infoop3=>operation: rockchip_cpufreq_cluster_initop4=>operation: 解析OPP-v2节点op5=>operation: 获取共享CPU掩码/总线信息op6=>operation: 读取SoC信息(nvmem)op7=>operation: 注册策略/转换通知链op8=>operation: 注册cpufreq-dt平台设备e=>end: 触发cpufreq-dt probe，初始化完成st->op1->op2->op3->op4->op5->op6->op7->op8->e

四、频率调整核心：从Governor到硬件

频率调整是cpufreq的核心流程，完整链路是：调速器决策→核心层处理→驱动层执行→ OPP子系统→硬件（时钟/电压）

4.1调速器决策：interactive为例

interactive是嵌入式场景最常用的调速器，核心是“按需快速升频，缓慢降频”，关键逻辑在负载计算和频率评估：

// drivers/cpufreq/cpufreq_interactive.c/* 核心数据结构 */structinteractive_cpu{ structupdate_util_dataupdate_util; // 注册到调度器的钩子 structinteractive_policy*ipolicy;
 structirq_workirq_work; // 中断上下文工作 u64 last_sample_time; boolwork_in_progress;
 /* 负载计算相关 */ spinlock_tload_lock; u64 time_in_idle; u64 time_in_idle_timestamp; u64 cputime_speedadj; // 加权 CPU 时间
 /* 频率控制 */ spinlock_ttarget_freq_lock; unsignedinttarget_freq; unsignedintfloor_freq; // 最低允许频率 u64 pol_floor_val_time; // 策略级 floor 时间 u64 loc_floor_val_time; // CPU 级 floor 时间 // ...};/* 调度器回调：每次 CPU 状态更新时调用 */staticvoiddbs_update_util_handler(structupdate_util_data *data, u64 time, unsignedintflags){ structinteractive_cpu*icpu =container_of(data,structinteractive_cpu, update_util); structinteractive_policy*ipolicy = icpu->ipolicy; structinteractive_tunables*tunables = ipolicy->tunables; u64 delta_ns, lst; /* 检查是否可以更新 */ if(!cpufreq_this_cpu_can_update(ipolicy->policy)) return; /* 避免重复工作 */ if(icpu->work_in_progress) return; /* 检查采样间隔 */ lst =READ_ONCE(icpu->last_sample_time); delta_ns = time - lst; if((s64)delta_ns < tunables->sampling_rate * NSEC_PER_USEC) return; /* 提交 irq_work，在中断上下文执行 */ icpu->last_sample_time = time; icpu->work_in_progress =true; irq_work_queue(&icpu->irq_work);}/* 实际频率评估函数 */staticvoideval_target_freq(structinteractive_cpu *icpu){ structinteractive_tunables*tunables = icpu->ipolicy->tunables; structcpufreq_policy*policy = icpu->ipolicy->policy; u64 cputime_speedadj, now, max_fvtime; unsignedintnew_freq, loadadjfreq, delta_time; unsignedlongflags; intcpu_load; /* 计算 CPU 负载 */ spin_lock_irqsave(&icpu->load_lock, flags); now =update_load(icpu,smp_processor_id()); delta_time = (unsignedint)(now - icpu->cputime_speedadj_timestamp); cputime_speedadj = icpu->cputime_speedadj; spin_unlock_irqrestore(&icpu->load_lock, flags); if(!delta_time) return; /* 计算负载百分比 */ cpu_load = (unsignedint)(100* cputime_speedadj / delta_time) / policy->cur; spin_lock_irqsave(&icpu->target_freq_lock, flags); /* 根据负载选择目标频率 */ loadadjfreq = cpu_load * policy->cur;
 if(cpu_load >= tunables->go_hispeed_load) { /* 高负载：进入 hispeed_freq */ if(policy->cur < tunables->hispeed_freq) { new_freq = tunables->hispeed_freq; }else{ new_freq =choose_freq(icpu, loadadjfreq);
 /* 检查 above_hispeed_delay */ if(now - max_fvtime < freq_to_above_hispeed_delay(tunables, new_freq)) new_freq =max(new_freq, tunables->hispeed_freq); } }else{ /* 低负载：按比例降频 */ new_freq =choose_freq(icpu, loadadjfreq); } /* 应用 floor 约束 */ if(new_freq < icpu->floor_freq) { if(now - icpu->pol_floor_val_time < tunables->min_sample_time) new_freq = icpu->floor_freq; } /* 限制在策略范围内 */ new_freq =max(new_freq, policy->min); new_freq =min(new_freq, policy->max); /* 提交频率变更 */ if(new_freq != policy->cur) { icpu->target_freq = new_freq; spin_lock(&speedchange_cpumask_lock); cpumask_set_cpu(smp_processor_id(), &speedchange_cpumask); spin_unlock(&speedchange_cpumask_lock); wake_up_process(speedchange_task); // 唤醒内核线程执行变更 } spin_unlock_irqrestore(&icpu->target_freq_lock, flags);}

4.2频率选择算法：choose_freq

interactive调速器的核心算法，用二分查找思想找到满足负载的最低频率：

/** 选择满足目标负载的最低频率* 采用二分查找思想，在频率表中寻找最优解*/staticunsignedintchoose_freq(structinteractive_cpu *icpu, unsignedintloadadjfreq){ structcpufreq_policy*policy = icpu->ipolicy->policy; structcpufreq_frequency_table*freq_table = policy->freq_table; unsignedintprevfreq, freqmin =0, freqmax = UINT_MAX, tl; unsignedintfreq = policy->cur; intindex; do{ prevfreq = freq;
 /* 获取当前频率的目标负载 */ tl =freq_to_targetload(icpu->ipolicy->tunables, freq); /* * 查找满足 loadadjfreq / tl <= freq 的最低频率 * 即：freq >= loadadjfreq / tl */ index =cpufreq_frequency_table_target(policy, loadadjfreq / tl, CPUFREQ_RELATION_L); freq = freq_table[index].frequency; if(freq > prevfreq) { /* 频率上升：记录最小值 */ freqmin = prevfreq; if(freq >= freqmax) { /* 超过上限，回退 */ index =cpufreq_frequency_table_target(policy, freqmax -1, CPUFREQ_RELATION_H); freq = freq_table[index].frequency; if(freq == freqmin) break; } }elseif(freq < prevfreq) { /* 频率下降：记录最大值 */ freqmax = prevfreq; if(freq <= freqmin) { /* 低于下限，回退 */ index =cpufreq_frequency_table_target(policy, freqmin +1, CPUFREQ_RELATION_L); freq = freq_table[index].frequency; if(freq == freqmax) break; } } }while(freq != prevfreq); returnfreq;}

4.3核心层频率切换：cpufreq_core

核心层负责频率切换的同步、通知和状态管理，保证线程安全：

// drivers/cpufreq/cpufreq.c/* 开始频率转换 */voidcpufreq_freq_transition_begin(structcpufreq_policy *policy, structcpufreq_freqs *freqs){ /* 防止重复调用导致死锁 */ WARN_ON(!(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION) && current == policy->transition_task);wait: /* 等待前一次转换完成 */ wait_event(policy->transition_wait, !policy->transition_ongoing); spin_lock(&policy->transition_lock); if(unlikely(policy->transition_ongoing)) { spin_unlock(&policy->transition_lock); gotowait; } policy->transition_ongoing =true; policy->transition_task = current; spin_unlock(&policy->transition_lock); /* 发送 PRECHANGE 通知 */ cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);}/* 频率转换通知 */staticvoidcpufreq_notify_transition(structcpufreq_policy *policy, structcpufreq_freqs *freqs, unsignedintstate){ intcpu; freqs->policy = policy; freqs->flags = cpufreq_driver->flags; switch(state) { caseCPUFREQ_PRECHANGE: /* 同步 old frequency */ if(policy->cur && policy->cur != freqs->old) { freqs->old = policy->cur; } /* 调用 transition notifier 链 */ srcu_notifier_call_chain(&cpufreq_transition_notifier_list, CPUFREQ_PRECHANGE, freqs); /* 调整 loops_per_jiffy */ adjust_jiffies(CPUFREQ_PRECHANGE, freqs); break; caseCPUFREQ_POSTCHANGE: adjust_jiffies(CPUFREQ_POSTCHANGE, freqs); /* 记录 tracepoint */ for_each_cpu(cpu, policy->cpus) trace_cpu_frequency(freqs->new, cpu); /* 调用 transition notifier 链 */ srcu_notifier_call_chain(&cpufreq_transition_notifier_list, CPUFREQ_POSTCHANGE, freqs); /* 更新统计 */ cpufreq_stats_record_transition(policy, freqs->new); policy->cur = freqs->new; }}/* 结束频率转换 */voidcpufreq_freq_transition_end(structcpufreq_policy *policy, structcpufreq_freqs *freqs, inttransition_failed){ cpufreq_notify_post_transition(policy, freqs, transition_failed); /* 更新频率缩放比例（用于调度器） */ arch_set_freq_scale(policy->related_cpus, policy->cur, policy->cpuinfo.max_freq); spin_lock(&policy->transition_lock); policy->transition_ongoing =false; policy->transition_task =NULL; spin_unlock(&policy->transition_lock); wake_up(&policy->transition_wait);}

4.4驱动层实现：cpufreq-dt

DT驱动是通用层，对接核心层和平台层，核心是频率/电压的实际设置：

// drivers/cpufreq/cpufreq-dt.c/* 设置目标频率 */staticintset_target(structcpufreq_policy *policy,unsignedintindex){ structprivate_data*priv = policy->driver_data; unsignedlongfreq = policy->freq_table[index].frequency;#ifdefCONFIG_ARCH_ROCKCHIP /* RK 平台使用特殊的 OPP 设置函数 */ returnrockchip_cpufreq_opp_set_rate(priv->cpu_dev, freq *1000);#else returndev_pm_opp_set_rate(priv->cpu_dev, freq *1000);#endif}/* 驱动初始化 */staticintcpufreq_init(structcpufreq_policy *policy){ structprivate_data*priv; structdevice*cpu_dev; structclk*cpu_clk; unsignedinttransition_latency; intret; priv =cpufreq_dt_find_data(policy->cpu); if(!priv) { pr_err("failed to find data for cpu%dn", policy->cpu); return-ENODEV; } cpu_dev = priv->cpu_dev; /* 获取 CPU 时钟 */ cpu_clk =clk_get(cpu_dev,NULL); if(IS_ERR(cpu_clk)) { ret =PTR_ERR(cpu_clk); dev_err(cpu_dev,"%s: failed to get clk: %dn", __func__, ret); returnret; } /* 获取最大转换延迟 */ transition_latency =dev_pm_opp_get_max_transition_latency(cpu_dev); if(!transition_latency) transition_latency = CPUFREQ_ETERNAL; /* 填充 policy */ cpumask_copy(policy->cpus, priv->cpus); policy->driver_data = priv; policy->clk = cpu_clk; policy->freq_table = priv->freq_table; policy->suspend_freq =dev_pm_opp_get_suspend_opp_freq(cpu_dev) /1000; policy->cpuinfo.transition_latency = transition_latency; policy->dvfs_possible_from_any_cpu =true; /* 支持 boost 模式 */ if(policy_has_boost_freq(policy)) { ret =cpufreq_enable_boost_support(); if(ret) gotoout_clk_put; cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs; } return0;out_clk_put: clk_put(cpu_clk); returnret;}staticstructcpufreq_driverdt_cpufreq_driver = { .flags = CPUFREQ_NEED_INITIAL_FREQ_CHECK | CPUFREQ_IS_COOLING_DEV, .verify = cpufreq_generic_frequency_table_verify, .target_index = set_target, .get = cpufreq_generic_get, .init = cpufreq_init, .exit = cpufreq_exit, .online = cpufreq_online, .offline = cpufreq_offline, .register_em = cpufreq_register_em_with_opp, .name ="cpufreq-dt", .attr = cpufreq_dt_attr, .suspend = cpufreq_generic_suspend,};

4.5 RK平台特殊处理：rockchip_cpufreq

RK3576的定制化逻辑，包括DVFS锁、Read Margin、多路电压调节器：

// drivers/cpufreq/rockchip-cpufreq.c/* RK 平台频率设置入口 */introckchip_cpufreq_opp_set_rate(structdevice *dev,unsignedlongtarget_freq){ structcluster_info*cluster; structdev_pm_opp*opp; structrockchip_opp_info*opp_info; structdev_pm_opp_supplysupplies[2] = {0}; unsignedlongfreq; intret =0; cluster =rockchip_cluster_info_lookup(dev->id); if(!cluster) return-EINVAL; opp_info = &cluster->opp_info; /* 获取 DVFS 锁，防止并发修改 */ rockchip_opp_dvfs_lock(opp_info);
 /* 调用 OPP 子系统设置频率 */ ret =dev_pm_opp_set_rate(dev, target_freq);
 if(!ret) { cluster->rate = freq = target_freq;
 /* 查找当前 OPP，获取电压信息 */ opp =dev_pm_opp_find_freq_ceil(dev, &freq); if(!IS_ERR(opp)) { dev_pm_opp_get_supplies(opp, supplies); cluster->volt = supplies[0].u_volt; if(opp_info->regulator_count >1) cluster->mem_volt = supplies[1].u_volt; dev_pm_opp_put(opp); } }
 rockchip_opp_dvfs_unlock(opp_info); returnret;}EXPORT_SYMBOL_GPL(rockchip_cpufreq_opp_set_rate);/* RK3576 Read Margin 设置 */staticintrk3576_cpu_set_read_margin(structdevice *dev, structrockchip_opp_info *opp_info, u32 rm){ if(!opp_info->volt_rm_tbl) return0; if(rm == opp_info->current_rm || rm == UINT_MAX) return0; dev_dbg(dev,"set rm to %dn", rm);
 /* 通过 GRF 配置 Read Margin */ if(opp_info->grf) { /* CPU0-3 核心 */ regmap_write(opp_info->grf,0x3c,0x001c0000| (rm << 2)); regmap_write(opp_info->grf,0x44,0x001c0000| (rm << 2));
 /* 触发更新 */ regmap_write(opp_info->grf,0x38,0x00020002); udelay(1); regmap_write(opp_info->grf,0x38,0x00020000); }
 /* CCI 接口 */ if(opp_info->cci_grf) regmap_write(opp_info->cci_grf,0x54,0x001c0000| (rm << 2)); opp_info->current_rm = rm; return0;}/* 多路 regulator 配置 */staticintcpu_opp_config_regulators(structdevice *dev, structdev_pm_opp *old_opp, structdev_pm_opp *new_opp, structregulator **regulators, unsignedintcount){ structcluster_info*cluster; cluster =rockchip_cluster_info_lookup(dev->id); if(!cluster) return-EINVAL; returnrockchip_opp_config_regulators(dev, old_opp, new_opp, regulators, count, &cluster->opp_info);}

流程图：RK3576频率调整完整流程

st=>start: 调度器触发负载更新op1=>operation: interactive调速器(eval_target_freq)op2=>operation: 计算CPU负载，选择目标频率op3=>operation: 核心层(cpufreq_freq_transition_begin)op4=>operation: 发送PRECHANGE通知op5=>operation: 驱动层(set_target)op6=>operation: RK平台(rockchip_cpufreq_opp_set_rate)op7=>operation: OPP子系统(dev_pm_opp_set_rate)op8=>operation: 升频：先升压后升频；降频：先降频后降压op9=>operation: 核心层(cpufreq_freq_transition_end)op10=>operation: 发送POSTCHANGE通知，更新统计e=>end: 频率切换完成st->op1->op2->op3->op4->op5->op6->op7->op8->op9->op10->e

五、OPP子系统：频率-电压表的奥秘

OPP（Operating Performance Point）是连接软件和硬件的关键，定义了“频率-电压”的映射关系，是DVFS的基础。

5.1 OPP数据结构

// include/linux/pm_opp.hstructdev_pm_opp{ structlist_headnode;
 unsignedlongrate; // 频率 (Hz) unsignedlongu_volt; // 电压 (uV) unsignedlongu_volt_min; // 最小电压 unsignedlongu_volt_max; // 最大电压
 structdevice_opp*dev_opp; // 所属设备
 /* 支持的条件 */ unsignedlongsupported_hw; // 硬件版本掩码
 /* 供电信息 */ structopp_supply*supplies; unsignedintsupply_count;
 /* 自定义数据 */ void*priv;};structdevice_opp{ structlist_headnode; structdevice*dev; structsrcu_notifier_headsrcu_head; structlist_headopp_list;
 structclk*clk; structregulator**regulators; unsignedintregulator_count;
 structopp_table*opp_table;};

5.2 Device Tree OPP定义

RK3576的OPP表在DTS中定义，不同芯片版本支持不同频率：

// arch/arm64/boot/dts/rockchip/rk3576.dtsicpu0_opp_table:opp-table-0{ compatible ="operating-points-v2"; opp-shared;
 /* 408 MHz */ opp-408000000{ opp-hz =/bits/64<408000000>; opp-microvolt = <800000>; clock-latency-ns = <40000>; };
 /* 600 MHz */ opp-600000000{ opp-hz =/bits/64<600000000>; opp-microvolt = <825000>; };
 /* 816 MHz */ opp-816000000{ opp-hz =/bits/64<816000000>; opp-microvolt = <850000>; };
 /* 1.2 GHz */ opp-1200000000{ opp-hz =/bits/64<1200000000>; opp-microvolt = <925000>; };
 /* 1.608 GHz - 仅支持特定芯片版本 */ opp-1608000000{ opp-hz =/bits/64<1608000000>; opp-microvolt = <1100000>; opp-supported-hw = <0x10x1>; //bin=0, volt_sel=0 };
 /* 1.8 GHz - 更高规格芯片 */ opp-1800000000{ opp-hz =/bits/64<1800000000>; opp-microvolt = <1175000>; opp-supported-hw = <0x10x3>; //bin=0, volt_sel=0,1,2 };};

5.3 OPP查找与设置流程

OPP子系统的核心函数，负责频率/电压的实际设置：

// drivers/opp/core.c/*** dev_pm_opp_set_rate() - 设置设备到指定频率* @dev: 设备* @target_freq: 目标频率 (Hz)** 1. 查找匹配的 OPP* 2. 设置 regulator 电压* 3. 设置时钟频率*/intdev_pm_opp_set_rate(structdevice *dev,unsignedlongtarget_freq){ structdevice_opp*dev_opp; structdev_pm_opp*opp; structclk*clk; unsignedlongold_freq, new_freq; intret; dev_opp = _find_device_opp(dev); if(IS_ERR(dev_opp)) returnPTR_ERR(dev_opp); clk = dev_opp->clk; old_freq =clk_get_rate(clk); /* 查找目标频率对应的 OPP */ opp = _find_freq_ceil(dev_opp, &target_freq); if(IS_ERR(opp)) { ret =PTR_ERR(opp); gotoput_opp; } new_freq = opp->rate; /* 如果频率相同，只更新电压 */ if(new_freq == old_freq) { ret = _set_opp_voltage(dev, dev_opp, opp); gotoput_opp; } /* 升频：先升压，后升频 */ if(new_freq > old_freq) { ret = _set_opp_voltage(dev, dev_opp, opp); if(ret) gotoput_opp;
 ret =clk_set_rate(clk, new_freq); if(ret) { /* 回滚电压 */ _set_opp_voltage(dev, dev_opp, _find_freq_floor(dev_opp, &old_freq)); } }else{ /* 降频：先降频，后降压 */ ret =clk_set_rate(clk, new_freq); if(ret) gotoput_opp;
 _set_opp_voltage(dev, dev_opp, opp); }put_opp: dev_pm_opp_put(opp); returnret;}

流程图：OPP频率-电压设置流程

st=>start: 调用dev_pm_opp_set_rateop1=>operation: 查找设备对应的device_oppop2=>operation: 获取当前时钟频率(old_freq)op3=>operation: 查找目标频率的OPP(ceil)op4=>operation: 判断new_freq == old_freq?op5=>operation: 仅更新电压(_set_opp_voltage)op6=>operation: new_freq > old_freq?op7=>operation: 先升压，后升频op8=>operation: 升频失败，回滚电压op9=>operation: 先降频，后降压e=>end: 返回设置结果st->op1->op2->op3->op4op4(yes)->op5->eop4(no)->op6op6(yes)->op7->eop7(no)->op8->eop6(no)->op9->e

六、通知链机制：频率变更的广播系统

cpufreq的通知链是“事件广播”机制，允许其他子系统（如温控、功耗管理）监听频率变更事件，是内核模块化设计的典型体现。

6.1两种通知链

// drivers/cpufreq/cpufreq.c/* 策略通知链：策略创建/销毁时调用 */staticBLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);/* 转换通知链：频率变更前后调用 */SRCU_NOTIFIER_HEAD_STATIC(cpufreq_transition_notifier_list);

6.2 RK平台的通知器注册

RK3576通过通知链实现“频率-空闲状态”联动、总线QoS约束：

// drivers/cpufreq/rockchip-cpufreq.c/* 策略通知器：处理监控注册和总线 QoS */staticintrockchip_cpufreq_notifier(structnotifier_block *nb, unsignedlongevent,void*data){ structcpufreq_policy *policy = data; structcluster_info *cluster; cluster = rockchip_cluster_info_lookup(policy->cpu); if(!cluster) returnNOTIFY_BAD; switch(event) { caseCPUFREQ_CREATE_POLICY: /* 注册系统监控 */ if(rockchip_cpufreq_add_monitor(cluster, policy)) returnNOTIFY_BAD;
 /* 添加总线频率 QoS 约束 */ if(rockchip_cpufreq_add_bus_qos_req(cluster, policy)) returnNOTIFY_BAD; break; caseCPUFREQ_REMOVE_POLICY: rockchip_cpufreq_remove_monitor(cluster); rockchip_cpufreq_remove_bus_qos(cluster); break; } returnNOTIFY_OK;}/* 转换通知器：处理空闲状态 */staticintrockchip_cpufreq_transition_notifier(structnotifier_block *nb, unsignedlongevent,void*data){ structcpufreq_freqs *freqs = data; structcpufreq_policy *policy = freqs->policy; structcluster_info *cluster; cluster = rockchip_cluster_info_lookup(policy->cpu); if(!cluster) returnNOTIFY_BAD; switch(event) { caseCPUFREQ_PRECHANGE: /* 高频时禁用深层空闲状态 */ if(cluster->idle_threshold_freq && freqs->new>= cluster->idle_threshold_freq && !cluster->is_idle_disabled) { rockchip_cpufreq_idle_state_disable(policy->cpus,1,true); cluster->is_idle_disabled =true; } break; caseCPUFREQ_POSTCHANGE: /* 低频时重新启用空闲状态 */ if(cluster->idle_threshold_freq && freqs->new< cluster->idle_threshold_freq && cluster->is_idle_disabled) { rockchip_cpufreq_idle_state_disable(policy->cpus,1,false); cluster->is_idle_disabled =false; }
 /* 更新总线频率请求 */ rockchip_cpufreq_update_bus_req(cluster, freqs->new); break; } returnNOTIFY_OK;}

6.3使用场景示例

温控驱动通过通知链监听频率变更，更新热模型：

/* 温度管理驱动注册通知器 */staticintthermal_cpufreq_notifier(structnotifier_block *nb, unsignedlongevent,void*data){ structcpufreq_freqs *freqs = data;
 if(event== CPUFREQ_POSTCHANGE) { /* 频率变更后更新热模型 */ update_thermal_model(freqs->new); }
 returnNOTIFY_OK;}staticstructnotifier_block thermal_nb = { .notifier_call = thermal_cpufreq_notifier,};/* 注册 */cpufreq_register_notifier(&thermal_nb, CPUFREQ_TRANSITION_NOTIFIER);

七、统计与调试：洞察系统行为

掌握调试技巧，才能快速定位频率调节的问题，cpufreq提供了丰富的统计和调试接口。

7.1统计模块实现

// drivers/cpufreq/cpufreq_stats.cstructcpufreq_stats{ unsignedinttotal_trans; // 总切换次数 unsignedlonglonglast_time; // 上次更新时间 unsignedintmax_state; // 最大状态数 unsignedintstate_num; // 实际状态数 unsignedintlast_index; // 当前状态索引 u64 *time_in_state; // 各频率驻留时间 unsignedint*freq_table; // 频率表 unsignedint*trans_table; // 切换矩阵};/* 记录一次频率切换 */voidcpufreq_stats_record_transition(structcpufreq_policy *policy, unsignedintnew_freq){ structcpufreq_stats*stats = policy->stats; intold_index, new_index; if(!stats) return; old_index = stats->last_index; new_index =freq_table_get_index(stats, new_freq); if(old_index ==-1|| new_index ==-1|| old_index == new_index) return; /* 更新驻留时间 */ cpufreq_stats_update(stats, stats->last_time); stats->last_index = new_index; stats->trans_table[old_index * stats->max_state + new_index]++; stats->total_trans++;}

7.2调试技巧

# 1. 查看当前频率和策略cat/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freqcat/sys/devices/system/cpu/cpu0/cpufreq/scaling_governorcat/sys/devices/system/cpu/cpu0/cpufreq/scaling_min_freqcat/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq# 2. 查看频率驻留时间统计cat/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state# 输出格式: 频率(Hz) 时间(时钟周期)# 408000 1234567# 600000 2345678# ...# 3. 查看频率切换矩阵cat/sys/devices/system/cpu/cpu0/cpufreq/stats/trans_table# 显示从每个频率切换到其他频率的次数# 4. 查看可用频率和调速器cat/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequenciescat/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors# 5. 动态切换调速器echouserspace > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governorecho1200000 > /sys/devices/system/cpu/cpu0/cpufreq/scaling_setspeed# 6. 内核日志调试dmesg | grep -i cpufreqdmesg | grep -i"rk3576|rockchip"# 7. 使用 tracepointcd/sys/kernel/debug/tracingecho1 > events/cpufreq/enablecattrace

八、实战：自定义调速器开发

掌握自定义调速器的开发，才能适配特定场景的性能/功耗需求。

8.1最小调速器框架

#include
      #include
      staticintmygov_target(structcpufreq_policy *policy,unsignedinttarget_freq, unsignedintrelation){ /* 简单的频率设置 */ return__cpufreq_driver_target(policy, target_freq, relation);}staticintmygov_init(structcpufreq_policy *policy){ /* 初始化 */ return0;}staticvoidmygov_exit(structcpufreq_policy *policy){ /* 清理 */}staticstructcpufreq_governormy_governor = { .name ="mygov", .target = mygov_target, .init = mygov_init, .exit = mygov_exit, .owner = THIS_MODULE,};staticint__initmygov_init_module(void){ returncpufreq_register_governor(&my_governor);}staticvoid__exitmygov_exit_module(void){ cpufreq_unregister_governor(&my_governor);}module_init(mygov_init_module);module_exit(mygov_exit_module);MODULE_LICENSE("GPL");

8.2基于负载的调速器

staticvoidmygov_update(structcpufreq_policy *policy){ unsignedintload =calculate_cpu_load(policy); unsignedintnew_freq; if(load >80) { /* 高负载：升频到最大 */ new_freq = policy->max; }elseif(load < 20) { /* 低负载：降频到最小 */ new_freq = policy->min; }else{ /* 中等负载：线性插值 */ new_freq = policy->min + load * (policy->max - policy->min) /100; } __cpufreq_driver_target(policy, new_freq, CPUFREQ_RELATION_H);}

脑图：自定义调速器开发

九、性能优化实战

针对实际开发中的痛点，优化频率切换延迟、负载计算精度。

9.1减少频率切换延迟

/* 1. 使用 fast frequency switching */staticstructcpufreq_drivermy_driver={ .flags=CPUFREQ_FAST_SWITCHING, .fast_switch=my_fast_switch, // 原子上下文切换};/* 2. 减少 transition latency */// 在 OPP 表中设置较小的 clock-latency-nsopp-1200000000{ opp-hz=/bits/64<1200000000>; clock-latency-ns=<10000>; // 10us，而不是 40us};

9.2优化负载计算

/* 使用 PELT 信号代替 idle time */#include
      staticunsignedintget_pelt_load(structcpufreq_policy *policy){ unsignedintcpu = policy->cpu; structrq*rq =cpu_rq(cpu);
 /* PELT (Per-Entity Load Tracking) 是调度器内部的负载跟踪机制 */ returnrq->cfs.avg.util_avg; // 0 ~ 1024}