| /* |
| * linux/drivers/thermal/cpu_cooling.c |
| * |
| * Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com) |
| * Copyright (C) 2012 Amit Daniel <amit.kachhap@linaro.org> |
| * |
| * Copyright (C) 2014 Viresh Kumar <viresh.kumar@linaro.org> |
| * |
| * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; version 2 of the License. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write to the Free Software Foundation, Inc., |
| * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
| * |
| * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| */ |
| #include <linux/module.h> |
| #include <linux/thermal.h> |
| #include <linux/cpufreq.h> |
| #include <linux/err.h> |
| #include <linux/pm_opp.h> |
| #include <linux/slab.h> |
| #include <linux/cpu.h> |
| #include <linux/cpu_cooling.h> |
| #include <linux/energy_model.h> |
| #include <linux/of_device.h> |
| |
| #include <trace/events/thermal.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 { |
| u64 time; |
| u64 timestamp; |
| }; |
| |
| /** |
| * struct cpufreq_cooling_device - data for cooling device with cpufreq |
| * @id: unique integer value corresponding to each cpufreq_cooling_device |
| * registered. |
| * @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. |
| * @clipped_freq: integer value representing the absolute value of the clipped |
| * frequency. |
| * @cpufreq_floor_state: integer value representing the frequency floor state |
| * of cpufreq cooling devices. |
| * @floor_freq: integer value representing the absolute value of the floor |
| * frequency. |
| * @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. |
| * @node: list_head to link all cpufreq_cooling_device together. |
| * @idle_time: idle time stats |
| * @plat_ops: platform mitigation ops. |
| * |
| * This structure is required for keeping information of each registered |
| * cpufreq_cooling_device. |
| */ |
| struct cpufreq_cooling_device { |
| int id; |
| u32 last_load; |
| unsigned int cpufreq_state; |
| unsigned int clipped_freq; |
| unsigned int cpufreq_floor_state; |
| unsigned int floor_freq; |
| unsigned int max_level; |
| struct em_perf_domain *em; |
| struct thermal_cooling_device *cdev; |
| struct cpufreq_policy *policy; |
| struct list_head node; |
| struct time_in_idle *idle_time; |
| struct cpu_cooling_ops *plat_ops; |
| }; |
| |
| static DEFINE_MUTEX(cooling_list_lock); |
| static LIST_HEAD(cpufreq_cdev_list); |
| |
| /* Below code defines functions to be used for cpufreq as cooling device */ |
| |
| /** |
| * cpufreq_thermal_notifier - notifier callback for cpufreq policy change. |
| * @nb: struct notifier_block * with callback info. |
| * @event: value showing cpufreq event for which this function invoked. |
| * @data: callback-specific data |
| * |
| * Callback to hijack the notification on cpufreq policy transition. |
| * Every time there is a change in policy, we will intercept and |
| * update the cpufreq policy with thermal constraints. |
| * |
| * Return: 0 (success) |
| */ |
| static int cpufreq_thermal_notifier(struct notifier_block *nb, |
| unsigned long event, void *data) |
| { |
| struct cpufreq_policy *policy = data; |
| unsigned long clipped_freq = ULONG_MAX, floor_freq = 0; |
| struct cpufreq_cooling_device *cpufreq_cdev; |
| |
| if (event != CPUFREQ_INCOMPATIBLE) |
| return NOTIFY_DONE; |
| |
| mutex_lock(&cooling_list_lock); |
| list_for_each_entry(cpufreq_cdev, &cpufreq_cdev_list, node) { |
| /* |
| * A new copy of the policy is sent to the notifier and can't |
| * compare that directly. |
| */ |
| if (policy->cpu != cpufreq_cdev->policy->cpu) |
| continue; |
| |
| /* |
| * policy->max is the maximum allowed frequency defined by user |
| * and clipped_freq is the maximum that thermal constraints |
| * allow. |
| * |
| * If clipped_freq is lower than policy->max, then we need to |
| * readjust policy->max. |
| * |
| * But, if clipped_freq is greater than policy->max, we don't |
| * need to do anything. |
| * |
| * Similarly, if policy minimum set by the user is less than |
| * the floor_frequency, then adjust the policy->min. |
| */ |
| clipped_freq = cpufreq_cdev->clipped_freq; |
| floor_freq = cpufreq_cdev->floor_freq; |
| if (policy->max > clipped_freq || policy->min < floor_freq) |
| cpufreq_verify_within_limits(policy, floor_freq, |
| clipped_freq); |
| break; |
| } |
| |
| mutex_unlock(&cooling_list_lock); |
| |
| return NOTIFY_OK; |
| } |
| |
| #ifdef CONFIG_ENERGY_MODEL |
| /** |
| * 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) |
| { |
| int i; |
| |
| for (i = cpufreq_cdev->max_level - 1; i >= 0; i--) { |
| if (freq > cpufreq_cdev->em->table[i].frequency) |
| break; |
| } |
| |
| return cpufreq_cdev->max_level - i - 1; |
| } |
| |
| |
| static u32 cpu_freq_to_power(struct cpufreq_cooling_device *cpufreq_cdev, |
| u32 freq) |
| { |
| int i; |
| |
| for (i = cpufreq_cdev->max_level - 1; i >= 0; i--) { |
| if (freq > cpufreq_cdev->em->table[i].frequency) |
| break; |
| } |
| |
| return cpufreq_cdev->em->table[i + 1].power; |
| } |
| |
| static u32 cpu_power_to_freq(struct cpufreq_cooling_device *cpufreq_cdev, |
| u32 power) |
| { |
| int i; |
| |
| for (i = cpufreq_cdev->max_level - 1; i >= 0; i--) { |
| if (power > cpufreq_cdev->em->table[i].power) |
| break; |
| } |
| |
| return cpufreq_cdev->em->table[i + 1].frequency; |
| } |
| |
| /** |
| * get_load() - get load for a cpu since last updated |
| * @cpufreq_cdev: &struct cpufreq_cooling_device for this cpu |
| * @cpu: cpu number |
| * @cpu_idx: index of the cpu in time_in_idle* |
| * |
| * Return: The average load of cpu @cpu in percentage since this |
| * function was last called. |
| */ |
| 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; |
| } |
| |
| /** |
| * 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) |
| { |
| u32 raw_cpu_power; |
| |
| raw_cpu_power = cpu_freq_to_power(cpufreq_cdev, freq); |
| return (raw_cpu_power * cpufreq_cdev->last_load) / 100; |
| } |
| #endif |
| |
| /* 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, an error code otherwise. |
| */ |
| static int cpufreq_get_max_state(struct thermal_cooling_device *cdev, |
| unsigned long *state) |
| { |
| struct cpufreq_cooling_device *cpufreq_cdev = cdev->devdata; |
| |
| *state = cpufreq_cdev->max_level; |
| return 0; |
| } |
| |
| /** |
| * cpufreq_get_min_state - callback function to get the device floor state. |
| * @cdev: thermal cooling device pointer. |
| * @state: fill this variable with the cooling device floor. |
| * |
| * Callback for the thermal cooling device to return the cpufreq |
| * floor state. |
| * |
| * Return: 0 on success, an error code otherwise. |
| */ |
| static int cpufreq_get_min_state(struct thermal_cooling_device *cdev, |
| unsigned long *state) |
| { |
| struct cpufreq_cooling_device *cpufreq_cdev = cdev->devdata; |
| |
| *state = cpufreq_cdev->cpufreq_floor_state; |
| |
| return 0; |
| } |
| |
| /** |
| * 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, an error code otherwise. |
| */ |
| static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev, |
| unsigned long *state) |
| { |
| struct cpufreq_cooling_device *cpufreq_cdev = cdev->devdata; |
| |
| *state = cpufreq_cdev->cpufreq_state; |
| |
| return 0; |
| } |
| |
| static unsigned int get_state_freq(struct cpufreq_cooling_device *cpufreq_cdev, |
| unsigned long state) |
| { |
| struct cpufreq_policy *policy; |
| unsigned long idx; |
| |
| #ifdef CONFIG_ENERGY_MODEL |
| /* Use the Energy Model table if available */ |
| if (cpufreq_cdev->em) { |
| idx = cpufreq_cdev->max_level - state; |
| return cpufreq_cdev->em->table[idx].frequency; |
| } |
| #endif |
| |
| /* Otherwise, fallback on the CPUFreq table */ |
| policy = cpufreq_cdev->policy; |
| if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) |
| idx = cpufreq_cdev->max_level - state; |
| else |
| idx = state; |
| |
| return policy->freq_table[idx].frequency; |
| } |
| |
| /** |
| * cpufreq_set_min_state - callback function to set the device floor 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 |
| * floor state. |
| * |
| * Return: 0 on success, an error code otherwise. |
| */ |
| static int cpufreq_set_min_state(struct thermal_cooling_device *cdev, |
| unsigned long state) |
| { |
| struct cpufreq_cooling_device *cpufreq_cdev = cdev->devdata; |
| unsigned int cpu = cpufreq_cdev->policy->cpu; |
| unsigned int floor_freq; |
| |
| if (state > cpufreq_cdev->max_level) |
| state = cpufreq_cdev->max_level; |
| |
| if (cpufreq_cdev->cpufreq_floor_state == state) |
| return 0; |
| |
| cpufreq_cdev->cpufreq_floor_state = state; |
| floor_freq = get_state_freq(cpufreq_cdev, state); |
| cpufreq_cdev->floor_freq = floor_freq; |
| |
| /* |
| * Check if the device has a platform mitigation function that |
| * can handle the CPU freq mitigation, if not, notify cpufreq |
| * framework. |
| */ |
| if (cpufreq_cdev->plat_ops && |
| cpufreq_cdev->plat_ops->floor_limit) |
| cpufreq_cdev->plat_ops->floor_limit(cpu, floor_freq); |
| else |
| cpufreq_update_policy(cpu); |
| |
| return 0; |
| } |
| |
| /** |
| * 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) |
| { |
| struct cpufreq_cooling_device *cpufreq_cdev = cdev->devdata; |
| unsigned int clip_freq; |
| |
| /* Request state should be less than max_level */ |
| if (WARN_ON(state > cpufreq_cdev->max_level)) |
| return -EINVAL; |
| |
| /* Check if the old cooling action is same as new cooling action */ |
| if (cpufreq_cdev->cpufreq_state == state) |
| return 0; |
| |
| clip_freq = get_state_freq(cpufreq_cdev, state); |
| cpufreq_cdev->cpufreq_state = state; |
| cpufreq_cdev->clipped_freq = clip_freq; |
| |
| /* Check if the device has a platform mitigation function that |
| * can handle the CPU freq mitigation, if not, notify cpufreq |
| * framework. |
| */ |
| if (cpufreq_cdev->plat_ops && |
| cpufreq_cdev->plat_ops->ceil_limit) |
| cpufreq_cdev->plat_ops->ceil_limit(cpufreq_cdev->policy->cpu, |
| clip_freq); |
| else |
| cpufreq_update_policy(cpufreq_cdev->policy->cpu); |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_ENERGY_MODEL |
| /** |
| * cpufreq_get_requested_power() - get the current power |
| * @cdev: &thermal_cooling_device pointer |
| * @tz: a valid thermal zone 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, -E* if getting the static power failed. |
| */ |
| static int cpufreq_get_requested_power(struct thermal_cooling_device *cdev, |
| struct thermal_zone_device *tz, |
| u32 *power) |
| { |
| unsigned long freq; |
| int i = 0, cpu; |
| u32 total_load = 0; |
| struct cpufreq_cooling_device *cpufreq_cdev = cdev->devdata; |
| struct cpufreq_policy *policy = cpufreq_cdev->policy; |
| u32 *load_cpu = NULL; |
| |
| freq = cpufreq_quick_get(policy->cpu); |
| |
| if (trace_thermal_power_cpu_get_power_enabled()) { |
| u32 ncpus = cpumask_weight(policy->related_cpus); |
| |
| load_cpu = kcalloc(ncpus, sizeof(*load_cpu), GFP_KERNEL); |
| } |
| |
| for_each_cpu(cpu, policy->related_cpus) { |
| u32 load; |
| |
| if (cpu_online(cpu)) |
| load = get_load(cpufreq_cdev, cpu, i); |
| else |
| load = 0; |
| |
| total_load += load; |
| if (trace_thermal_power_cpu_limit_enabled() && load_cpu) |
| load_cpu[i] = load; |
| |
| i++; |
| } |
| |
| cpufreq_cdev->last_load = total_load; |
| |
| *power = get_dynamic_power(cpufreq_cdev, freq); |
| |
| if (load_cpu) { |
| trace_thermal_power_cpu_get_power(policy->related_cpus, freq, |
| load_cpu, i, *power); |
| |
| kfree(load_cpu); |
| } |
| |
| return 0; |
| } |
| |
| /** |
| * cpufreq_state2power() - convert a cpu cdev state to power consumed |
| * @cdev: &thermal_cooling_device pointer |
| * @tz: a valid thermal zone 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 could not |
| * be converted into a frequency or other -E* if there was an error |
| * when calculating the static power. |
| */ |
| static int cpufreq_state2power(struct thermal_cooling_device *cdev, |
| struct thermal_zone_device *tz, |
| unsigned long state, u32 *power) |
| { |
| unsigned int freq, num_cpus, idx; |
| struct cpufreq_cooling_device *cpufreq_cdev = cdev->devdata; |
| |
| /* Request state should be less than max_level */ |
| if (WARN_ON(state > cpufreq_cdev->max_level)) |
| return -EINVAL; |
| |
| num_cpus = cpumask_weight(cpufreq_cdev->policy->cpus); |
| |
| idx = cpufreq_cdev->max_level - state; |
| freq = cpufreq_cdev->em->table[idx].frequency; |
| *power = cpu_freq_to_power(cpufreq_cdev, freq) * num_cpus; |
| |
| return 0; |
| } |
| |
| /** |
| * cpufreq_power2state() - convert power to a cooling device state |
| * @cdev: &thermal_cooling_device pointer |
| * @tz: a valid thermal zone 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 cpu load or the current static power. Calling this |
| * function with the same power as input can yield different cooling |
| * device states depending on those external factors. |
| * |
| * Return: 0 on success, -ENODEV if no cpus are online or -EINVAL if |
| * the calculated frequency could not be converted to a valid state. |
| * The latter should not happen unless the frequencies available to |
| * cpufreq have changed since the initialization of the cpu cooling |
| * device. |
| */ |
| static int cpufreq_power2state(struct thermal_cooling_device *cdev, |
| struct thermal_zone_device *tz, u32 power, |
| unsigned long *state) |
| { |
| unsigned int cur_freq, target_freq; |
| u32 last_load, normalised_power; |
| struct cpufreq_cooling_device *cpufreq_cdev = cdev->devdata; |
| struct cpufreq_policy *policy = cpufreq_cdev->policy; |
| |
| cur_freq = cpufreq_quick_get(policy->cpu); |
| power = power > 0 ? power : 0; |
| last_load = cpufreq_cdev->last_load ?: 1; |
| normalised_power = (power * 100) / last_load; |
| target_freq = cpu_power_to_freq(cpufreq_cdev, normalised_power); |
| |
| *state = get_level(cpufreq_cdev, target_freq); |
| trace_thermal_power_cpu_limit(policy->related_cpus, target_freq, *state, |
| power); |
| return 0; |
| } |
| |
| static struct thermal_cooling_device_ops cpufreq_power_cooling_ops = { |
| .get_max_state = cpufreq_get_max_state, |
| .get_cur_state = cpufreq_get_cur_state, |
| .set_cur_state = cpufreq_set_cur_state, |
| .set_min_state = cpufreq_set_min_state, |
| .get_min_state = cpufreq_get_min_state, |
| .get_requested_power = cpufreq_get_requested_power, |
| .state2power = cpufreq_state2power, |
| .power2state = cpufreq_power2state, |
| }; |
| #endif |
| |
| /* Bind cpufreq callbacks to thermal cooling device ops */ |
| |
| static struct thermal_cooling_device_ops cpufreq_cooling_ops = { |
| .get_max_state = cpufreq_get_max_state, |
| .get_cur_state = cpufreq_get_cur_state, |
| .set_cur_state = cpufreq_set_cur_state, |
| .set_min_state = cpufreq_set_min_state, |
| .get_min_state = cpufreq_get_min_state, |
| }; |
| |
| /* Notifier for cpufreq policy change */ |
| static struct notifier_block thermal_cpufreq_notifier_block = { |
| .notifier_call = cpufreq_thermal_notifier, |
| }; |
| |
| /** |
| * __cpufreq_cooling_register - helper function to create cpufreq cooling device |
| * @np: a valid struct device_node to the cooling device device tree node |
| * @policy: cpufreq policy |
| * Normally this should be same as cpufreq policy->related_cpus. |
| * @try_model: true if a power model should be used |
| * @plat_ops: function that does the mitigation by changing the |
| * frequencies (Optional). By default, cpufreq framework will |
| * be notified of the new limits. |
| * |
| * This interface function registers the cpufreq cooling device with the name |
| * "thermal-cpufreq-%x". 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, bool try_model, |
| struct cpu_cooling_ops *plat_ops) |
| { |
| struct thermal_cooling_device *cdev; |
| struct cpufreq_cooling_device *cpufreq_cdev; |
| char dev_name[THERMAL_NAME_LENGTH]; |
| unsigned int i, num_cpus; |
| struct thermal_cooling_device_ops *cooling_ops; |
| bool first; |
| |
| if (IS_ERR_OR_NULL(policy)) { |
| pr_err("%s: cpufreq policy isn't valid: %p\n", __func__, policy); |
| return ERR_PTR(-EINVAL); |
| } |
| |
| i = cpufreq_table_count_valid_entries(policy); |
| if (!i) { |
| pr_debug("%s: CPUFreq table not found or has no valid entries\n", |
| __func__); |
| return ERR_PTR(-ENODEV); |
| } |
| |
| cpufreq_cdev = kzalloc(sizeof(*cpufreq_cdev), GFP_KERNEL); |
| if (!cpufreq_cdev) |
| return ERR_PTR(-ENOMEM); |
| |
| cpufreq_cdev->policy = policy; |
| num_cpus = cpumask_weight(policy->related_cpus); |
| cpufreq_cdev->idle_time = kcalloc(num_cpus, |
| sizeof(*cpufreq_cdev->idle_time), |
| GFP_KERNEL); |
| if (!cpufreq_cdev->idle_time) { |
| cdev = ERR_PTR(-ENOMEM); |
| goto free_cdev; |
| } |
| |
| /* max_level is an index, not a counter */ |
| cpufreq_cdev->max_level = i - 1; |
| |
| #ifdef CONFIG_ENERGY_MODEL |
| if (try_model) { |
| struct em_perf_domain *em = em_cpu_get(policy->cpu); |
| |
| if (!em || !cpumask_equal(policy->related_cpus, |
| to_cpumask(em->cpus))) { |
| cdev = ERR_PTR(-EINVAL); |
| goto free_idle_time; |
| } |
| cpufreq_cdev->em = em; |
| cooling_ops = &cpufreq_power_cooling_ops; |
| } else |
| #endif |
| cooling_ops = &cpufreq_cooling_ops; |
| |
| cpufreq_cdev->id = policy->cpu; |
| |
| snprintf(dev_name, sizeof(dev_name), "thermal-cpufreq-%d", |
| cpufreq_cdev->id); |
| cpufreq_cdev->plat_ops = plat_ops; |
| |
| cdev = thermal_of_cooling_device_register(np, dev_name, cpufreq_cdev, |
| cooling_ops); |
| if (IS_ERR(cdev)) |
| goto free_idle_time; |
| |
| cpufreq_cdev->clipped_freq = get_state_freq(cpufreq_cdev, 0); |
| cpufreq_cdev->floor_freq = get_state_freq(cpufreq_cdev, |
| cpufreq_cdev->max_level); |
| cpufreq_cdev->cpufreq_floor_state = cpufreq_cdev->max_level; |
| cpufreq_cdev->cdev = cdev; |
| |
| mutex_lock(&cooling_list_lock); |
| /* Register the notifier for first cpufreq cooling device */ |
| first = list_empty(&cpufreq_cdev_list); |
| list_add(&cpufreq_cdev->node, &cpufreq_cdev_list); |
| mutex_unlock(&cooling_list_lock); |
| |
| if (first && !cpufreq_cdev->plat_ops) |
| cpufreq_register_notifier(&thermal_cpufreq_notifier_block, |
| CPUFREQ_POLICY_NOTIFIER); |
| |
| return cdev; |
| |
| free_idle_time: |
| kfree(cpufreq_cdev->idle_time); |
| free_cdev: |
| kfree(cpufreq_cdev); |
| return cdev; |
| } |
| |
| /** |
| * cpufreq_cooling_register - function to create cpufreq cooling device. |
| * @policy: cpufreq policy |
| * |
| * This interface function registers the cpufreq cooling device with the name |
| * "thermal-cpufreq-%x". 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) |
| { |
| return __cpufreq_cooling_register(NULL, policy, false, NULL); |
| } |
| EXPORT_SYMBOL_GPL(cpufreq_cooling_register); |
| |
| /** |
| * of_cpufreq_cooling_register - function to create cpufreq cooling device. |
| * @policy: cpufreq policy |
| * |
| * This interface function registers the cpufreq cooling device with the name |
| * "thermal-cpufreq-%x". 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 a simple cpu power model. The cpus must have |
| * registered their OPPs using the OPP library. |
| * |
| * It also takes into account, if property present in policy CPU node, the |
| * static power consumed by the cpu. |
| * |
| * 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) |
| { |
| struct device_node *np = of_get_cpu_node(policy->cpu, NULL); |
| struct thermal_cooling_device *cdev = NULL; |
| |
| if (!np) { |
| pr_err("cpu_cooling: OF node not available for cpu%d\n", |
| policy->cpu); |
| return NULL; |
| } |
| |
| if (of_find_property(np, "#cooling-cells", NULL)) { |
| cdev = __cpufreq_cooling_register(np, policy, true, NULL); |
| if (IS_ERR(cdev)) { |
| pr_err("cpu_cooling: cpu%d is not running as cooling device: %ld\n", |
| policy->cpu, PTR_ERR(cdev)); |
| cdev = NULL; |
| } |
| } |
| |
| of_node_put(np); |
| return cdev; |
| } |
| EXPORT_SYMBOL_GPL(of_cpufreq_cooling_register); |
| |
| /** |
| * cpufreq_platform_cooling_register() - create cpufreq cooling device with |
| * additional platform specific mitigation function. |
| * |
| * @policy: cpufreq policy |
| * @plat_ops: the platform mitigation functions that will be called insted of |
| * cpufreq, if provided. |
| * |
| * Return: a valid struct thermal_cooling_device pointer on success, |
| * on failure, it returns a corresponding ERR_PTR(). |
| */ |
| struct thermal_cooling_device * |
| cpufreq_platform_cooling_register(struct cpufreq_policy *policy, |
| struct cpu_cooling_ops *plat_ops) |
| { |
| struct device_node *cpu_node = NULL; |
| u32 capacitance = 0; |
| struct thermal_cooling_device *cdev = NULL; |
| |
| cpu_node = of_cpu_device_node_get(policy->cpu); |
| if (!cpu_node) { |
| pr_err("No cpu node\n"); |
| return ERR_PTR(-EINVAL); |
| } |
| if (of_find_property(cpu_node, "#cooling-cells", NULL)) { |
| of_property_read_u32(cpu_node, "dynamic-power-coefficient", |
| &capacitance); |
| |
| cdev = __cpufreq_cooling_register(cpu_node, policy, capacitance, |
| plat_ops); |
| if (IS_ERR(cdev)) |
| pr_err("cpu_cooling: cpu%d cooling device err: %ld\n", |
| policy->cpu, PTR_ERR(cdev)); |
| } |
| |
| of_node_put(cpu_node); |
| return cdev; |
| } |
| EXPORT_SYMBOL(cpufreq_platform_cooling_register); |
| |
| |
| /** |
| * cpufreq_cooling_unregister - function to remove cpufreq cooling device. |
| * @cdev: thermal cooling device pointer. |
| * |
| * This interface function unregisters the "thermal-cpufreq-%x" cooling device. |
| */ |
| void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev) |
| { |
| struct cpufreq_cooling_device *cpufreq_cdev; |
| bool last; |
| |
| if (!cdev) |
| return; |
| |
| cpufreq_cdev = cdev->devdata; |
| |
| mutex_lock(&cooling_list_lock); |
| list_del(&cpufreq_cdev->node); |
| /* Unregister the notifier for the last cpufreq cooling device */ |
| last = list_empty(&cpufreq_cdev_list); |
| mutex_unlock(&cooling_list_lock); |
| |
| if (last) { |
| if (!cpufreq_cdev->plat_ops) |
| cpufreq_unregister_notifier( |
| &thermal_cpufreq_notifier_block, |
| CPUFREQ_POLICY_NOTIFIER); |
| } |
| |
| thermal_cooling_device_unregister(cpufreq_cdev->cdev); |
| kfree(cpufreq_cdev->idle_time); |
| kfree(cpufreq_cdev); |
| } |
| EXPORT_SYMBOL_GPL(cpufreq_cooling_unregister); |