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 * @cpufreq_val: 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 cpufreq_val
;
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 LIST_HEAD(cpufreq_dev_list
);
113 * get_idr - function to get a unique id.
114 * @idr: struct idr * handle used to create a id.
115 * @id: int * value generated by this function.
117 * This function will populate @id with an unique
118 * id, using the idr API.
120 * Return: 0 on success, an error code on failure.
122 static int get_idr(struct idr
*idr
, int *id
)
126 mutex_lock(&cooling_cpufreq_lock
);
127 ret
= idr_alloc(idr
, NULL
, 0, 0, GFP_KERNEL
);
128 mutex_unlock(&cooling_cpufreq_lock
);
129 if (unlikely(ret
< 0))
137 * release_idr - function to free the unique id.
138 * @idr: struct idr * handle used for creating the id.
139 * @id: int value representing the unique id.
141 static void release_idr(struct idr
*idr
, int id
)
143 mutex_lock(&cooling_cpufreq_lock
);
145 mutex_unlock(&cooling_cpufreq_lock
);
148 /* Below code defines functions to be used for cpufreq as cooling device */
151 * get_level: Find the level for a particular frequency
152 * @cpufreq_dev: cpufreq_dev for which the property is required
155 * Return: level on success, THERMAL_CSTATE_INVALID on error.
157 static unsigned long get_level(struct cpufreq_cooling_device
*cpufreq_dev
,
162 for (level
= 0; level
<= cpufreq_dev
->max_level
; level
++) {
163 if (freq
== cpufreq_dev
->freq_table
[level
])
166 if (freq
> cpufreq_dev
->freq_table
[level
])
170 return THERMAL_CSTATE_INVALID
;
174 * cpufreq_cooling_get_level - for a given cpu, return the cooling level.
175 * @cpu: cpu for which the level is required
176 * @freq: the frequency of interest
178 * This function will match the cooling level corresponding to the
179 * requested @freq and return it.
181 * Return: The matched cooling level on success or THERMAL_CSTATE_INVALID
184 unsigned long cpufreq_cooling_get_level(unsigned int cpu
, unsigned int freq
)
186 struct cpufreq_cooling_device
*cpufreq_dev
;
188 mutex_lock(&cooling_cpufreq_lock
);
189 list_for_each_entry(cpufreq_dev
, &cpufreq_dev_list
, node
) {
190 if (cpumask_test_cpu(cpu
, &cpufreq_dev
->allowed_cpus
)) {
191 mutex_unlock(&cooling_cpufreq_lock
);
192 return get_level(cpufreq_dev
, freq
);
195 mutex_unlock(&cooling_cpufreq_lock
);
197 pr_err("%s: cpu:%d not part of any cooling device\n", __func__
, cpu
);
198 return THERMAL_CSTATE_INVALID
;
200 EXPORT_SYMBOL_GPL(cpufreq_cooling_get_level
);
202 static void update_cpu_device(int cpu
)
204 struct cpufreq_cooling_device
*cpufreq_dev
;
206 mutex_lock(&cooling_cpufreq_lock
);
207 list_for_each_entry(cpufreq_dev
, &cpufreq_dev_list
, node
) {
208 if (cpumask_test_cpu(cpu
, &cpufreq_dev
->allowed_cpus
)) {
209 cpufreq_dev
->cpu_dev
= get_cpu_device(cpu
);
210 if (!cpufreq_dev
->cpu_dev
) {
211 dev_warn(&cpufreq_dev
->cool_dev
->device
,
212 "No cpu device for new policy cpu %d\n",
218 mutex_unlock(&cooling_cpufreq_lock
);
221 static void remove_cpu_device(int cpu
)
223 struct cpufreq_cooling_device
*cpufreq_dev
;
225 mutex_lock(&cooling_cpufreq_lock
);
226 list_for_each_entry(cpufreq_dev
, &cpufreq_dev_list
, node
) {
227 if (cpumask_test_cpu(cpu
, &cpufreq_dev
->allowed_cpus
)) {
228 cpufreq_dev
->cpu_dev
= NULL
;
232 mutex_unlock(&cooling_cpufreq_lock
);
236 * cpufreq_thermal_notifier - notifier callback for cpufreq policy change.
237 * @nb: struct notifier_block * with callback info.
238 * @event: value showing cpufreq event for which this function invoked.
239 * @data: callback-specific data
241 * Callback to hijack the notification on cpufreq policy transition.
242 * Every time there is a change in policy, we will intercept and
243 * update the cpufreq policy with thermal constraints.
245 * Return: 0 (success)
247 static int cpufreq_thermal_notifier(struct notifier_block
*nb
,
248 unsigned long event
, void *data
)
250 struct cpufreq_policy
*policy
= data
;
251 unsigned long max_freq
= 0;
252 struct cpufreq_cooling_device
*cpufreq_dev
;
257 mutex_lock(&cooling_cpufreq_lock
);
258 list_for_each_entry(cpufreq_dev
, &cpufreq_dev_list
, node
) {
259 if (!cpumask_test_cpu(policy
->cpu
,
260 &cpufreq_dev
->allowed_cpus
))
263 max_freq
= cpufreq_dev
->cpufreq_val
;
265 if (policy
->max
!= max_freq
)
266 cpufreq_verify_within_limits(policy
, 0,
269 mutex_unlock(&cooling_cpufreq_lock
);
272 case CPUFREQ_CREATE_POLICY
:
273 update_cpu_device(policy
->cpu
);
275 case CPUFREQ_REMOVE_POLICY
:
276 remove_cpu_device(policy
->cpu
);
286 * build_dyn_power_table() - create a dynamic power to frequency table
287 * @cpufreq_device: the cpufreq cooling device in which to store the table
288 * @capacitance: dynamic power coefficient for these cpus
290 * Build a dynamic power to frequency table for this cpu and store it
291 * in @cpufreq_device. This table will be used in cpu_power_to_freq() and
292 * cpu_freq_to_power() to convert between power and frequency
293 * efficiently. Power is stored in mW, frequency in KHz. The
294 * resulting table is in ascending order.
296 * Return: 0 on success, -E* on error.
298 static int build_dyn_power_table(struct cpufreq_cooling_device
*cpufreq_device
,
301 struct power_table
*power_table
;
302 struct dev_pm_opp
*opp
;
303 struct device
*dev
= NULL
;
304 int num_opps
= 0, cpu
, i
, ret
= 0;
309 for_each_cpu(cpu
, &cpufreq_device
->allowed_cpus
) {
310 dev
= get_cpu_device(cpu
);
312 dev_warn(&cpufreq_device
->cool_dev
->device
,
313 "No cpu device for cpu %d\n", cpu
);
317 num_opps
= dev_pm_opp_get_opp_count(dev
);
320 } else if (num_opps
< 0) {
331 power_table
= kcalloc(num_opps
, sizeof(*power_table
), GFP_KERNEL
);
337 for (freq
= 0, i
= 0;
338 opp
= dev_pm_opp_find_freq_ceil(dev
, &freq
), !IS_ERR(opp
);
340 u32 freq_mhz
, voltage_mv
;
343 freq_mhz
= freq
/ 1000000;
344 voltage_mv
= dev_pm_opp_get_voltage(opp
) / 1000;
347 * Do the multiplication with MHz and millivolt so as
350 power
= (u64
)capacitance
* freq_mhz
* voltage_mv
* voltage_mv
;
351 do_div(power
, 1000000000);
353 /* frequency is stored in power_table in KHz */
354 power_table
[i
].frequency
= freq
/ 1000;
356 /* power is stored in mW */
357 power_table
[i
].power
= power
;
365 cpufreq_device
->cpu_dev
= dev
;
366 cpufreq_device
->dyn_power_table
= power_table
;
367 cpufreq_device
->dyn_power_table_entries
= i
;
374 static u32
cpu_freq_to_power(struct cpufreq_cooling_device
*cpufreq_device
,
378 struct power_table
*pt
= cpufreq_device
->dyn_power_table
;
380 for (i
= 1; i
< cpufreq_device
->dyn_power_table_entries
; i
++)
381 if (freq
< pt
[i
].frequency
)
384 return pt
[i
- 1].power
;
387 static u32
cpu_power_to_freq(struct cpufreq_cooling_device
*cpufreq_device
,
391 struct power_table
*pt
= cpufreq_device
->dyn_power_table
;
393 for (i
= 1; i
< cpufreq_device
->dyn_power_table_entries
; i
++)
394 if (power
< pt
[i
].power
)
397 return pt
[i
- 1].frequency
;
401 * get_load() - get load for a cpu since last updated
402 * @cpufreq_device: &struct cpufreq_cooling_device for this cpu
405 * Return: The average load of cpu @cpu in percentage since this
406 * function was last called.
408 static u32
get_load(struct cpufreq_cooling_device
*cpufreq_device
, int cpu
)
411 u64 now
, now_idle
, delta_time
, delta_idle
;
413 now_idle
= get_cpu_idle_time(cpu
, &now
, 0);
414 delta_idle
= now_idle
- cpufreq_device
->time_in_idle
[cpu
];
415 delta_time
= now
- cpufreq_device
->time_in_idle_timestamp
[cpu
];
417 if (delta_time
<= delta_idle
)
420 load
= div64_u64(100 * (delta_time
- delta_idle
), delta_time
);
422 cpufreq_device
->time_in_idle
[cpu
] = now_idle
;
423 cpufreq_device
->time_in_idle_timestamp
[cpu
] = now
;
429 * get_static_power() - calculate the static power consumed by the cpus
430 * @cpufreq_device: struct &cpufreq_cooling_device for this cpu cdev
431 * @tz: thermal zone device in which we're operating
432 * @freq: frequency in KHz
433 * @power: pointer in which to store the calculated static power
435 * Calculate the static power consumed by the cpus described by
436 * @cpu_actor running at frequency @freq. This function relies on a
437 * platform specific function that should have been provided when the
438 * actor was registered. If it wasn't, the static power is assumed to
439 * be negligible. The calculated static power is stored in @power.
441 * Return: 0 on success, -E* on failure.
443 static int get_static_power(struct cpufreq_cooling_device
*cpufreq_device
,
444 struct thermal_zone_device
*tz
, unsigned long freq
,
447 struct dev_pm_opp
*opp
;
448 unsigned long voltage
;
449 struct cpumask
*cpumask
= &cpufreq_device
->allowed_cpus
;
450 unsigned long freq_hz
= freq
* 1000;
452 if (!cpufreq_device
->plat_get_static_power
||
453 !cpufreq_device
->cpu_dev
) {
460 opp
= dev_pm_opp_find_freq_exact(cpufreq_device
->cpu_dev
, freq_hz
,
462 voltage
= dev_pm_opp_get_voltage(opp
);
467 dev_warn_ratelimited(cpufreq_device
->cpu_dev
,
468 "Failed to get voltage for frequency %lu: %ld\n",
469 freq_hz
, IS_ERR(opp
) ? PTR_ERR(opp
) : 0);
473 return cpufreq_device
->plat_get_static_power(cpumask
, tz
->passive_delay
,
478 * get_dynamic_power() - calculate the dynamic power
479 * @cpufreq_device: &cpufreq_cooling_device for this cdev
480 * @freq: current frequency
482 * Return: the dynamic power consumed by the cpus described by
485 static u32
get_dynamic_power(struct cpufreq_cooling_device
*cpufreq_device
,
490 raw_cpu_power
= cpu_freq_to_power(cpufreq_device
, freq
);
491 return (raw_cpu_power
* cpufreq_device
->last_load
) / 100;
494 /* cpufreq cooling device callback functions are defined below */
497 * cpufreq_get_max_state - callback function to get the max cooling state.
498 * @cdev: thermal cooling device pointer.
499 * @state: fill this variable with the max cooling state.
501 * Callback for the thermal cooling device to return the cpufreq
504 * Return: 0 on success, an error code otherwise.
506 static int cpufreq_get_max_state(struct thermal_cooling_device
*cdev
,
507 unsigned long *state
)
509 struct cpufreq_cooling_device
*cpufreq_device
= cdev
->devdata
;
511 *state
= cpufreq_device
->max_level
;
516 * cpufreq_get_cur_state - callback function to get the current cooling state.
517 * @cdev: thermal cooling device pointer.
518 * @state: fill this variable with the current cooling state.
520 * Callback for the thermal cooling device to return the cpufreq
521 * current cooling state.
523 * Return: 0 on success, an error code otherwise.
525 static int cpufreq_get_cur_state(struct thermal_cooling_device
*cdev
,
526 unsigned long *state
)
528 struct cpufreq_cooling_device
*cpufreq_device
= cdev
->devdata
;
530 *state
= cpufreq_device
->cpufreq_state
;
536 * cpufreq_set_cur_state - callback function to set the current cooling state.
537 * @cdev: thermal cooling device pointer.
538 * @state: set this variable to the current cooling state.
540 * Callback for the thermal cooling device to change the cpufreq
541 * current cooling state.
543 * Return: 0 on success, an error code otherwise.
545 static int cpufreq_set_cur_state(struct thermal_cooling_device
*cdev
,
548 struct cpufreq_cooling_device
*cpufreq_device
= cdev
->devdata
;
549 unsigned int cpu
= cpumask_any(&cpufreq_device
->allowed_cpus
);
550 unsigned int clip_freq
;
552 /* Request state should be less than max_level */
553 if (WARN_ON(state
> cpufreq_device
->max_level
))
556 /* Check if the old cooling action is same as new cooling action */
557 if (cpufreq_device
->cpufreq_state
== state
)
560 clip_freq
= cpufreq_device
->freq_table
[state
];
561 cpufreq_device
->cpufreq_state
= state
;
562 cpufreq_device
->cpufreq_val
= clip_freq
;
564 cpufreq_update_policy(cpu
);
570 * cpufreq_get_requested_power() - get the current power
571 * @cdev: &thermal_cooling_device pointer
572 * @tz: a valid thermal zone device pointer
573 * @power: pointer in which to store the resulting power
575 * Calculate the current power consumption of the cpus in milliwatts
576 * and store it in @power. This function should actually calculate
577 * the requested power, but it's hard to get the frequency that
578 * cpufreq would have assigned if there were no thermal limits.
579 * Instead, we calculate the current power on the assumption that the
580 * immediate future will look like the immediate past.
582 * We use the current frequency and the average load since this
583 * function was last called. In reality, there could have been
584 * multiple opps since this function was last called and that affects
585 * the load calculation. While it's not perfectly accurate, this
586 * simplification is good enough and works. REVISIT this, as more
587 * complex code may be needed if experiments show that it's not
590 * Return: 0 on success, -E* if getting the static power failed.
592 static int cpufreq_get_requested_power(struct thermal_cooling_device
*cdev
,
593 struct thermal_zone_device
*tz
,
598 u32 static_power
, dynamic_power
, total_load
= 0;
599 struct cpufreq_cooling_device
*cpufreq_device
= cdev
->devdata
;
600 u32
*load_cpu
= NULL
;
602 freq
= cpufreq_quick_get(cpumask_any(&cpufreq_device
->allowed_cpus
));
604 if (trace_thermal_power_cpu_get_power_enabled()) {
605 u32 ncpus
= cpumask_weight(&cpufreq_device
->allowed_cpus
);
607 load_cpu
= devm_kcalloc(&cdev
->device
, ncpus
, sizeof(*load_cpu
),
611 for_each_cpu(cpu
, &cpufreq_device
->allowed_cpus
) {
615 load
= get_load(cpufreq_device
, cpu
);
620 if (trace_thermal_power_cpu_limit_enabled() && load_cpu
)
626 cpufreq_device
->last_load
= total_load
;
628 dynamic_power
= get_dynamic_power(cpufreq_device
, freq
);
629 ret
= get_static_power(cpufreq_device
, tz
, freq
, &static_power
);
632 devm_kfree(&cdev
->device
, load_cpu
);
637 trace_thermal_power_cpu_get_power(
638 &cpufreq_device
->allowed_cpus
,
639 freq
, load_cpu
, i
, dynamic_power
, static_power
);
641 devm_kfree(&cdev
->device
, load_cpu
);
644 *power
= static_power
+ dynamic_power
;
649 * cpufreq_state2power() - convert a cpu cdev state to power consumed
650 * @cdev: &thermal_cooling_device pointer
651 * @tz: a valid thermal zone device pointer
652 * @state: cooling device state to be converted
653 * @power: pointer in which to store the resulting power
655 * Convert cooling device state @state into power consumption in
656 * milliwatts assuming 100% load. Store the calculated power in
659 * Return: 0 on success, -EINVAL if the cooling device state could not
660 * be converted into a frequency or other -E* if there was an error
661 * when calculating the static power.
663 static int cpufreq_state2power(struct thermal_cooling_device
*cdev
,
664 struct thermal_zone_device
*tz
,
665 unsigned long state
, u32
*power
)
667 unsigned int freq
, num_cpus
;
669 u32 static_power
, dynamic_power
;
671 struct cpufreq_cooling_device
*cpufreq_device
= cdev
->devdata
;
673 cpumask_and(&cpumask
, &cpufreq_device
->allowed_cpus
, cpu_online_mask
);
674 num_cpus
= cpumask_weight(&cpumask
);
676 /* None of our cpus are online, so no power */
682 freq
= cpufreq_device
->freq_table
[state
];
686 dynamic_power
= cpu_freq_to_power(cpufreq_device
, freq
) * num_cpus
;
687 ret
= get_static_power(cpufreq_device
, tz
, freq
, &static_power
);
691 *power
= static_power
+ dynamic_power
;
696 * cpufreq_power2state() - convert power to a cooling device state
697 * @cdev: &thermal_cooling_device pointer
698 * @tz: a valid thermal zone device pointer
699 * @power: power in milliwatts to be converted
700 * @state: pointer in which to store the resulting state
702 * Calculate a cooling device state for the cpus described by @cdev
703 * that would allow them to consume at most @power mW and store it in
704 * @state. Note that this calculation depends on external factors
705 * such as the cpu load or the current static power. Calling this
706 * function with the same power as input can yield different cooling
707 * device states depending on those external factors.
709 * Return: 0 on success, -ENODEV if no cpus are online or -EINVAL if
710 * the calculated frequency could not be converted to a valid state.
711 * The latter should not happen unless the frequencies available to
712 * cpufreq have changed since the initialization of the cpu cooling
715 static int cpufreq_power2state(struct thermal_cooling_device
*cdev
,
716 struct thermal_zone_device
*tz
, u32 power
,
717 unsigned long *state
)
719 unsigned int cpu
, cur_freq
, target_freq
;
722 u32 last_load
, normalised_power
, static_power
;
723 struct cpufreq_cooling_device
*cpufreq_device
= cdev
->devdata
;
725 cpu
= cpumask_any_and(&cpufreq_device
->allowed_cpus
, cpu_online_mask
);
727 /* None of our cpus are online */
728 if (cpu
>= nr_cpu_ids
)
731 cur_freq
= cpufreq_quick_get(cpu
);
732 ret
= get_static_power(cpufreq_device
, tz
, cur_freq
, &static_power
);
736 dyn_power
= power
- static_power
;
737 dyn_power
= dyn_power
> 0 ? dyn_power
: 0;
738 last_load
= cpufreq_device
->last_load
?: 1;
739 normalised_power
= (dyn_power
* 100) / last_load
;
740 target_freq
= cpu_power_to_freq(cpufreq_device
, normalised_power
);
742 *state
= cpufreq_cooling_get_level(cpu
, target_freq
);
743 if (*state
== THERMAL_CSTATE_INVALID
) {
744 dev_warn_ratelimited(&cdev
->device
,
745 "Failed to convert %dKHz for cpu %d into a cdev state\n",
750 trace_thermal_power_cpu_limit(&cpufreq_device
->allowed_cpus
,
751 target_freq
, *state
, power
);
755 /* Bind cpufreq callbacks to thermal cooling device ops */
756 static struct thermal_cooling_device_ops cpufreq_cooling_ops
= {
757 .get_max_state
= cpufreq_get_max_state
,
758 .get_cur_state
= cpufreq_get_cur_state
,
759 .set_cur_state
= cpufreq_set_cur_state
,
762 /* Notifier for cpufreq policy change */
763 static struct notifier_block thermal_cpufreq_notifier_block
= {
764 .notifier_call
= cpufreq_thermal_notifier
,
767 static unsigned int find_next_max(struct cpufreq_frequency_table
*table
,
768 unsigned int prev_max
)
770 struct cpufreq_frequency_table
*pos
;
771 unsigned int max
= 0;
773 cpufreq_for_each_valid_entry(pos
, table
) {
774 if (pos
->frequency
> max
&& pos
->frequency
< prev_max
)
775 max
= pos
->frequency
;
782 * __cpufreq_cooling_register - helper function to create cpufreq cooling device
783 * @np: a valid struct device_node to the cooling device device tree node
784 * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
785 * Normally this should be same as cpufreq policy->related_cpus.
786 * @capacitance: dynamic power coefficient for these cpus
787 * @plat_static_func: function to calculate the static power consumed by these
790 * This interface function registers the cpufreq cooling device with the name
791 * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
792 * cooling devices. It also gives the opportunity to link the cooling device
793 * with a device tree node, in order to bind it via the thermal DT code.
795 * Return: a valid struct thermal_cooling_device pointer on success,
796 * on failure, it returns a corresponding ERR_PTR().
798 static struct thermal_cooling_device
*
799 __cpufreq_cooling_register(struct device_node
*np
,
800 const struct cpumask
*clip_cpus
, u32 capacitance
,
801 get_static_t plat_static_func
)
803 struct thermal_cooling_device
*cool_dev
;
804 struct cpufreq_cooling_device
*cpufreq_dev
;
805 char dev_name
[THERMAL_NAME_LENGTH
];
806 struct cpufreq_frequency_table
*pos
, *table
;
807 unsigned int freq
, i
, num_cpus
;
810 table
= cpufreq_frequency_get_table(cpumask_first(clip_cpus
));
812 pr_debug("%s: CPUFreq table not found\n", __func__
);
813 return ERR_PTR(-EPROBE_DEFER
);
816 cpufreq_dev
= kzalloc(sizeof(*cpufreq_dev
), GFP_KERNEL
);
818 return ERR_PTR(-ENOMEM
);
820 num_cpus
= cpumask_weight(clip_cpus
);
821 cpufreq_dev
->time_in_idle
= kcalloc(num_cpus
,
822 sizeof(*cpufreq_dev
->time_in_idle
),
824 if (!cpufreq_dev
->time_in_idle
) {
825 cool_dev
= ERR_PTR(-ENOMEM
);
829 cpufreq_dev
->time_in_idle_timestamp
=
830 kcalloc(num_cpus
, sizeof(*cpufreq_dev
->time_in_idle_timestamp
),
832 if (!cpufreq_dev
->time_in_idle_timestamp
) {
833 cool_dev
= ERR_PTR(-ENOMEM
);
834 goto free_time_in_idle
;
837 /* Find max levels */
838 cpufreq_for_each_valid_entry(pos
, table
)
839 cpufreq_dev
->max_level
++;
841 cpufreq_dev
->freq_table
= kmalloc(sizeof(*cpufreq_dev
->freq_table
) *
842 cpufreq_dev
->max_level
, GFP_KERNEL
);
843 if (!cpufreq_dev
->freq_table
) {
844 cool_dev
= ERR_PTR(-ENOMEM
);
845 goto free_time_in_idle_timestamp
;
848 /* max_level is an index, not a counter */
849 cpufreq_dev
->max_level
--;
851 cpumask_copy(&cpufreq_dev
->allowed_cpus
, clip_cpus
);
854 cpufreq_cooling_ops
.get_requested_power
=
855 cpufreq_get_requested_power
;
856 cpufreq_cooling_ops
.state2power
= cpufreq_state2power
;
857 cpufreq_cooling_ops
.power2state
= cpufreq_power2state
;
858 cpufreq_dev
->plat_get_static_power
= plat_static_func
;
860 ret
= build_dyn_power_table(cpufreq_dev
, capacitance
);
862 cool_dev
= ERR_PTR(ret
);
867 ret
= get_idr(&cpufreq_idr
, &cpufreq_dev
->id
);
869 cool_dev
= ERR_PTR(ret
);
873 snprintf(dev_name
, sizeof(dev_name
), "thermal-cpufreq-%d",
876 cool_dev
= thermal_of_cooling_device_register(np
, dev_name
, cpufreq_dev
,
877 &cpufreq_cooling_ops
);
878 if (IS_ERR(cool_dev
))
881 /* Fill freq-table in descending order of frequencies */
882 for (i
= 0, freq
= -1; i
<= cpufreq_dev
->max_level
; i
++) {
883 freq
= find_next_max(table
, freq
);
884 cpufreq_dev
->freq_table
[i
] = freq
;
886 /* Warn for duplicate entries */
888 pr_warn("%s: table has duplicate entries\n", __func__
);
890 pr_debug("%s: freq:%u KHz\n", __func__
, freq
);
893 cpufreq_dev
->cpufreq_val
= cpufreq_dev
->freq_table
[0];
894 cpufreq_dev
->cool_dev
= cool_dev
;
896 mutex_lock(&cooling_cpufreq_lock
);
898 /* Register the notifier for first cpufreq cooling device */
899 if (list_empty(&cpufreq_dev_list
))
900 cpufreq_register_notifier(&thermal_cpufreq_notifier_block
,
901 CPUFREQ_POLICY_NOTIFIER
);
902 list_add(&cpufreq_dev
->node
, &cpufreq_dev_list
);
904 mutex_unlock(&cooling_cpufreq_lock
);
909 release_idr(&cpufreq_idr
, cpufreq_dev
->id
);
911 kfree(cpufreq_dev
->freq_table
);
912 free_time_in_idle_timestamp
:
913 kfree(cpufreq_dev
->time_in_idle_timestamp
);
915 kfree(cpufreq_dev
->time_in_idle
);
923 * cpufreq_cooling_register - function to create cpufreq cooling device.
924 * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
926 * This interface function registers the cpufreq cooling device with the name
927 * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
930 * Return: a valid struct thermal_cooling_device pointer on success,
931 * on failure, it returns a corresponding ERR_PTR().
933 struct thermal_cooling_device
*
934 cpufreq_cooling_register(const struct cpumask
*clip_cpus
)
936 return __cpufreq_cooling_register(NULL
, clip_cpus
, 0, NULL
);
938 EXPORT_SYMBOL_GPL(cpufreq_cooling_register
);
941 * of_cpufreq_cooling_register - function to create cpufreq cooling device.
942 * @np: a valid struct device_node to the cooling device device tree node
943 * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
945 * This interface function registers the cpufreq cooling device with the name
946 * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
947 * cooling devices. Using this API, the cpufreq cooling device will be
948 * linked to the device tree node provided.
950 * Return: a valid struct thermal_cooling_device pointer on success,
951 * on failure, it returns a corresponding ERR_PTR().
953 struct thermal_cooling_device
*
954 of_cpufreq_cooling_register(struct device_node
*np
,
955 const struct cpumask
*clip_cpus
)
958 return ERR_PTR(-EINVAL
);
960 return __cpufreq_cooling_register(np
, clip_cpus
, 0, NULL
);
962 EXPORT_SYMBOL_GPL(of_cpufreq_cooling_register
);
965 * cpufreq_power_cooling_register() - create cpufreq cooling device with power extensions
966 * @clip_cpus: cpumask of cpus where the frequency constraints will happen
967 * @capacitance: dynamic power coefficient for these cpus
968 * @plat_static_func: function to calculate the static power consumed by these
971 * This interface function registers the cpufreq cooling device with
972 * the name "thermal-cpufreq-%x". This api can support multiple
973 * instances of cpufreq cooling devices. Using this function, the
974 * cooling device will implement the power extensions by using a
975 * simple cpu power model. The cpus must have registered their OPPs
976 * using the OPP library.
978 * An optional @plat_static_func may be provided to calculate the
979 * static power consumed by these cpus. If the platform's static
980 * power consumption is unknown or negligible, make it NULL.
982 * Return: a valid struct thermal_cooling_device pointer on success,
983 * on failure, it returns a corresponding ERR_PTR().
985 struct thermal_cooling_device
*
986 cpufreq_power_cooling_register(const struct cpumask
*clip_cpus
, u32 capacitance
,
987 get_static_t plat_static_func
)
989 return __cpufreq_cooling_register(NULL
, clip_cpus
, capacitance
,
992 EXPORT_SYMBOL(cpufreq_power_cooling_register
);
995 * of_cpufreq_power_cooling_register() - create cpufreq cooling device with power extensions
996 * @np: a valid struct device_node to the cooling device device tree node
997 * @clip_cpus: cpumask of cpus where the frequency constraints will happen
998 * @capacitance: dynamic power coefficient for these cpus
999 * @plat_static_func: function to calculate the static power consumed by these
1002 * This interface function registers the cpufreq cooling device with
1003 * the name "thermal-cpufreq-%x". This api can support multiple
1004 * instances of cpufreq cooling devices. Using this API, the cpufreq
1005 * cooling device will be linked to the device tree node provided.
1006 * Using this function, the cooling device will implement the power
1007 * extensions by using a simple cpu power model. The cpus must have
1008 * registered their OPPs using the OPP library.
1010 * An optional @plat_static_func may be provided to calculate the
1011 * static power consumed by these cpus. If the platform's static
1012 * power consumption is unknown or negligible, make it NULL.
1014 * Return: a valid struct thermal_cooling_device pointer on success,
1015 * on failure, it returns a corresponding ERR_PTR().
1017 struct thermal_cooling_device
*
1018 of_cpufreq_power_cooling_register(struct device_node
*np
,
1019 const struct cpumask
*clip_cpus
,
1021 get_static_t plat_static_func
)
1024 return ERR_PTR(-EINVAL
);
1026 return __cpufreq_cooling_register(np
, clip_cpus
, capacitance
,
1029 EXPORT_SYMBOL(of_cpufreq_power_cooling_register
);
1032 * cpufreq_cooling_unregister - function to remove cpufreq cooling device.
1033 * @cdev: thermal cooling device pointer.
1035 * This interface function unregisters the "thermal-cpufreq-%x" cooling device.
1037 void cpufreq_cooling_unregister(struct thermal_cooling_device
*cdev
)
1039 struct cpufreq_cooling_device
*cpufreq_dev
;
1044 cpufreq_dev
= cdev
->devdata
;
1045 mutex_lock(&cooling_cpufreq_lock
);
1046 list_del(&cpufreq_dev
->node
);
1048 /* Unregister the notifier for the last cpufreq cooling device */
1049 if (list_empty(&cpufreq_dev_list
))
1050 cpufreq_unregister_notifier(&thermal_cpufreq_notifier_block
,
1051 CPUFREQ_POLICY_NOTIFIER
);
1052 mutex_unlock(&cooling_cpufreq_lock
);
1054 thermal_cooling_device_unregister(cpufreq_dev
->cool_dev
);
1055 release_idr(&cpufreq_idr
, cpufreq_dev
->id
);
1056 kfree(cpufreq_dev
->time_in_idle_timestamp
);
1057 kfree(cpufreq_dev
->time_in_idle
);
1058 kfree(cpufreq_dev
->freq_table
);
1061 EXPORT_SYMBOL_GPL(cpufreq_cooling_unregister
);