]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/cpufreq/cpufreq.c
cpufreq: Clear policy->cpus bits in __cpufreq_remove_dev_finish()
[mirror_ubuntu-artful-kernel.git] / drivers / cpufreq / cpufreq.c
CommitLineData
1da177e4
LT
1/*
2 * linux/drivers/cpufreq/cpufreq.c
3 *
4 * Copyright (C) 2001 Russell King
5 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
bb176f7d 6 * (C) 2013 Viresh Kumar <viresh.kumar@linaro.org>
1da177e4 7 *
c32b6b8e 8 * Oct 2005 - Ashok Raj <ashok.raj@intel.com>
32ee8c3e 9 * Added handling for CPU hotplug
8ff69732
DJ
10 * Feb 2006 - Jacob Shin <jacob.shin@amd.com>
11 * Fix handling for CPU hotplug -- affected CPUs
c32b6b8e 12 *
1da177e4
LT
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License version 2 as
15 * published by the Free Software Foundation.
1da177e4
LT
16 */
17
db701151
VK
18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
5ff0a268 20#include <linux/cpu.h>
1da177e4
LT
21#include <linux/cpufreq.h>
22#include <linux/delay.h>
1da177e4 23#include <linux/device.h>
5ff0a268
VK
24#include <linux/init.h>
25#include <linux/kernel_stat.h>
26#include <linux/module.h>
3fc54d37 27#include <linux/mutex.h>
5ff0a268 28#include <linux/slab.h>
e00e56df 29#include <linux/syscore_ops.h>
5ff0a268 30#include <linux/tick.h>
6f4f2723
TR
31#include <trace/events/power.h>
32
1da177e4 33/**
cd878479 34 * The "cpufreq driver" - the arch- or hardware-dependent low
1da177e4
LT
35 * level driver of CPUFreq support, and its spinlock. This lock
36 * also protects the cpufreq_cpu_data array.
37 */
1c3d85dd 38static struct cpufreq_driver *cpufreq_driver;
7a6aedfa 39static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
8414809c 40static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data_fallback);
bb176f7d
VK
41static DEFINE_RWLOCK(cpufreq_driver_lock);
42static DEFINE_MUTEX(cpufreq_governor_lock);
c88a1f8b 43static LIST_HEAD(cpufreq_policy_list);
bb176f7d 44
084f3493
TR
45#ifdef CONFIG_HOTPLUG_CPU
46/* This one keeps track of the previously set governor of a removed CPU */
e77b89f1 47static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
084f3493 48#endif
1da177e4 49
5a01f2e8
VP
50/*
51 * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
52 * all cpufreq/hotplug/workqueue/etc related lock issues.
53 *
54 * The rules for this semaphore:
55 * - Any routine that wants to read from the policy structure will
56 * do a down_read on this semaphore.
57 * - Any routine that will write to the policy structure and/or may take away
58 * the policy altogether (eg. CPU hotplug), will hold this lock in write
59 * mode before doing so.
60 *
61 * Additional rules:
5a01f2e8
VP
62 * - Governor routines that can be called in cpufreq hotplug path should not
63 * take this sem as top level hotplug notifier handler takes this.
395913d0
MD
64 * - Lock should not be held across
65 * __cpufreq_governor(data, CPUFREQ_GOV_STOP);
5a01f2e8 66 */
5a01f2e8
VP
67static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
68
69#define lock_policy_rwsem(mode, cpu) \
fa1d8af4 70static int lock_policy_rwsem_##mode(int cpu) \
5a01f2e8 71{ \
474deff7
VK
72 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); \
73 BUG_ON(!policy); \
74 down_##mode(&per_cpu(cpu_policy_rwsem, policy->cpu)); \
5a01f2e8
VP
75 \
76 return 0; \
77}
78
79lock_policy_rwsem(read, cpu);
5a01f2e8 80lock_policy_rwsem(write, cpu);
5a01f2e8 81
fa1d8af4
VK
82#define unlock_policy_rwsem(mode, cpu) \
83static void unlock_policy_rwsem_##mode(int cpu) \
84{ \
474deff7
VK
85 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); \
86 BUG_ON(!policy); \
87 up_##mode(&per_cpu(cpu_policy_rwsem, policy->cpu)); \
5a01f2e8 88}
5a01f2e8 89
fa1d8af4
VK
90unlock_policy_rwsem(read, cpu);
91unlock_policy_rwsem(write, cpu);
5a01f2e8 92
6eed9404
VK
93/*
94 * rwsem to guarantee that cpufreq driver module doesn't unload during critical
95 * sections
96 */
97static DECLARE_RWSEM(cpufreq_rwsem);
98
1da177e4 99/* internal prototypes */
29464f28
DJ
100static int __cpufreq_governor(struct cpufreq_policy *policy,
101 unsigned int event);
5a01f2e8 102static unsigned int __cpufreq_get(unsigned int cpu);
65f27f38 103static void handle_update(struct work_struct *work);
1da177e4
LT
104
105/**
32ee8c3e
DJ
106 * Two notifier lists: the "policy" list is involved in the
107 * validation process for a new CPU frequency policy; the
1da177e4
LT
108 * "transition" list for kernel code that needs to handle
109 * changes to devices when the CPU clock speed changes.
110 * The mutex locks both lists.
111 */
e041c683 112static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
b4dfdbb3 113static struct srcu_notifier_head cpufreq_transition_notifier_list;
1da177e4 114
74212ca4 115static bool init_cpufreq_transition_notifier_list_called;
b4dfdbb3
AS
116static int __init init_cpufreq_transition_notifier_list(void)
117{
118 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
74212ca4 119 init_cpufreq_transition_notifier_list_called = true;
b4dfdbb3
AS
120 return 0;
121}
b3438f82 122pure_initcall(init_cpufreq_transition_notifier_list);
1da177e4 123
a7b422cd 124static int off __read_mostly;
da584455 125static int cpufreq_disabled(void)
a7b422cd
KRW
126{
127 return off;
128}
129void disable_cpufreq(void)
130{
131 off = 1;
132}
1da177e4 133static LIST_HEAD(cpufreq_governor_list);
29464f28 134static DEFINE_MUTEX(cpufreq_governor_mutex);
1da177e4 135
4d5dcc42
VK
136bool have_governor_per_policy(void)
137{
1c3d85dd 138 return cpufreq_driver->have_governor_per_policy;
4d5dcc42 139}
3f869d6d 140EXPORT_SYMBOL_GPL(have_governor_per_policy);
4d5dcc42 141
944e9a03
VK
142struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
143{
144 if (have_governor_per_policy())
145 return &policy->kobj;
146 else
147 return cpufreq_global_kobject;
148}
149EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
150
72a4ce34
VK
151static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
152{
153 u64 idle_time;
154 u64 cur_wall_time;
155 u64 busy_time;
156
157 cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
158
159 busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
160 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
161 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
162 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
163 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
164 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
165
166 idle_time = cur_wall_time - busy_time;
167 if (wall)
168 *wall = cputime_to_usecs(cur_wall_time);
169
170 return cputime_to_usecs(idle_time);
171}
172
173u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
174{
175 u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);
176
177 if (idle_time == -1ULL)
178 return get_cpu_idle_time_jiffy(cpu, wall);
179 else if (!io_busy)
180 idle_time += get_cpu_iowait_time_us(cpu, wall);
181
182 return idle_time;
183}
184EXPORT_SYMBOL_GPL(get_cpu_idle_time);
185
6eed9404 186struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
1da177e4 187{
6eed9404 188 struct cpufreq_policy *policy = NULL;
1da177e4
LT
189 unsigned long flags;
190
6eed9404
VK
191 if (cpufreq_disabled() || (cpu >= nr_cpu_ids))
192 return NULL;
193
194 if (!down_read_trylock(&cpufreq_rwsem))
195 return NULL;
1da177e4
LT
196
197 /* get the cpufreq driver */
1c3d85dd 198 read_lock_irqsave(&cpufreq_driver_lock, flags);
1da177e4 199
6eed9404
VK
200 if (cpufreq_driver) {
201 /* get the CPU */
202 policy = per_cpu(cpufreq_cpu_data, cpu);
203 if (policy)
204 kobject_get(&policy->kobj);
205 }
1da177e4 206
6eed9404 207 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1da177e4 208
3a3e9e06 209 if (!policy)
6eed9404 210 up_read(&cpufreq_rwsem);
1da177e4 211
3a3e9e06 212 return policy;
a9144436 213}
1da177e4
LT
214EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
215
3a3e9e06 216void cpufreq_cpu_put(struct cpufreq_policy *policy)
1da177e4 217{
d5aaffa9
DB
218 if (cpufreq_disabled())
219 return;
220
6eed9404
VK
221 kobject_put(&policy->kobj);
222 up_read(&cpufreq_rwsem);
1da177e4
LT
223}
224EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
225
1da177e4
LT
226/*********************************************************************
227 * EXTERNALLY AFFECTING FREQUENCY CHANGES *
228 *********************************************************************/
229
230/**
231 * adjust_jiffies - adjust the system "loops_per_jiffy"
232 *
233 * This function alters the system "loops_per_jiffy" for the clock
234 * speed change. Note that loops_per_jiffy cannot be updated on SMP
32ee8c3e 235 * systems as each CPU might be scaled differently. So, use the arch
1da177e4
LT
236 * per-CPU loops_per_jiffy value wherever possible.
237 */
238#ifndef CONFIG_SMP
239static unsigned long l_p_j_ref;
bb176f7d 240static unsigned int l_p_j_ref_freq;
1da177e4 241
858119e1 242static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
1da177e4
LT
243{
244 if (ci->flags & CPUFREQ_CONST_LOOPS)
245 return;
246
247 if (!l_p_j_ref_freq) {
248 l_p_j_ref = loops_per_jiffy;
249 l_p_j_ref_freq = ci->old;
2d06d8c4 250 pr_debug("saving %lu as reference value for loops_per_jiffy; "
e08f5f5b 251 "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
1da177e4 252 }
bb176f7d 253 if ((val == CPUFREQ_POSTCHANGE && ci->old != ci->new) ||
42d4dc3f 254 (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
e08f5f5b
GS
255 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
256 ci->new);
2d06d8c4 257 pr_debug("scaling loops_per_jiffy to %lu "
e08f5f5b 258 "for frequency %u kHz\n", loops_per_jiffy, ci->new);
1da177e4
LT
259 }
260}
261#else
e08f5f5b
GS
262static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
263{
264 return;
265}
1da177e4
LT
266#endif
267
0956df9c 268static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
b43a7ffb 269 struct cpufreq_freqs *freqs, unsigned int state)
1da177e4
LT
270{
271 BUG_ON(irqs_disabled());
272
d5aaffa9
DB
273 if (cpufreq_disabled())
274 return;
275
1c3d85dd 276 freqs->flags = cpufreq_driver->flags;
2d06d8c4 277 pr_debug("notification %u of frequency transition to %u kHz\n",
e4472cb3 278 state, freqs->new);
1da177e4 279
1da177e4 280 switch (state) {
e4472cb3 281
1da177e4 282 case CPUFREQ_PRECHANGE:
32ee8c3e 283 /* detect if the driver reported a value as "old frequency"
e4472cb3
DJ
284 * which is not equal to what the cpufreq core thinks is
285 * "old frequency".
1da177e4 286 */
1c3d85dd 287 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
e4472cb3
DJ
288 if ((policy) && (policy->cpu == freqs->cpu) &&
289 (policy->cur) && (policy->cur != freqs->old)) {
2d06d8c4 290 pr_debug("Warning: CPU frequency is"
e4472cb3
DJ
291 " %u, cpufreq assumed %u kHz.\n",
292 freqs->old, policy->cur);
293 freqs->old = policy->cur;
1da177e4
LT
294 }
295 }
b4dfdbb3 296 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
e041c683 297 CPUFREQ_PRECHANGE, freqs);
1da177e4
LT
298 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
299 break;
e4472cb3 300
1da177e4
LT
301 case CPUFREQ_POSTCHANGE:
302 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
2d06d8c4 303 pr_debug("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
6f4f2723 304 (unsigned long)freqs->cpu);
25e41933 305 trace_cpu_frequency(freqs->new, freqs->cpu);
b4dfdbb3 306 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
e041c683 307 CPUFREQ_POSTCHANGE, freqs);
e4472cb3
DJ
308 if (likely(policy) && likely(policy->cpu == freqs->cpu))
309 policy->cur = freqs->new;
1da177e4
LT
310 break;
311 }
1da177e4 312}
bb176f7d 313
b43a7ffb
VK
314/**
315 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
316 * on frequency transition.
317 *
318 * This function calls the transition notifiers and the "adjust_jiffies"
319 * function. It is called twice on all CPU frequency changes that have
320 * external effects.
321 */
322void cpufreq_notify_transition(struct cpufreq_policy *policy,
323 struct cpufreq_freqs *freqs, unsigned int state)
324{
325 for_each_cpu(freqs->cpu, policy->cpus)
326 __cpufreq_notify_transition(policy, freqs, state);
327}
1da177e4
LT
328EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
329
330
1da177e4
LT
331/*********************************************************************
332 * SYSFS INTERFACE *
333 *********************************************************************/
334
3bcb09a3
JF
335static struct cpufreq_governor *__find_governor(const char *str_governor)
336{
337 struct cpufreq_governor *t;
338
339 list_for_each_entry(t, &cpufreq_governor_list, governor_list)
29464f28 340 if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
3bcb09a3
JF
341 return t;
342
343 return NULL;
344}
345
1da177e4
LT
346/**
347 * cpufreq_parse_governor - parse a governor string
348 */
905d77cd 349static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
1da177e4
LT
350 struct cpufreq_governor **governor)
351{
3bcb09a3 352 int err = -EINVAL;
1c3d85dd
RW
353
354 if (!cpufreq_driver)
3bcb09a3
JF
355 goto out;
356
1c3d85dd 357 if (cpufreq_driver->setpolicy) {
1da177e4
LT
358 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
359 *policy = CPUFREQ_POLICY_PERFORMANCE;
3bcb09a3 360 err = 0;
e08f5f5b
GS
361 } else if (!strnicmp(str_governor, "powersave",
362 CPUFREQ_NAME_LEN)) {
1da177e4 363 *policy = CPUFREQ_POLICY_POWERSAVE;
3bcb09a3 364 err = 0;
1da177e4 365 }
1c3d85dd 366 } else if (cpufreq_driver->target) {
1da177e4 367 struct cpufreq_governor *t;
3bcb09a3 368
3fc54d37 369 mutex_lock(&cpufreq_governor_mutex);
3bcb09a3
JF
370
371 t = __find_governor(str_governor);
372
ea714970 373 if (t == NULL) {
1a8e1463 374 int ret;
ea714970 375
1a8e1463
KC
376 mutex_unlock(&cpufreq_governor_mutex);
377 ret = request_module("cpufreq_%s", str_governor);
378 mutex_lock(&cpufreq_governor_mutex);
ea714970 379
1a8e1463
KC
380 if (ret == 0)
381 t = __find_governor(str_governor);
ea714970
JF
382 }
383
3bcb09a3
JF
384 if (t != NULL) {
385 *governor = t;
386 err = 0;
1da177e4 387 }
3bcb09a3 388
3fc54d37 389 mutex_unlock(&cpufreq_governor_mutex);
1da177e4 390 }
29464f28 391out:
3bcb09a3 392 return err;
1da177e4 393}
1da177e4 394
1da177e4 395/**
e08f5f5b
GS
396 * cpufreq_per_cpu_attr_read() / show_##file_name() -
397 * print out cpufreq information
1da177e4
LT
398 *
399 * Write out information from cpufreq_driver->policy[cpu]; object must be
400 * "unsigned int".
401 */
402
32ee8c3e
DJ
403#define show_one(file_name, object) \
404static ssize_t show_##file_name \
905d77cd 405(struct cpufreq_policy *policy, char *buf) \
32ee8c3e 406{ \
29464f28 407 return sprintf(buf, "%u\n", policy->object); \
1da177e4
LT
408}
409
410show_one(cpuinfo_min_freq, cpuinfo.min_freq);
411show_one(cpuinfo_max_freq, cpuinfo.max_freq);
ed129784 412show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
1da177e4
LT
413show_one(scaling_min_freq, min);
414show_one(scaling_max_freq, max);
415show_one(scaling_cur_freq, cur);
416
3a3e9e06
VK
417static int __cpufreq_set_policy(struct cpufreq_policy *policy,
418 struct cpufreq_policy *new_policy);
7970e08b 419
1da177e4
LT
420/**
421 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
422 */
423#define store_one(file_name, object) \
424static ssize_t store_##file_name \
905d77cd 425(struct cpufreq_policy *policy, const char *buf, size_t count) \
1da177e4 426{ \
5136fa56 427 int ret; \
1da177e4
LT
428 struct cpufreq_policy new_policy; \
429 \
430 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
431 if (ret) \
432 return -EINVAL; \
433 \
29464f28 434 ret = sscanf(buf, "%u", &new_policy.object); \
1da177e4
LT
435 if (ret != 1) \
436 return -EINVAL; \
437 \
7970e08b
TR
438 ret = __cpufreq_set_policy(policy, &new_policy); \
439 policy->user_policy.object = policy->object; \
1da177e4
LT
440 \
441 return ret ? ret : count; \
442}
443
29464f28
DJ
444store_one(scaling_min_freq, min);
445store_one(scaling_max_freq, max);
1da177e4
LT
446
447/**
448 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
449 */
905d77cd
DJ
450static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
451 char *buf)
1da177e4 452{
5a01f2e8 453 unsigned int cur_freq = __cpufreq_get(policy->cpu);
1da177e4
LT
454 if (!cur_freq)
455 return sprintf(buf, "<unknown>");
456 return sprintf(buf, "%u\n", cur_freq);
457}
458
1da177e4
LT
459/**
460 * show_scaling_governor - show the current policy for the specified CPU
461 */
905d77cd 462static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
1da177e4 463{
29464f28 464 if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
1da177e4
LT
465 return sprintf(buf, "powersave\n");
466 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
467 return sprintf(buf, "performance\n");
468 else if (policy->governor)
4b972f0b 469 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
29464f28 470 policy->governor->name);
1da177e4
LT
471 return -EINVAL;
472}
473
1da177e4
LT
474/**
475 * store_scaling_governor - store policy for the specified CPU
476 */
905d77cd
DJ
477static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
478 const char *buf, size_t count)
1da177e4 479{
5136fa56 480 int ret;
1da177e4
LT
481 char str_governor[16];
482 struct cpufreq_policy new_policy;
483
484 ret = cpufreq_get_policy(&new_policy, policy->cpu);
485 if (ret)
486 return ret;
487
29464f28 488 ret = sscanf(buf, "%15s", str_governor);
1da177e4
LT
489 if (ret != 1)
490 return -EINVAL;
491
e08f5f5b
GS
492 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
493 &new_policy.governor))
1da177e4
LT
494 return -EINVAL;
495
bb176f7d
VK
496 /*
497 * Do not use cpufreq_set_policy here or the user_policy.max
498 * will be wrongly overridden
499 */
7970e08b
TR
500 ret = __cpufreq_set_policy(policy, &new_policy);
501
502 policy->user_policy.policy = policy->policy;
503 policy->user_policy.governor = policy->governor;
7970e08b 504
e08f5f5b
GS
505 if (ret)
506 return ret;
507 else
508 return count;
1da177e4
LT
509}
510
511/**
512 * show_scaling_driver - show the cpufreq driver currently loaded
513 */
905d77cd 514static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
1da177e4 515{
1c3d85dd 516 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
1da177e4
LT
517}
518
519/**
520 * show_scaling_available_governors - show the available CPUfreq governors
521 */
905d77cd
DJ
522static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
523 char *buf)
1da177e4
LT
524{
525 ssize_t i = 0;
526 struct cpufreq_governor *t;
527
1c3d85dd 528 if (!cpufreq_driver->target) {
1da177e4
LT
529 i += sprintf(buf, "performance powersave");
530 goto out;
531 }
532
533 list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
29464f28
DJ
534 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
535 - (CPUFREQ_NAME_LEN + 2)))
1da177e4 536 goto out;
4b972f0b 537 i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
1da177e4 538 }
7d5e350f 539out:
1da177e4
LT
540 i += sprintf(&buf[i], "\n");
541 return i;
542}
e8628dd0 543
f4fd3797 544ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
1da177e4
LT
545{
546 ssize_t i = 0;
547 unsigned int cpu;
548
835481d9 549 for_each_cpu(cpu, mask) {
1da177e4
LT
550 if (i)
551 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
552 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
553 if (i >= (PAGE_SIZE - 5))
29464f28 554 break;
1da177e4
LT
555 }
556 i += sprintf(&buf[i], "\n");
557 return i;
558}
f4fd3797 559EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
1da177e4 560
e8628dd0
DW
561/**
562 * show_related_cpus - show the CPUs affected by each transition even if
563 * hw coordination is in use
564 */
565static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
566{
f4fd3797 567 return cpufreq_show_cpus(policy->related_cpus, buf);
e8628dd0
DW
568}
569
570/**
571 * show_affected_cpus - show the CPUs affected by each transition
572 */
573static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
574{
f4fd3797 575 return cpufreq_show_cpus(policy->cpus, buf);
e8628dd0
DW
576}
577
9e76988e 578static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
905d77cd 579 const char *buf, size_t count)
9e76988e
VP
580{
581 unsigned int freq = 0;
582 unsigned int ret;
583
879000f9 584 if (!policy->governor || !policy->governor->store_setspeed)
9e76988e
VP
585 return -EINVAL;
586
587 ret = sscanf(buf, "%u", &freq);
588 if (ret != 1)
589 return -EINVAL;
590
591 policy->governor->store_setspeed(policy, freq);
592
593 return count;
594}
595
596static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
597{
879000f9 598 if (!policy->governor || !policy->governor->show_setspeed)
9e76988e
VP
599 return sprintf(buf, "<unsupported>\n");
600
601 return policy->governor->show_setspeed(policy, buf);
602}
1da177e4 603
e2f74f35 604/**
8bf1ac72 605 * show_bios_limit - show the current cpufreq HW/BIOS limitation
e2f74f35
TR
606 */
607static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
608{
609 unsigned int limit;
610 int ret;
1c3d85dd
RW
611 if (cpufreq_driver->bios_limit) {
612 ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
e2f74f35
TR
613 if (!ret)
614 return sprintf(buf, "%u\n", limit);
615 }
616 return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
617}
618
6dad2a29
BP
619cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
620cpufreq_freq_attr_ro(cpuinfo_min_freq);
621cpufreq_freq_attr_ro(cpuinfo_max_freq);
622cpufreq_freq_attr_ro(cpuinfo_transition_latency);
623cpufreq_freq_attr_ro(scaling_available_governors);
624cpufreq_freq_attr_ro(scaling_driver);
625cpufreq_freq_attr_ro(scaling_cur_freq);
626cpufreq_freq_attr_ro(bios_limit);
627cpufreq_freq_attr_ro(related_cpus);
628cpufreq_freq_attr_ro(affected_cpus);
629cpufreq_freq_attr_rw(scaling_min_freq);
630cpufreq_freq_attr_rw(scaling_max_freq);
631cpufreq_freq_attr_rw(scaling_governor);
632cpufreq_freq_attr_rw(scaling_setspeed);
1da177e4 633
905d77cd 634static struct attribute *default_attrs[] = {
1da177e4
LT
635 &cpuinfo_min_freq.attr,
636 &cpuinfo_max_freq.attr,
ed129784 637 &cpuinfo_transition_latency.attr,
1da177e4
LT
638 &scaling_min_freq.attr,
639 &scaling_max_freq.attr,
640 &affected_cpus.attr,
e8628dd0 641 &related_cpus.attr,
1da177e4
LT
642 &scaling_governor.attr,
643 &scaling_driver.attr,
644 &scaling_available_governors.attr,
9e76988e 645 &scaling_setspeed.attr,
1da177e4
LT
646 NULL
647};
648
29464f28
DJ
649#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
650#define to_attr(a) container_of(a, struct freq_attr, attr)
1da177e4 651
29464f28 652static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
1da177e4 653{
905d77cd
DJ
654 struct cpufreq_policy *policy = to_policy(kobj);
655 struct freq_attr *fattr = to_attr(attr);
0db4a8a9 656 ssize_t ret = -EINVAL;
6eed9404
VK
657
658 if (!down_read_trylock(&cpufreq_rwsem))
659 goto exit;
5a01f2e8
VP
660
661 if (lock_policy_rwsem_read(policy->cpu) < 0)
6eed9404 662 goto up_read;
5a01f2e8 663
e08f5f5b
GS
664 if (fattr->show)
665 ret = fattr->show(policy, buf);
666 else
667 ret = -EIO;
668
5a01f2e8 669 unlock_policy_rwsem_read(policy->cpu);
6eed9404
VK
670
671up_read:
672 up_read(&cpufreq_rwsem);
673exit:
1da177e4
LT
674 return ret;
675}
676
905d77cd
DJ
677static ssize_t store(struct kobject *kobj, struct attribute *attr,
678 const char *buf, size_t count)
1da177e4 679{
905d77cd
DJ
680 struct cpufreq_policy *policy = to_policy(kobj);
681 struct freq_attr *fattr = to_attr(attr);
a07530b4 682 ssize_t ret = -EINVAL;
6eed9404 683
4f750c93
SB
684 get_online_cpus();
685
686 if (!cpu_online(policy->cpu))
687 goto unlock;
688
6eed9404 689 if (!down_read_trylock(&cpufreq_rwsem))
4f750c93 690 goto unlock;
5a01f2e8
VP
691
692 if (lock_policy_rwsem_write(policy->cpu) < 0)
6eed9404 693 goto up_read;
5a01f2e8 694
e08f5f5b
GS
695 if (fattr->store)
696 ret = fattr->store(policy, buf, count);
697 else
698 ret = -EIO;
699
5a01f2e8 700 unlock_policy_rwsem_write(policy->cpu);
6eed9404
VK
701
702up_read:
703 up_read(&cpufreq_rwsem);
4f750c93
SB
704unlock:
705 put_online_cpus();
706
1da177e4
LT
707 return ret;
708}
709
905d77cd 710static void cpufreq_sysfs_release(struct kobject *kobj)
1da177e4 711{
905d77cd 712 struct cpufreq_policy *policy = to_policy(kobj);
2d06d8c4 713 pr_debug("last reference is dropped\n");
1da177e4
LT
714 complete(&policy->kobj_unregister);
715}
716
52cf25d0 717static const struct sysfs_ops sysfs_ops = {
1da177e4
LT
718 .show = show,
719 .store = store,
720};
721
722static struct kobj_type ktype_cpufreq = {
723 .sysfs_ops = &sysfs_ops,
724 .default_attrs = default_attrs,
725 .release = cpufreq_sysfs_release,
726};
727
2361be23
VK
728struct kobject *cpufreq_global_kobject;
729EXPORT_SYMBOL(cpufreq_global_kobject);
730
731static int cpufreq_global_kobject_usage;
732
733int cpufreq_get_global_kobject(void)
734{
735 if (!cpufreq_global_kobject_usage++)
736 return kobject_add(cpufreq_global_kobject,
737 &cpu_subsys.dev_root->kobj, "%s", "cpufreq");
738
739 return 0;
740}
741EXPORT_SYMBOL(cpufreq_get_global_kobject);
742
743void cpufreq_put_global_kobject(void)
744{
745 if (!--cpufreq_global_kobject_usage)
746 kobject_del(cpufreq_global_kobject);
747}
748EXPORT_SYMBOL(cpufreq_put_global_kobject);
749
750int cpufreq_sysfs_create_file(const struct attribute *attr)
751{
752 int ret = cpufreq_get_global_kobject();
753
754 if (!ret) {
755 ret = sysfs_create_file(cpufreq_global_kobject, attr);
756 if (ret)
757 cpufreq_put_global_kobject();
758 }
759
760 return ret;
761}
762EXPORT_SYMBOL(cpufreq_sysfs_create_file);
763
764void cpufreq_sysfs_remove_file(const struct attribute *attr)
765{
766 sysfs_remove_file(cpufreq_global_kobject, attr);
767 cpufreq_put_global_kobject();
768}
769EXPORT_SYMBOL(cpufreq_sysfs_remove_file);
770
19d6f7ec 771/* symlink affected CPUs */
308b60e7 772static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
19d6f7ec
DJ
773{
774 unsigned int j;
775 int ret = 0;
776
777 for_each_cpu(j, policy->cpus) {
8a25a2fd 778 struct device *cpu_dev;
19d6f7ec 779
308b60e7 780 if (j == policy->cpu)
19d6f7ec 781 continue;
19d6f7ec 782
e8fdde10 783 pr_debug("Adding link for CPU: %u\n", j);
8a25a2fd
KS
784 cpu_dev = get_cpu_device(j);
785 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
19d6f7ec 786 "cpufreq");
71c3461e
RW
787 if (ret)
788 break;
19d6f7ec
DJ
789 }
790 return ret;
791}
792
308b60e7 793static int cpufreq_add_dev_interface(struct cpufreq_policy *policy,
8a25a2fd 794 struct device *dev)
909a694e
DJ
795{
796 struct freq_attr **drv_attr;
909a694e 797 int ret = 0;
909a694e
DJ
798
799 /* prepare interface data */
800 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
8a25a2fd 801 &dev->kobj, "cpufreq");
909a694e
DJ
802 if (ret)
803 return ret;
804
805 /* set up files for this cpu device */
1c3d85dd 806 drv_attr = cpufreq_driver->attr;
909a694e
DJ
807 while ((drv_attr) && (*drv_attr)) {
808 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
809 if (ret)
1c3d85dd 810 goto err_out_kobj_put;
909a694e
DJ
811 drv_attr++;
812 }
1c3d85dd 813 if (cpufreq_driver->get) {
909a694e
DJ
814 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
815 if (ret)
1c3d85dd 816 goto err_out_kobj_put;
909a694e 817 }
1c3d85dd 818 if (cpufreq_driver->target) {
909a694e
DJ
819 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
820 if (ret)
1c3d85dd 821 goto err_out_kobj_put;
909a694e 822 }
1c3d85dd 823 if (cpufreq_driver->bios_limit) {
e2f74f35
TR
824 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
825 if (ret)
1c3d85dd 826 goto err_out_kobj_put;
e2f74f35 827 }
909a694e 828
308b60e7 829 ret = cpufreq_add_dev_symlink(policy);
ecf7e461
DJ
830 if (ret)
831 goto err_out_kobj_put;
832
e18f1682
SB
833 return ret;
834
835err_out_kobj_put:
836 kobject_put(&policy->kobj);
837 wait_for_completion(&policy->kobj_unregister);
838 return ret;
839}
840
841static void cpufreq_init_policy(struct cpufreq_policy *policy)
842{
843 struct cpufreq_policy new_policy;
844 int ret = 0;
845
d5b73cd8 846 memcpy(&new_policy, policy, sizeof(*policy));
ecf7e461
DJ
847 /* assure that the starting sequence is run in __cpufreq_set_policy */
848 policy->governor = NULL;
849
850 /* set default policy */
851 ret = __cpufreq_set_policy(policy, &new_policy);
852 policy->user_policy.policy = policy->policy;
853 policy->user_policy.governor = policy->governor;
854
855 if (ret) {
2d06d8c4 856 pr_debug("setting policy failed\n");
1c3d85dd
RW
857 if (cpufreq_driver->exit)
858 cpufreq_driver->exit(policy);
ecf7e461 859 }
909a694e
DJ
860}
861
fcf80582 862#ifdef CONFIG_HOTPLUG_CPU
d8d3b471
VK
863static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy,
864 unsigned int cpu, struct device *dev,
865 bool frozen)
fcf80582 866{
1c3d85dd 867 int ret = 0, has_target = !!cpufreq_driver->target;
fcf80582
VK
868 unsigned long flags;
869
3de9bdeb
VK
870 if (has_target) {
871 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
872 if (ret) {
873 pr_err("%s: Failed to stop governor\n", __func__);
874 return ret;
875 }
876 }
fcf80582 877
d8d3b471 878 lock_policy_rwsem_write(policy->cpu);
2eaa3e2d 879
0d1857a1 880 write_lock_irqsave(&cpufreq_driver_lock, flags);
2eaa3e2d 881
fcf80582
VK
882 cpumask_set_cpu(cpu, policy->cpus);
883 per_cpu(cpufreq_cpu_data, cpu) = policy;
0d1857a1 884 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
fcf80582 885
d8d3b471 886 unlock_policy_rwsem_write(policy->cpu);
2eaa3e2d 887
820c6ca2 888 if (has_target) {
3de9bdeb
VK
889 if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
890 (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
891 pr_err("%s: Failed to start governor\n", __func__);
892 return ret;
893 }
820c6ca2 894 }
fcf80582 895
a82fab29 896 /* Don't touch sysfs links during light-weight init */
71c3461e
RW
897 if (!frozen)
898 ret = sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
a82fab29
SB
899
900 return ret;
fcf80582
VK
901}
902#endif
1da177e4 903
8414809c
SB
904static struct cpufreq_policy *cpufreq_policy_restore(unsigned int cpu)
905{
906 struct cpufreq_policy *policy;
907 unsigned long flags;
908
44871c9c 909 read_lock_irqsave(&cpufreq_driver_lock, flags);
8414809c
SB
910
911 policy = per_cpu(cpufreq_cpu_data_fallback, cpu);
912
44871c9c 913 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
8414809c
SB
914
915 return policy;
916}
917
e9698cc5
SB
918static struct cpufreq_policy *cpufreq_policy_alloc(void)
919{
920 struct cpufreq_policy *policy;
921
922 policy = kzalloc(sizeof(*policy), GFP_KERNEL);
923 if (!policy)
924 return NULL;
925
926 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
927 goto err_free_policy;
928
929 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
930 goto err_free_cpumask;
931
c88a1f8b 932 INIT_LIST_HEAD(&policy->policy_list);
e9698cc5
SB
933 return policy;
934
935err_free_cpumask:
936 free_cpumask_var(policy->cpus);
937err_free_policy:
938 kfree(policy);
939
940 return NULL;
941}
942
943static void cpufreq_policy_free(struct cpufreq_policy *policy)
944{
945 free_cpumask_var(policy->related_cpus);
946 free_cpumask_var(policy->cpus);
947 kfree(policy);
948}
949
0d66b91e
SB
950static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
951{
cb38ed5c
SB
952 if (cpu == policy->cpu)
953 return;
954
0d66b91e
SB
955 policy->last_cpu = policy->cpu;
956 policy->cpu = cpu;
957
958#ifdef CONFIG_CPU_FREQ_TABLE
959 cpufreq_frequency_table_update_policy_cpu(policy);
960#endif
961 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
962 CPUFREQ_UPDATE_POLICY_CPU, policy);
963}
964
a82fab29
SB
965static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif,
966 bool frozen)
1da177e4 967{
fcf80582 968 unsigned int j, cpu = dev->id;
65922465 969 int ret = -ENOMEM;
1da177e4 970 struct cpufreq_policy *policy;
1da177e4 971 unsigned long flags;
90e41bac 972#ifdef CONFIG_HOTPLUG_CPU
1b274294 973 struct cpufreq_policy *tpolicy;
fcf80582 974 struct cpufreq_governor *gov;
90e41bac 975#endif
1da177e4 976
c32b6b8e
AR
977 if (cpu_is_offline(cpu))
978 return 0;
979
2d06d8c4 980 pr_debug("adding CPU %u\n", cpu);
1da177e4
LT
981
982#ifdef CONFIG_SMP
983 /* check whether a different CPU already registered this
984 * CPU because it is in the same boat. */
985 policy = cpufreq_cpu_get(cpu);
986 if (unlikely(policy)) {
8ff69732 987 cpufreq_cpu_put(policy);
1da177e4
LT
988 return 0;
989 }
5025d628 990#endif
fcf80582 991
6eed9404
VK
992 if (!down_read_trylock(&cpufreq_rwsem))
993 return 0;
994
fcf80582
VK
995#ifdef CONFIG_HOTPLUG_CPU
996 /* Check if this cpu was hot-unplugged earlier and has siblings */
0d1857a1 997 read_lock_irqsave(&cpufreq_driver_lock, flags);
1b274294
VK
998 list_for_each_entry(tpolicy, &cpufreq_policy_list, policy_list) {
999 if (cpumask_test_cpu(cpu, tpolicy->related_cpus)) {
0d1857a1 1000 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1b274294 1001 ret = cpufreq_add_policy_cpu(tpolicy, cpu, dev, frozen);
6eed9404
VK
1002 up_read(&cpufreq_rwsem);
1003 return ret;
2eaa3e2d 1004 }
fcf80582 1005 }
0d1857a1 1006 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1da177e4
LT
1007#endif
1008
8414809c
SB
1009 if (frozen)
1010 /* Restore the saved policy when doing light-weight init */
1011 policy = cpufreq_policy_restore(cpu);
1012 else
1013 policy = cpufreq_policy_alloc();
1014
059019a3 1015 if (!policy)
1da177e4 1016 goto nomem_out;
059019a3 1017
0d66b91e
SB
1018
1019 /*
1020 * In the resume path, since we restore a saved policy, the assignment
1021 * to policy->cpu is like an update of the existing policy, rather than
1022 * the creation of a brand new one. So we need to perform this update
1023 * by invoking update_policy_cpu().
1024 */
1025 if (frozen && cpu != policy->cpu)
1026 update_policy_cpu(policy, cpu);
1027 else
1028 policy->cpu = cpu;
1029
65922465 1030 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
835481d9 1031 cpumask_copy(policy->cpus, cpumask_of(cpu));
1da177e4 1032
1da177e4 1033 init_completion(&policy->kobj_unregister);
65f27f38 1034 INIT_WORK(&policy->update, handle_update);
1da177e4
LT
1035
1036 /* call driver. From then on the cpufreq must be able
1037 * to accept all calls to ->verify and ->setpolicy for this CPU
1038 */
1c3d85dd 1039 ret = cpufreq_driver->init(policy);
1da177e4 1040 if (ret) {
2d06d8c4 1041 pr_debug("initialization failed\n");
2eaa3e2d 1042 goto err_set_policy_cpu;
1da177e4 1043 }
643ae6e8 1044
fcf80582
VK
1045 /* related cpus should atleast have policy->cpus */
1046 cpumask_or(policy->related_cpus, policy->related_cpus, policy->cpus);
1047
643ae6e8
VK
1048 /*
1049 * affected cpus must always be the one, which are online. We aren't
1050 * managing offline cpus here.
1051 */
1052 cpumask_and(policy->cpus, policy->cpus, cpu_online_mask);
1053
187d9f4e
MC
1054 policy->user_policy.min = policy->min;
1055 policy->user_policy.max = policy->max;
1da177e4 1056
a1531acd
TR
1057 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1058 CPUFREQ_START, policy);
1059
fcf80582
VK
1060#ifdef CONFIG_HOTPLUG_CPU
1061 gov = __find_governor(per_cpu(cpufreq_cpu_governor, cpu));
1062 if (gov) {
1063 policy->governor = gov;
1064 pr_debug("Restoring governor %s for cpu %d\n",
1065 policy->governor->name, cpu);
4bfa042c 1066 }
fcf80582 1067#endif
1da177e4 1068
e18f1682 1069 write_lock_irqsave(&cpufreq_driver_lock, flags);
474deff7 1070 for_each_cpu(j, policy->cpus)
e18f1682 1071 per_cpu(cpufreq_cpu_data, j) = policy;
e18f1682
SB
1072 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1073
a82fab29 1074 if (!frozen) {
308b60e7 1075 ret = cpufreq_add_dev_interface(policy, dev);
a82fab29
SB
1076 if (ret)
1077 goto err_out_unregister;
1078 }
8ff69732 1079
9515f4d6
VK
1080 write_lock_irqsave(&cpufreq_driver_lock, flags);
1081 list_add(&policy->policy_list, &cpufreq_policy_list);
1082 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1083
e18f1682
SB
1084 cpufreq_init_policy(policy);
1085
038c5b3e 1086 kobject_uevent(&policy->kobj, KOBJ_ADD);
6eed9404
VK
1087 up_read(&cpufreq_rwsem);
1088
2d06d8c4 1089 pr_debug("initialization complete\n");
87c32271 1090
1da177e4
LT
1091 return 0;
1092
1da177e4 1093err_out_unregister:
0d1857a1 1094 write_lock_irqsave(&cpufreq_driver_lock, flags);
474deff7 1095 for_each_cpu(j, policy->cpus)
7a6aedfa 1096 per_cpu(cpufreq_cpu_data, j) = NULL;
0d1857a1 1097 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1da177e4 1098
2eaa3e2d 1099err_set_policy_cpu:
e9698cc5 1100 cpufreq_policy_free(policy);
1da177e4 1101nomem_out:
6eed9404
VK
1102 up_read(&cpufreq_rwsem);
1103
1da177e4
LT
1104 return ret;
1105}
1106
a82fab29
SB
1107/**
1108 * cpufreq_add_dev - add a CPU device
1109 *
1110 * Adds the cpufreq interface for a CPU device.
1111 *
1112 * The Oracle says: try running cpufreq registration/unregistration concurrently
1113 * with with cpu hotplugging and all hell will break loose. Tried to clean this
1114 * mess up, but more thorough testing is needed. - Mathieu
1115 */
1116static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
1117{
1118 return __cpufreq_add_dev(dev, sif, false);
1119}
1120
3a3e9e06 1121static int cpufreq_nominate_new_policy_cpu(struct cpufreq_policy *policy,
a82fab29 1122 unsigned int old_cpu, bool frozen)
f9ba680d
SB
1123{
1124 struct device *cpu_dev;
f9ba680d
SB
1125 int ret;
1126
1127 /* first sibling now owns the new sysfs dir */
9c8f1ee4 1128 cpu_dev = get_cpu_device(cpumask_any_but(policy->cpus, old_cpu));
a82fab29
SB
1129
1130 /* Don't touch sysfs files during light-weight tear-down */
1131 if (frozen)
1132 return cpu_dev->id;
1133
f9ba680d 1134 sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
3a3e9e06 1135 ret = kobject_move(&policy->kobj, &cpu_dev->kobj);
f9ba680d
SB
1136 if (ret) {
1137 pr_err("%s: Failed to move kobj: %d", __func__, ret);
1138
1139 WARN_ON(lock_policy_rwsem_write(old_cpu));
3a3e9e06 1140 cpumask_set_cpu(old_cpu, policy->cpus);
f9ba680d
SB
1141 unlock_policy_rwsem_write(old_cpu);
1142
3a3e9e06 1143 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
f9ba680d
SB
1144 "cpufreq");
1145
1146 return -EINVAL;
1147 }
1148
1149 return cpu_dev->id;
1150}
1151
cedb70af
SB
1152static int __cpufreq_remove_dev_prepare(struct device *dev,
1153 struct subsys_interface *sif,
1154 bool frozen)
1da177e4 1155{
f9ba680d 1156 unsigned int cpu = dev->id, cpus;
3de9bdeb 1157 int new_cpu, ret;
1da177e4 1158 unsigned long flags;
3a3e9e06 1159 struct cpufreq_policy *policy;
1da177e4 1160
b8eed8af 1161 pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
1da177e4 1162
0d1857a1 1163 write_lock_irqsave(&cpufreq_driver_lock, flags);
2eaa3e2d 1164
3a3e9e06 1165 policy = per_cpu(cpufreq_cpu_data, cpu);
2eaa3e2d 1166
8414809c
SB
1167 /* Save the policy somewhere when doing a light-weight tear-down */
1168 if (frozen)
3a3e9e06 1169 per_cpu(cpufreq_cpu_data_fallback, cpu) = policy;
8414809c 1170
0d1857a1 1171 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1da177e4 1172
3a3e9e06 1173 if (!policy) {
b8eed8af 1174 pr_debug("%s: No cpu_data found\n", __func__);
1da177e4
LT
1175 return -EINVAL;
1176 }
1da177e4 1177
3de9bdeb
VK
1178 if (cpufreq_driver->target) {
1179 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
1180 if (ret) {
1181 pr_err("%s: Failed to stop governor\n", __func__);
1182 return ret;
1183 }
1184 }
1da177e4 1185
084f3493 1186#ifdef CONFIG_HOTPLUG_CPU
1c3d85dd 1187 if (!cpufreq_driver->setpolicy)
fa69e33f 1188 strncpy(per_cpu(cpufreq_cpu_governor, cpu),
3a3e9e06 1189 policy->governor->name, CPUFREQ_NAME_LEN);
1da177e4
LT
1190#endif
1191
9c8f1ee4 1192 lock_policy_rwsem_read(cpu);
3a3e9e06 1193 cpus = cpumask_weight(policy->cpus);
9c8f1ee4 1194 unlock_policy_rwsem_read(cpu);
084f3493 1195
61173f25
SB
1196 if (cpu != policy->cpu) {
1197 if (!frozen)
1198 sysfs_remove_link(&dev->kobj, "cpufreq");
73bf0fc2 1199 } else if (cpus > 1) {
084f3493 1200
3a3e9e06 1201 new_cpu = cpufreq_nominate_new_policy_cpu(policy, cpu, frozen);
f9ba680d 1202 if (new_cpu >= 0) {
2eaa3e2d 1203 WARN_ON(lock_policy_rwsem_write(cpu));
3a3e9e06 1204 update_policy_cpu(policy, new_cpu);
499bca9b 1205 unlock_policy_rwsem_write(cpu);
a82fab29
SB
1206
1207 if (!frozen) {
1208 pr_debug("%s: policy Kobject moved to cpu: %d "
1209 "from: %d\n",__func__, new_cpu, cpu);
1210 }
1da177e4
LT
1211 }
1212 }
1da177e4 1213
cedb70af
SB
1214 return 0;
1215}
1216
1217static int __cpufreq_remove_dev_finish(struct device *dev,
1218 struct subsys_interface *sif,
1219 bool frozen)
1220{
1221 unsigned int cpu = dev->id, cpus;
1222 int ret;
1223 unsigned long flags;
1224 struct cpufreq_policy *policy;
1225 struct kobject *kobj;
1226 struct completion *cmp;
1227
1228 read_lock_irqsave(&cpufreq_driver_lock, flags);
1229 policy = per_cpu(cpufreq_cpu_data, cpu);
1230 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1231
1232 if (!policy) {
1233 pr_debug("%s: No cpu_data found\n", __func__);
1234 return -EINVAL;
1235 }
1236
9c8f1ee4 1237 WARN_ON(lock_policy_rwsem_write(cpu));
cedb70af 1238 cpus = cpumask_weight(policy->cpus);
9c8f1ee4
VK
1239
1240 if (cpus > 1)
1241 cpumask_clear_cpu(cpu, policy->cpus);
1242 unlock_policy_rwsem_write(cpu);
cedb70af 1243
b8eed8af
VK
1244 /* If cpu is last user of policy, free policy */
1245 if (cpus == 1) {
3de9bdeb
VK
1246 if (cpufreq_driver->target) {
1247 ret = __cpufreq_governor(policy,
1248 CPUFREQ_GOV_POLICY_EXIT);
1249 if (ret) {
1250 pr_err("%s: Failed to exit governor\n",
1251 __func__);
1252 return ret;
1253 }
edab2fbc 1254 }
2a998599 1255
8414809c
SB
1256 if (!frozen) {
1257 lock_policy_rwsem_read(cpu);
3a3e9e06
VK
1258 kobj = &policy->kobj;
1259 cmp = &policy->kobj_unregister;
8414809c
SB
1260 unlock_policy_rwsem_read(cpu);
1261 kobject_put(kobj);
1262
1263 /*
1264 * We need to make sure that the underlying kobj is
1265 * actually not referenced anymore by anybody before we
1266 * proceed with unloading.
1267 */
1268 pr_debug("waiting for dropping of refcount\n");
1269 wait_for_completion(cmp);
1270 pr_debug("wait complete\n");
1271 }
7d26e2d5 1272
8414809c
SB
1273 /*
1274 * Perform the ->exit() even during light-weight tear-down,
1275 * since this is a core component, and is essential for the
1276 * subsequent light-weight ->init() to succeed.
b8eed8af 1277 */
1c3d85dd 1278 if (cpufreq_driver->exit)
3a3e9e06 1279 cpufreq_driver->exit(policy);
27ecddc2 1280
9515f4d6
VK
1281 /* Remove policy from list of active policies */
1282 write_lock_irqsave(&cpufreq_driver_lock, flags);
1283 list_del(&policy->policy_list);
1284 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1285
8414809c 1286 if (!frozen)
3a3e9e06 1287 cpufreq_policy_free(policy);
2a998599 1288 } else {
2a998599 1289 if (cpufreq_driver->target) {
3de9bdeb
VK
1290 if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
1291 (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
1292 pr_err("%s: Failed to start governor\n",
1293 __func__);
1294 return ret;
1295 }
2a998599 1296 }
27ecddc2 1297 }
1da177e4 1298
474deff7 1299 per_cpu(cpufreq_cpu_data, cpu) = NULL;
1da177e4
LT
1300 return 0;
1301}
1302
cedb70af
SB
1303/**
1304 * __cpufreq_remove_dev - remove a CPU device
1305 *
1306 * Removes the cpufreq interface for a CPU device.
1307 * Caller should already have policy_rwsem in write mode for this CPU.
1308 * This routine frees the rwsem before returning.
1309 */
1310static inline int __cpufreq_remove_dev(struct device *dev,
1311 struct subsys_interface *sif,
1312 bool frozen)
1313{
1314 int ret;
1315
1316 ret = __cpufreq_remove_dev_prepare(dev, sif, frozen);
1317
1318 if (!ret)
1319 ret = __cpufreq_remove_dev_finish(dev, sif, frozen);
1320
1321 return ret;
1322}
1323
8a25a2fd 1324static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
5a01f2e8 1325{
8a25a2fd 1326 unsigned int cpu = dev->id;
5a01f2e8 1327 int retval;
ec28297a
VP
1328
1329 if (cpu_is_offline(cpu))
1330 return 0;
1331
a82fab29 1332 retval = __cpufreq_remove_dev(dev, sif, false);
5a01f2e8
VP
1333 return retval;
1334}
1335
65f27f38 1336static void handle_update(struct work_struct *work)
1da177e4 1337{
65f27f38
DH
1338 struct cpufreq_policy *policy =
1339 container_of(work, struct cpufreq_policy, update);
1340 unsigned int cpu = policy->cpu;
2d06d8c4 1341 pr_debug("handle_update for cpu %u called\n", cpu);
1da177e4
LT
1342 cpufreq_update_policy(cpu);
1343}
1344
1345/**
bb176f7d
VK
1346 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're
1347 * in deep trouble.
1da177e4
LT
1348 * @cpu: cpu number
1349 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1350 * @new_freq: CPU frequency the CPU actually runs at
1351 *
29464f28
DJ
1352 * We adjust to current frequency first, and need to clean up later.
1353 * So either call to cpufreq_update_policy() or schedule handle_update()).
1da177e4 1354 */
e08f5f5b
GS
1355static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1356 unsigned int new_freq)
1da177e4 1357{
b43a7ffb 1358 struct cpufreq_policy *policy;
1da177e4 1359 struct cpufreq_freqs freqs;
b43a7ffb
VK
1360 unsigned long flags;
1361
2d06d8c4 1362 pr_debug("Warning: CPU frequency out of sync: cpufreq and timing "
1da177e4
LT
1363 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1364
1da177e4
LT
1365 freqs.old = old_freq;
1366 freqs.new = new_freq;
b43a7ffb
VK
1367
1368 read_lock_irqsave(&cpufreq_driver_lock, flags);
1369 policy = per_cpu(cpufreq_cpu_data, cpu);
1370 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1371
1372 cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
1373 cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
1da177e4
LT
1374}
1375
32ee8c3e 1376/**
4ab70df4 1377 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
95235ca2
VP
1378 * @cpu: CPU number
1379 *
1380 * This is the last known freq, without actually getting it from the driver.
1381 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1382 */
1383unsigned int cpufreq_quick_get(unsigned int cpu)
1384{
9e21ba8b 1385 struct cpufreq_policy *policy;
e08f5f5b 1386 unsigned int ret_freq = 0;
95235ca2 1387
1c3d85dd
RW
1388 if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
1389 return cpufreq_driver->get(cpu);
9e21ba8b
DB
1390
1391 policy = cpufreq_cpu_get(cpu);
95235ca2 1392 if (policy) {
e08f5f5b 1393 ret_freq = policy->cur;
95235ca2
VP
1394 cpufreq_cpu_put(policy);
1395 }
1396
4d34a67d 1397 return ret_freq;
95235ca2
VP
1398}
1399EXPORT_SYMBOL(cpufreq_quick_get);
1400
3d737108
JB
1401/**
1402 * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU
1403 * @cpu: CPU number
1404 *
1405 * Just return the max possible frequency for a given CPU.
1406 */
1407unsigned int cpufreq_quick_get_max(unsigned int cpu)
1408{
1409 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1410 unsigned int ret_freq = 0;
1411
1412 if (policy) {
1413 ret_freq = policy->max;
1414 cpufreq_cpu_put(policy);
1415 }
1416
1417 return ret_freq;
1418}
1419EXPORT_SYMBOL(cpufreq_quick_get_max);
1420
5a01f2e8 1421static unsigned int __cpufreq_get(unsigned int cpu)
1da177e4 1422{
7a6aedfa 1423 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
e08f5f5b 1424 unsigned int ret_freq = 0;
5800043b 1425
1c3d85dd 1426 if (!cpufreq_driver->get)
4d34a67d 1427 return ret_freq;
1da177e4 1428
1c3d85dd 1429 ret_freq = cpufreq_driver->get(cpu);
1da177e4 1430
e08f5f5b 1431 if (ret_freq && policy->cur &&
1c3d85dd 1432 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
e08f5f5b
GS
1433 /* verify no discrepancy between actual and
1434 saved value exists */
1435 if (unlikely(ret_freq != policy->cur)) {
1436 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
1da177e4
LT
1437 schedule_work(&policy->update);
1438 }
1439 }
1440
4d34a67d 1441 return ret_freq;
5a01f2e8 1442}
1da177e4 1443
5a01f2e8
VP
1444/**
1445 * cpufreq_get - get the current CPU frequency (in kHz)
1446 * @cpu: CPU number
1447 *
1448 * Get the CPU current (static) CPU frequency
1449 */
1450unsigned int cpufreq_get(unsigned int cpu)
1451{
1452 unsigned int ret_freq = 0;
5a01f2e8 1453
6eed9404
VK
1454 if (!down_read_trylock(&cpufreq_rwsem))
1455 return 0;
5a01f2e8
VP
1456
1457 if (unlikely(lock_policy_rwsem_read(cpu)))
1458 goto out_policy;
1459
1460 ret_freq = __cpufreq_get(cpu);
1461
1462 unlock_policy_rwsem_read(cpu);
1da177e4 1463
5a01f2e8 1464out_policy:
6eed9404
VK
1465 up_read(&cpufreq_rwsem);
1466
4d34a67d 1467 return ret_freq;
1da177e4
LT
1468}
1469EXPORT_SYMBOL(cpufreq_get);
1470
8a25a2fd
KS
1471static struct subsys_interface cpufreq_interface = {
1472 .name = "cpufreq",
1473 .subsys = &cpu_subsys,
1474 .add_dev = cpufreq_add_dev,
1475 .remove_dev = cpufreq_remove_dev,
e00e56df
RW
1476};
1477
42d4dc3f 1478/**
e00e56df
RW
1479 * cpufreq_bp_suspend - Prepare the boot CPU for system suspend.
1480 *
1481 * This function is only executed for the boot processor. The other CPUs
1482 * have been put offline by means of CPU hotplug.
42d4dc3f 1483 */
e00e56df 1484static int cpufreq_bp_suspend(void)
42d4dc3f 1485{
e08f5f5b 1486 int ret = 0;
4bc5d341 1487
e00e56df 1488 int cpu = smp_processor_id();
3a3e9e06 1489 struct cpufreq_policy *policy;
42d4dc3f 1490
2d06d8c4 1491 pr_debug("suspending cpu %u\n", cpu);
42d4dc3f 1492
e00e56df 1493 /* If there's no policy for the boot CPU, we have nothing to do. */
3a3e9e06
VK
1494 policy = cpufreq_cpu_get(cpu);
1495 if (!policy)
e00e56df 1496 return 0;
42d4dc3f 1497
1c3d85dd 1498 if (cpufreq_driver->suspend) {
3a3e9e06 1499 ret = cpufreq_driver->suspend(policy);
ce6c3997 1500 if (ret)
42d4dc3f 1501 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
3a3e9e06 1502 "step on CPU %u\n", policy->cpu);
42d4dc3f
BH
1503 }
1504
3a3e9e06 1505 cpufreq_cpu_put(policy);
c9060494 1506 return ret;
42d4dc3f
BH
1507}
1508
1da177e4 1509/**
e00e56df 1510 * cpufreq_bp_resume - Restore proper frequency handling of the boot CPU.
1da177e4
LT
1511 *
1512 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
ce6c3997
DB
1513 * 2.) schedule call cpufreq_update_policy() ASAP as interrupts are
1514 * restored. It will verify that the current freq is in sync with
1515 * what we believe it to be. This is a bit later than when it
1516 * should be, but nonethteless it's better than calling
1517 * cpufreq_driver->get() here which might re-enable interrupts...
e00e56df
RW
1518 *
1519 * This function is only executed for the boot CPU. The other CPUs have not
1520 * been turned on yet.
1da177e4 1521 */
e00e56df 1522static void cpufreq_bp_resume(void)
1da177e4 1523{
e08f5f5b 1524 int ret = 0;
4bc5d341 1525
e00e56df 1526 int cpu = smp_processor_id();
3a3e9e06 1527 struct cpufreq_policy *policy;
1da177e4 1528
2d06d8c4 1529 pr_debug("resuming cpu %u\n", cpu);
1da177e4 1530
e00e56df 1531 /* If there's no policy for the boot CPU, we have nothing to do. */
3a3e9e06
VK
1532 policy = cpufreq_cpu_get(cpu);
1533 if (!policy)
e00e56df 1534 return;
1da177e4 1535
1c3d85dd 1536 if (cpufreq_driver->resume) {
3a3e9e06 1537 ret = cpufreq_driver->resume(policy);
1da177e4
LT
1538 if (ret) {
1539 printk(KERN_ERR "cpufreq: resume failed in ->resume "
3a3e9e06 1540 "step on CPU %u\n", policy->cpu);
c9060494 1541 goto fail;
1da177e4
LT
1542 }
1543 }
1544
3a3e9e06 1545 schedule_work(&policy->update);
ce6c3997 1546
c9060494 1547fail:
3a3e9e06 1548 cpufreq_cpu_put(policy);
1da177e4
LT
1549}
1550
e00e56df
RW
1551static struct syscore_ops cpufreq_syscore_ops = {
1552 .suspend = cpufreq_bp_suspend,
1553 .resume = cpufreq_bp_resume,
1da177e4
LT
1554};
1555
9d95046e
BP
1556/**
1557 * cpufreq_get_current_driver - return current driver's name
1558 *
1559 * Return the name string of the currently loaded cpufreq driver
1560 * or NULL, if none.
1561 */
1562const char *cpufreq_get_current_driver(void)
1563{
1c3d85dd
RW
1564 if (cpufreq_driver)
1565 return cpufreq_driver->name;
1566
1567 return NULL;
9d95046e
BP
1568}
1569EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
1da177e4
LT
1570
1571/*********************************************************************
1572 * NOTIFIER LISTS INTERFACE *
1573 *********************************************************************/
1574
1575/**
1576 * cpufreq_register_notifier - register a driver with cpufreq
1577 * @nb: notifier function to register
1578 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1579 *
32ee8c3e 1580 * Add a driver to one of two lists: either a list of drivers that
1da177e4
LT
1581 * are notified about clock rate changes (once before and once after
1582 * the transition), or a list of drivers that are notified about
1583 * changes in cpufreq policy.
1584 *
1585 * This function may sleep, and has the same return conditions as
e041c683 1586 * blocking_notifier_chain_register.
1da177e4
LT
1587 */
1588int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1589{
1590 int ret;
1591
d5aaffa9
DB
1592 if (cpufreq_disabled())
1593 return -EINVAL;
1594
74212ca4
CEB
1595 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1596
1da177e4
LT
1597 switch (list) {
1598 case CPUFREQ_TRANSITION_NOTIFIER:
b4dfdbb3 1599 ret = srcu_notifier_chain_register(
e041c683 1600 &cpufreq_transition_notifier_list, nb);
1da177e4
LT
1601 break;
1602 case CPUFREQ_POLICY_NOTIFIER:
e041c683
AS
1603 ret = blocking_notifier_chain_register(
1604 &cpufreq_policy_notifier_list, nb);
1da177e4
LT
1605 break;
1606 default:
1607 ret = -EINVAL;
1608 }
1da177e4
LT
1609
1610 return ret;
1611}
1612EXPORT_SYMBOL(cpufreq_register_notifier);
1613
1da177e4
LT
1614/**
1615 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1616 * @nb: notifier block to be unregistered
bb176f7d 1617 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1da177e4
LT
1618 *
1619 * Remove a driver from the CPU frequency notifier list.
1620 *
1621 * This function may sleep, and has the same return conditions as
e041c683 1622 * blocking_notifier_chain_unregister.
1da177e4
LT
1623 */
1624int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1625{
1626 int ret;
1627
d5aaffa9
DB
1628 if (cpufreq_disabled())
1629 return -EINVAL;
1630
1da177e4
LT
1631 switch (list) {
1632 case CPUFREQ_TRANSITION_NOTIFIER:
b4dfdbb3 1633 ret = srcu_notifier_chain_unregister(
e041c683 1634 &cpufreq_transition_notifier_list, nb);
1da177e4
LT
1635 break;
1636 case CPUFREQ_POLICY_NOTIFIER:
e041c683
AS
1637 ret = blocking_notifier_chain_unregister(
1638 &cpufreq_policy_notifier_list, nb);
1da177e4
LT
1639 break;
1640 default:
1641 ret = -EINVAL;
1642 }
1da177e4
LT
1643
1644 return ret;
1645}
1646EXPORT_SYMBOL(cpufreq_unregister_notifier);
1647
1648
1649/*********************************************************************
1650 * GOVERNORS *
1651 *********************************************************************/
1652
1da177e4
LT
1653int __cpufreq_driver_target(struct cpufreq_policy *policy,
1654 unsigned int target_freq,
1655 unsigned int relation)
1656{
1657 int retval = -EINVAL;
7249924e 1658 unsigned int old_target_freq = target_freq;
c32b6b8e 1659
a7b422cd
KRW
1660 if (cpufreq_disabled())
1661 return -ENODEV;
1662
7249924e
VK
1663 /* Make sure that target_freq is within supported range */
1664 if (target_freq > policy->max)
1665 target_freq = policy->max;
1666 if (target_freq < policy->min)
1667 target_freq = policy->min;
1668
1669 pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
1670 policy->cpu, target_freq, relation, old_target_freq);
5a1c0228
VK
1671
1672 if (target_freq == policy->cur)
1673 return 0;
1674
1c3d85dd
RW
1675 if (cpufreq_driver->target)
1676 retval = cpufreq_driver->target(policy, target_freq, relation);
90d45d17 1677
1da177e4
LT
1678 return retval;
1679}
1680EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1681
1da177e4
LT
1682int cpufreq_driver_target(struct cpufreq_policy *policy,
1683 unsigned int target_freq,
1684 unsigned int relation)
1685{
f1829e4a 1686 int ret = -EINVAL;
1da177e4 1687
5a01f2e8 1688 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
f1829e4a 1689 goto fail;
1da177e4
LT
1690
1691 ret = __cpufreq_driver_target(policy, target_freq, relation);
1692
5a01f2e8 1693 unlock_policy_rwsem_write(policy->cpu);
1da177e4 1694
f1829e4a 1695fail:
1da177e4
LT
1696 return ret;
1697}
1698EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1699
153d7f3f 1700/*
153d7f3f
AV
1701 * when "event" is CPUFREQ_GOV_LIMITS
1702 */
1da177e4 1703
e08f5f5b
GS
1704static int __cpufreq_governor(struct cpufreq_policy *policy,
1705 unsigned int event)
1da177e4 1706{
cc993cab 1707 int ret;
6afde10c
TR
1708
1709 /* Only must be defined when default governor is known to have latency
1710 restrictions, like e.g. conservative or ondemand.
1711 That this is the case is already ensured in Kconfig
1712 */
1713#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1714 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1715#else
1716 struct cpufreq_governor *gov = NULL;
1717#endif
1c256245
TR
1718
1719 if (policy->governor->max_transition_latency &&
1720 policy->cpuinfo.transition_latency >
1721 policy->governor->max_transition_latency) {
6afde10c
TR
1722 if (!gov)
1723 return -EINVAL;
1724 else {
1725 printk(KERN_WARNING "%s governor failed, too long"
1726 " transition latency of HW, fallback"
1727 " to %s governor\n",
1728 policy->governor->name,
1729 gov->name);
1730 policy->governor = gov;
1731 }
1c256245 1732 }
1da177e4 1733
fe492f3f
VK
1734 if (event == CPUFREQ_GOV_POLICY_INIT)
1735 if (!try_module_get(policy->governor->owner))
1736 return -EINVAL;
1da177e4 1737
2d06d8c4 1738 pr_debug("__cpufreq_governor for CPU %u, event %u\n",
e08f5f5b 1739 policy->cpu, event);
95731ebb
XC
1740
1741 mutex_lock(&cpufreq_governor_lock);
56d07db2 1742 if ((policy->governor_enabled && event == CPUFREQ_GOV_START)
f73d3933
VK
1743 || (!policy->governor_enabled
1744 && (event == CPUFREQ_GOV_LIMITS || event == CPUFREQ_GOV_STOP))) {
95731ebb
XC
1745 mutex_unlock(&cpufreq_governor_lock);
1746 return -EBUSY;
1747 }
1748
1749 if (event == CPUFREQ_GOV_STOP)
1750 policy->governor_enabled = false;
1751 else if (event == CPUFREQ_GOV_START)
1752 policy->governor_enabled = true;
1753
1754 mutex_unlock(&cpufreq_governor_lock);
1755
1da177e4
LT
1756 ret = policy->governor->governor(policy, event);
1757
4d5dcc42
VK
1758 if (!ret) {
1759 if (event == CPUFREQ_GOV_POLICY_INIT)
1760 policy->governor->initialized++;
1761 else if (event == CPUFREQ_GOV_POLICY_EXIT)
1762 policy->governor->initialized--;
95731ebb
XC
1763 } else {
1764 /* Restore original values */
1765 mutex_lock(&cpufreq_governor_lock);
1766 if (event == CPUFREQ_GOV_STOP)
1767 policy->governor_enabled = true;
1768 else if (event == CPUFREQ_GOV_START)
1769 policy->governor_enabled = false;
1770 mutex_unlock(&cpufreq_governor_lock);
4d5dcc42 1771 }
b394058f 1772
fe492f3f
VK
1773 if (((event == CPUFREQ_GOV_POLICY_INIT) && ret) ||
1774 ((event == CPUFREQ_GOV_POLICY_EXIT) && !ret))
1da177e4
LT
1775 module_put(policy->governor->owner);
1776
1777 return ret;
1778}
1779
1da177e4
LT
1780int cpufreq_register_governor(struct cpufreq_governor *governor)
1781{
3bcb09a3 1782 int err;
1da177e4
LT
1783
1784 if (!governor)
1785 return -EINVAL;
1786
a7b422cd
KRW
1787 if (cpufreq_disabled())
1788 return -ENODEV;
1789
3fc54d37 1790 mutex_lock(&cpufreq_governor_mutex);
32ee8c3e 1791
b394058f 1792 governor->initialized = 0;
3bcb09a3
JF
1793 err = -EBUSY;
1794 if (__find_governor(governor->name) == NULL) {
1795 err = 0;
1796 list_add(&governor->governor_list, &cpufreq_governor_list);
1da177e4 1797 }
1da177e4 1798
32ee8c3e 1799 mutex_unlock(&cpufreq_governor_mutex);
3bcb09a3 1800 return err;
1da177e4
LT
1801}
1802EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1803
1da177e4
LT
1804void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1805{
90e41bac
PB
1806#ifdef CONFIG_HOTPLUG_CPU
1807 int cpu;
1808#endif
1809
1da177e4
LT
1810 if (!governor)
1811 return;
1812
a7b422cd
KRW
1813 if (cpufreq_disabled())
1814 return;
1815
90e41bac
PB
1816#ifdef CONFIG_HOTPLUG_CPU
1817 for_each_present_cpu(cpu) {
1818 if (cpu_online(cpu))
1819 continue;
1820 if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
1821 strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
1822 }
1823#endif
1824
3fc54d37 1825 mutex_lock(&cpufreq_governor_mutex);
1da177e4 1826 list_del(&governor->governor_list);
3fc54d37 1827 mutex_unlock(&cpufreq_governor_mutex);
1da177e4
LT
1828 return;
1829}
1830EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1831
1832
1da177e4
LT
1833/*********************************************************************
1834 * POLICY INTERFACE *
1835 *********************************************************************/
1836
1837/**
1838 * cpufreq_get_policy - get the current cpufreq_policy
29464f28
DJ
1839 * @policy: struct cpufreq_policy into which the current cpufreq_policy
1840 * is written
1da177e4
LT
1841 *
1842 * Reads the current cpufreq policy.
1843 */
1844int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1845{
1846 struct cpufreq_policy *cpu_policy;
1847 if (!policy)
1848 return -EINVAL;
1849
1850 cpu_policy = cpufreq_cpu_get(cpu);
1851 if (!cpu_policy)
1852 return -EINVAL;
1853
d5b73cd8 1854 memcpy(policy, cpu_policy, sizeof(*policy));
1da177e4
LT
1855
1856 cpufreq_cpu_put(cpu_policy);
1da177e4
LT
1857 return 0;
1858}
1859EXPORT_SYMBOL(cpufreq_get_policy);
1860
153d7f3f 1861/*
e08f5f5b
GS
1862 * data : current policy.
1863 * policy : policy to be set.
153d7f3f 1864 */
3a3e9e06
VK
1865static int __cpufreq_set_policy(struct cpufreq_policy *policy,
1866 struct cpufreq_policy *new_policy)
1da177e4 1867{
7bd353a9 1868 int ret = 0, failed = 1;
1da177e4 1869
3a3e9e06
VK
1870 pr_debug("setting new policy for CPU %u: %u - %u kHz\n", new_policy->cpu,
1871 new_policy->min, new_policy->max);
1da177e4 1872
d5b73cd8 1873 memcpy(&new_policy->cpuinfo, &policy->cpuinfo, sizeof(policy->cpuinfo));
1da177e4 1874
3a3e9e06 1875 if (new_policy->min > policy->max || new_policy->max < policy->min) {
9c9a43ed
MD
1876 ret = -EINVAL;
1877 goto error_out;
1878 }
1879
1da177e4 1880 /* verify the cpu speed can be set within this limit */
3a3e9e06 1881 ret = cpufreq_driver->verify(new_policy);
1da177e4
LT
1882 if (ret)
1883 goto error_out;
1884
1da177e4 1885 /* adjust if necessary - all reasons */
e041c683 1886 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
3a3e9e06 1887 CPUFREQ_ADJUST, new_policy);
1da177e4
LT
1888
1889 /* adjust if necessary - hardware incompatibility*/
e041c683 1890 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
3a3e9e06 1891 CPUFREQ_INCOMPATIBLE, new_policy);
1da177e4 1892
bb176f7d
VK
1893 /*
1894 * verify the cpu speed can be set within this limit, which might be
1895 * different to the first one
1896 */
3a3e9e06 1897 ret = cpufreq_driver->verify(new_policy);
e041c683 1898 if (ret)
1da177e4 1899 goto error_out;
1da177e4
LT
1900
1901 /* notification of the new policy */
e041c683 1902 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
3a3e9e06 1903 CPUFREQ_NOTIFY, new_policy);
1da177e4 1904
3a3e9e06
VK
1905 policy->min = new_policy->min;
1906 policy->max = new_policy->max;
1da177e4 1907
2d06d8c4 1908 pr_debug("new min and max freqs are %u - %u kHz\n",
3a3e9e06 1909 policy->min, policy->max);
1da177e4 1910
1c3d85dd 1911 if (cpufreq_driver->setpolicy) {
3a3e9e06 1912 policy->policy = new_policy->policy;
2d06d8c4 1913 pr_debug("setting range\n");
3a3e9e06 1914 ret = cpufreq_driver->setpolicy(new_policy);
1da177e4 1915 } else {
3a3e9e06 1916 if (new_policy->governor != policy->governor) {
1da177e4 1917 /* save old, working values */
3a3e9e06 1918 struct cpufreq_governor *old_gov = policy->governor;
1da177e4 1919
2d06d8c4 1920 pr_debug("governor switch\n");
1da177e4
LT
1921
1922 /* end old governor */
3a3e9e06
VK
1923 if (policy->governor) {
1924 __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
1925 unlock_policy_rwsem_write(new_policy->cpu);
1926 __cpufreq_governor(policy,
7bd353a9 1927 CPUFREQ_GOV_POLICY_EXIT);
3a3e9e06 1928 lock_policy_rwsem_write(new_policy->cpu);
7bd353a9 1929 }
1da177e4
LT
1930
1931 /* start new governor */
3a3e9e06
VK
1932 policy->governor = new_policy->governor;
1933 if (!__cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT)) {
1934 if (!__cpufreq_governor(policy, CPUFREQ_GOV_START)) {
7bd353a9 1935 failed = 0;
955ef483 1936 } else {
3a3e9e06
VK
1937 unlock_policy_rwsem_write(new_policy->cpu);
1938 __cpufreq_governor(policy,
7bd353a9 1939 CPUFREQ_GOV_POLICY_EXIT);
3a3e9e06 1940 lock_policy_rwsem_write(new_policy->cpu);
955ef483 1941 }
7bd353a9
VK
1942 }
1943
1944 if (failed) {
1da177e4 1945 /* new governor failed, so re-start old one */
2d06d8c4 1946 pr_debug("starting governor %s failed\n",
3a3e9e06 1947 policy->governor->name);
1da177e4 1948 if (old_gov) {
3a3e9e06
VK
1949 policy->governor = old_gov;
1950 __cpufreq_governor(policy,
7bd353a9 1951 CPUFREQ_GOV_POLICY_INIT);
3a3e9e06 1952 __cpufreq_governor(policy,
e08f5f5b 1953 CPUFREQ_GOV_START);
1da177e4
LT
1954 }
1955 ret = -EINVAL;
1956 goto error_out;
1957 }
1958 /* might be a policy change, too, so fall through */
1959 }
2d06d8c4 1960 pr_debug("governor: change or update limits\n");
3de9bdeb 1961 ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
1da177e4
LT
1962 }
1963
7d5e350f 1964error_out:
1da177e4
LT
1965 return ret;
1966}
1967
1da177e4
LT
1968/**
1969 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1970 * @cpu: CPU which shall be re-evaluated
1971 *
25985edc 1972 * Useful for policy notifiers which have different necessities
1da177e4
LT
1973 * at different times.
1974 */
1975int cpufreq_update_policy(unsigned int cpu)
1976{
3a3e9e06
VK
1977 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1978 struct cpufreq_policy new_policy;
f1829e4a 1979 int ret;
1da177e4 1980
3a3e9e06 1981 if (!policy) {
f1829e4a
JL
1982 ret = -ENODEV;
1983 goto no_policy;
1984 }
1da177e4 1985
f1829e4a
JL
1986 if (unlikely(lock_policy_rwsem_write(cpu))) {
1987 ret = -EINVAL;
1988 goto fail;
1989 }
1da177e4 1990
2d06d8c4 1991 pr_debug("updating policy for CPU %u\n", cpu);
d5b73cd8 1992 memcpy(&new_policy, policy, sizeof(*policy));
3a3e9e06
VK
1993 new_policy.min = policy->user_policy.min;
1994 new_policy.max = policy->user_policy.max;
1995 new_policy.policy = policy->user_policy.policy;
1996 new_policy.governor = policy->user_policy.governor;
1da177e4 1997
bb176f7d
VK
1998 /*
1999 * BIOS might change freq behind our back
2000 * -> ask driver for current freq and notify governors about a change
2001 */
1c3d85dd 2002 if (cpufreq_driver->get) {
3a3e9e06
VK
2003 new_policy.cur = cpufreq_driver->get(cpu);
2004 if (!policy->cur) {
2d06d8c4 2005 pr_debug("Driver did not initialize current freq");
3a3e9e06 2006 policy->cur = new_policy.cur;
a85f7bd3 2007 } else {
3a3e9e06
VK
2008 if (policy->cur != new_policy.cur && cpufreq_driver->target)
2009 cpufreq_out_of_sync(cpu, policy->cur,
2010 new_policy.cur);
a85f7bd3 2011 }
0961dd0d
TR
2012 }
2013
3a3e9e06 2014 ret = __cpufreq_set_policy(policy, &new_policy);
1da177e4 2015
5a01f2e8
VP
2016 unlock_policy_rwsem_write(cpu);
2017
f1829e4a 2018fail:
3a3e9e06 2019 cpufreq_cpu_put(policy);
f1829e4a 2020no_policy:
1da177e4
LT
2021 return ret;
2022}
2023EXPORT_SYMBOL(cpufreq_update_policy);
2024
2760984f 2025static int cpufreq_cpu_callback(struct notifier_block *nfb,
c32b6b8e
AR
2026 unsigned long action, void *hcpu)
2027{
2028 unsigned int cpu = (unsigned long)hcpu;
8a25a2fd 2029 struct device *dev;
5302c3fb 2030 bool frozen = false;
c32b6b8e 2031
8a25a2fd
KS
2032 dev = get_cpu_device(cpu);
2033 if (dev) {
5302c3fb
SB
2034
2035 if (action & CPU_TASKS_FROZEN)
2036 frozen = true;
2037
2038 switch (action & ~CPU_TASKS_FROZEN) {
c32b6b8e 2039 case CPU_ONLINE:
5302c3fb 2040 __cpufreq_add_dev(dev, NULL, frozen);
23d32899 2041 cpufreq_update_policy(cpu);
c32b6b8e 2042 break;
5302c3fb 2043
c32b6b8e 2044 case CPU_DOWN_PREPARE:
cedb70af 2045 __cpufreq_remove_dev_prepare(dev, NULL, frozen);
1aee40ac
SB
2046 break;
2047
2048 case CPU_POST_DEAD:
cedb70af 2049 __cpufreq_remove_dev_finish(dev, NULL, frozen);
c32b6b8e 2050 break;
5302c3fb 2051
5a01f2e8 2052 case CPU_DOWN_FAILED:
5302c3fb 2053 __cpufreq_add_dev(dev, NULL, frozen);
c32b6b8e
AR
2054 break;
2055 }
2056 }
2057 return NOTIFY_OK;
2058}
2059
9c36f746 2060static struct notifier_block __refdata cpufreq_cpu_notifier = {
bb176f7d 2061 .notifier_call = cpufreq_cpu_callback,
c32b6b8e 2062};
1da177e4
LT
2063
2064/*********************************************************************
2065 * REGISTER / UNREGISTER CPUFREQ DRIVER *
2066 *********************************************************************/
2067
2068/**
2069 * cpufreq_register_driver - register a CPU Frequency driver
2070 * @driver_data: A struct cpufreq_driver containing the values#
2071 * submitted by the CPU Frequency driver.
2072 *
bb176f7d 2073 * Registers a CPU Frequency driver to this core code. This code
1da177e4 2074 * returns zero on success, -EBUSY when another driver got here first
32ee8c3e 2075 * (and isn't unregistered in the meantime).
1da177e4
LT
2076 *
2077 */
221dee28 2078int cpufreq_register_driver(struct cpufreq_driver *driver_data)
1da177e4
LT
2079{
2080 unsigned long flags;
2081 int ret;
2082
a7b422cd
KRW
2083 if (cpufreq_disabled())
2084 return -ENODEV;
2085
1da177e4
LT
2086 if (!driver_data || !driver_data->verify || !driver_data->init ||
2087 ((!driver_data->setpolicy) && (!driver_data->target)))
2088 return -EINVAL;
2089
2d06d8c4 2090 pr_debug("trying to register driver %s\n", driver_data->name);
1da177e4
LT
2091
2092 if (driver_data->setpolicy)
2093 driver_data->flags |= CPUFREQ_CONST_LOOPS;
2094
0d1857a1 2095 write_lock_irqsave(&cpufreq_driver_lock, flags);
1c3d85dd 2096 if (cpufreq_driver) {
0d1857a1 2097 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1da177e4
LT
2098 return -EBUSY;
2099 }
1c3d85dd 2100 cpufreq_driver = driver_data;
0d1857a1 2101 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1da177e4 2102
8a25a2fd 2103 ret = subsys_interface_register(&cpufreq_interface);
8f5bc2ab
JS
2104 if (ret)
2105 goto err_null_driver;
1da177e4 2106
1c3d85dd 2107 if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
1da177e4
LT
2108 int i;
2109 ret = -ENODEV;
2110
2111 /* check for at least one working CPU */
7a6aedfa
MT
2112 for (i = 0; i < nr_cpu_ids; i++)
2113 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
1da177e4 2114 ret = 0;
7a6aedfa
MT
2115 break;
2116 }
1da177e4
LT
2117
2118 /* if all ->init() calls failed, unregister */
2119 if (ret) {
2d06d8c4 2120 pr_debug("no CPU initialized for driver %s\n",
e08f5f5b 2121 driver_data->name);
8a25a2fd 2122 goto err_if_unreg;
1da177e4
LT
2123 }
2124 }
2125
8f5bc2ab 2126 register_hotcpu_notifier(&cpufreq_cpu_notifier);
2d06d8c4 2127 pr_debug("driver %s up and running\n", driver_data->name);
1da177e4 2128
8f5bc2ab 2129 return 0;
8a25a2fd
KS
2130err_if_unreg:
2131 subsys_interface_unregister(&cpufreq_interface);
8f5bc2ab 2132err_null_driver:
0d1857a1 2133 write_lock_irqsave(&cpufreq_driver_lock, flags);
1c3d85dd 2134 cpufreq_driver = NULL;
0d1857a1 2135 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
4d34a67d 2136 return ret;
1da177e4
LT
2137}
2138EXPORT_SYMBOL_GPL(cpufreq_register_driver);
2139
1da177e4
LT
2140/**
2141 * cpufreq_unregister_driver - unregister the current CPUFreq driver
2142 *
bb176f7d 2143 * Unregister the current CPUFreq driver. Only call this if you have
1da177e4
LT
2144 * the right to do so, i.e. if you have succeeded in initialising before!
2145 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
2146 * currently not initialised.
2147 */
221dee28 2148int cpufreq_unregister_driver(struct cpufreq_driver *driver)
1da177e4
LT
2149{
2150 unsigned long flags;
2151
1c3d85dd 2152 if (!cpufreq_driver || (driver != cpufreq_driver))
1da177e4 2153 return -EINVAL;
1da177e4 2154
2d06d8c4 2155 pr_debug("unregistering driver %s\n", driver->name);
1da177e4 2156
8a25a2fd 2157 subsys_interface_unregister(&cpufreq_interface);
65edc68c 2158 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
1da177e4 2159
6eed9404 2160 down_write(&cpufreq_rwsem);
0d1857a1 2161 write_lock_irqsave(&cpufreq_driver_lock, flags);
6eed9404 2162
1c3d85dd 2163 cpufreq_driver = NULL;
6eed9404 2164
0d1857a1 2165 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
6eed9404 2166 up_write(&cpufreq_rwsem);
1da177e4
LT
2167
2168 return 0;
2169}
2170EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
5a01f2e8
VP
2171
2172static int __init cpufreq_core_init(void)
2173{
2174 int cpu;
2175
a7b422cd
KRW
2176 if (cpufreq_disabled())
2177 return -ENODEV;
2178
474deff7 2179 for_each_possible_cpu(cpu)
5a01f2e8 2180 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
8aa84ad8 2181
2361be23 2182 cpufreq_global_kobject = kobject_create();
8aa84ad8 2183 BUG_ON(!cpufreq_global_kobject);
e00e56df 2184 register_syscore_ops(&cpufreq_syscore_ops);
8aa84ad8 2185
5a01f2e8
VP
2186 return 0;
2187}
5a01f2e8 2188core_initcall(cpufreq_core_init);