// SPDX-License-Identifier: GPL-2.0 /* * linux/drivers/thermal/cpufreq_cooling.c * * Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com) * * Copyright (C) 2012-2018 Linaro Limited. * * Authors: Amit Daniel <[email protected]> * Viresh Kumar <[email protected]> * */ #include <linux/cpu.h> #include <linux/cpufreq.h> #include <linux/cpu_cooling.h> #include <linux/device.h> #include <linux/energy_model.h> #include <linux/err.h> #include <linux/export.h> #include <linux/pm_opp.h> #include <linux/pm_qos.h> #include <linux/slab.h> #include <linux/thermal.h> #include <linux/units.h> #include "thermal_trace.h" /* * Cooling state <-> CPUFreq frequency * * Cooling states are translated to frequencies throughout this driver and this * is the relation between them. * * Highest cooling state corresponds to lowest possible frequency. * * i.e. * level 0 --> 1st Max Freq * level 1 --> 2nd Max Freq * ... */ /** * struct time_in_idle - Idle time stats * @time: previous reading of the absolute time that this cpu was idle * @timestamp: wall time of the last invocation of get_cpu_idle_time_us() */ struct time_in_idle { … }; /** * struct cpufreq_cooling_device - data for cooling device with cpufreq * @last_load: load measured by the latest call to cpufreq_get_requested_power() * @cpufreq_state: integer value representing the current state of cpufreq * cooling devices. * @max_level: maximum cooling level. One less than total number of valid * cpufreq frequencies. * @em: Reference on the Energy Model of the device * @cdev: thermal_cooling_device pointer to keep track of the * registered cooling device. * @policy: cpufreq policy. * @cooling_ops: cpufreq callbacks to thermal cooling device ops * @idle_time: idle time stats * @qos_req: PM QoS contraint to apply * * This structure is required for keeping information of each registered * cpufreq_cooling_device. */ struct cpufreq_cooling_device { … }; #ifdef CONFIG_THERMAL_GOV_POWER_ALLOCATOR /** * get_level: Find the level for a particular frequency * @cpufreq_cdev: cpufreq_cdev for which the property is required * @freq: Frequency * * Return: level corresponding to the frequency. */ static unsigned long get_level(struct cpufreq_cooling_device *cpufreq_cdev, unsigned int freq) { … } static u32 cpu_freq_to_power(struct cpufreq_cooling_device *cpufreq_cdev, u32 freq) { … } static u32 cpu_power_to_freq(struct cpufreq_cooling_device *cpufreq_cdev, u32 power) { … } /** * get_load() - get load for a cpu * @cpufreq_cdev: struct cpufreq_cooling_device for the cpu * @cpu: cpu number * @cpu_idx: index of the cpu in time_in_idle array * * Return: The average load of cpu @cpu in percentage since this * function was last called. */ #ifdef CONFIG_SMP static u32 get_load(struct cpufreq_cooling_device *cpufreq_cdev, int cpu, int cpu_idx) { … } #else /* !CONFIG_SMP */ static u32 get_load(struct cpufreq_cooling_device *cpufreq_cdev, int cpu, int cpu_idx) { u32 load; u64 now, now_idle, delta_time, delta_idle; struct time_in_idle *idle_time = &cpufreq_cdev->idle_time[cpu_idx]; now_idle = get_cpu_idle_time(cpu, &now, 0); delta_idle = now_idle - idle_time->time; delta_time = now - idle_time->timestamp; if (delta_time <= delta_idle) load = 0; else load = div64_u64(100 * (delta_time - delta_idle), delta_time); idle_time->time = now_idle; idle_time->timestamp = now; return load; } #endif /* CONFIG_SMP */ /** * get_dynamic_power() - calculate the dynamic power * @cpufreq_cdev: &cpufreq_cooling_device for this cdev * @freq: current frequency * * Return: the dynamic power consumed by the cpus described by * @cpufreq_cdev. */ static u32 get_dynamic_power(struct cpufreq_cooling_device *cpufreq_cdev, unsigned long freq) { … } /** * cpufreq_get_requested_power() - get the current power * @cdev: &thermal_cooling_device pointer * @power: pointer in which to store the resulting power * * Calculate the current power consumption of the cpus in milliwatts * and store it in @power. This function should actually calculate * the requested power, but it's hard to get the frequency that * cpufreq would have assigned if there were no thermal limits. * Instead, we calculate the current power on the assumption that the * immediate future will look like the immediate past. * * We use the current frequency and the average load since this * function was last called. In reality, there could have been * multiple opps since this function was last called and that affects * the load calculation. While it's not perfectly accurate, this * simplification is good enough and works. REVISIT this, as more * complex code may be needed if experiments show that it's not * accurate enough. * * Return: 0 on success, this function doesn't fail. */ static int cpufreq_get_requested_power(struct thermal_cooling_device *cdev, u32 *power) { … } /** * cpufreq_state2power() - convert a cpu cdev state to power consumed * @cdev: &thermal_cooling_device pointer * @state: cooling device state to be converted * @power: pointer in which to store the resulting power * * Convert cooling device state @state into power consumption in * milliwatts assuming 100% load. Store the calculated power in * @power. * * Return: 0 on success, -EINVAL if the cooling device state is bigger * than maximum allowed. */ static int cpufreq_state2power(struct thermal_cooling_device *cdev, unsigned long state, u32 *power) { … } /** * cpufreq_power2state() - convert power to a cooling device state * @cdev: &thermal_cooling_device pointer * @power: power in milliwatts to be converted * @state: pointer in which to store the resulting state * * Calculate a cooling device state for the cpus described by @cdev * that would allow them to consume at most @power mW and store it in * @state. Note that this calculation depends on external factors * such as the CPUs load. Calling this function with the same power * as input can yield different cooling device states depending on those * external factors. * * Return: 0 on success, this function doesn't fail. */ static int cpufreq_power2state(struct thermal_cooling_device *cdev, u32 power, unsigned long *state) { … } static inline bool em_is_sane(struct cpufreq_cooling_device *cpufreq_cdev, struct em_perf_domain *em) { … } #endif /* CONFIG_THERMAL_GOV_POWER_ALLOCATOR */ #ifdef CONFIG_SMP static inline int allocate_idle_time(struct cpufreq_cooling_device *cpufreq_cdev) { … } static inline void free_idle_time(struct cpufreq_cooling_device *cpufreq_cdev) { … } #else static int allocate_idle_time(struct cpufreq_cooling_device *cpufreq_cdev) { unsigned int num_cpus = cpumask_weight(cpufreq_cdev->policy->related_cpus); cpufreq_cdev->idle_time = kcalloc(num_cpus, sizeof(*cpufreq_cdev->idle_time), GFP_KERNEL); if (!cpufreq_cdev->idle_time) return -ENOMEM; return 0; } static void free_idle_time(struct cpufreq_cooling_device *cpufreq_cdev) { kfree(cpufreq_cdev->idle_time); cpufreq_cdev->idle_time = NULL; } #endif /* CONFIG_SMP */ static unsigned int get_state_freq(struct cpufreq_cooling_device *cpufreq_cdev, unsigned long state) { … } /* cpufreq cooling device callback functions are defined below */ /** * cpufreq_get_max_state - callback function to get the max cooling state. * @cdev: thermal cooling device pointer. * @state: fill this variable with the max cooling state. * * Callback for the thermal cooling device to return the cpufreq * max cooling state. * * Return: 0 on success, this function doesn't fail. */ static int cpufreq_get_max_state(struct thermal_cooling_device *cdev, unsigned long *state) { … } /** * cpufreq_get_cur_state - callback function to get the current cooling state. * @cdev: thermal cooling device pointer. * @state: fill this variable with the current cooling state. * * Callback for the thermal cooling device to return the cpufreq * current cooling state. * * Return: 0 on success, this function doesn't fail. */ static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev, unsigned long *state) { … } /** * cpufreq_set_cur_state - callback function to set the current cooling state. * @cdev: thermal cooling device pointer. * @state: set this variable to the current cooling state. * * Callback for the thermal cooling device to change the cpufreq * current cooling state. * * Return: 0 on success, an error code otherwise. */ static int cpufreq_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state) { … } /** * __cpufreq_cooling_register - helper function to create cpufreq cooling device * @np: a valid struct device_node to the cooling device tree node * @policy: cpufreq policy * Normally this should be same as cpufreq policy->related_cpus. * @em: Energy Model of the cpufreq policy * * This interface function registers the cpufreq cooling device with the name * "cpufreq-%s". This API can support multiple instances of cpufreq * cooling devices. It also gives the opportunity to link the cooling device * with a device tree node, in order to bind it via the thermal DT code. * * Return: a valid struct thermal_cooling_device pointer on success, * on failure, it returns a corresponding ERR_PTR(). */ static struct thermal_cooling_device * __cpufreq_cooling_register(struct device_node *np, struct cpufreq_policy *policy, struct em_perf_domain *em) { … } /** * cpufreq_cooling_register - function to create cpufreq cooling device. * @policy: cpufreq policy * * This interface function registers the cpufreq cooling device with the name * "cpufreq-%s". This API can support multiple instances of cpufreq cooling * devices. * * Return: a valid struct thermal_cooling_device pointer on success, * on failure, it returns a corresponding ERR_PTR(). */ struct thermal_cooling_device * cpufreq_cooling_register(struct cpufreq_policy *policy) { … } EXPORT_SYMBOL_GPL(…); /** * of_cpufreq_cooling_register - function to create cpufreq cooling device. * @policy: cpufreq policy * * This interface function registers the cpufreq cooling device with the name * "cpufreq-%s". This API can support multiple instances of cpufreq cooling * devices. Using this API, the cpufreq cooling device will be linked to the * device tree node provided. * * Using this function, the cooling device will implement the power * extensions by using the Energy Model (if present). The cpus must have * registered their OPPs using the OPP library. * * Return: a valid struct thermal_cooling_device pointer on success, * and NULL on failure. */ struct thermal_cooling_device * of_cpufreq_cooling_register(struct cpufreq_policy *policy) { … } EXPORT_SYMBOL_GPL(…); /** * cpufreq_cooling_unregister - function to remove cpufreq cooling device. * @cdev: thermal cooling device pointer. * * This interface function unregisters the "cpufreq-%x" cooling device. */ void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev) { … } EXPORT_SYMBOL_GPL(…);
Codebase Browser
linux