1 /*
2 * linux/drivers/thermal/cpu_cooling.c
3 *
4 * Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com)
5 * Copyright (C) 2012 Amit Daniel <amit.kachhap@linaro.org>
6 *
7 * Copyright (C) 2014 Viresh Kumar <viresh.kumar@linaro.org>
8 *
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.
13 *
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.
18 *
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.
22 *
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24 */
25 #include <linux/module.h>
26 #include <linux/thermal.h>
27 #include <linux/cpufreq.h>
28 #include <linux/err.h>
29 #include <linux/slab.h>
30 #include <linux/cpu.h>
31 #include <linux/cpu_cooling.h>
32
33 /*
34 * Cooling state <-> CPUFreq frequency
35 *
36 * Cooling states are translated to frequencies throughout this driver and this
37 * is the relation between them.
38 *
39 * Highest cooling state corresponds to lowest possible frequency.
40 *
41 * i.e.
42 * level 0 --> 1st Max Freq
43 * level 1 --> 2nd Max Freq
44 * ...
45 */
46
47 /**
48 * struct cpufreq_cooling_device - data for cooling device with cpufreq
49 * @id: unique integer value corresponding to each cpufreq_cooling_device
50 * registered.
51 * @cool_dev: thermal_cooling_device pointer to keep track of the
52 * registered cooling device.
53 * @cpufreq_state: integer value representing the current state of cpufreq
54 * cooling devices.
55 * @clipped_freq: integer value representing the absolute value of the clipped
56 * frequency.
57 * @max_level: maximum cooling level. One less than total number of valid
58 * cpufreq frequencies.
59 * @allowed_cpus: all the cpus involved for this cpufreq_cooling_device.
60 * @node: list_head to link all cpufreq_cooling_device together.
61 *
62 * This structure is required for keeping information of each registered
63 * cpufreq_cooling_device.
64 */
65 struct cpufreq_cooling_device {
66 int id;
67 struct thermal_cooling_device *cool_dev;
68 unsigned int cpufreq_state;
69 unsigned int clipped_freq;
70 unsigned int max_level;
71 unsigned int *freq_table; /* In descending order */
72 struct cpumask allowed_cpus;
73 struct list_head node;
74 };
75 static DEFINE_IDR(cpufreq_idr);
76 static DEFINE_MUTEX(cooling_cpufreq_lock);
77
78 static LIST_HEAD(cpufreq_dev_list);
79
80 /**
81 * get_idr - function to get a unique id.
82 * @idr: struct idr * handle used to create a id.
83 * @id: int * value generated by this function.
84 *
85 * This function will populate @id with an unique
86 * id, using the idr API.
87 *
88 * Return: 0 on success, an error code on failure.
89 */
get_idr(struct idr * idr,int * id)90 static int get_idr(struct idr *idr, int *id)
91 {
92 int ret;
93
94 mutex_lock(&cooling_cpufreq_lock);
95 ret = idr_alloc(idr, NULL, 0, 0, GFP_KERNEL);
96 mutex_unlock(&cooling_cpufreq_lock);
97 if (unlikely(ret < 0))
98 return ret;
99 *id = ret;
100
101 return 0;
102 }
103
104 /**
105 * release_idr - function to free the unique id.
106 * @idr: struct idr * handle used for creating the id.
107 * @id: int value representing the unique id.
108 */
release_idr(struct idr * idr,int id)109 static void release_idr(struct idr *idr, int id)
110 {
111 mutex_lock(&cooling_cpufreq_lock);
112 idr_remove(idr, id);
113 mutex_unlock(&cooling_cpufreq_lock);
114 }
115
116 /* Below code defines functions to be used for cpufreq as cooling device */
117
118 /**
119 * get_level: Find the level for a particular frequency
120 * @cpufreq_dev: cpufreq_dev for which the property is required
121 * @freq: Frequency
122 *
123 * Return: level on success, THERMAL_CSTATE_INVALID on error.
124 */
get_level(struct cpufreq_cooling_device * cpufreq_dev,unsigned int freq)125 static unsigned long get_level(struct cpufreq_cooling_device *cpufreq_dev,
126 unsigned int freq)
127 {
128 unsigned long level;
129
130 for (level = 0; level <= cpufreq_dev->max_level; level++) {
131 if (freq == cpufreq_dev->freq_table[level])
132 return level;
133
134 if (freq > cpufreq_dev->freq_table[level])
135 break;
136 }
137
138 return THERMAL_CSTATE_INVALID;
139 }
140
141 /**
142 * cpufreq_cooling_get_level - for a given cpu, return the cooling level.
143 * @cpu: cpu for which the level is required
144 * @freq: the frequency of interest
145 *
146 * This function will match the cooling level corresponding to the
147 * requested @freq and return it.
148 *
149 * Return: The matched cooling level on success or THERMAL_CSTATE_INVALID
150 * otherwise.
151 */
cpufreq_cooling_get_level(unsigned int cpu,unsigned int freq)152 unsigned long cpufreq_cooling_get_level(unsigned int cpu, unsigned int freq)
153 {
154 struct cpufreq_cooling_device *cpufreq_dev;
155
156 mutex_lock(&cooling_cpufreq_lock);
157 list_for_each_entry(cpufreq_dev, &cpufreq_dev_list, node) {
158 if (cpumask_test_cpu(cpu, &cpufreq_dev->allowed_cpus)) {
159 mutex_unlock(&cooling_cpufreq_lock);
160 return get_level(cpufreq_dev, freq);
161 }
162 }
163 mutex_unlock(&cooling_cpufreq_lock);
164
165 pr_err("%s: cpu:%d not part of any cooling device\n", __func__, cpu);
166 return THERMAL_CSTATE_INVALID;
167 }
168 EXPORT_SYMBOL_GPL(cpufreq_cooling_get_level);
169
170 /**
171 * cpufreq_thermal_notifier - notifier callback for cpufreq policy change.
172 * @nb: struct notifier_block * with callback info.
173 * @event: value showing cpufreq event for which this function invoked.
174 * @data: callback-specific data
175 *
176 * Callback to hijack the notification on cpufreq policy transition.
177 * Every time there is a change in policy, we will intercept and
178 * update the cpufreq policy with thermal constraints.
179 *
180 * Return: 0 (success)
181 */
cpufreq_thermal_notifier(struct notifier_block * nb,unsigned long event,void * data)182 static int cpufreq_thermal_notifier(struct notifier_block *nb,
183 unsigned long event, void *data)
184 {
185 struct cpufreq_policy *policy = data;
186 unsigned long max_freq = 0;
187 struct cpufreq_cooling_device *cpufreq_dev;
188
189 if (event != CPUFREQ_ADJUST)
190 return 0;
191
192 mutex_lock(&cooling_cpufreq_lock);
193 list_for_each_entry(cpufreq_dev, &cpufreq_dev_list, node) {
194 if (!cpumask_test_cpu(policy->cpu,
195 &cpufreq_dev->allowed_cpus))
196 continue;
197
198 max_freq = cpufreq_dev->clipped_freq;
199
200 if (policy->max != max_freq)
201 cpufreq_verify_within_limits(policy, 0, max_freq);
202 }
203 mutex_unlock(&cooling_cpufreq_lock);
204
205 return 0;
206 }
207
208 /* cpufreq cooling device callback functions are defined below */
209
210 /**
211 * cpufreq_get_max_state - callback function to get the max cooling state.
212 * @cdev: thermal cooling device pointer.
213 * @state: fill this variable with the max cooling state.
214 *
215 * Callback for the thermal cooling device to return the cpufreq
216 * max cooling state.
217 *
218 * Return: 0 on success, an error code otherwise.
219 */
cpufreq_get_max_state(struct thermal_cooling_device * cdev,unsigned long * state)220 static int cpufreq_get_max_state(struct thermal_cooling_device *cdev,
221 unsigned long *state)
222 {
223 struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
224
225 *state = cpufreq_device->max_level;
226 return 0;
227 }
228
229 /**
230 * cpufreq_get_cur_state - callback function to get the current cooling state.
231 * @cdev: thermal cooling device pointer.
232 * @state: fill this variable with the current cooling state.
233 *
234 * Callback for the thermal cooling device to return the cpufreq
235 * current cooling state.
236 *
237 * Return: 0 on success, an error code otherwise.
238 */
cpufreq_get_cur_state(struct thermal_cooling_device * cdev,unsigned long * state)239 static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev,
240 unsigned long *state)
241 {
242 struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
243
244 *state = cpufreq_device->cpufreq_state;
245
246 return 0;
247 }
248
249 /**
250 * cpufreq_set_cur_state - callback function to set the current cooling state.
251 * @cdev: thermal cooling device pointer.
252 * @state: set this variable to the current cooling state.
253 *
254 * Callback for the thermal cooling device to change the cpufreq
255 * current cooling state.
256 *
257 * Return: 0 on success, an error code otherwise.
258 */
cpufreq_set_cur_state(struct thermal_cooling_device * cdev,unsigned long state)259 static int cpufreq_set_cur_state(struct thermal_cooling_device *cdev,
260 unsigned long state)
261 {
262 struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
263 unsigned int cpu = cpumask_any(&cpufreq_device->allowed_cpus);
264 unsigned int clip_freq;
265
266 /* Request state should be less than max_level */
267 if (WARN_ON(state > cpufreq_device->max_level))
268 return -EINVAL;
269
270 /* Check if the old cooling action is same as new cooling action */
271 if (cpufreq_device->cpufreq_state == state)
272 return 0;
273
274 clip_freq = cpufreq_device->freq_table[state];
275 cpufreq_device->cpufreq_state = state;
276 cpufreq_device->clipped_freq = clip_freq;
277
278 cpufreq_update_policy(cpu);
279
280 return 0;
281 }
282
283 /* Bind cpufreq callbacks to thermal cooling device ops */
284 static struct thermal_cooling_device_ops const cpufreq_cooling_ops = {
285 .get_max_state = cpufreq_get_max_state,
286 .get_cur_state = cpufreq_get_cur_state,
287 .set_cur_state = cpufreq_set_cur_state,
288 };
289
290 /* Notifier for cpufreq policy change */
291 static struct notifier_block thermal_cpufreq_notifier_block = {
292 .notifier_call = cpufreq_thermal_notifier,
293 };
294
find_next_max(struct cpufreq_frequency_table * table,unsigned int prev_max)295 static unsigned int find_next_max(struct cpufreq_frequency_table *table,
296 unsigned int prev_max)
297 {
298 struct cpufreq_frequency_table *pos;
299 unsigned int max = 0;
300
301 cpufreq_for_each_valid_entry(pos, table) {
302 if (pos->frequency > max && pos->frequency < prev_max)
303 max = pos->frequency;
304 }
305
306 return max;
307 }
308
309 /**
310 * __cpufreq_cooling_register - helper function to create cpufreq cooling device
311 * @np: a valid struct device_node to the cooling device device tree node
312 * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
313 * Normally this should be same as cpufreq policy->related_cpus.
314 *
315 * This interface function registers the cpufreq cooling device with the name
316 * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
317 * cooling devices. It also gives the opportunity to link the cooling device
318 * with a device tree node, in order to bind it via the thermal DT code.
319 *
320 * Return: a valid struct thermal_cooling_device pointer on success,
321 * on failure, it returns a corresponding ERR_PTR().
322 */
323 static struct thermal_cooling_device *
__cpufreq_cooling_register(struct device_node * np,const struct cpumask * clip_cpus)324 __cpufreq_cooling_register(struct device_node *np,
325 const struct cpumask *clip_cpus)
326 {
327 struct thermal_cooling_device *cool_dev;
328 struct cpufreq_cooling_device *cpufreq_dev;
329 char dev_name[THERMAL_NAME_LENGTH];
330 struct cpufreq_frequency_table *pos, *table;
331 unsigned int freq, i;
332 int ret;
333
334 table = cpufreq_frequency_get_table(cpumask_first(clip_cpus));
335 if (!table) {
336 pr_debug("%s: CPUFreq table not found\n", __func__);
337 return ERR_PTR(-EPROBE_DEFER);
338 }
339
340 cpufreq_dev = kzalloc(sizeof(*cpufreq_dev), GFP_KERNEL);
341 if (!cpufreq_dev)
342 return ERR_PTR(-ENOMEM);
343
344 /* Find max levels */
345 cpufreq_for_each_valid_entry(pos, table)
346 cpufreq_dev->max_level++;
347
348 cpufreq_dev->freq_table = kmalloc(sizeof(*cpufreq_dev->freq_table) *
349 cpufreq_dev->max_level, GFP_KERNEL);
350 if (!cpufreq_dev->freq_table) {
351 cool_dev = ERR_PTR(-ENOMEM);
352 goto free_cdev;
353 }
354
355 /* max_level is an index, not a counter */
356 cpufreq_dev->max_level--;
357
358 cpumask_copy(&cpufreq_dev->allowed_cpus, clip_cpus);
359
360 ret = get_idr(&cpufreq_idr, &cpufreq_dev->id);
361 if (ret) {
362 cool_dev = ERR_PTR(ret);
363 goto free_table;
364 }
365
366 /* Fill freq-table in descending order of frequencies */
367 for (i = 0, freq = -1; i <= cpufreq_dev->max_level; i++) {
368 freq = find_next_max(table, freq);
369 cpufreq_dev->freq_table[i] = freq;
370
371 /* Warn for duplicate entries */
372 if (!freq)
373 pr_warn("%s: table has duplicate entries\n", __func__);
374 else
375 pr_debug("%s: freq:%u KHz\n", __func__, freq);
376 }
377
378 snprintf(dev_name, sizeof(dev_name), "thermal-cpufreq-%d",
379 cpufreq_dev->id);
380
381 cool_dev = thermal_of_cooling_device_register(np, dev_name, cpufreq_dev,
382 &cpufreq_cooling_ops);
383 if (IS_ERR(cool_dev))
384 goto remove_idr;
385
386 cpufreq_dev->clipped_freq = cpufreq_dev->freq_table[0];
387 cpufreq_dev->cool_dev = cool_dev;
388
389 mutex_lock(&cooling_cpufreq_lock);
390
391 /* Register the notifier for first cpufreq cooling device */
392 if (list_empty(&cpufreq_dev_list))
393 cpufreq_register_notifier(&thermal_cpufreq_notifier_block,
394 CPUFREQ_POLICY_NOTIFIER);
395 list_add(&cpufreq_dev->node, &cpufreq_dev_list);
396
397 mutex_unlock(&cooling_cpufreq_lock);
398
399 return cool_dev;
400
401 remove_idr:
402 release_idr(&cpufreq_idr, cpufreq_dev->id);
403 free_table:
404 kfree(cpufreq_dev->freq_table);
405 free_cdev:
406 kfree(cpufreq_dev);
407
408 return cool_dev;
409 }
410
411 /**
412 * cpufreq_cooling_register - function to create cpufreq cooling device.
413 * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
414 *
415 * This interface function registers the cpufreq cooling device with the name
416 * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
417 * cooling devices.
418 *
419 * Return: a valid struct thermal_cooling_device pointer on success,
420 * on failure, it returns a corresponding ERR_PTR().
421 */
422 struct thermal_cooling_device *
cpufreq_cooling_register(const struct cpumask * clip_cpus)423 cpufreq_cooling_register(const struct cpumask *clip_cpus)
424 {
425 return __cpufreq_cooling_register(NULL, clip_cpus);
426 }
427 EXPORT_SYMBOL_GPL(cpufreq_cooling_register);
428
429 /**
430 * of_cpufreq_cooling_register - function to create cpufreq cooling device.
431 * @np: a valid struct device_node to the cooling device device tree node
432 * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
433 *
434 * This interface function registers the cpufreq cooling device with the name
435 * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
436 * cooling devices. Using this API, the cpufreq cooling device will be
437 * linked to the device tree node provided.
438 *
439 * Return: a valid struct thermal_cooling_device pointer on success,
440 * on failure, it returns a corresponding ERR_PTR().
441 */
442 struct thermal_cooling_device *
of_cpufreq_cooling_register(struct device_node * np,const struct cpumask * clip_cpus)443 of_cpufreq_cooling_register(struct device_node *np,
444 const struct cpumask *clip_cpus)
445 {
446 if (!np)
447 return ERR_PTR(-EINVAL);
448
449 return __cpufreq_cooling_register(np, clip_cpus);
450 }
451 EXPORT_SYMBOL_GPL(of_cpufreq_cooling_register);
452
453 /**
454 * cpufreq_cooling_unregister - function to remove cpufreq cooling device.
455 * @cdev: thermal cooling device pointer.
456 *
457 * This interface function unregisters the "thermal-cpufreq-%x" cooling device.
458 */
cpufreq_cooling_unregister(struct thermal_cooling_device * cdev)459 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
460 {
461 struct cpufreq_cooling_device *cpufreq_dev;
462
463 if (!cdev)
464 return;
465
466 cpufreq_dev = cdev->devdata;
467 mutex_lock(&cooling_cpufreq_lock);
468 list_del(&cpufreq_dev->node);
469
470 /* Unregister the notifier for the last cpufreq cooling device */
471 if (list_empty(&cpufreq_dev_list))
472 cpufreq_unregister_notifier(&thermal_cpufreq_notifier_block,
473 CPUFREQ_POLICY_NOTIFIER);
474 mutex_unlock(&cooling_cpufreq_lock);
475
476 thermal_cooling_device_unregister(cpufreq_dev->cool_dev);
477 release_idr(&cpufreq_idr, cpufreq_dev->id);
478 kfree(cpufreq_dev->freq_table);
479 kfree(cpufreq_dev);
480 }
481 EXPORT_SYMBOL_GPL(cpufreq_cooling_unregister);
482