cpufreq 代码分析

static int cpufreq_online(unsigned int cpu)
{
	/* call driver. From then on the cpufreq must be able
	 * to accept all calls to ->verify and ->setpolicy for this CPU
	 */
	ret = cpufreq_driver->init(policy);  // 1.调用 cpufreq_driver->init 函数 初始化policy	

	down_write(&policy->rwsem);	

	if (new_policy) {
		ret = cpufreq_add_dev_interface(policy);  // 创建 sys 节点 cpufreq/scaling_cur_freq  等
		if (ret)
			goto out_exit_policy;

		cpufreq_stats_create_table(policy);    // 创建 cpufreq/sys  stats 节点

		write_lock_irqsave(&cpufreq_driver_lock, flags);
		list_add(&policy->policy_list, &cpufreq_policy_list);  //
		write_unlock_irqrestore(&cpufreq_driver_lock, flags);
	}

	ret = cpufreq_init_policy(policy);   //	初始化policy 的 governor

	up_write(&policy->rwsem);

	kobject_uevent(&policy->kobj, KOBJ_ADD);

	/* Callback for handling stuff after policy is ready */
	if (cpufreq_driver->ready)
		cpufreq_driver->ready(policy);    // cpufreq_driver->ready , 创建了cpufreq_cooling_dev,
                                           // 与 thermal 系统关联

	pr_debug("initialization complete\n");

	return 0;

}

cpufreq_driver->init -----------------> cpufreq_init ，主要是填充policy结构体中的 freq_table

static int cpufreq_init(struct cpufreq_policy *policy)
{	
	
	dev_pm_opp_of_cpumask_add_table(policy->cpus);  // 从dts 中读取 opp cpufreq table

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv) {
		ret = -ENOMEM;
		goto out_free_opp;
	}

	priv->reg_name = name;
	priv->opp_table = opp_table;

	ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);  //取出 freq_table
	if (ret) {
		dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
		goto out_free_priv;
	}

	priv->cpu_dev = cpu_dev;
	policy->driver_data = priv;
	policy->clk = cpu_clk;

	policy->suspend_freq = dev_pm_opp_get_suspend_opp_freq(cpu_dev) / 1000;

	ret = cpufreq_table_validate_and_show(policy, freq_table);	// freq_table 填入 policy

	transition_latency = dev_pm_opp_get_max_transition_latency(cpu_dev);
	if (!transition_latency)
		transition_latency = CPUFREQ_ETERNAL;

	policy->cpuinfo.transition_latency = transition_latency;
	policy->dvfs_possible_from_any_cpu = true;

	return 0;


}

static int cpufreq_init_policy(struct cpufreq_policy *policy)
{
	new_policy.governor = gov;	
	
	/* set default policy */
	return cpufreq_set_policy(policy, &new_policy);  // cpufreq_set_policy
}

static int cpufreq_set_policy(struct cpufreq_policy *policy,
				struct cpufreq_policy *new_policy)
{	
	/* start new governor */
	policy->governor = new_policy->governor;
	ret = cpufreq_init_governor(policy);
	if (!ret) {
		ret = cpufreq_start_governor(policy);     // start_governor		
	}	

	return ret;
}

static int cpufreq_start_governor(struct cpufreq_policy *policy)
{
	int ret;

	if (cpufreq_suspended)
		return 0;

	if (!policy->governor)
		return -EINVAL;

	pr_debug("%s: for CPU %u\n", __func__, policy->cpu);

	if (cpufreq_driver->get && !cpufreq_driver->setpolicy)
		cpufreq_update_current_freq(policy);

	if (policy->governor->start) {
		ret = policy->governor->start(policy);    // governor->start  
		if (ret)
			return ret;
	}

	if (policy->governor->limits)
		policy->governor->limits(policy);        // governor->limits

	return 0;
}

static struct dbs_governor od_dbs_gov = {
	.gov = CPUFREQ_DBS_GOVERNOR_INITIALIZER("ondemand"),
	.kobj_type = { .default_attrs = od_attributes },
	.gov_dbs_update = od_dbs_update,
	.alloc = od_alloc,
	.free = od_free,
	.init = od_init,
	.exit = od_exit,
	.start = od_start,
};

#define CPUFREQ_DBS_GOVERNOR_INITIALIZER(_name_)			\
	{								\
		.name = _name_,						\
		.dynamic_switching = true,				\
		.owner = THIS_MODULE,					\
		.init = cpufreq_dbs_governor_init,			\
		.exit = cpufreq_dbs_governor_exit,			\
		.start = cpufreq_dbs_governor_start,			\
		.stop = cpufreq_dbs_governor_stop,			\
		.limits = cpufreq_dbs_governor_limits,			\
	}