2 * linux/drivers/thermal/cpu_cooling.c
4 * Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com)
5 * Copyright (C) 2012 Amit Daniel <amit.kachhap@linaro.org>
7 * Copyright (C) 2014 Viresh Kumar <viresh.kumar@linaro.org>
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 #include <linux/module.h>
26 #include <linux/thermal.h>
27 #include <linux/cpufreq.h>
28 #include <linux/err.h>
29 #include <linux/pm_opp.h>
30 #include <linux/slab.h>
31 #include <linux/cpu.h>
32 #include <linux/cpu_cooling.h>
34 #include <trace/events/thermal.h>
37 * Cooling state <-> CPUFreq frequency
39 * Cooling states are translated to frequencies throughout this driver and this
40 * is the relation between them.
42 * Highest cooling state corresponds to lowest possible frequency.
45 * level 0 --> 1st Max Freq
46 * level 1 --> 2nd Max Freq
51 * struct power_table - frequency to power conversion
52 * @frequency: frequency in KHz
55 * This structure is built when the cooling device registers and helps
56 * in translating frequency to power and viceversa.
64 * struct cpufreq_cooling_device - data for cooling device with cpufreq
65 * @id: unique integer value corresponding to each cpufreq_cooling_device
67 * @cool_dev: thermal_cooling_device pointer to keep track of the
68 * registered cooling device.
69 * @cpufreq_state: integer value representing the current state of cpufreq
71 * @clipped_freq: integer value representing the absolute value of the clipped
73 * @max_level: maximum cooling level. One less than total number of valid
74 * cpufreq frequencies.
75 * @allowed_cpus: all the cpus involved for this cpufreq_cooling_device.
76 * @node: list_head to link all cpufreq_cooling_device together.
77 * @last_load: load measured by the latest call to cpufreq_get_actual_power()
78 * @time_in_idle: previous reading of the absolute time that this cpu was idle
79 * @time_in_idle_timestamp: wall time of the last invocation of
80 * get_cpu_idle_time_us()
81 * @dyn_power_table: array of struct power_table for frequency to power
82 * conversion, sorted in ascending order.
83 * @dyn_power_table_entries: number of entries in the @dyn_power_table array
84 * @cpu_dev: the first cpu_device from @allowed_cpus that has OPPs registered
85 * @plat_get_static_power: callback to calculate the static power
87 * This structure is required for keeping information of each registered
88 * cpufreq_cooling_device.
90 struct cpufreq_cooling_device {
92 struct thermal_cooling_device *cool_dev;
93 unsigned int cpufreq_state;
94 unsigned int clipped_freq;
95 unsigned int max_level;
96 unsigned int *freq_table; /* In descending order */
97 struct cpumask allowed_cpus;
98 struct list_head node;
101 u64 *time_in_idle_timestamp;
102 struct power_table *dyn_power_table;
103 int dyn_power_table_entries;
104 struct device *cpu_dev;
105 get_static_t plat_get_static_power;
107 static DEFINE_IDR(cpufreq_idr);
108 static DEFINE_MUTEX(cooling_cpufreq_lock);
110 static unsigned int cpufreq_dev_count;
112 static DEFINE_MUTEX(cooling_list_lock);
113 static LIST_HEAD(cpufreq_dev_list);
116 * get_idr - function to get a unique id.
117 * @idr: struct idr * handle used to create a id.
118 * @id: int * value generated by this function.
120 * This function will populate @id with an unique
121 * id, using the idr API.
123 * Return: 0 on success, an error code on failure.
125 static int get_idr(struct idr *idr, int *id)
129 mutex_lock(&cooling_cpufreq_lock);
130 ret = idr_alloc(idr, NULL, 0, 0, GFP_KERNEL);
131 mutex_unlock(&cooling_cpufreq_lock);
132 if (unlikely(ret < 0))
140 * release_idr - function to free the unique id.
141 * @idr: struct idr * handle used for creating the id.
142 * @id: int value representing the unique id.
144 static void release_idr(struct idr *idr, int id)
146 mutex_lock(&cooling_cpufreq_lock);
148 mutex_unlock(&cooling_cpufreq_lock);
151 /* Below code defines functions to be used for cpufreq as cooling device */
154 * get_level: Find the level for a particular frequency
155 * @cpufreq_dev: cpufreq_dev for which the property is required
158 * Return: level on success, THERMAL_CSTATE_INVALID on error.
160 static unsigned long get_level(struct cpufreq_cooling_device *cpufreq_dev,
165 for (level = 0; level <= cpufreq_dev->max_level; level++) {
166 if (freq == cpufreq_dev->freq_table[level])
169 if (freq > cpufreq_dev->freq_table[level])
173 return THERMAL_CSTATE_INVALID;
177 * cpufreq_cooling_get_level - for a given cpu, return the cooling level.
178 * @cpu: cpu for which the level is required
179 * @freq: the frequency of interest
181 * This function will match the cooling level corresponding to the
182 * requested @freq and return it.
184 * Return: The matched cooling level on success or THERMAL_CSTATE_INVALID
187 unsigned long cpufreq_cooling_get_level(unsigned int cpu, unsigned int freq)
189 struct cpufreq_cooling_device *cpufreq_dev;
191 mutex_lock(&cooling_list_lock);
192 list_for_each_entry(cpufreq_dev, &cpufreq_dev_list, node) {
193 if (cpumask_test_cpu(cpu, &cpufreq_dev->allowed_cpus)) {
194 mutex_unlock(&cooling_list_lock);
195 return get_level(cpufreq_dev, freq);
198 mutex_unlock(&cooling_list_lock);
200 pr_err("%s: cpu:%d not part of any cooling device\n", __func__, cpu);
201 return THERMAL_CSTATE_INVALID;
203 EXPORT_SYMBOL_GPL(cpufreq_cooling_get_level);
206 * cpufreq_thermal_notifier - notifier callback for cpufreq policy change.
207 * @nb: struct notifier_block * with callback info.
208 * @event: value showing cpufreq event for which this function invoked.
209 * @data: callback-specific data
211 * Callback to hijack the notification on cpufreq policy transition.
212 * Every time there is a change in policy, we will intercept and
213 * update the cpufreq policy with thermal constraints.
215 * Return: 0 (success)
217 static int cpufreq_thermal_notifier(struct notifier_block *nb,
218 unsigned long event, void *data)
220 struct cpufreq_policy *policy = data;
221 unsigned long clipped_freq;
222 struct cpufreq_cooling_device *cpufreq_dev;
224 if (event != CPUFREQ_ADJUST)
227 mutex_lock(&cooling_list_lock);
228 list_for_each_entry(cpufreq_dev, &cpufreq_dev_list, node) {
229 if (!cpumask_test_cpu(policy->cpu, &cpufreq_dev->allowed_cpus))
232 clipped_freq = cpufreq_dev->clipped_freq;
234 if (policy->max != clipped_freq)
235 cpufreq_verify_within_limits(policy, 0, clipped_freq);
238 mutex_unlock(&cooling_list_lock);
244 * build_dyn_power_table() - create a dynamic power to frequency table
245 * @cpufreq_device: the cpufreq cooling device in which to store the table
246 * @capacitance: dynamic power coefficient for these cpus
248 * Build a dynamic power to frequency table for this cpu and store it
249 * in @cpufreq_device. This table will be used in cpu_power_to_freq() and
250 * cpu_freq_to_power() to convert between power and frequency
251 * efficiently. Power is stored in mW, frequency in KHz. The
252 * resulting table is in ascending order.
254 * Return: 0 on success, -E* on error.
256 static int build_dyn_power_table(struct cpufreq_cooling_device *cpufreq_device,
259 struct power_table *power_table;
260 struct dev_pm_opp *opp;
261 struct device *dev = NULL;
262 int num_opps = 0, cpu, i, ret = 0;
267 for_each_cpu(cpu, &cpufreq_device->allowed_cpus) {
268 dev = get_cpu_device(cpu);
270 dev_warn(&cpufreq_device->cool_dev->device,
271 "No cpu device for cpu %d\n", cpu);
275 num_opps = dev_pm_opp_get_opp_count(dev);
278 } else if (num_opps < 0) {
289 power_table = kcalloc(num_opps, sizeof(*power_table), GFP_KERNEL);
295 for (freq = 0, i = 0;
296 opp = dev_pm_opp_find_freq_ceil(dev, &freq), !IS_ERR(opp);
298 u32 freq_mhz, voltage_mv;
301 freq_mhz = freq / 1000000;
302 voltage_mv = dev_pm_opp_get_voltage(opp) / 1000;
305 * Do the multiplication with MHz and millivolt so as
308 power = (u64)capacitance * freq_mhz * voltage_mv * voltage_mv;
309 do_div(power, 1000000000);
311 /* frequency is stored in power_table in KHz */
312 power_table[i].frequency = freq / 1000;
314 /* power is stored in mW */
315 power_table[i].power = power;
323 cpufreq_device->cpu_dev = dev;
324 cpufreq_device->dyn_power_table = power_table;
325 cpufreq_device->dyn_power_table_entries = i;
332 static u32 cpu_freq_to_power(struct cpufreq_cooling_device *cpufreq_device,
336 struct power_table *pt = cpufreq_device->dyn_power_table;
338 for (i = 1; i < cpufreq_device->dyn_power_table_entries; i++)
339 if (freq < pt[i].frequency)
342 return pt[i - 1].power;
345 static u32 cpu_power_to_freq(struct cpufreq_cooling_device *cpufreq_device,
349 struct power_table *pt = cpufreq_device->dyn_power_table;
351 for (i = 1; i < cpufreq_device->dyn_power_table_entries; i++)
352 if (power < pt[i].power)
355 return pt[i - 1].frequency;
359 * get_load() - get load for a cpu since last updated
360 * @cpufreq_device: &struct cpufreq_cooling_device for this cpu
363 * Return: The average load of cpu @cpu in percentage since this
364 * function was last called.
366 static u32 get_load(struct cpufreq_cooling_device *cpufreq_device, int cpu)
369 u64 now, now_idle, delta_time, delta_idle;
371 now_idle = get_cpu_idle_time(cpu, &now, 0);
372 delta_idle = now_idle - cpufreq_device->time_in_idle[cpu];
373 delta_time = now - cpufreq_device->time_in_idle_timestamp[cpu];
375 if (delta_time <= delta_idle)
378 load = div64_u64(100 * (delta_time - delta_idle), delta_time);
380 cpufreq_device->time_in_idle[cpu] = now_idle;
381 cpufreq_device->time_in_idle_timestamp[cpu] = now;
387 * get_static_power() - calculate the static power consumed by the cpus
388 * @cpufreq_device: struct &cpufreq_cooling_device for this cpu cdev
389 * @tz: thermal zone device in which we're operating
390 * @freq: frequency in KHz
391 * @power: pointer in which to store the calculated static power
393 * Calculate the static power consumed by the cpus described by
394 * @cpu_actor running at frequency @freq. This function relies on a
395 * platform specific function that should have been provided when the
396 * actor was registered. If it wasn't, the static power is assumed to
397 * be negligible. The calculated static power is stored in @power.
399 * Return: 0 on success, -E* on failure.
401 static int get_static_power(struct cpufreq_cooling_device *cpufreq_device,
402 struct thermal_zone_device *tz, unsigned long freq,
405 struct dev_pm_opp *opp;
406 unsigned long voltage;
407 struct cpumask *cpumask = &cpufreq_device->allowed_cpus;
408 unsigned long freq_hz = freq * 1000;
410 if (!cpufreq_device->plat_get_static_power ||
411 !cpufreq_device->cpu_dev) {
418 opp = dev_pm_opp_find_freq_exact(cpufreq_device->cpu_dev, freq_hz,
420 voltage = dev_pm_opp_get_voltage(opp);
425 dev_warn_ratelimited(cpufreq_device->cpu_dev,
426 "Failed to get voltage for frequency %lu: %ld\n",
427 freq_hz, IS_ERR(opp) ? PTR_ERR(opp) : 0);
431 return cpufreq_device->plat_get_static_power(cpumask, tz->passive_delay,
436 * get_dynamic_power() - calculate the dynamic power
437 * @cpufreq_device: &cpufreq_cooling_device for this cdev
438 * @freq: current frequency
440 * Return: the dynamic power consumed by the cpus described by
443 static u32 get_dynamic_power(struct cpufreq_cooling_device *cpufreq_device,
448 raw_cpu_power = cpu_freq_to_power(cpufreq_device, freq);
449 return (raw_cpu_power * cpufreq_device->last_load) / 100;
452 /* cpufreq cooling device callback functions are defined below */
455 * cpufreq_get_max_state - callback function to get the max cooling state.
456 * @cdev: thermal cooling device pointer.
457 * @state: fill this variable with the max cooling state.
459 * Callback for the thermal cooling device to return the cpufreq
462 * Return: 0 on success, an error code otherwise.
464 static int cpufreq_get_max_state(struct thermal_cooling_device *cdev,
465 unsigned long *state)
467 struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
469 *state = cpufreq_device->max_level;
474 * cpufreq_get_cur_state - callback function to get the current cooling state.
475 * @cdev: thermal cooling device pointer.
476 * @state: fill this variable with the current cooling state.
478 * Callback for the thermal cooling device to return the cpufreq
479 * current cooling state.
481 * Return: 0 on success, an error code otherwise.
483 static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev,
484 unsigned long *state)
486 struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
488 *state = cpufreq_device->cpufreq_state;
494 * cpufreq_set_cur_state - callback function to set the current cooling state.
495 * @cdev: thermal cooling device pointer.
496 * @state: set this variable to the current cooling state.
498 * Callback for the thermal cooling device to change the cpufreq
499 * current cooling state.
501 * Return: 0 on success, an error code otherwise.
503 static int cpufreq_set_cur_state(struct thermal_cooling_device *cdev,
506 struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
507 unsigned int cpu = cpumask_any(&cpufreq_device->allowed_cpus);
508 unsigned int clip_freq;
510 /* Request state should be less than max_level */
511 if (WARN_ON(state > cpufreq_device->max_level))
514 /* Check if the old cooling action is same as new cooling action */
515 if (cpufreq_device->cpufreq_state == state)
518 clip_freq = cpufreq_device->freq_table[state];
519 cpufreq_device->cpufreq_state = state;
520 cpufreq_device->clipped_freq = clip_freq;
522 cpufreq_update_policy(cpu);
528 * cpufreq_get_requested_power() - get the current power
529 * @cdev: &thermal_cooling_device pointer
530 * @tz: a valid thermal zone device pointer
531 * @power: pointer in which to store the resulting power
533 * Calculate the current power consumption of the cpus in milliwatts
534 * and store it in @power. This function should actually calculate
535 * the requested power, but it's hard to get the frequency that
536 * cpufreq would have assigned if there were no thermal limits.
537 * Instead, we calculate the current power on the assumption that the
538 * immediate future will look like the immediate past.
540 * We use the current frequency and the average load since this
541 * function was last called. In reality, there could have been
542 * multiple opps since this function was last called and that affects
543 * the load calculation. While it's not perfectly accurate, this
544 * simplification is good enough and works. REVISIT this, as more
545 * complex code may be needed if experiments show that it's not
548 * Return: 0 on success, -E* if getting the static power failed.
550 static int cpufreq_get_requested_power(struct thermal_cooling_device *cdev,
551 struct thermal_zone_device *tz,
556 u32 static_power, dynamic_power, total_load = 0;
557 struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
558 u32 *load_cpu = NULL;
560 cpu = cpumask_any_and(&cpufreq_device->allowed_cpus, cpu_online_mask);
563 * All the CPUs are offline, thus the requested power by
566 if (cpu >= nr_cpu_ids) {
571 freq = cpufreq_quick_get(cpu);
573 if (trace_thermal_power_cpu_get_power_enabled()) {
574 u32 ncpus = cpumask_weight(&cpufreq_device->allowed_cpus);
576 load_cpu = devm_kcalloc(&cdev->device, ncpus, sizeof(*load_cpu),
580 for_each_cpu(cpu, &cpufreq_device->allowed_cpus) {
584 load = get_load(cpufreq_device, cpu);
589 if (trace_thermal_power_cpu_limit_enabled() && load_cpu)
595 cpufreq_device->last_load = total_load;
597 dynamic_power = get_dynamic_power(cpufreq_device, freq);
598 ret = get_static_power(cpufreq_device, tz, freq, &static_power);
601 devm_kfree(&cdev->device, load_cpu);
606 trace_thermal_power_cpu_get_power(
607 &cpufreq_device->allowed_cpus,
608 freq, load_cpu, i, dynamic_power, static_power);
610 devm_kfree(&cdev->device, load_cpu);
613 *power = static_power + dynamic_power;
618 * cpufreq_state2power() - convert a cpu cdev state to power consumed
619 * @cdev: &thermal_cooling_device pointer
620 * @tz: a valid thermal zone device pointer
621 * @state: cooling device state to be converted
622 * @power: pointer in which to store the resulting power
624 * Convert cooling device state @state into power consumption in
625 * milliwatts assuming 100% load. Store the calculated power in
628 * Return: 0 on success, -EINVAL if the cooling device state could not
629 * be converted into a frequency or other -E* if there was an error
630 * when calculating the static power.
632 static int cpufreq_state2power(struct thermal_cooling_device *cdev,
633 struct thermal_zone_device *tz,
634 unsigned long state, u32 *power)
636 unsigned int freq, num_cpus;
638 u32 static_power, dynamic_power;
640 struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
642 cpumask_and(&cpumask, &cpufreq_device->allowed_cpus, cpu_online_mask);
643 num_cpus = cpumask_weight(&cpumask);
645 /* None of our cpus are online, so no power */
651 freq = cpufreq_device->freq_table[state];
655 dynamic_power = cpu_freq_to_power(cpufreq_device, freq) * num_cpus;
656 ret = get_static_power(cpufreq_device, tz, freq, &static_power);
660 *power = static_power + dynamic_power;
665 * cpufreq_power2state() - convert power to a cooling device state
666 * @cdev: &thermal_cooling_device pointer
667 * @tz: a valid thermal zone device pointer
668 * @power: power in milliwatts to be converted
669 * @state: pointer in which to store the resulting state
671 * Calculate a cooling device state for the cpus described by @cdev
672 * that would allow them to consume at most @power mW and store it in
673 * @state. Note that this calculation depends on external factors
674 * such as the cpu load or the current static power. Calling this
675 * function with the same power as input can yield different cooling
676 * device states depending on those external factors.
678 * Return: 0 on success, -ENODEV if no cpus are online or -EINVAL if
679 * the calculated frequency could not be converted to a valid state.
680 * The latter should not happen unless the frequencies available to
681 * cpufreq have changed since the initialization of the cpu cooling
684 static int cpufreq_power2state(struct thermal_cooling_device *cdev,
685 struct thermal_zone_device *tz, u32 power,
686 unsigned long *state)
688 unsigned int cpu, cur_freq, target_freq;
691 u32 last_load, normalised_power, static_power;
692 struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
694 cpu = cpumask_any_and(&cpufreq_device->allowed_cpus, cpu_online_mask);
696 /* None of our cpus are online */
697 if (cpu >= nr_cpu_ids)
700 cur_freq = cpufreq_quick_get(cpu);
701 ret = get_static_power(cpufreq_device, tz, cur_freq, &static_power);
705 dyn_power = power - static_power;
706 dyn_power = dyn_power > 0 ? dyn_power : 0;
707 last_load = cpufreq_device->last_load ?: 1;
708 normalised_power = (dyn_power * 100) / last_load;
709 target_freq = cpu_power_to_freq(cpufreq_device, normalised_power);
711 *state = cpufreq_cooling_get_level(cpu, target_freq);
712 if (*state == THERMAL_CSTATE_INVALID) {
713 dev_warn_ratelimited(&cdev->device,
714 "Failed to convert %dKHz for cpu %d into a cdev state\n",
719 trace_thermal_power_cpu_limit(&cpufreq_device->allowed_cpus,
720 target_freq, *state, power);
724 /* Bind cpufreq callbacks to thermal cooling device ops */
725 static struct thermal_cooling_device_ops cpufreq_cooling_ops = {
726 .get_max_state = cpufreq_get_max_state,
727 .get_cur_state = cpufreq_get_cur_state,
728 .set_cur_state = cpufreq_set_cur_state,
731 /* Notifier for cpufreq policy change */
732 static struct notifier_block thermal_cpufreq_notifier_block = {
733 .notifier_call = cpufreq_thermal_notifier,
736 static unsigned int find_next_max(struct cpufreq_frequency_table *table,
737 unsigned int prev_max)
739 struct cpufreq_frequency_table *pos;
740 unsigned int max = 0;
742 cpufreq_for_each_valid_entry(pos, table) {
743 if (pos->frequency > max && pos->frequency < prev_max)
744 max = pos->frequency;
751 * __cpufreq_cooling_register - helper function to create cpufreq cooling device
752 * @np: a valid struct device_node to the cooling device device tree node
753 * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
754 * Normally this should be same as cpufreq policy->related_cpus.
755 * @capacitance: dynamic power coefficient for these cpus
756 * @plat_static_func: function to calculate the static power consumed by these
759 * This interface function registers the cpufreq cooling device with the name
760 * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
761 * cooling devices. It also gives the opportunity to link the cooling device
762 * with a device tree node, in order to bind it via the thermal DT code.
764 * Return: a valid struct thermal_cooling_device pointer on success,
765 * on failure, it returns a corresponding ERR_PTR().
767 static struct thermal_cooling_device *
768 __cpufreq_cooling_register(struct device_node *np,
769 const struct cpumask *clip_cpus, u32 capacitance,
770 get_static_t plat_static_func)
772 struct thermal_cooling_device *cool_dev;
773 struct cpufreq_cooling_device *cpufreq_dev;
774 char dev_name[THERMAL_NAME_LENGTH];
775 struct cpufreq_frequency_table *pos, *table;
776 unsigned int freq, i, num_cpus;
779 table = cpufreq_frequency_get_table(cpumask_first(clip_cpus));
781 pr_debug("%s: CPUFreq table not found\n", __func__);
782 return ERR_PTR(-EPROBE_DEFER);
785 cpufreq_dev = kzalloc(sizeof(*cpufreq_dev), GFP_KERNEL);
787 return ERR_PTR(-ENOMEM);
789 num_cpus = cpumask_weight(clip_cpus);
790 cpufreq_dev->time_in_idle = kcalloc(num_cpus,
791 sizeof(*cpufreq_dev->time_in_idle),
793 if (!cpufreq_dev->time_in_idle) {
794 cool_dev = ERR_PTR(-ENOMEM);
798 cpufreq_dev->time_in_idle_timestamp =
799 kcalloc(num_cpus, sizeof(*cpufreq_dev->time_in_idle_timestamp),
801 if (!cpufreq_dev->time_in_idle_timestamp) {
802 cool_dev = ERR_PTR(-ENOMEM);
803 goto free_time_in_idle;
806 /* Find max levels */
807 cpufreq_for_each_valid_entry(pos, table)
808 cpufreq_dev->max_level++;
810 cpufreq_dev->freq_table = kmalloc(sizeof(*cpufreq_dev->freq_table) *
811 cpufreq_dev->max_level, GFP_KERNEL);
812 if (!cpufreq_dev->freq_table) {
813 cool_dev = ERR_PTR(-ENOMEM);
814 goto free_time_in_idle_timestamp;
817 /* max_level is an index, not a counter */
818 cpufreq_dev->max_level--;
820 cpumask_copy(&cpufreq_dev->allowed_cpus, clip_cpus);
823 cpufreq_cooling_ops.get_requested_power =
824 cpufreq_get_requested_power;
825 cpufreq_cooling_ops.state2power = cpufreq_state2power;
826 cpufreq_cooling_ops.power2state = cpufreq_power2state;
827 cpufreq_dev->plat_get_static_power = plat_static_func;
829 ret = build_dyn_power_table(cpufreq_dev, capacitance);
831 cool_dev = ERR_PTR(ret);
836 ret = get_idr(&cpufreq_idr, &cpufreq_dev->id);
838 cool_dev = ERR_PTR(ret);
842 snprintf(dev_name, sizeof(dev_name), "thermal-cpufreq-%d",
845 cool_dev = thermal_of_cooling_device_register(np, dev_name, cpufreq_dev,
846 &cpufreq_cooling_ops);
847 if (IS_ERR(cool_dev))
850 /* Fill freq-table in descending order of frequencies */
851 for (i = 0, freq = -1; i <= cpufreq_dev->max_level; i++) {
852 freq = find_next_max(table, freq);
853 cpufreq_dev->freq_table[i] = freq;
855 /* Warn for duplicate entries */
857 pr_warn("%s: table has duplicate entries\n", __func__);
859 pr_debug("%s: freq:%u KHz\n", __func__, freq);
862 cpufreq_dev->clipped_freq = cpufreq_dev->freq_table[0];
863 cpufreq_dev->cool_dev = cool_dev;
865 mutex_lock(&cooling_cpufreq_lock);
867 mutex_lock(&cooling_list_lock);
868 list_add(&cpufreq_dev->node, &cpufreq_dev_list);
869 mutex_unlock(&cooling_list_lock);
871 /* Register the notifier for first cpufreq cooling device */
872 if (!cpufreq_dev_count++)
873 cpufreq_register_notifier(&thermal_cpufreq_notifier_block,
874 CPUFREQ_POLICY_NOTIFIER);
875 mutex_unlock(&cooling_cpufreq_lock);
880 release_idr(&cpufreq_idr, cpufreq_dev->id);
882 kfree(cpufreq_dev->freq_table);
883 free_time_in_idle_timestamp:
884 kfree(cpufreq_dev->time_in_idle_timestamp);
886 kfree(cpufreq_dev->time_in_idle);
894 * cpufreq_cooling_register - function to create cpufreq cooling device.
895 * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
897 * This interface function registers the cpufreq cooling device with the name
898 * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
901 * Return: a valid struct thermal_cooling_device pointer on success,
902 * on failure, it returns a corresponding ERR_PTR().
904 struct thermal_cooling_device *
905 cpufreq_cooling_register(const struct cpumask *clip_cpus)
907 return __cpufreq_cooling_register(NULL, clip_cpus, 0, NULL);
909 EXPORT_SYMBOL_GPL(cpufreq_cooling_register);
912 * of_cpufreq_cooling_register - function to create cpufreq cooling device.
913 * @np: a valid struct device_node to the cooling device device tree node
914 * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
916 * This interface function registers the cpufreq cooling device with the name
917 * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
918 * cooling devices. Using this API, the cpufreq cooling device will be
919 * linked to the device tree node provided.
921 * Return: a valid struct thermal_cooling_device pointer on success,
922 * on failure, it returns a corresponding ERR_PTR().
924 struct thermal_cooling_device *
925 of_cpufreq_cooling_register(struct device_node *np,
926 const struct cpumask *clip_cpus)
929 return ERR_PTR(-EINVAL);
931 return __cpufreq_cooling_register(np, clip_cpus, 0, NULL);
933 EXPORT_SYMBOL_GPL(of_cpufreq_cooling_register);
936 * cpufreq_power_cooling_register() - create cpufreq cooling device with power extensions
937 * @clip_cpus: cpumask of cpus where the frequency constraints will happen
938 * @capacitance: dynamic power coefficient for these cpus
939 * @plat_static_func: function to calculate the static power consumed by these
942 * This interface function registers the cpufreq cooling device with
943 * the name "thermal-cpufreq-%x". This api can support multiple
944 * instances of cpufreq cooling devices. Using this function, the
945 * cooling device will implement the power extensions by using a
946 * simple cpu power model. The cpus must have registered their OPPs
947 * using the OPP library.
949 * An optional @plat_static_func may be provided to calculate the
950 * static power consumed by these cpus. If the platform's static
951 * power consumption is unknown or negligible, make it NULL.
953 * Return: a valid struct thermal_cooling_device pointer on success,
954 * on failure, it returns a corresponding ERR_PTR().
956 struct thermal_cooling_device *
957 cpufreq_power_cooling_register(const struct cpumask *clip_cpus, u32 capacitance,
958 get_static_t plat_static_func)
960 return __cpufreq_cooling_register(NULL, clip_cpus, capacitance,
963 EXPORT_SYMBOL(cpufreq_power_cooling_register);
966 * of_cpufreq_power_cooling_register() - create cpufreq cooling device with power extensions
967 * @np: a valid struct device_node to the cooling device device tree node
968 * @clip_cpus: cpumask of cpus where the frequency constraints will happen
969 * @capacitance: dynamic power coefficient for these cpus
970 * @plat_static_func: function to calculate the static power consumed by these
973 * This interface function registers the cpufreq cooling device with
974 * the name "thermal-cpufreq-%x". This api can support multiple
975 * instances of cpufreq cooling devices. Using this API, the cpufreq
976 * cooling device will be linked to the device tree node provided.
977 * Using this function, the cooling device will implement the power
978 * extensions by using a simple cpu power model. The cpus must have
979 * registered their OPPs using the OPP library.
981 * An optional @plat_static_func may be provided to calculate the
982 * static power consumed by these cpus. If the platform's static
983 * power consumption is unknown or negligible, make it NULL.
985 * Return: a valid struct thermal_cooling_device pointer on success,
986 * on failure, it returns a corresponding ERR_PTR().
988 struct thermal_cooling_device *
989 of_cpufreq_power_cooling_register(struct device_node *np,
990 const struct cpumask *clip_cpus,
992 get_static_t plat_static_func)
995 return ERR_PTR(-EINVAL);
997 return __cpufreq_cooling_register(np, clip_cpus, capacitance,
1000 EXPORT_SYMBOL(of_cpufreq_power_cooling_register);
1003 * cpufreq_cooling_unregister - function to remove cpufreq cooling device.
1004 * @cdev: thermal cooling device pointer.
1006 * This interface function unregisters the "thermal-cpufreq-%x" cooling device.
1008 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
1010 struct cpufreq_cooling_device *cpufreq_dev;
1015 cpufreq_dev = cdev->devdata;
1017 /* Unregister the notifier for the last cpufreq cooling device */
1018 mutex_lock(&cooling_cpufreq_lock);
1019 if (!--cpufreq_dev_count)
1020 cpufreq_unregister_notifier(&thermal_cpufreq_notifier_block,
1021 CPUFREQ_POLICY_NOTIFIER);
1023 mutex_lock(&cooling_list_lock);
1024 list_del(&cpufreq_dev->node);
1025 mutex_unlock(&cooling_list_lock);
1027 mutex_unlock(&cooling_cpufreq_lock);
1029 thermal_cooling_device_unregister(cpufreq_dev->cool_dev);
1030 release_idr(&cpufreq_idr, cpufreq_dev->id);
1031 kfree(cpufreq_dev->time_in_idle_timestamp);
1032 kfree(cpufreq_dev->time_in_idle);
1033 kfree(cpufreq_dev->freq_table);
1036 EXPORT_SYMBOL_GPL(cpufreq_cooling_unregister);