万字长文|Thermal框架源码剖析

作者简介：阅码场用户世至其美，目前就职小米，专注于内核调度，Kite热体验优化工具的作者。

1. 框架结构

thermal core：thermal主要的程序，驱动初始化程序，维系thermal zone、governor、cooling device三者的关系。

thermal zone device：创建thermal zone节点和连接thermal sensor，在/sys/class/thermal/目录下的thermal_zone*，通过dtsi文件进行配置生成。thermal sensor是温度传感器（即热敏电阻NTC），主要是给thermal提供温度感知。

thermal govnernor：温度控制算法，解决温控发生时（即throttle），cooling device如何选择cooling state的问题。

• step_wise

• power_allocator

• user_space

• bang_bang

• fair_share

thermal cooling device：系统温控的执行者，实施冷却措施的驱动（cpufreq_cooling、cpuidle_cooling、 devfreq_cooling等）。cooling device根据governor计算出来的state，实施冷却操作，一般情况下，state越高表示系统的冷却需求越高。cooling device需要与trip point进行绑定，当 trip point 触发后，由相应的cooling device 去实施冷却措施。

2. 代码结构

2.1 thermal core

thermal_core.c源代码 | v5.10.43> 主要是初始化driver，注册governor，解析dtsi文件，创建thermal zone和初始通信。

2.1.1 thermal结构体定义

thermal.h源代码 | v5.10.43> ，公开接口给其他驱动程序调用

// thermal_zone_device ops配置
struct thermal_zone_device_ops {
    int (*bind) (struct thermal_zone_device *,
             struct thermal_cooling_device *);
    int (*unbind) (struct thermal_zone_device *,
               struct thermal_cooling_device *);
    int (*get_temp) (struct thermal_zone_device *, int *);
    int (*set_trips) (struct thermal_zone_device *, int, int);
    int (*change_mode) (struct thermal_zone_device *,
        enumthermal_device_mode);
    int (*get_trip_type) (struct thermal_zone_device *, int,
        enumthermal_trip_type *);
    int(*get_trip_temp) (struct thermal_zone_device *, int, int *);
    int(*set_trip_temp) (struct thermal_zone_device *, int, int);
    int(*get_trip_hyst) (struct thermal_zone_device *, int, int *);
    int(*set_trip_hyst) (struct thermal_zone_device *, int, int);
    int(*get_crit_temp) (struct thermal_zone_device *, int *);
    int (*set_emul_temp) (struct thermal_zone_device *, int);
    int (*get_trend) (struct thermal_zone_device *, int,
              enum thermal_trend *);
    int (*notify) (struct thermal_zone_device *, int,
               enumthermal_trip_type);
};

// thermal_cooling_device ops配置
struct thermal_cooling_device_ops {
    int(*get_max_state) (struct thermal_cooling_device *, unsigned long *);
    int(*get_cur_state) (struct thermal_cooling_device *, unsigned long *);
    int (*set_cur_state) (struct thermal_cooling_device *, unsigned long);
    int(*get_requested_power)(struct thermal_cooling_device *, u32 *);
    int(*state2power)(struct thermal_cooling_device *, unsigned long, u32 *);
    int(*power2state)(struct thermal_cooling_device *, u32, unsigned long *);
};

thermal_core.c源代码 | v5.10.43>

//thermal驱动的init入口函数

static int __init thermal_init(void)

{

    int result;

    // generic netlink初始化

    result =thermal_netlink_init();

    if (result)

        goto error;

    // 注册thermal governor

    result =thermal_register_governors();

    if (result)

        goto error;

    // 注册/sys/class/thermal节点

    result =class_register(&thermal_class);

    if (result)

        goto unregister_governors;

    // 解析dtsi配置文件中的thermal-zones字段，并注册thermal_zone_device

    result =of_parse_thermal_zones();

    if (result)

        goto unregister_class;

    // 注册notifier

    result =register_pm_notifier(&thermal_pm_nb);

    if (result)

pr_warn("Thermal: Can not register suspend notifier, return %d\n",

            result);

    return 0;

unregister_class:

class_unregister(&thermal_class);

unregister_governors:

thermal_unregister_governors();

error:

ida_destroy(&thermal_tz_ida);

ida_destroy(&thermal_cdev_ida);

mutex_destroy(&thermal_list_lock);

mutex_destroy(&thermal_governor_lock);

mutex_destroy(&poweroff_lock);

    return result;

}

/* 将所有的governor策略（step_wise、power_allocator、user_space、fair_share）默认都注册给kernel */

static int __init thermal_register_governors(void)

{

    int ret = 0;

    structthermal_governor **governor;

    //遍历注册所有的governor策略

    for_each_governor_table(governor) {

        //注册governor策略接口

        ret =thermal_register_governor(*governor);

        if (ret) {

            pr_err("Failed to register governor: '%s'",

                   (*governor)->name);

            break;

        }

        pr_info("Registered thermal governor '%s'",

            (*governor)->name);

    }

    if (ret) {

        structthermal_governor **gov;

    for_each_governor_table(gov) {

            if (gov ==governor)

                break;

            thermal_unregister_governor(*gov);

        }

    }

    return ret;

}

// 将新governor添加到全局governor_list，设置默认的governor

int thermal_register_governor(struct thermal_governor *governor)

{

    int err;

    const char *name;

    struct thermal_zone_device *pos;

    if (!governor)

        return -EINVAL;

    mutex_lock(&thermal_governor_lock);

    err = -EBUSY;

    if (!__find_governor(governor->name)) {

        bool match_default;

        err = 0;

        // 将新governor添加到全局governor_list

        list_add(&governor->governor_list, &thermal_governor_list);

        // 查找匹配默认的governor，并设置默认值

        match_default = !strncmp(governor->name,

                     DEFAULT_THERMAL_GOVERNOR,

                     THERMAL_NAME_LENGTH);

        // Kconfig中配置默认的governor

        if (!def_governor && match_default)

            def_governor = governor;

    }

    mutex_lock(&thermal_list_lock);

    list_for_each_entry(pos, &thermal_tz_list, node) {

        /*

         * only thermal zones with specified tz->tzp->governor_name

         * may run with tz->govenor unset

         */

        if (pos->governor)

            continue;

        name = pos->tzp->governor_name;

        if (!strncasecmp(name, governor->name, THERMAL_NAME_LENGTH)) {

            int ret;

            ret = thermal_set_governor(pos, governor);

            if (ret)

                dev_err(&pos->device,

                    "Failed to set governor %s for thermal zone %s: %d\n",

                    governor->name, pos->type, ret);

        }

    }

    mutex_unlock(&thermal_list_lock);

    mutex_unlock(&thermal_governor_lock);

    return err;

}

// 注册一个thermal_zone_device

struct thermal_zone_device *

thermal_zone_device_register(const char *type, int trips, int mask,

                 void *devdata, struct thermal_zone_device_ops *ops,

                 struct thermal_zone_params *tzp, int passive_delay,

                 int polling_delay)

{

    struct thermal_zone_device *tz;

    enum thermal_trip_type trip_type;

    int trip_temp;

    int id;

    int result;

    int count;

    struct thermal_governor *governor;

    if (!type || strlen(type) == 0) {

        pr_err("Error: No thermal zone type defined\n");

        return ERR_PTR(-EINVAL);

    }

    if (type && strlen(type) >= THERMAL_NAME_LENGTH) {

        pr_err("Error: Thermal zone name (%s) too long, should be under %d chars\n",

               type, THERMAL_NAME_LENGTH);

        return ERR_PTR(-EINVAL);

    }

    if (trips > THERMAL_MAX_TRIPS || trips < 0 || mask >> trips) {

        pr_err("Error: Incorrect number of thermal trips\n");

        return ERR_PTR(-EINVAL);

    }

    if (!ops) {

        pr_err("Error: Thermal zone device ops not defined\n");

        return ERR_PTR(-EINVAL);

    }

    if (trips > 0 && (!ops->get_trip_type || !ops->get_trip_temp))

        return ERR_PTR(-EINVAL);

    tz = kzalloc(sizeof(*tz), GFP_KERNEL);

    if (!tz)

        return ERR_PTR(-ENOMEM);

    // 初始化一个链表thermal_instances

    INIT_LIST_HEAD(&tz->thermal_instances);

    ida_init(&tz->ida);

    mutex_init(&tz->lock);

    // 自动分配id

    id = ida_simple_get(&thermal_tz_ida, 0, 0, GFP_KERNEL);

    if (id < 0) {

        result = id;

        goto free_tz;

    }

    tz->id = id;

    strlcpy(tz->type, type, sizeof(tz->type));

    tz->ops = ops;

    tz->tzp = tzp;

    tz->device.class = &thermal_class;

    tz->devdata = devdata;

    tz->trips = trips;

    tz->passive_delay = passive_delay;

    tz->polling_delay = polling_delay;

    /* sys I/F */

    /* Add nodes that are always present via .groups */

    result = thermal_zone_create_device_groups(tz, mask);

    if (result)

        goto remove_id;

    /* A new thermal zone needs to be updated anyway. */

    atomic_set(&tz->need_update, 1);

    // 设置thermal_zone节点名称

    dev_set_name(&tz->device, "thermal_zone%d", tz->id);

    result = device_register(&tz->device);

    if (result)

        goto release_device;

    for (count = 0; count < trips; count++) {

        if (tz->ops->get_trip_type(tz, count, &trip_type))

            set_bit(count, &tz->trips_disabled);

        if (tz->ops->get_trip_temp(tz, count, &trip_temp))

            set_bit(count, &tz->trips_disabled);

        /* Check for bogus trip points */

        if (trip_temp == 0)

            set_bit(count, &tz->trips_disabled);

    }

    /* Update 'this' zone's governor information */

    mutex_lock(&thermal_governor_lock);

    // thermal_zone设置governor,否则默认governor

    if (tz->tzp)

        governor = __find_governor(tz->tzp->governor_name);

    else

        governor = def_governor;

    result = thermal_set_governor(tz, governor);

    if (result) {

        mutex_unlock(&thermal_governor_lock);

        goto unregister;

    }

    mutex_unlock(&thermal_governor_lock);

    if (!tz->tzp || !tz->tzp->no_hwmon) {

        result = thermal_add_hwmon_sysfs(tz);

        if (result)

            goto unregister;

    }

    mutex_lock(&thermal_list_lock);

  // 将thermal zone加入到thermal_tz_list

    list_add_tail(&tz->node, &thermal_tz_list);

    mutex_unlock(&thermal_list_lock);

    // 将thermal_cdev_list上的cooling设备绑定到thermal_zone_device上

    bind_tz(tz);

    // 初始化work queue下半部分，处理中断需要响应的操作，定时去调用thermal_zone_device_update函数

    // 设置polling_delay值为轮询周期

    INIT_DELAYED_WORK(&tz->poll_queue, thermal_zone_device_check);

    // 对thermal zone的温度等复位。

    thermal_zone_device_reset(tz);

    /* Update the new thermal zone and mark it as already updated. */

    if (atomic_cmpxchg(&tz->need_update, 1, 0))

        thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);

    thermal_notify_tz_create(tz->id, tz->type);

    return tz;

unregister:

    device_del(&tz->device);

release_device:

    put_device(&tz->device);

    tz = NULL;

remove_id:

    ida_simple_remove(&thermal_tz_ida, id);

free_tz:

    kfree(tz);

    return ERR_PTR(result);

}

// 将thermal_cdev_list上的cooling设备绑定到thermal_zone_device上

static void bind_tz(struct thermal_zone_device *tz)

{

    int i, ret;

    struct thermal_cooling_device *pos = NULL;

    const struct thermal_zone_params *tzp = tz->tzp;

    if (!tzp && !tz->ops->bind)

        return;

    mutex_lock(&thermal_list_lock);

    /* If there is ops->bind, try to use ops->bind */

    if (tz->ops->bind) {

        // 遍历thermal_cdev_list，绑定cooling设备

        list_for_each_entry(pos, &thermal_cdev_list, node) {

            ret = tz->ops->bind(tz, pos);

            if (ret)

                print_bind_err_msg(tz, pos, ret);

        }

        goto exit;

    }

    if (!tzp || !tzp->tbp)

        goto exit;

    list_for_each_entry(pos, &thermal_cdev_list, node) {

        for (i = 0; i < tzp->num_tbps; i++) {

            if (tzp->tbp[i].cdev || !tzp->tbp[i].match)

                continue;

            if (tzp->tbp[i].match(tz, pos))

                continue;

            tzp->tbp[i].cdev = pos;

            __bind(tz, tzp->tbp[i].trip_mask, pos,

                   tzp->tbp[i].binding_limits,

                   tzp->tbp[i].weight);

        }

    }

exit:

    mutex_unlock(&thermal_list_lock);

}

// 检查thermal_zone_device

static void thermal_zone_device_check(struct work_struct *work)

{

    //通过结构体成员变量地址来获取这个thermal_zone_device结构体的地址

    struct thermal_zone_device *tz = container_of(work, struct

                              thermal_zone_device,

                              poll_queue.work);

    //更新thermal_zone_device

    thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);

}

void thermal_zone_device_update(struct thermal_zone_device *tz,

                enum thermal_notify_event event)

{

    int count;

    //判断是否需要轮询的方式

    if (should_stop_polling(tz))

        return;

    if (atomic_read(&in_suspend))

        return;

    // 判断sensor是否实现get_temp函数

    if (!tz->ops->get_temp)

        return;

    // 更新sensor温度，也就是thermal_zone的温度

    update_temperature(tz);

    // 更新trip值

    thermal_zone_set_trips(tz);

    tz->notify_event = event;

    for (count = 0; count < tz->trips; count++)

        handle_thermal_trip(tz, count);

}

// 更新thermal zone温度

static void update_temperature(struct thermal_zone_device *tz)

{

    int temp, ret;

    // 获取thermal_zone的温度

    ret = thermal_zone_get_temp(tz, &temp);

    if (ret) {

        if (ret != -EAGAIN)

            dev_warn(&tz->device,

                 "failed to read out thermal zone (%d)\n",

                 ret);

        return;

    }

    mutex_lock(&tz->lock);

    tz->last_temperature = tz->temperature;

    tz->temperature = temp;

    mutex_unlock(&tz->lock);

    trace_thermal_temperature(tz);

    thermal_genl_sampling_temp(tz->id, temp);

}

// 遍历处理符合条件的trips

static void handle_thermal_trip(struct thermal_zone_device *tz, int trip)

{

    enum thermal_trip_type type;

    int trip_temp, hyst = 0;

    /* Ignore disabled trip points */

    if (test_bit(trip, &tz->trips_disabled))

        return;

    // 获取trip_temp、trip_type、get_trip_hyst

    tz->ops->get_trip_temp(tz, trip, &trip_temp);

    tz->ops->get_trip_type(tz, trip, &type);

    if (tz->ops->get_trip_hyst)

        tz->ops->get_trip_hyst(tz, trip, &hyst);

    if (tz->last_temperature != THERMAL_TEMP_INVALID) {

        // 触发trip

        if (tz->last_temperature < trip_temp &&

            tz->temperature >= trip_temp)

            thermal_notify_tz_trip_up(tz->id, trip);

    // 触发hysteresis

        if (tz->last_temperature >= trip_temp &&

            tz->temperature < (trip_temp - hyst))

            thermal_notify_tz_trip_down(tz->id, trip);

    }

    // 处理critical||hot的trips

    if (type == THERMAL_TRIP_CRITICAL || type == THERMAL_TRIP_HOT)

        handle_critical_trips(tz, trip, type);

    // 如果设置了governor，调用governor->throttle函数

    else

        handle_non_critical_trips(tz, trip);

    /*

     * Alright, we handled this trip successfully.

     * So, start monitoring again.

     */

    monitor_thermal_zone(tz);

}

// 处理type为critical||hot的trips

static void handle_critical_trips(struct thermal_zone_device *tz,

                  int trip, enum thermal_trip_type trip_type)

{

    int trip_temp;

    tz->ops->get_trip_temp(tz, trip, &trip_temp);

    /* If we have not crossed the trip_temp, we do not care. */

    if (trip_temp <= 0 || tz->temperature < trip_temp)

        return;

    trace_thermal_zone_trip(tz, trip, trip_type);

    if (tz->ops->notify)

        tz->ops->notify(tz, trip, trip_type);

    // 如果是critical，准备关机

    if (trip_type == THERMAL_TRIP_CRITICAL) {

        dev_emerg(&tz->device,

              "critical temperature reached (%d C), shutting down\n",

              tz->temperature / 1000);

        mutex_lock(&poweroff_lock);

        if (!power_off_triggered) {

            /*

             * Queue a backup emergency shutdown in the event of

             * orderly_poweroff failure

             */

            // 调用thermal_emergency_poweroff准备关机操作

            thermal_emergency_poweroff();

            orderly_poweroff(true);

            power_off_triggered = true;

        }

        mutex_unlock(&poweroff_lock);

    }

}

//处理其他的trips

//一般情况都是这个

static void handle_non_critical_trips(struct thermal_zone_device *tz, int trip)

{

    //如果设置了governor，调用governor->throttle函数

    //否则调用默认的

    tz->governor ? tz->governor->throttle(tz, trip) :

               def_governor->throttle(tz, trip);

}

// 监控delay时间进行延时后工作

static void monitor_thermal_zone(struct thermal_zone_device *tz)

{

    bool stop;

    stop = should_stop_polling(tz);

    mutex_lock(&tz->lock);

    // 超过阀值轮询时间

    if (!stop && tz->passive)

        thermal_zone_device_set_polling(tz, tz->passive_delay);

    // 未超过阀值轮询时间

    else if (!stop && tz->polling_delay)

        thermal_zone_device_set_polling(tz, tz->polling_delay);

  // 取消调用，不轮询

    else

        thermal_zone_device_set_polling(tz, 0);

    mutex_unlock(&tz->lock);

}

static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,

                        int delay)

{

    //需延时后再使用system_freezable_power_efficient_wq的工作队列进行工作

    if (delay > 1000)

        mod_delayed_work(system_freezable_power_efficient_wq,

                 &tz->poll_queue,

                 round_jiffies(msecs_to_jiffies(delay)));

    else if (delay)

        mod_delayed_work(system_freezable_power_efficient_wq,

                 &tz->poll_queue,

                 msecs_to_jiffies(delay));

    // 删除提交到工作队列的任务，不轮询

    else

        cancel_delayed_work(&tz->poll_queue);

}

在thermal_helps.c 源代码 | v5.10.43> 定义thermal_zone_get_temp函数

int thermal_zone_get_temp(struct thermal_zone_device *tz, int *temp)

{

    int ret = -EINVAL;

    int count;

    int crit_temp = INT_MAX;

    enum thermal_trip_type type;

    if (!tz || IS_ERR(tz) || !tz->ops->get_temp)

        goto exit;

    mutex_lock(&tz->lock);

    // 获取当前sensor的温度，sensor里面实现

    ret = tz->ops->get_temp(tz, temp);

    // thermal debug开关

    if (IS_ENABLED(CONFIG_THERMAL_EMULATION) && tz->emul_temperature) {

        for (count = 0; count < tz->trips; count++) {

            ret = tz->ops->get_trip_type(tz, count, &type);

            if (!ret && type == THERMAL_TRIP_CRITICAL) {

                ret = tz->ops->get_trip_temp(tz, count,

                        &crit_temp);

                break;

            }

        }

        /*

         * Only allow emulating a temperature when the real temperature

         * is below the critical temperature so that the emulation code

         * cannot hide critical conditions.

         */

        if (!ret && *temp < crit_temp)

            *temp = tz->emul_temperature;

    }

    mutex_unlock(&tz->lock);

exit:

    return ret;

}

// 获取当前温度下的thermal zone下一次的trip点

void thermal_zone_set_trips(struct thermal_zone_device *tz)

{

    int low = -INT_MAX;

    int high = INT_MAX;

    int trip_temp, hysteresis;

    int i, ret;

    mutex_lock(&tz->lock);

    if (!tz->ops->set_trips || !tz->ops->get_trip_hyst)

        goto exit;

    for (i = 0; i < tz->trips; i++) {

        int trip_low;

        // 获取sensor的触发温度

        tz->ops->get_trip_temp(tz, i, &trip_temp);

        // 获取sensor下降温度值恢复状态

        tz->ops->get_trip_hyst(tz, i, &hysteresis);

        trip_low = trip_temp - hysteresis;

        if (trip_low < tz->temperature && trip_low > low)

            low = trip_low;

        if (trip_temp > tz->temperature && trip_temp < high)

            high = trip_temp;

    }

    /* No need to change trip points */

    // 与上次对比相同，不需要进行更新

    if (tz->prev_low_trip == low && tz->prev_high_trip == high)

        goto exit;

    tz->prev_low_trip = low;

    tz->prev_high_trip = high;

    dev_dbg(&tz->device,

        "new temperature boundaries: %d < x < %d\n", low, high);

    /*

     * Set a temperature window. When this window is left the driver

     * must inform the thermal core via thermal_zone_device_update.

     */

    // 设置新的温度trip

    ret = tz->ops->set_trips(tz, low, high);

    if (ret)

        dev_err(&tz->device, "Failed to set trips: %d\n", ret);

exit:

    mutex_unlock(&tz->lock);

}

2.2 dtsi文件解析

thermal_of.c源代码 | v5.10.43> 解析dtsi文件，主要函数是of_parse_thermal_zones，创建解析生成thermal zone节点。

//解析dtsi中的&thermal_zones

int __init of_parse_thermal_zones(void)

{

    struct device_node *np, *child;

    struct __thermal_zone *tz;

    struct thermal_zone_device_ops *ops;

    //查找到thermal-zones

    np = of_find_node_by_name(NULL, "thermal-zones");

    if (!np) {

        pr_debug("unable to find thermal zones\n");

        return 0; /* Run successfully on systems without thermal DT */

    }

    for_each_available_child_of_node(np, child) {

        struct thermal_zone_device *zone;

        struct thermal_zone_params *tzp;

        int i, mask = 0;

        u32 prop;

        //创建一个thermal zone节点

        tz = thermal_of_build_thermal_zone(child);

        if (IS_ERR(tz)) {

            pr_err("failed to build thermal zone %pOFn: %ld\n",

                   child,

                   PTR_ERR(tz));

            continue;

        }

        //申请一段新内存，并将of_thermal_ops中的内容复制到新申请的这段内存中

        ops = kmemdup(&of_thermal_ops, sizeof(*ops), GFP_KERNEL);

        if (!ops)

            goto exit_free;

        tzp = kzalloc(sizeof(*tzp), GFP_KERNEL);

        if (!tzp) {

            kfree(ops);

            goto exit_free;

        }

        /* No hwmon because there might be hwmon drivers registering */

        tzp->no_hwmon = true;

        // 解析sustainable-power字段

        if (!of_property_read_u32(child, "sustainable-power", &prop))

            tzp->sustainable_power = prop;

        for (i = 0; i < tz->ntrips; i++)

            mask |= 1 << i;

        /* these two are left for temperature drivers to use */

        tzp->slope = tz->slope;

        tzp->offset = tz->offset;

        // 向thermal_core注册thermal_zone_device

        zone = thermal_zone_device_register(child->name, tz->ntrips,

                            mask, tz,

                            ops, tzp,

                            tz->passive_delay,

                            tz->polling_delay);

        if (IS_ERR(zone)) {

            pr_err("Failed to build %pOFn zone %ld\n", child,

                   PTR_ERR(zone));

            kfree(tzp);

            kfree(ops);

            of_thermal_free_zone(tz);

            /* attempting to build remaining zones still */

        }

    }

    of_node_put(np);

    return 0;

exit_free:

    of_node_put(child);

    of_node_put(np);

    of_thermal_free_zone(tz);

    /* no memory available, so free what we have built */

    of_thermal_destroy_zones();

    return -ENOMEM;

}

//创建一个thermal zone节点

static struct __thermal_zone

__init *thermal_of_build_thermal_zone(struct device_node *np)

{

    struct device_node *child = NULL, *gchild;

    struct __thermal_zone *tz;

    int ret, i;

    u32 prop, coef[2];

    if (!np) {

        pr_err("no thermal zone np\n");

        return ERR_PTR(-EINVAL);

    }

    tz = kzalloc(sizeof(*tz), GFP_KERNEL);

    if (!tz)

        return ERR_PTR(-ENOMEM);

    //解析polling-delay-passive，超过阀值轮询时间

    ret = of_property_read_u32(np, "polling-delay-passive", &prop);

    if (ret < 0) {

        pr_err("%pOFn: missing polling-delay-passive property\n", np);

        goto free_tz;

    }

    tz->passive_delay = prop;

    //解析polling-delay，未超阀值轮询时间

    ret = of_property_read_u32(np, "polling-delay", &prop);

    if (ret < 0) {

        pr_err("%pOFn: missing polling-delay property\n", np);

        goto free_tz;

    }

    tz->polling_delay = prop;

    /*

     * REVIST: for now, the thermal framework supports only

     * one sensor per thermal zone. Thus, we are considering

     * only the first two values as slope and offset.

     */

    //暂时支持一个sensor对应一个thermal zone

    ret = of_property_read_u32_array(np, "coefficients", coef, 2);

    if (ret == 0) {

        tz->slope = coef[0];

        tz->offset = coef[1];

    } else {

        tz->slope = 1;

        tz->offset = 0;

    }

    /* trips */

    // 查找trips字段

    child = of_get_child_by_name(np, "trips");

    /* No trips provided */

    if (!child)

        goto finish;

    //获取trips字段下child数量

    tz->ntrips = of_get_child_count(child);

    if (tz->ntrips == 0) /* must have at least one child */

        goto finish;

    tz->trips = kcalloc(tz->ntrips, sizeof(*tz->trips), GFP_KERNEL);

    if (!tz->trips) {

        ret = -ENOMEM;

        goto free_tz;

    }

    i = 0;

    for_each_child_of_node(child, gchild) {

        // 遍历解析trips字段下面的字段

        ret = thermal_of_populate_trip(gchild, &tz->trips[i++]);

        if (ret)

            goto free_trips;

    }

    // 减少节点引用

    of_node_put(child);

    /* cooling-maps */

  // 查找cooling-maps字段

    child = of_get_child_by_name(np, "cooling-maps");

    /* cooling-maps not provided */

    if (!child)

        goto finish;

    tz->num_tbps = of_get_child_count(child);

    if (tz->num_tbps == 0)

        goto finish;

    tz->tbps = kcalloc(tz->num_tbps, sizeof(*tz->tbps), GFP_KERNEL);

    if (!tz->tbps) {

        ret = -ENOMEM;

        goto free_trips;

    }

    i = 0;

    for_each_child_of_node(child, gchild) {

        // 遍历解析cooling-maps下的字段,绑定cooling device

        ret = thermal_of_populate_bind_params(gchild, &tz->tbps[i++],

                              tz->trips, tz->ntrips);

        if (ret)

            goto free_tbps;

    }

finish:

    of_node_put(child);

    return tz;

free_tbps:

    for (i = i - 1; i >= 0; i--) {

        struct __thermal_bind_params *tbp = tz->tbps + i;

        int j;

        for (j = 0; j < tbp->count; j++)

            of_node_put(tbp->tcbp[j].cooling_device);

        kfree(tbp->tcbp);

    }

    kfree(tz->tbps);

free_trips:

    for (i = 0; i < tz->ntrips; i++)

        of_node_put(tz->trips[i].np);

    kfree(tz->trips);

    of_node_put(gchild);

free_tz:

    kfree(tz);

    of_node_put(child);

    return ERR_PTR(ret);

}

// 遍历解析trips下的字段

static int thermal_of_populate_trip(struct device_node *np,

                    struct thermal_trip *trip)

{

    int prop;

    int ret;

    // 解析temperature字段，触发温度值

    ret = of_property_read_u32(np, "temperature", &prop);

    if (ret < 0) {

        pr_err("missing temperature property\n");

        return ret;

    }

    trip->temperature = prop;

    // 解析hysteresis字段，下降温度值恢复状态

    ret = of_property_read_u32(np, "hysteresis", &prop);

    if (ret < 0) {

        pr_err("missing hysteresis property\n");

        return ret;

    }

    trip->hysteresis = prop;

    // 解析type字段，一般配置为passive，当温控发生后由governor控制

    ret = thermal_of_get_trip_type(np, &trip->type);

    if (ret < 0) {

        pr_err("wrong trip type property\n");

        return ret;

    }

    /* Required for cooling map matching */

    trip->np = np;

    of_node_get(np);

    return 0;

}

//解析cooling-maps下字段

static int thermal_of_populate_bind_params(struct device_node *np,

                       struct __thermal_bind_params *__tbp,

                       struct thermal_trip *trips,

                       int ntrips)

{

    struct of_phandle_args cooling_spec;

    struct __thermal_cooling_bind_param *__tcbp;

    struct device_node *trip;

    int ret, i, count;

    u32 prop;

    // 默认contribution字段，表示权重值，可选

    __tbp->usage = THERMAL_WEIGHT_DEFAULT;

    ret = of_property_read_u32(np, "contribution", &prop);

    if (ret == 0)

        __tbp->usage = prop;

    // 获取trip字段下phandle

    trip = of_parse_phandle(np, "trip", 0);

    if (!trip) {

        pr_err("missing trip property\n");

        return -ENODEV;

    }

    //匹配trips列表中的trip

    for (i = 0; i < ntrips; i++)

        if (trip == trips[i].np) {

            __tbp->trip_id = i;

            break;

        }

    if (i == ntrips) {

        ret = -ENODEV;

        goto end;

    }

    //获取cooling-device的phandle个数

    count = of_count_phandle_with_args(np, "cooling-device",

                       "#cooling-cells");

    if (count <= 0) {

        pr_err("Add a cooling_device property with at least one device\n");

        ret = -ENOENT;

        goto end;

    }

    __tcbp = kcalloc(count, sizeof(*__tcbp), GFP_KERNEL);

    if (!__tcbp) {

        ret = -ENOMEM;

        goto end;

    }

    for (i = 0; i < count; i++) {

        //获取cooling-device的phandle参数

        ret = of_parse_phandle_with_args(np, "cooling-device",

                "#cooling-cells", i, &cooling_spec);

        if (ret < 0) {

            pr_err("Invalid cooling-device entry\n");

            goto free_tcbp;

        }

        __tcbp[i].cooling_device = cooling_spec.np;

        //参数个数必须大于等于2，写最小最大的范围值，代表可调整最小最大档位

        if (cooling_spec.args_count >= 2) { /* at least min and max */

            __tcbp[i].min = cooling_spec.args[0];

            __tcbp[i].max = cooling_spec.args[1];

        } else {

            pr_err("wrong reference to cooling device, missing limits\n");

        }

    }

    __tbp->tcbp = __tcbp;

    __tbp->count = count;

    goto end;

free_tcbp:

    for (i = i - 1; i >= 0; i--)

        of_node_put(__tcbp[i].cooling_device);

    kfree(__tcbp);

end:

    of_node_put(trip);

    return ret;

}

thermal_extra.drawio.svg

2.3 thermal governor

目前可配置默认的thermal governor策略

/* Default Thermal Governor */

#if defined(CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE)

#define DEFAULT_THERMAL_GOVERNOR       "step_wise"

#elif defined(CONFIG_THERMAL_DEFAULT_GOV_FAIR_SHARE)

#define DEFAULT_THERMAL_GOVERNOR       "fair_share"

#elif defined(CONFIG_THERMAL_DEFAULT_GOV_USER_SPACE)

#define DEFAULT_THERMAL_GOVERNOR       "user_space"

#elif defined(CONFIG_THERMAL_DEFAULT_GOV_POWER_ALLOCATOR)

#define DEFAULT_THERMAL_GOVERNOR       "power_allocator"

#endif

Kconfig中配置thermal governor默认step_wise下降温度值恢复状态

config THERMAL_WRITABLE_TRIPS

    bool "Enable writable trip points"

    help

      This option allows the system integrator to choose whether

      trip temperatures can be changed from userspace. The

      writable trips need to be specified when setting up the

      thermal zone but the choice here takes precedence.

      Say 'Y' here if you would like to allow userspace tools to

      change trip temperatures.

choice

    prompt "Default Thermal governor"

    default THERMAL_DEFAULT_GOV_STEP_WISE

    help

      This option sets which thermal governor shall be loaded at

      startup. If in doubt, select 'step_wise'.

config THERMAL_DEFAULT_GOV_STEP_WISE

    bool "step_wise"

    select THERMAL_GOV_STEP_WISE

    help

      Use the step_wise governor as default. This throttles the

      devices one step at a time.

config THERMAL_DEFAULT_GOV_FAIR_SHARE

    bool "fair_share"

    select THERMAL_GOV_FAIR_SHARE

    help

      Use the fair_share governor as default. This throttles the

      devices based on their 'contribution' to a zone. The

      contribution should be provided through platform data.

config THERMAL_DEFAULT_GOV_USER_SPACE

    bool "user_space"

    select THERMAL_GOV_USER_SPACE

    help

      Select this if you want to let the user space manage the

      platform thermals.

config THERMAL_DEFAULT_GOV_POWER_ALLOCATOR

    bool "power_allocator"

    depends on THERMAL_GOV_POWER_ALLOCATOR

    help

      Select this if you want to control temperature based on

      system and device power allocation. This governor can only

      operate on cooling devices that implement the power API.

endchoice

2.3.1 step_wise governor

step_wise governor 是每个轮询周期逐级提高冷却状态，是一种相对温和的温控策略。根据cur_state、温升趋势trend、是否throttle去计算cooling_device的target_state，从而达到控制cooling_device来控制温升。

对于cooling state的计算策略：

1. 1.     当温升趋势为上升且发生throttle，使用更高一级的cooling state

2. 2.     当温升趋势为下降

若发生throttle，不改变cooling state

若解除throttle，使用更低一级的cooling state

1. 1.     当达到最高温线且发生throttle，使用最高级的 cooling state

2. 2.     当达到最低温线且发生throttle，使用最低级的cooling state

注意： cooling state 取值范围在[instance->lower,instance->upper]，若cur_state < instance->lower，target_state则取值为THERMAL_NO_TARGET。

代码框架图

thermal.h源代码 | v5.10.43> 定义了温升趋势trend。

enum thermal_trend {THERMAL_TREND_STABLE, /* 稳定temperature is stable */ THERMAL_TREND_RAISING,/* 上升 temperature is raising */THERMAL_TREND_DROPPING, /* 下降temperature is dropping */THERMAL_TREND_RAISE_FULL, /* 最高温线apply highest cooling action */THERMAL_TREND_DROP_FULL, /* 最低温线apply lowest cooling action */};

gov_step_wise.c源代码 | v5.10.43>

static int step_wise_throttle(struct thermal_zone_device *tz, int trip){  struct thermal_instance*instance; // 更新trip、trend和计算cooling_device的target_statethermal_zone_trip_update(tz, trip); if (tz->forced_passive)thermal_zone_trip_update(tz, THERMAL_TRIPS_NONE);mutex_lock(&tz->lock); // 遍历更新cooling_device的statelist_for_each_entry(instance, &tz->thermal_instances, tz_node)thermal_cdev_update(instance->cdev);mutex_unlock(&tz->lock); return 0;}// 更新trip、trend和计算cooling_device的target_statestatic void thermal_zone_trip_update(struct thermal_zone_device *tz, int trip){ int trip_temp; enum thermal_trip_type trip_type; enum thermal_trend trend; struct thermal_instance *instance;  bool throttle = false; int old_target; // 获取trip的类型和温度 if (trip == THERMAL_TRIPS_NONE) {trip_temp = tz->forced_passive;trip_type = THERMAL_TRIPS_NONE; } else {tz->ops->get_trip_temp(tz, trip, &trip_temp);tz->ops->get_trip_type(tz, trip, &trip_type); } // 获取温升趋势，稳定(THERMAL_TREND_STABLE),上升（THERMAL_TREND_RAISING）,下降（THERMAL_TREND_DROPPING） trend =get_tz_trend(tz, trip); // 当zone温度大于trip_temp，则需要进行触发 if (tz->temperature >= trip_temp) {throttle = true;trace_thermal_zone_trip(tz, trip, trip_type); }dev_dbg(&tz->device, "Trip%d[type=%d,temp=%d]:trend=%d,throttle=%d\n",trip, trip_type, trip_temp, trend, throttle);mutex_lock(&tz->lock);list_for_each_entry(instance, &tz->thermal_instances, tz_node) { if (instance->trip != trip)continue;old_target = instance->target;     // 计算cooling_device的target_stateinstance->target = get_target_state(instance, trend, throttle);dev_dbg(&instance->cdev->device, "old_target=%d,target=%d\n", old_target, (int)instance->target); if (instance->initialized && old_target== instance->target)continue; /* Activate a passive thermal instance */ if (old_target == THERMAL_NO_TARGET &&instance->target != THERMAL_NO_TARGET)update_passive_instance(tz, trip_type, 1); /* Deactivate a passive thermal instance */ else if (old_target != THERMAL_NO_TARGET &&instance->target == THERMAL_NO_TARGET)update_passive_instance(tz, trip_type, -1);instance->initialized = true;mutex_lock(&instance->cdev->lock);instance->cdev->updated = false; /* cdev needs update */mutex_unlock(&instance->cdev->lock); } mutex_unlock(&tz->lock);}// 计算cooling_device的target_statestatic unsigned long get_target_state(structthermal_instance *instance,enum thermal_trend trend,bool throttle){ struct thermal_cooling_device *cdev = instance->cdev; unsigned long cur_state; unsigned long next_target; /* * Wekeep this instance the way it is by default. *Otherwise, we use the current state of the * cdevin use to determine the next_target. */ //获取coolingdevice的当前statecdev->ops->get_cur_state(cdev, &cur_state);next_target = instance->target;dev_dbg(&cdev->device, "cur_state=%ld\n", cur_state); //如果没有初始化 if (!instance->initialized) { if (throttle) {// next_target初始值为(cur_state + 1)，取值范围在[instance->lower,instance->upper]next_target = (cur_state + 1) >= instance->upper ? instance->upper : ((cur_state + 1) < instance->lower ? instance->lower :(cur_state + 1)); } else {next_target = THERMAL_NO_TARGET; } return next_target; } switch (trend) { // 当温升趋势为上升且发生throttle，使用更高一级的cooling state // 取值范围在[instance->lower,instance->upper]   case THERMAL_TREND_RAISING: if (throttle) {next_target = cur_state < instance->upper ? (cur_state + 1) : instance->upper;if (next_target <instance->lower)next_target = instance->lower; } break; // 当达到最高温线且发生throttle，使用最高级的cooling state，将温度快速降下来 case THERMAL_TREND_RAISE_FULL: if (throttle)next_target = instance->upper; break; // 当温升趋势为下降 // 发生throttle，不改变coolingstate // 解除throttle，使用低一级的coolingstate case THERMAL_TREND_DROPPING: if (cur_state <= instance->lower) {if (!throttle)next_target = THERMAL_NO_TARGET; } else {   if (!throttle) {next_target = cur_state - 1;if (next_target >instance->upper) next_target =instance->upper;} } break; // 当达到最低温线且发生throttle，使用最低级的coolingstate case THERMAL_TREND_DROP_FULL: if (cur_state == instance->lower) {if (!throttle)next_target = THERMAL_NO_TARGET; } elsenext_target = instance->lower; break; default: break; } return next_target;}

thermal_cdev_update函数 源代码 | v5.10.43>

// 更新cooling device的statevoid thermal_cdev_update(structthermal_cooling_device *cdev){ struct thermal_instance *instance; unsigned long target = 0;mutex_lock(&cdev->lock); /* cooling device is updated*/ if (cdev->updated) {mutex_unlock(&cdev->lock); return; } /* Make sure cdev enters the deepest cooling state */list_for_each_entry(instance, &cdev->thermal_instances,cdev_node) {dev_dbg(&cdev->device, "zone%d->target=%lu\n",           instance->tz->id,instance->target); if (instance->target == THERMAL_NO_TARGET)continue; if (instance->target > target)target = instance->target; } // 设置coolingdevice的statethermal_cdev_set_cur_state(cdev, target);cdev->updated = true;mutex_unlock(&cdev->lock);trace_cdev_update(cdev, target);dev_dbg(&cdev->device, "set to state%lu\n", target);}

2.3.2 power_allocator governor

IPA(Intelligent PowerAllocation)源代码 | v5.10.43>是由ARM开发的符合linux内核thermalframework的governor，代码中的名字为power_allocator，旨在满足温控效果的条件下最大化性能。IPA（Intelligent Power Allocator）模型的核心是利用 PID 控制器，ThermalZone 的温度作为输入，可分配功耗值作为输出，调节 Allocator 的频率和电压值。

代码框架图

功耗均衡原理图

gov_power_allocator.c源代码 | v5.10.43>

static int power_allocator_throttle(struct thermal_zone_device *tz, int trip)

{

    int ret;

    int switch_on_temp, control_temp;

    struct power_allocator_params *params = tz->governor_data;

    /*

     * We get called for every trip point but we only need to do

     * our calculations once

     */

    if (trip != params->trip_max_desired_temperature)

        return 0;

    // 获取trip温度，作为switch_on触发温度

    ret = tz->ops->get_trip_temp(tz, params->trip_switch_on,

                     &switch_on_temp);

    if (!ret && (tz->temperature < switch_on_temp)) {

        tz->passive = 0;

        reset_pid_controller(params);

        allow_maximum_power(tz);

        return 0;

    }

    tz->passive = 1;

    // 获取trip温度，作为目标的温度值

    ret = tz->ops->get_trip_temp(tz, params->trip_max_desired_temperature,

                &control_temp);

    if (ret) {

        dev_warn(&tz->device,

             "Failed to get the maximum desired temperature: %d\n",

             ret);

        return ret;

    }

    // IPA主要的算法逻辑

    return allocate_power(tz, control_temp);

}

// IPA主要的算法逻辑

static int allocate_power(struct thermal_zone_device *tz,

              int control_temp)

{

    struct thermal_instance *instance;

    struct power_allocator_params *params = tz->governor_data;

    u32 *req_power, *max_power, *granted_power, *extra_actor_power;

    u32 *weighted_req_power;

    u32 total_req_power, max_allocatable_power, total_weighted_req_power;

    u32 total_granted_power, power_range;

    int i, num_actors, total_weight, ret = 0;

    int trip_max_desired_temperature = params->trip_max_desired_temperature;

    mutex_lock(&tz->lock);

    num_actors = 0;

    total_weight = 0;

    list_for_each_entry(instance, &tz->thermal_instances, tz_node) {

        if ((instance->trip == trip_max_desired_temperature) &&

            cdev_is_power_actor(instance->cdev)) {

            num_actors++;

            total_weight += instance->weight;

        }

    }

    if (!num_actors) {

        ret = -ENODEV;

        goto unlock;

    }

    /*

     * We need to allocate five arrays of the same size:

     * req_power, max_power, granted_power, extra_actor_power and

     * weighted_req_power.  They are going to be needed until this

     * function returns.  Allocate them all in one go to simplify

     * the allocation and deallocation logic.

     */

    BUILD_BUG_ON(sizeof(*req_power) != sizeof(*max_power));

    BUILD_BUG_ON(sizeof(*req_power) != sizeof(*granted_power));

    BUILD_BUG_ON(sizeof(*req_power) != sizeof(*extra_actor_power));

    BUILD_BUG_ON(sizeof(*req_power) != sizeof(*weighted_req_power));

    req_power = kcalloc(num_actors * 5, sizeof(*req_power), GFP_KERNEL);

    if (!req_power) {

        ret = -ENOMEM;

        goto unlock;

    }

    max_power = &req_power[num_actors];

    granted_power = &req_power[2 * num_actors];

    extra_actor_power = &req_power[3 * num_actors];

    weighted_req_power = &req_power[4 * num_actors];

    i = 0;

    total_weighted_req_power = 0;

    total_req_power = 0;

    max_allocatable_power = 0;

    // 遍历所有的cooling device

    list_for_each_entry(instance, &tz->thermal_instances, tz_node) {

        int weight;

        struct thermal_cooling_device *cdev = instance->cdev;

        if (instance->trip != trip_max_desired_temperature)

            continue;