blob: 6e2ec0b189489803ebaa55ecb4ae094bd2a1fdf0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/cpufreq/cpufreq.c
3 *
4 * Copyright (C) 2001 Russell King
5 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
6 *
Ashok Rajc32b6b82005-10-30 14:59:54 -08007 * Oct 2005 - Ashok Raj <ashok.raj@intel.com>
Dave Jones32ee8c32006-02-28 00:43:23 -05008 * Added handling for CPU hotplug
Dave Jones8ff69732006-03-05 03:37:23 -05009 * Feb 2006 - Jacob Shin <jacob.shin@amd.com>
10 * Fix handling for CPU hotplug -- affected CPUs
Ashok Rajc32b6b82005-10-30 14:59:54 -080011 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
15 *
16 */
17
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/kernel.h>
19#include <linux/module.h>
20#include <linux/init.h>
21#include <linux/notifier.h>
22#include <linux/cpufreq.h>
23#include <linux/delay.h>
24#include <linux/interrupt.h>
25#include <linux/spinlock.h>
26#include <linux/device.h>
27#include <linux/slab.h>
28#include <linux/cpu.h>
29#include <linux/completion.h>
akpm@osdl.org3fc54d32006-01-13 15:54:22 -080030#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Gautham R Shenoye08f5f52006-10-26 16:20:58 +053032#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
33 "cpufreq-core", msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35/**
Dave Jonescd878472006-08-11 17:59:28 -040036 * The "cpufreq driver" - the arch- or hardware-dependent low
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 * level driver of CPUFreq support, and its spinlock. This lock
38 * also protects the cpufreq_cpu_data array.
39 */
Dave Jones7d5e3502006-02-02 17:03:42 -050040static struct cpufreq_driver *cpufreq_driver;
Mike Travis7a6aedf2008-03-25 15:06:53 -070041static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
Thomas Renninger084f3492007-07-09 11:35:28 -070042#ifdef CONFIG_HOTPLUG_CPU
43/* This one keeps track of the previously set governor of a removed CPU */
Mike Travis7a6aedf2008-03-25 15:06:53 -070044static DEFINE_PER_CPU(struct cpufreq_governor *, cpufreq_cpu_governor);
Thomas Renninger084f3492007-07-09 11:35:28 -070045#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070046static DEFINE_SPINLOCK(cpufreq_driver_lock);
47
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080048/*
49 * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
50 * all cpufreq/hotplug/workqueue/etc related lock issues.
51 *
52 * The rules for this semaphore:
53 * - Any routine that wants to read from the policy structure will
54 * do a down_read on this semaphore.
55 * - Any routine that will write to the policy structure and/or may take away
56 * the policy altogether (eg. CPU hotplug), will hold this lock in write
57 * mode before doing so.
58 *
59 * Additional rules:
60 * - All holders of the lock should check to make sure that the CPU they
61 * are concerned with are online after they get the lock.
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.
64 */
65static DEFINE_PER_CPU(int, policy_cpu);
66static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
67
68#define lock_policy_rwsem(mode, cpu) \
69int lock_policy_rwsem_##mode \
70(int cpu) \
71{ \
72 int policy_cpu = per_cpu(policy_cpu, cpu); \
73 BUG_ON(policy_cpu == -1); \
74 down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
75 if (unlikely(!cpu_online(cpu))) { \
76 up_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
77 return -1; \
78 } \
79 \
80 return 0; \
81}
82
83lock_policy_rwsem(read, cpu);
84EXPORT_SYMBOL_GPL(lock_policy_rwsem_read);
85
86lock_policy_rwsem(write, cpu);
87EXPORT_SYMBOL_GPL(lock_policy_rwsem_write);
88
89void unlock_policy_rwsem_read(int cpu)
90{
91 int policy_cpu = per_cpu(policy_cpu, cpu);
92 BUG_ON(policy_cpu == -1);
93 up_read(&per_cpu(cpu_policy_rwsem, policy_cpu));
94}
95EXPORT_SYMBOL_GPL(unlock_policy_rwsem_read);
96
97void unlock_policy_rwsem_write(int cpu)
98{
99 int policy_cpu = per_cpu(policy_cpu, cpu);
100 BUG_ON(policy_cpu == -1);
101 up_write(&per_cpu(cpu_policy_rwsem, policy_cpu));
102}
103EXPORT_SYMBOL_GPL(unlock_policy_rwsem_write);
104
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106/* internal prototypes */
Dave Jones29464f22009-01-18 01:37:11 -0500107static int __cpufreq_governor(struct cpufreq_policy *policy,
108 unsigned int event);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800109static unsigned int __cpufreq_get(unsigned int cpu);
David Howells65f27f32006-11-22 14:55:48 +0000110static void handle_update(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112/**
Dave Jones32ee8c32006-02-28 00:43:23 -0500113 * Two notifier lists: the "policy" list is involved in the
114 * validation process for a new CPU frequency policy; the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 * "transition" list for kernel code that needs to handle
116 * changes to devices when the CPU clock speed changes.
117 * The mutex locks both lists.
118 */
Alan Sterne041c682006-03-27 01:16:30 -0800119static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700120static struct srcu_notifier_head cpufreq_transition_notifier_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -0200122static bool init_cpufreq_transition_notifier_list_called;
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700123static int __init init_cpufreq_transition_notifier_list(void)
124{
125 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -0200126 init_cpufreq_transition_notifier_list_called = true;
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700127 return 0;
128}
Linus Torvaldsb3438f82006-11-20 11:47:18 -0800129pure_initcall(init_cpufreq_transition_notifier_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
131static LIST_HEAD(cpufreq_governor_list);
Dave Jones29464f22009-01-18 01:37:11 -0500132static DEFINE_MUTEX(cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Dave Jones7d5e3502006-02-02 17:03:42 -0500134struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135{
136 struct cpufreq_policy *data;
137 unsigned long flags;
138
Mike Travis7a6aedf2008-03-25 15:06:53 -0700139 if (cpu >= nr_cpu_ids)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 goto err_out;
141
142 /* get the cpufreq driver */
143 spin_lock_irqsave(&cpufreq_driver_lock, flags);
144
145 if (!cpufreq_driver)
146 goto err_out_unlock;
147
148 if (!try_module_get(cpufreq_driver->owner))
149 goto err_out_unlock;
150
151
152 /* get the CPU */
Mike Travis7a6aedf2008-03-25 15:06:53 -0700153 data = per_cpu(cpufreq_cpu_data, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 if (!data)
156 goto err_out_put_module;
157
158 if (!kobject_get(&data->kobj))
159 goto err_out_put_module;
160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 return data;
163
Dave Jones7d5e3502006-02-02 17:03:42 -0500164err_out_put_module:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 module_put(cpufreq_driver->owner);
Dave Jones7d5e3502006-02-02 17:03:42 -0500166err_out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Dave Jones7d5e3502006-02-02 17:03:42 -0500168err_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 return NULL;
170}
171EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
172
Dave Jones7d5e3502006-02-02 17:03:42 -0500173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174void cpufreq_cpu_put(struct cpufreq_policy *data)
175{
176 kobject_put(&data->kobj);
177 module_put(cpufreq_driver->owner);
178}
179EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
180
181
182/*********************************************************************
183 * UNIFIED DEBUG HELPERS *
184 *********************************************************************/
185#ifdef CONFIG_CPU_FREQ_DEBUG
186
187/* what part(s) of the CPUfreq subsystem are debugged? */
188static unsigned int debug;
189
190/* is the debug output ratelimit'ed using printk_ratelimit? User can
191 * set or modify this value.
192 */
193static unsigned int debug_ratelimit = 1;
194
195/* is the printk_ratelimit'ing enabled? It's enabled after a successful
196 * loading of a cpufreq driver, temporarily disabled when a new policy
197 * is set, and disabled upon cpufreq driver removal
198 */
199static unsigned int disable_ratelimit = 1;
200static DEFINE_SPINLOCK(disable_ratelimit_lock);
201
Arjan van de Ven858119e2006-01-14 13:20:43 -0800202static void cpufreq_debug_enable_ratelimit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203{
204 unsigned long flags;
205
206 spin_lock_irqsave(&disable_ratelimit_lock, flags);
207 if (disable_ratelimit)
208 disable_ratelimit--;
209 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
210}
211
Arjan van de Ven858119e2006-01-14 13:20:43 -0800212static void cpufreq_debug_disable_ratelimit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
214 unsigned long flags;
215
216 spin_lock_irqsave(&disable_ratelimit_lock, flags);
217 disable_ratelimit++;
218 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
219}
220
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530221void cpufreq_debug_printk(unsigned int type, const char *prefix,
Dave Jones905d77c2008-03-05 14:28:32 -0500222 const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223{
224 char s[256];
225 va_list args;
226 unsigned int len;
227 unsigned long flags;
Dave Jones32ee8c32006-02-28 00:43:23 -0500228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 WARN_ON(!prefix);
230 if (type & debug) {
231 spin_lock_irqsave(&disable_ratelimit_lock, flags);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530232 if (!disable_ratelimit && debug_ratelimit
233 && !printk_ratelimit()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
235 return;
236 }
237 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
238
239 len = snprintf(s, 256, KERN_DEBUG "%s: ", prefix);
240
241 va_start(args, fmt);
242 len += vsnprintf(&s[len], (256 - len), fmt, args);
243 va_end(args);
244
245 printk(s);
246
247 WARN_ON(len < 5);
248 }
249}
250EXPORT_SYMBOL(cpufreq_debug_printk);
251
252
253module_param(debug, uint, 0644);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530254MODULE_PARM_DESC(debug, "CPUfreq debugging: add 1 to debug core,"
255 " 2 to debug drivers, and 4 to debug governors.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257module_param(debug_ratelimit, uint, 0644);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530258MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging:"
259 " set to 0 to disable ratelimiting.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261#else /* !CONFIG_CPU_FREQ_DEBUG */
262
263static inline void cpufreq_debug_enable_ratelimit(void) { return; }
264static inline void cpufreq_debug_disable_ratelimit(void) { return; }
265
266#endif /* CONFIG_CPU_FREQ_DEBUG */
267
268
269/*********************************************************************
270 * EXTERNALLY AFFECTING FREQUENCY CHANGES *
271 *********************************************************************/
272
273/**
274 * adjust_jiffies - adjust the system "loops_per_jiffy"
275 *
276 * This function alters the system "loops_per_jiffy" for the clock
277 * speed change. Note that loops_per_jiffy cannot be updated on SMP
Dave Jones32ee8c32006-02-28 00:43:23 -0500278 * systems as each CPU might be scaled differently. So, use the arch
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 * per-CPU loops_per_jiffy value wherever possible.
280 */
281#ifndef CONFIG_SMP
282static unsigned long l_p_j_ref;
283static unsigned int l_p_j_ref_freq;
284
Arjan van de Ven858119e2006-01-14 13:20:43 -0800285static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
287 if (ci->flags & CPUFREQ_CONST_LOOPS)
288 return;
289
290 if (!l_p_j_ref_freq) {
291 l_p_j_ref = loops_per_jiffy;
292 l_p_j_ref_freq = ci->old;
Joe Perchesa4a9df52007-11-19 17:48:06 -0800293 dprintk("saving %lu as reference value for loops_per_jiffy; "
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530294 "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 }
296 if ((val == CPUFREQ_PRECHANGE && ci->old < ci->new) ||
297 (val == CPUFREQ_POSTCHANGE && ci->old > ci->new) ||
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -0700298 (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530299 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
300 ci->new);
Joe Perchesa4a9df52007-11-19 17:48:06 -0800301 dprintk("scaling loops_per_jiffy to %lu "
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530302 "for frequency %u kHz\n", loops_per_jiffy, ci->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 }
304}
305#else
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530306static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
307{
308 return;
309}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310#endif
311
312
313/**
Dave Jonese4472cb2006-01-31 15:53:55 -0800314 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
315 * on frequency transition.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 *
Dave Jonese4472cb2006-01-31 15:53:55 -0800317 * This function calls the transition notifiers and the "adjust_jiffies"
318 * function. It is called twice on all CPU frequency changes that have
Dave Jones32ee8c32006-02-28 00:43:23 -0500319 * external effects.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 */
321void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
322{
Dave Jonese4472cb2006-01-31 15:53:55 -0800323 struct cpufreq_policy *policy;
324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 BUG_ON(irqs_disabled());
326
327 freqs->flags = cpufreq_driver->flags;
Dave Jonese4472cb2006-01-31 15:53:55 -0800328 dprintk("notification %u of frequency transition to %u kHz\n",
329 state, freqs->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
Mike Travis7a6aedf2008-03-25 15:06:53 -0700331 policy = per_cpu(cpufreq_cpu_data, freqs->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 switch (state) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 case CPUFREQ_PRECHANGE:
Dave Jones32ee8c32006-02-28 00:43:23 -0500335 /* detect if the driver reported a value as "old frequency"
Dave Jonese4472cb2006-01-31 15:53:55 -0800336 * which is not equal to what the cpufreq core thinks is
337 * "old frequency".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 */
339 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800340 if ((policy) && (policy->cpu == freqs->cpu) &&
341 (policy->cur) && (policy->cur != freqs->old)) {
Jan Beulichb10eec22006-04-28 13:47:13 +0200342 dprintk("Warning: CPU frequency is"
Dave Jonese4472cb2006-01-31 15:53:55 -0800343 " %u, cpufreq assumed %u kHz.\n",
344 freqs->old, policy->cur);
345 freqs->old = policy->cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 }
347 }
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700348 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800349 CPUFREQ_PRECHANGE, freqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
351 break;
Dave Jonese4472cb2006-01-31 15:53:55 -0800352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 case CPUFREQ_POSTCHANGE:
354 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700355 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800356 CPUFREQ_POSTCHANGE, freqs);
Dave Jonese4472cb2006-01-31 15:53:55 -0800357 if (likely(policy) && likely(policy->cpu == freqs->cpu))
358 policy->cur = freqs->new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 break;
360 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361}
362EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
363
364
365
366/*********************************************************************
367 * SYSFS INTERFACE *
368 *********************************************************************/
369
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700370static struct cpufreq_governor *__find_governor(const char *str_governor)
371{
372 struct cpufreq_governor *t;
373
374 list_for_each_entry(t, &cpufreq_governor_list, governor_list)
Dave Jones29464f22009-01-18 01:37:11 -0500375 if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700376 return t;
377
378 return NULL;
379}
380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381/**
382 * cpufreq_parse_governor - parse a governor string
383 */
Dave Jones905d77c2008-03-05 14:28:32 -0500384static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 struct cpufreq_governor **governor)
386{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700387 int err = -EINVAL;
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 if (!cpufreq_driver)
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700390 goto out;
391
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 if (cpufreq_driver->setpolicy) {
393 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
394 *policy = CPUFREQ_POLICY_PERFORMANCE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700395 err = 0;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530396 } else if (!strnicmp(str_governor, "powersave",
397 CPUFREQ_NAME_LEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 *policy = CPUFREQ_POLICY_POWERSAVE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700399 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700401 } else if (cpufreq_driver->target) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 struct cpufreq_governor *t;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700403
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800404 mutex_lock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700405
406 t = __find_governor(str_governor);
407
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700408 if (t == NULL) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530409 char *name = kasprintf(GFP_KERNEL, "cpufreq_%s",
410 str_governor);
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700411
412 if (name) {
413 int ret;
414
415 mutex_unlock(&cpufreq_governor_mutex);
Chris Wright326f6a52008-06-06 21:26:02 -0700416 ret = request_module("%s", name);
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700417 mutex_lock(&cpufreq_governor_mutex);
418
419 if (ret == 0)
420 t = __find_governor(str_governor);
421 }
422
423 kfree(name);
424 }
425
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700426 if (t != NULL) {
427 *governor = t;
428 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700430
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800431 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 }
Dave Jones29464f22009-01-18 01:37:11 -0500433out:
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700434 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438/**
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530439 * cpufreq_per_cpu_attr_read() / show_##file_name() -
440 * print out cpufreq information
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 *
442 * Write out information from cpufreq_driver->policy[cpu]; object must be
443 * "unsigned int".
444 */
445
Dave Jones32ee8c32006-02-28 00:43:23 -0500446#define show_one(file_name, object) \
447static ssize_t show_##file_name \
Dave Jones905d77c2008-03-05 14:28:32 -0500448(struct cpufreq_policy *policy, char *buf) \
Dave Jones32ee8c32006-02-28 00:43:23 -0500449{ \
Dave Jones29464f22009-01-18 01:37:11 -0500450 return sprintf(buf, "%u\n", policy->object); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451}
452
453show_one(cpuinfo_min_freq, cpuinfo.min_freq);
454show_one(cpuinfo_max_freq, cpuinfo.max_freq);
Thomas Renningered129782009-02-04 01:17:41 +0100455show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456show_one(scaling_min_freq, min);
457show_one(scaling_max_freq, max);
458show_one(scaling_cur_freq, cur);
459
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530460static int __cpufreq_set_policy(struct cpufreq_policy *data,
461 struct cpufreq_policy *policy);
Thomas Renninger7970e082006-04-13 15:14:04 +0200462
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463/**
464 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
465 */
466#define store_one(file_name, object) \
467static ssize_t store_##file_name \
Dave Jones905d77c2008-03-05 14:28:32 -0500468(struct cpufreq_policy *policy, const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469{ \
470 unsigned int ret = -EINVAL; \
471 struct cpufreq_policy new_policy; \
472 \
473 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
474 if (ret) \
475 return -EINVAL; \
476 \
Dave Jones29464f22009-01-18 01:37:11 -0500477 ret = sscanf(buf, "%u", &new_policy.object); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 if (ret != 1) \
479 return -EINVAL; \
480 \
Thomas Renninger7970e082006-04-13 15:14:04 +0200481 ret = __cpufreq_set_policy(policy, &new_policy); \
482 policy->user_policy.object = policy->object; \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 \
484 return ret ? ret : count; \
485}
486
Dave Jones29464f22009-01-18 01:37:11 -0500487store_one(scaling_min_freq, min);
488store_one(scaling_max_freq, max);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490/**
491 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
492 */
Dave Jones905d77c2008-03-05 14:28:32 -0500493static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
494 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495{
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800496 unsigned int cur_freq = __cpufreq_get(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 if (!cur_freq)
498 return sprintf(buf, "<unknown>");
499 return sprintf(buf, "%u\n", cur_freq);
500}
501
502
503/**
504 * show_scaling_governor - show the current policy for the specified CPU
505 */
Dave Jones905d77c2008-03-05 14:28:32 -0500506static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507{
Dave Jones29464f22009-01-18 01:37:11 -0500508 if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 return sprintf(buf, "powersave\n");
510 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
511 return sprintf(buf, "performance\n");
512 else if (policy->governor)
Dave Jones29464f22009-01-18 01:37:11 -0500513 return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n",
514 policy->governor->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 return -EINVAL;
516}
517
518
519/**
520 * store_scaling_governor - store policy for the specified CPU
521 */
Dave Jones905d77c2008-03-05 14:28:32 -0500522static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
523 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
525 unsigned int ret = -EINVAL;
526 char str_governor[16];
527 struct cpufreq_policy new_policy;
528
529 ret = cpufreq_get_policy(&new_policy, policy->cpu);
530 if (ret)
531 return ret;
532
Dave Jones29464f22009-01-18 01:37:11 -0500533 ret = sscanf(buf, "%15s", str_governor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 if (ret != 1)
535 return -EINVAL;
536
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530537 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
538 &new_policy.governor))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 return -EINVAL;
540
Thomas Renninger7970e082006-04-13 15:14:04 +0200541 /* Do not use cpufreq_set_policy here or the user_policy.max
542 will be wrongly overridden */
Thomas Renninger7970e082006-04-13 15:14:04 +0200543 ret = __cpufreq_set_policy(policy, &new_policy);
544
545 policy->user_policy.policy = policy->policy;
546 policy->user_policy.governor = policy->governor;
Thomas Renninger7970e082006-04-13 15:14:04 +0200547
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530548 if (ret)
549 return ret;
550 else
551 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552}
553
554/**
555 * show_scaling_driver - show the cpufreq driver currently loaded
556 */
Dave Jones905d77c2008-03-05 14:28:32 -0500557static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
559 return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", cpufreq_driver->name);
560}
561
562/**
563 * show_scaling_available_governors - show the available CPUfreq governors
564 */
Dave Jones905d77c2008-03-05 14:28:32 -0500565static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
566 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
568 ssize_t i = 0;
569 struct cpufreq_governor *t;
570
571 if (!cpufreq_driver->target) {
572 i += sprintf(buf, "performance powersave");
573 goto out;
574 }
575
576 list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
Dave Jones29464f22009-01-18 01:37:11 -0500577 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
578 - (CPUFREQ_NAME_LEN + 2)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 goto out;
580 i += scnprintf(&buf[i], CPUFREQ_NAME_LEN, "%s ", t->name);
581 }
Dave Jones7d5e3502006-02-02 17:03:42 -0500582out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 i += sprintf(&buf[i], "\n");
584 return i;
585}
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700586
Rusty Russell835481d2009-01-04 05:18:06 -0800587static ssize_t show_cpus(const struct cpumask *mask, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588{
589 ssize_t i = 0;
590 unsigned int cpu;
591
Rusty Russell835481d2009-01-04 05:18:06 -0800592 for_each_cpu(cpu, mask) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 if (i)
594 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
595 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
596 if (i >= (PAGE_SIZE - 5))
Dave Jones29464f22009-01-18 01:37:11 -0500597 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 }
599 i += sprintf(&buf[i], "\n");
600 return i;
601}
602
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700603/**
604 * show_related_cpus - show the CPUs affected by each transition even if
605 * hw coordination is in use
606 */
607static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
608{
Rusty Russell835481d2009-01-04 05:18:06 -0800609 if (cpumask_empty(policy->related_cpus))
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700610 return show_cpus(policy->cpus, buf);
611 return show_cpus(policy->related_cpus, buf);
612}
613
614/**
615 * show_affected_cpus - show the CPUs affected by each transition
616 */
617static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
618{
619 return show_cpus(policy->cpus, buf);
620}
621
Venki Pallipadi9e769882007-10-26 10:18:21 -0700622static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
Dave Jones905d77c2008-03-05 14:28:32 -0500623 const char *buf, size_t count)
Venki Pallipadi9e769882007-10-26 10:18:21 -0700624{
625 unsigned int freq = 0;
626 unsigned int ret;
627
CHIKAMA masaki879000f2008-06-05 22:46:33 -0700628 if (!policy->governor || !policy->governor->store_setspeed)
Venki Pallipadi9e769882007-10-26 10:18:21 -0700629 return -EINVAL;
630
631 ret = sscanf(buf, "%u", &freq);
632 if (ret != 1)
633 return -EINVAL;
634
635 policy->governor->store_setspeed(policy, freq);
636
637 return count;
638}
639
640static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
641{
CHIKAMA masaki879000f2008-06-05 22:46:33 -0700642 if (!policy->governor || !policy->governor->show_setspeed)
Venki Pallipadi9e769882007-10-26 10:18:21 -0700643 return sprintf(buf, "<unsupported>\n");
644
645 return policy->governor->show_setspeed(policy, buf);
646}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
648#define define_one_ro(_name) \
649static struct freq_attr _name = \
650__ATTR(_name, 0444, show_##_name, NULL)
651
652#define define_one_ro0400(_name) \
653static struct freq_attr _name = \
654__ATTR(_name, 0400, show_##_name, NULL)
655
656#define define_one_rw(_name) \
657static struct freq_attr _name = \
658__ATTR(_name, 0644, show_##_name, store_##_name)
659
660define_one_ro0400(cpuinfo_cur_freq);
661define_one_ro(cpuinfo_min_freq);
662define_one_ro(cpuinfo_max_freq);
Thomas Renningered129782009-02-04 01:17:41 +0100663define_one_ro(cpuinfo_transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664define_one_ro(scaling_available_governors);
665define_one_ro(scaling_driver);
666define_one_ro(scaling_cur_freq);
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700667define_one_ro(related_cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668define_one_ro(affected_cpus);
669define_one_rw(scaling_min_freq);
670define_one_rw(scaling_max_freq);
671define_one_rw(scaling_governor);
Venki Pallipadi9e769882007-10-26 10:18:21 -0700672define_one_rw(scaling_setspeed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
Dave Jones905d77c2008-03-05 14:28:32 -0500674static struct attribute *default_attrs[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 &cpuinfo_min_freq.attr,
676 &cpuinfo_max_freq.attr,
Thomas Renningered129782009-02-04 01:17:41 +0100677 &cpuinfo_transition_latency.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 &scaling_min_freq.attr,
679 &scaling_max_freq.attr,
680 &affected_cpus.attr,
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700681 &related_cpus.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 &scaling_governor.attr,
683 &scaling_driver.attr,
684 &scaling_available_governors.attr,
Venki Pallipadi9e769882007-10-26 10:18:21 -0700685 &scaling_setspeed.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 NULL
687};
688
Dave Jones29464f22009-01-18 01:37:11 -0500689#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
690#define to_attr(a) container_of(a, struct freq_attr, attr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Dave Jones29464f22009-01-18 01:37:11 -0500692static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Dave Jones905d77c2008-03-05 14:28:32 -0500694 struct cpufreq_policy *policy = to_policy(kobj);
695 struct freq_attr *fattr = to_attr(attr);
Dave Jones0db4a8a2008-03-05 14:20:57 -0500696 ssize_t ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 policy = cpufreq_cpu_get(policy->cpu);
698 if (!policy)
Dave Jones0db4a8a2008-03-05 14:20:57 -0500699 goto no_policy;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800700
701 if (lock_policy_rwsem_read(policy->cpu) < 0)
Dave Jones0db4a8a2008-03-05 14:20:57 -0500702 goto fail;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800703
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530704 if (fattr->show)
705 ret = fattr->show(policy, buf);
706 else
707 ret = -EIO;
708
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800709 unlock_policy_rwsem_read(policy->cpu);
Dave Jones0db4a8a2008-03-05 14:20:57 -0500710fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 cpufreq_cpu_put(policy);
Dave Jones0db4a8a2008-03-05 14:20:57 -0500712no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 return ret;
714}
715
Dave Jones905d77c2008-03-05 14:28:32 -0500716static ssize_t store(struct kobject *kobj, struct attribute *attr,
717 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718{
Dave Jones905d77c2008-03-05 14:28:32 -0500719 struct cpufreq_policy *policy = to_policy(kobj);
720 struct freq_attr *fattr = to_attr(attr);
Dave Jonesa07530b2008-03-05 14:22:25 -0500721 ssize_t ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 policy = cpufreq_cpu_get(policy->cpu);
723 if (!policy)
Dave Jonesa07530b2008-03-05 14:22:25 -0500724 goto no_policy;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800725
726 if (lock_policy_rwsem_write(policy->cpu) < 0)
Dave Jonesa07530b2008-03-05 14:22:25 -0500727 goto fail;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800728
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530729 if (fattr->store)
730 ret = fattr->store(policy, buf, count);
731 else
732 ret = -EIO;
733
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800734 unlock_policy_rwsem_write(policy->cpu);
Dave Jonesa07530b2008-03-05 14:22:25 -0500735fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 cpufreq_cpu_put(policy);
Dave Jonesa07530b2008-03-05 14:22:25 -0500737no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 return ret;
739}
740
Dave Jones905d77c2008-03-05 14:28:32 -0500741static void cpufreq_sysfs_release(struct kobject *kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742{
Dave Jones905d77c2008-03-05 14:28:32 -0500743 struct cpufreq_policy *policy = to_policy(kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 dprintk("last reference is dropped\n");
745 complete(&policy->kobj_unregister);
746}
747
748static struct sysfs_ops sysfs_ops = {
749 .show = show,
750 .store = store,
751};
752
753static struct kobj_type ktype_cpufreq = {
754 .sysfs_ops = &sysfs_ops,
755 .default_attrs = default_attrs,
756 .release = cpufreq_sysfs_release,
757};
758
759
760/**
761 * cpufreq_add_dev - add a CPU device
762 *
Dave Jones32ee8c32006-02-28 00:43:23 -0500763 * Adds the cpufreq interface for a CPU device.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 */
Dave Jones905d77c2008-03-05 14:28:32 -0500765static int cpufreq_add_dev(struct sys_device *sys_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766{
767 unsigned int cpu = sys_dev->id;
768 int ret = 0;
769 struct cpufreq_policy new_policy;
770 struct cpufreq_policy *policy;
771 struct freq_attr **drv_attr;
Dave Jones8ff69732006-03-05 03:37:23 -0500772 struct sys_device *cpu_sys_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 unsigned long flags;
774 unsigned int j;
Dave Jones8ff69732006-03-05 03:37:23 -0500775#ifdef CONFIG_SMP
776 struct cpufreq_policy *managed_policy;
777#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Ashok Rajc32b6b82005-10-30 14:59:54 -0800779 if (cpu_is_offline(cpu))
780 return 0;
781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 cpufreq_debug_disable_ratelimit();
783 dprintk("adding CPU %u\n", cpu);
784
785#ifdef CONFIG_SMP
786 /* check whether a different CPU already registered this
787 * CPU because it is in the same boat. */
788 policy = cpufreq_cpu_get(cpu);
789 if (unlikely(policy)) {
Dave Jones8ff69732006-03-05 03:37:23 -0500790 cpufreq_cpu_put(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 cpufreq_debug_enable_ratelimit();
792 return 0;
793 }
794#endif
795
796 if (!try_module_get(cpufreq_driver->owner)) {
797 ret = -EINVAL;
798 goto module_out;
799 }
800
Dave Jonese98df502005-10-20 15:17:43 -0700801 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 if (!policy) {
803 ret = -ENOMEM;
804 goto nomem_out;
805 }
Rusty Russell835481d2009-01-04 05:18:06 -0800806 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL)) {
807 kfree(policy);
808 ret = -ENOMEM;
809 goto nomem_out;
810 }
Yinghai Lueaa95842009-06-06 14:51:36 -0700811 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL)) {
Rusty Russell835481d2009-01-04 05:18:06 -0800812 free_cpumask_var(policy->cpus);
813 kfree(policy);
814 ret = -ENOMEM;
815 goto nomem_out;
816 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
818 policy->cpu = cpu;
Rusty Russell835481d2009-01-04 05:18:06 -0800819 cpumask_copy(policy->cpus, cpumask_of(cpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800821 /* Initially set CPU itself as the policy_cpu */
822 per_cpu(policy_cpu, cpu) = cpu;
823 lock_policy_rwsem_write(cpu);
824
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 init_completion(&policy->kobj_unregister);
David Howells65f27f32006-11-22 14:55:48 +0000826 INIT_WORK(&policy->update, handle_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Thomas Renninger8122c6c2007-10-02 13:28:09 -0700828 /* Set governor before ->init, so that driver could check it */
829 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 /* call driver. From then on the cpufreq must be able
831 * to accept all calls to ->verify and ->setpolicy for this CPU
832 */
833 ret = cpufreq_driver->init(policy);
834 if (ret) {
835 dprintk("initialization failed\n");
836 goto err_out;
837 }
Mike Chan187d9f42008-12-04 12:19:17 -0800838 policy->user_policy.min = policy->min;
839 policy->user_policy.max = policy->max;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
Thomas Renningera1531ac2008-07-29 22:32:58 -0700841 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
842 CPUFREQ_START, policy);
843
Dave Jones8ff69732006-03-05 03:37:23 -0500844#ifdef CONFIG_SMP
Thomas Renninger084f3492007-07-09 11:35:28 -0700845
846#ifdef CONFIG_HOTPLUG_CPU
Mike Travis7a6aedf2008-03-25 15:06:53 -0700847 if (per_cpu(cpufreq_cpu_governor, cpu)) {
848 policy->governor = per_cpu(cpufreq_cpu_governor, cpu);
Thomas Renninger084f3492007-07-09 11:35:28 -0700849 dprintk("Restoring governor %s for cpu %d\n",
850 policy->governor->name, cpu);
851 }
852#endif
853
Rusty Russell835481d2009-01-04 05:18:06 -0800854 for_each_cpu(j, policy->cpus) {
Dave Jones8ff69732006-03-05 03:37:23 -0500855 if (cpu == j)
856 continue;
857
Dave Jones29464f22009-01-18 01:37:11 -0500858 /* Check for existing affected CPUs.
859 * They may not be aware of it due to CPU Hotplug.
Dave Jones8ff69732006-03-05 03:37:23 -0500860 */
Dave Jones29464f22009-01-18 01:37:11 -0500861 managed_policy = cpufreq_cpu_get(j); /* FIXME: Where is this released? What about error paths? */
Dave Jones8ff69732006-03-05 03:37:23 -0500862 if (unlikely(managed_policy)) {
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800863
864 /* Set proper policy_cpu */
865 unlock_policy_rwsem_write(cpu);
866 per_cpu(policy_cpu, cpu) = managed_policy->cpu;
867
868 if (lock_policy_rwsem_write(cpu) < 0)
869 goto err_out_driver_exit;
870
Dave Jones8ff69732006-03-05 03:37:23 -0500871 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Rusty Russell835481d2009-01-04 05:18:06 -0800872 cpumask_copy(managed_policy->cpus, policy->cpus);
Mike Travis7a6aedf2008-03-25 15:06:53 -0700873 per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
Dave Jones8ff69732006-03-05 03:37:23 -0500874 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
875
876 dprintk("CPU already managed, adding link\n");
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200877 ret = sysfs_create_link(&sys_dev->kobj,
878 &managed_policy->kobj,
879 "cpufreq");
Dave Jones45709112008-03-05 14:07:34 -0500880 if (ret)
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200881 goto err_out_driver_exit;
Dave Jones8ff69732006-03-05 03:37:23 -0500882
883 cpufreq_debug_enable_ratelimit();
Dave Jones8ff69732006-03-05 03:37:23 -0500884 ret = 0;
885 goto err_out_driver_exit; /* call driver->exit() */
886 }
887 }
888#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
890
891 /* prepare interface data */
Dave Jones129f8ae2009-03-09 15:07:33 -0400892 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq, &sys_dev->kobj,
893 "cpufreq");
894 if (ret)
895 goto err_out_driver_exit;
896
897 /* set up files for this cpu device */
898 drv_attr = cpufreq_driver->attr;
899 while ((drv_attr) && (*drv_attr)) {
900 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
Matthew Garrette088e4c2008-11-25 13:29:47 -0500901 if (ret)
902 goto err_out_driver_exit;
Dave Jones129f8ae2009-03-09 15:07:33 -0400903 drv_attr++;
904 }
905 if (cpufreq_driver->get) {
906 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
907 if (ret)
908 goto err_out_driver_exit;
909 }
910 if (cpufreq_driver->target) {
911 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
Dave Jones45709112008-03-05 14:07:34 -0500912 if (ret)
Thomas Renninger0a4b2cc2007-05-21 07:20:04 -0500913 goto err_out_driver_exit;
914 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915
916 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Rusty Russell835481d2009-01-04 05:18:06 -0800917 for_each_cpu(j, policy->cpus) {
Mike Travis7a6aedf2008-03-25 15:06:53 -0700918 per_cpu(cpufreq_cpu_data, j) = policy;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800919 per_cpu(policy_cpu, j) = policy->cpu;
920 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Dave Jones8ff69732006-03-05 03:37:23 -0500922
923 /* symlink affected CPUs */
Rusty Russell835481d2009-01-04 05:18:06 -0800924 for_each_cpu(j, policy->cpus) {
Dave Jones8ff69732006-03-05 03:37:23 -0500925 if (j == cpu)
926 continue;
927 if (!cpu_online(j))
928 continue;
929
Dave Jones1f8b2c92006-03-29 01:40:04 -0500930 dprintk("CPU %u already managed, adding link\n", j);
Dave Jones8ff69732006-03-05 03:37:23 -0500931 cpufreq_cpu_get(cpu);
932 cpu_sys_dev = get_cpu_sysdev(j);
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200933 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
934 "cpufreq");
Dave Jones45709112008-03-05 14:07:34 -0500935 if (ret)
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200936 goto err_out_unregister;
Dave Jones8ff69732006-03-05 03:37:23 -0500937 }
938
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 policy->governor = NULL; /* to assure that the starting sequence is
940 * run in cpufreq_set_policy */
Dave Jones87c32272006-03-29 01:48:37 -0500941
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 /* set default policy */
Thomas Renninger22c970f2007-04-19 15:48:34 +0200943 ret = __cpufreq_set_policy(policy, &new_policy);
944 policy->user_policy.policy = policy->policy;
Thomas Renninger084f3492007-07-09 11:35:28 -0700945 policy->user_policy.governor = policy->governor;
Thomas Renninger22c970f2007-04-19 15:48:34 +0200946
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 if (ret) {
948 dprintk("setting policy failed\n");
949 goto err_out_unregister;
950 }
951
Lothar Waßmanndca02612008-05-29 17:54:52 +0200952 unlock_policy_rwsem_write(cpu);
953
Greg Kroah-Hartman038c5b32007-12-17 15:54:39 -0400954 kobject_uevent(&policy->kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 module_put(cpufreq_driver->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 dprintk("initialization complete\n");
957 cpufreq_debug_enable_ratelimit();
Dave Jones87c32272006-03-29 01:48:37 -0500958
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 return 0;
960
961
962err_out_unregister:
963 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Rusty Russell835481d2009-01-04 05:18:06 -0800964 for_each_cpu(j, policy->cpus)
Mike Travis7a6aedf2008-03-25 15:06:53 -0700965 per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
967
Greg Kroah-Hartmanc10997f2007-12-20 08:13:05 -0800968 kobject_put(&policy->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 wait_for_completion(&policy->kobj_unregister);
970
Venkatesh Pallipadi8085e1f2005-08-25 13:14:06 -0700971err_out_driver_exit:
972 if (cpufreq_driver->exit)
973 cpufreq_driver->exit(policy);
974
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975err_out:
Dave Jones45709112008-03-05 14:07:34 -0500976 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 kfree(policy);
978
979nomem_out:
980 module_put(cpufreq_driver->owner);
Ashok Rajc32b6b82005-10-30 14:59:54 -0800981module_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 cpufreq_debug_enable_ratelimit();
983 return ret;
984}
985
986
987/**
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800988 * __cpufreq_remove_dev - remove a CPU device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 *
990 * Removes the cpufreq interface for a CPU device.
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800991 * Caller should already have policy_rwsem in write mode for this CPU.
992 * This routine frees the rwsem before returning.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 */
Dave Jones905d77c2008-03-05 14:28:32 -0500994static int __cpufreq_remove_dev(struct sys_device *sys_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995{
996 unsigned int cpu = sys_dev->id;
997 unsigned long flags;
998 struct cpufreq_policy *data;
999#ifdef CONFIG_SMP
Grant Coadye738cf62005-11-21 21:32:28 -08001000 struct sys_device *cpu_sys_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 unsigned int j;
1002#endif
1003
1004 cpufreq_debug_disable_ratelimit();
1005 dprintk("unregistering CPU %u\n", cpu);
1006
1007 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Mike Travis7a6aedf2008-03-25 15:06:53 -07001008 data = per_cpu(cpufreq_cpu_data, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009
1010 if (!data) {
1011 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 cpufreq_debug_enable_ratelimit();
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001013 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 return -EINVAL;
1015 }
Mike Travis7a6aedf2008-03-25 15:06:53 -07001016 per_cpu(cpufreq_cpu_data, cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017
1018
1019#ifdef CONFIG_SMP
1020 /* if this isn't the CPU which is the parent of the kobj, we
Dave Jones32ee8c32006-02-28 00:43:23 -05001021 * only need to unlink, put and exit
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 */
1023 if (unlikely(cpu != data->cpu)) {
1024 dprintk("removing link\n");
Rusty Russell835481d2009-01-04 05:18:06 -08001025 cpumask_clear_cpu(cpu, data->cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1027 sysfs_remove_link(&sys_dev->kobj, "cpufreq");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 cpufreq_cpu_put(data);
1029 cpufreq_debug_enable_ratelimit();
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001030 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 return 0;
1032 }
1033#endif
1034
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035#ifdef CONFIG_SMP
Thomas Renninger084f3492007-07-09 11:35:28 -07001036
1037#ifdef CONFIG_HOTPLUG_CPU
Mike Travis7a6aedf2008-03-25 15:06:53 -07001038 per_cpu(cpufreq_cpu_governor, cpu) = data->governor;
Thomas Renninger084f3492007-07-09 11:35:28 -07001039#endif
1040
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 /* if we have other CPUs still registered, we need to unlink them,
1042 * or else wait_for_completion below will lock up. Clean the
Mike Travis7a6aedf2008-03-25 15:06:53 -07001043 * per_cpu(cpufreq_cpu_data) while holding the lock, and remove
1044 * the sysfs links afterwards.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 */
Rusty Russell835481d2009-01-04 05:18:06 -08001046 if (unlikely(cpumask_weight(data->cpus) > 1)) {
1047 for_each_cpu(j, data->cpus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 if (j == cpu)
1049 continue;
Mike Travis7a6aedf2008-03-25 15:06:53 -07001050 per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 }
1052 }
1053
1054 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1055
Rusty Russell835481d2009-01-04 05:18:06 -08001056 if (unlikely(cpumask_weight(data->cpus) > 1)) {
1057 for_each_cpu(j, data->cpus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 if (j == cpu)
1059 continue;
1060 dprintk("removing link for cpu %u\n", j);
Thomas Renninger084f3492007-07-09 11:35:28 -07001061#ifdef CONFIG_HOTPLUG_CPU
Mike Travis7a6aedf2008-03-25 15:06:53 -07001062 per_cpu(cpufreq_cpu_governor, j) = data->governor;
Thomas Renninger084f3492007-07-09 11:35:28 -07001063#endif
Ashok Rajd434fca2005-10-30 14:59:52 -08001064 cpu_sys_dev = get_cpu_sysdev(j);
1065 sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 cpufreq_cpu_put(data);
1067 }
1068 }
1069#else
1070 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1071#endif
1072
Mathieu Desnoyers42a06f22009-05-17 10:23:52 -04001073 unlock_policy_rwsem_write(cpu);
1074
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 if (cpufreq_driver->target)
1076 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001077
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 kobject_put(&data->kobj);
1079
1080 /* we need to make sure that the underlying kobj is actually
Dave Jones32ee8c32006-02-28 00:43:23 -05001081 * not referenced anymore by anybody before we proceed with
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 * unloading.
1083 */
1084 dprintk("waiting for dropping of refcount\n");
1085 wait_for_completion(&data->kobj_unregister);
1086 dprintk("wait complete\n");
1087
1088 if (cpufreq_driver->exit)
1089 cpufreq_driver->exit(data);
1090
Rusty Russell835481d2009-01-04 05:18:06 -08001091 free_cpumask_var(data->related_cpus);
1092 free_cpumask_var(data->cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 kfree(data);
Rusty Russell835481d2009-01-04 05:18:06 -08001094 per_cpu(cpufreq_cpu_data, cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
1096 cpufreq_debug_enable_ratelimit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 return 0;
1098}
1099
1100
Dave Jones905d77c2008-03-05 14:28:32 -05001101static int cpufreq_remove_dev(struct sys_device *sys_dev)
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001102{
1103 unsigned int cpu = sys_dev->id;
1104 int retval;
Venki Pallipadiec282972007-03-26 12:03:19 -07001105
1106 if (cpu_is_offline(cpu))
1107 return 0;
1108
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001109 if (unlikely(lock_policy_rwsem_write(cpu)))
1110 BUG();
1111
1112 retval = __cpufreq_remove_dev(sys_dev);
1113 return retval;
1114}
1115
1116
David Howells65f27f32006-11-22 14:55:48 +00001117static void handle_update(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118{
David Howells65f27f32006-11-22 14:55:48 +00001119 struct cpufreq_policy *policy =
1120 container_of(work, struct cpufreq_policy, update);
1121 unsigned int cpu = policy->cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 dprintk("handle_update for cpu %u called\n", cpu);
1123 cpufreq_update_policy(cpu);
1124}
1125
1126/**
1127 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
1128 * @cpu: cpu number
1129 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1130 * @new_freq: CPU frequency the CPU actually runs at
1131 *
Dave Jones29464f22009-01-18 01:37:11 -05001132 * We adjust to current frequency first, and need to clean up later.
1133 * So either call to cpufreq_update_policy() or schedule handle_update()).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301135static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1136 unsigned int new_freq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137{
1138 struct cpufreq_freqs freqs;
1139
Jan Beulichb10eec22006-04-28 13:47:13 +02001140 dprintk("Warning: CPU frequency out of sync: cpufreq and timing "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1142
1143 freqs.cpu = cpu;
1144 freqs.old = old_freq;
1145 freqs.new = new_freq;
1146 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
1147 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
1148}
1149
1150
Dave Jones32ee8c32006-02-28 00:43:23 -05001151/**
Dhaval Giani4ab70df2006-12-13 14:49:15 +05301152 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001153 * @cpu: CPU number
1154 *
1155 * This is the last known freq, without actually getting it from the driver.
1156 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1157 */
1158unsigned int cpufreq_quick_get(unsigned int cpu)
1159{
1160 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301161 unsigned int ret_freq = 0;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001162
1163 if (policy) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301164 ret_freq = policy->cur;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001165 cpufreq_cpu_put(policy);
1166 }
1167
Dave Jones4d34a672008-02-07 16:33:49 -05001168 return ret_freq;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001169}
1170EXPORT_SYMBOL(cpufreq_quick_get);
1171
1172
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001173static unsigned int __cpufreq_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174{
Mike Travis7a6aedf2008-03-25 15:06:53 -07001175 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301176 unsigned int ret_freq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 if (!cpufreq_driver->get)
Dave Jones4d34a672008-02-07 16:33:49 -05001179 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301181 ret_freq = cpufreq_driver->get(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301183 if (ret_freq && policy->cur &&
1184 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1185 /* verify no discrepancy between actual and
1186 saved value exists */
1187 if (unlikely(ret_freq != policy->cur)) {
1188 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 schedule_work(&policy->update);
1190 }
1191 }
1192
Dave Jones4d34a672008-02-07 16:33:49 -05001193 return ret_freq;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001194}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001196/**
1197 * cpufreq_get - get the current CPU frequency (in kHz)
1198 * @cpu: CPU number
1199 *
1200 * Get the CPU current (static) CPU frequency
1201 */
1202unsigned int cpufreq_get(unsigned int cpu)
1203{
1204 unsigned int ret_freq = 0;
1205 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1206
1207 if (!policy)
1208 goto out;
1209
1210 if (unlikely(lock_policy_rwsem_read(cpu)))
1211 goto out_policy;
1212
1213 ret_freq = __cpufreq_get(cpu);
1214
1215 unlock_policy_rwsem_read(cpu);
1216
1217out_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 cpufreq_cpu_put(policy);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001219out:
Dave Jones4d34a672008-02-07 16:33:49 -05001220 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221}
1222EXPORT_SYMBOL(cpufreq_get);
1223
1224
1225/**
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001226 * cpufreq_suspend - let the low level driver prepare for suspend
1227 */
1228
Dave Jones905d77c2008-03-05 14:28:32 -05001229static int cpufreq_suspend(struct sys_device *sysdev, pm_message_t pmsg)
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001230{
1231 int cpu = sysdev->id;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301232 int ret = 0;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001233 unsigned int cur_freq = 0;
1234 struct cpufreq_policy *cpu_policy;
1235
Dave Jones0e37b152006-09-26 23:02:34 -04001236 dprintk("suspending cpu %u\n", cpu);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001237
1238 if (!cpu_online(cpu))
1239 return 0;
1240
1241 /* we may be lax here as interrupts are off. Nonetheless
1242 * we need to grab the correct cpu policy, as to check
1243 * whether we really run on this CPU.
1244 */
1245
1246 cpu_policy = cpufreq_cpu_get(cpu);
1247 if (!cpu_policy)
1248 return -EINVAL;
1249
1250 /* only handle each CPU group once */
Dave Jonesc9060492008-02-07 16:32:18 -05001251 if (unlikely(cpu_policy->cpu != cpu))
1252 goto out;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001253
1254 if (cpufreq_driver->suspend) {
Bernard Blackhame00d9962005-07-07 17:56:42 -07001255 ret = cpufreq_driver->suspend(cpu_policy, pmsg);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001256 if (ret) {
1257 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1258 "step on CPU %u\n", cpu_policy->cpu);
Dave Jonesc9060492008-02-07 16:32:18 -05001259 goto out;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001260 }
1261 }
1262
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001263 if (cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)
1264 goto out;
1265
1266 if (cpufreq_driver->get)
1267 cur_freq = cpufreq_driver->get(cpu_policy->cpu);
1268
1269 if (!cur_freq || !cpu_policy->cur) {
1270 printk(KERN_ERR "cpufreq: suspend failed to assert current "
1271 "frequency is what timing core thinks it is.\n");
1272 goto out;
1273 }
1274
1275 if (unlikely(cur_freq != cpu_policy->cur)) {
1276 struct cpufreq_freqs freqs;
1277
1278 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
Jan Beulichb10eec22006-04-28 13:47:13 +02001279 dprintk("Warning: CPU frequency is %u, "
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001280 "cpufreq assumed %u kHz.\n",
1281 cur_freq, cpu_policy->cur);
1282
1283 freqs.cpu = cpu;
1284 freqs.old = cpu_policy->cur;
1285 freqs.new = cur_freq;
1286
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001287 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001288 CPUFREQ_SUSPENDCHANGE, &freqs);
1289 adjust_jiffies(CPUFREQ_SUSPENDCHANGE, &freqs);
1290
1291 cpu_policy->cur = cur_freq;
1292 }
1293
Dave Jones7d5e3502006-02-02 17:03:42 -05001294out:
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001295 cpufreq_cpu_put(cpu_policy);
Dave Jonesc9060492008-02-07 16:32:18 -05001296 return ret;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001297}
1298
1299/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 * cpufreq_resume - restore proper CPU frequency handling after resume
1301 *
1302 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1303 * 2.) if ->target and !CPUFREQ_CONST_LOOPS: verify we're in sync
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001304 * 3.) schedule call cpufreq_update_policy() ASAP as interrupts are
1305 * restored.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 */
Dave Jones905d77c2008-03-05 14:28:32 -05001307static int cpufreq_resume(struct sys_device *sysdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308{
1309 int cpu = sysdev->id;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301310 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 struct cpufreq_policy *cpu_policy;
1312
1313 dprintk("resuming cpu %u\n", cpu);
1314
1315 if (!cpu_online(cpu))
1316 return 0;
1317
1318 /* we may be lax here as interrupts are off. Nonetheless
1319 * we need to grab the correct cpu policy, as to check
1320 * whether we really run on this CPU.
1321 */
1322
1323 cpu_policy = cpufreq_cpu_get(cpu);
1324 if (!cpu_policy)
1325 return -EINVAL;
1326
1327 /* only handle each CPU group once */
Dave Jonesc9060492008-02-07 16:32:18 -05001328 if (unlikely(cpu_policy->cpu != cpu))
1329 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
1331 if (cpufreq_driver->resume) {
1332 ret = cpufreq_driver->resume(cpu_policy);
1333 if (ret) {
1334 printk(KERN_ERR "cpufreq: resume failed in ->resume "
1335 "step on CPU %u\n", cpu_policy->cpu);
Dave Jonesc9060492008-02-07 16:32:18 -05001336 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 }
1338 }
1339
1340 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1341 unsigned int cur_freq = 0;
1342
1343 if (cpufreq_driver->get)
1344 cur_freq = cpufreq_driver->get(cpu_policy->cpu);
1345
1346 if (!cur_freq || !cpu_policy->cur) {
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001347 printk(KERN_ERR "cpufreq: resume failed to assert "
1348 "current frequency is what timing core "
1349 "thinks it is.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 goto out;
1351 }
1352
1353 if (unlikely(cur_freq != cpu_policy->cur)) {
1354 struct cpufreq_freqs freqs;
1355
Benjamin Herrenschmidtac09f692005-05-02 16:25:10 +10001356 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
Joe Perchesa4a9df52007-11-19 17:48:06 -08001357 dprintk("Warning: CPU frequency "
Benjamin Herrenschmidtac09f692005-05-02 16:25:10 +10001358 "is %u, cpufreq assumed %u kHz.\n",
1359 cur_freq, cpu_policy->cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
1361 freqs.cpu = cpu;
1362 freqs.old = cpu_policy->cur;
1363 freqs.new = cur_freq;
1364
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001365 srcu_notifier_call_chain(
Alan Sterne041c682006-03-27 01:16:30 -08001366 &cpufreq_transition_notifier_list,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001367 CPUFREQ_RESUMECHANGE, &freqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 adjust_jiffies(CPUFREQ_RESUMECHANGE, &freqs);
1369
1370 cpu_policy->cur = cur_freq;
1371 }
1372 }
1373
1374out:
1375 schedule_work(&cpu_policy->update);
Dave Jonesc9060492008-02-07 16:32:18 -05001376fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 cpufreq_cpu_put(cpu_policy);
1378 return ret;
1379}
1380
1381static struct sysdev_driver cpufreq_sysdev_driver = {
1382 .add = cpufreq_add_dev,
1383 .remove = cpufreq_remove_dev,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001384 .suspend = cpufreq_suspend,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 .resume = cpufreq_resume,
1386};
1387
1388
1389/*********************************************************************
1390 * NOTIFIER LISTS INTERFACE *
1391 *********************************************************************/
1392
1393/**
1394 * cpufreq_register_notifier - register a driver with cpufreq
1395 * @nb: notifier function to register
1396 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1397 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001398 * Add a driver to one of two lists: either a list of drivers that
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 * are notified about clock rate changes (once before and once after
1400 * the transition), or a list of drivers that are notified about
1401 * changes in cpufreq policy.
1402 *
1403 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001404 * blocking_notifier_chain_register.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 */
1406int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1407{
1408 int ret;
1409
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -02001410 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1411
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 switch (list) {
1413 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001414 ret = srcu_notifier_chain_register(
Alan Sterne041c682006-03-27 01:16:30 -08001415 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 break;
1417 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001418 ret = blocking_notifier_chain_register(
1419 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 break;
1421 default:
1422 ret = -EINVAL;
1423 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424
1425 return ret;
1426}
1427EXPORT_SYMBOL(cpufreq_register_notifier);
1428
1429
1430/**
1431 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1432 * @nb: notifier block to be unregistered
1433 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1434 *
1435 * Remove a driver from the CPU frequency notifier list.
1436 *
1437 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001438 * blocking_notifier_chain_unregister.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 */
1440int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1441{
1442 int ret;
1443
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 switch (list) {
1445 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001446 ret = srcu_notifier_chain_unregister(
Alan Sterne041c682006-03-27 01:16:30 -08001447 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 break;
1449 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001450 ret = blocking_notifier_chain_unregister(
1451 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 break;
1453 default:
1454 ret = -EINVAL;
1455 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456
1457 return ret;
1458}
1459EXPORT_SYMBOL(cpufreq_unregister_notifier);
1460
1461
1462/*********************************************************************
1463 * GOVERNORS *
1464 *********************************************************************/
1465
1466
1467int __cpufreq_driver_target(struct cpufreq_policy *policy,
1468 unsigned int target_freq,
1469 unsigned int relation)
1470{
1471 int retval = -EINVAL;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001472
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
1474 target_freq, relation);
1475 if (cpu_online(policy->cpu) && cpufreq_driver->target)
1476 retval = cpufreq_driver->target(policy, target_freq, relation);
Ashok Raj90d45d12005-11-08 21:34:24 -08001477
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 return retval;
1479}
1480EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1481
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482int cpufreq_driver_target(struct cpufreq_policy *policy,
1483 unsigned int target_freq,
1484 unsigned int relation)
1485{
Julia Lawallf1829e42008-07-25 22:44:53 +02001486 int ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487
1488 policy = cpufreq_cpu_get(policy->cpu);
1489 if (!policy)
Julia Lawallf1829e42008-07-25 22:44:53 +02001490 goto no_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001492 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
Julia Lawallf1829e42008-07-25 22:44:53 +02001493 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
1495 ret = __cpufreq_driver_target(policy, target_freq, relation);
1496
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001497 unlock_policy_rwsem_write(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
Julia Lawallf1829e42008-07-25 22:44:53 +02001499fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 cpufreq_cpu_put(policy);
Julia Lawallf1829e42008-07-25 22:44:53 +02001501no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 return ret;
1503}
1504EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1505
venkatesh.pallipadi@intel.combf0b90e2008-08-04 11:59:07 -07001506int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001507{
1508 int ret = 0;
1509
1510 policy = cpufreq_cpu_get(policy->cpu);
1511 if (!policy)
1512 return -EINVAL;
1513
venkatesh.pallipadi@intel.combf0b90e2008-08-04 11:59:07 -07001514 if (cpu_online(cpu) && cpufreq_driver->getavg)
1515 ret = cpufreq_driver->getavg(policy, cpu);
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001516
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001517 cpufreq_cpu_put(policy);
1518 return ret;
1519}
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001520EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001521
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001522/*
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001523 * when "event" is CPUFREQ_GOV_LIMITS
1524 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301526static int __cpufreq_governor(struct cpufreq_policy *policy,
1527 unsigned int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528{
Dave Jonescc993ca2005-07-28 09:43:56 -07001529 int ret;
Thomas Renninger6afde102007-10-02 13:28:13 -07001530
1531 /* Only must be defined when default governor is known to have latency
1532 restrictions, like e.g. conservative or ondemand.
1533 That this is the case is already ensured in Kconfig
1534 */
1535#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1536 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1537#else
1538 struct cpufreq_governor *gov = NULL;
1539#endif
Thomas Renninger1c256242007-10-02 13:28:12 -07001540
1541 if (policy->governor->max_transition_latency &&
1542 policy->cpuinfo.transition_latency >
1543 policy->governor->max_transition_latency) {
Thomas Renninger6afde102007-10-02 13:28:13 -07001544 if (!gov)
1545 return -EINVAL;
1546 else {
1547 printk(KERN_WARNING "%s governor failed, too long"
1548 " transition latency of HW, fallback"
1549 " to %s governor\n",
1550 policy->governor->name,
1551 gov->name);
1552 policy->governor = gov;
1553 }
Thomas Renninger1c256242007-10-02 13:28:12 -07001554 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555
1556 if (!try_module_get(policy->governor->owner))
1557 return -EINVAL;
1558
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301559 dprintk("__cpufreq_governor for CPU %u, event %u\n",
1560 policy->cpu, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 ret = policy->governor->governor(policy, event);
1562
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301563 /* we keep one module reference alive for
1564 each CPU governed by this CPU */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 if ((event != CPUFREQ_GOV_START) || ret)
1566 module_put(policy->governor->owner);
1567 if ((event == CPUFREQ_GOV_STOP) && !ret)
1568 module_put(policy->governor->owner);
1569
1570 return ret;
1571}
1572
1573
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574int cpufreq_register_governor(struct cpufreq_governor *governor)
1575{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001576 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
1578 if (!governor)
1579 return -EINVAL;
1580
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001581 mutex_lock(&cpufreq_governor_mutex);
Dave Jones32ee8c32006-02-28 00:43:23 -05001582
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001583 err = -EBUSY;
1584 if (__find_governor(governor->name) == NULL) {
1585 err = 0;
1586 list_add(&governor->governor_list, &cpufreq_governor_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
Dave Jones32ee8c32006-02-28 00:43:23 -05001589 mutex_unlock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001590 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591}
1592EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1593
1594
1595void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1596{
1597 if (!governor)
1598 return;
1599
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001600 mutex_lock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 list_del(&governor->governor_list);
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001602 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 return;
1604}
1605EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1606
1607
1608
1609/*********************************************************************
1610 * POLICY INTERFACE *
1611 *********************************************************************/
1612
1613/**
1614 * cpufreq_get_policy - get the current cpufreq_policy
Dave Jones29464f22009-01-18 01:37:11 -05001615 * @policy: struct cpufreq_policy into which the current cpufreq_policy
1616 * is written
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 *
1618 * Reads the current cpufreq policy.
1619 */
1620int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1621{
1622 struct cpufreq_policy *cpu_policy;
1623 if (!policy)
1624 return -EINVAL;
1625
1626 cpu_policy = cpufreq_cpu_get(cpu);
1627 if (!cpu_policy)
1628 return -EINVAL;
1629
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
1632 cpufreq_cpu_put(cpu_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 return 0;
1634}
1635EXPORT_SYMBOL(cpufreq_get_policy);
1636
1637
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001638/*
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301639 * data : current policy.
1640 * policy : policy to be set.
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001641 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301642static int __cpufreq_set_policy(struct cpufreq_policy *data,
1643 struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644{
1645 int ret = 0;
1646
1647 cpufreq_debug_disable_ratelimit();
1648 dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1649 policy->min, policy->max);
1650
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301651 memcpy(&policy->cpuinfo, &data->cpuinfo,
1652 sizeof(struct cpufreq_cpuinfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
Yi Yang53391fa2008-01-30 13:33:34 +01001654 if (policy->min > data->max || policy->max < data->min) {
Mattia Dongili9c9a43e2006-07-05 23:12:20 +02001655 ret = -EINVAL;
1656 goto error_out;
1657 }
1658
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 /* verify the cpu speed can be set within this limit */
1660 ret = cpufreq_driver->verify(policy);
1661 if (ret)
1662 goto error_out;
1663
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 /* adjust if necessary - all reasons */
Alan Sterne041c682006-03-27 01:16:30 -08001665 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1666 CPUFREQ_ADJUST, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
1668 /* adjust if necessary - hardware incompatibility*/
Alan Sterne041c682006-03-27 01:16:30 -08001669 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1670 CPUFREQ_INCOMPATIBLE, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671
1672 /* verify the cpu speed can be set within this limit,
1673 which might be different to the first one */
1674 ret = cpufreq_driver->verify(policy);
Alan Sterne041c682006-03-27 01:16:30 -08001675 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 goto error_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
1678 /* notification of the new policy */
Alan Sterne041c682006-03-27 01:16:30 -08001679 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1680 CPUFREQ_NOTIFY, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681
Dave Jones7d5e3502006-02-02 17:03:42 -05001682 data->min = policy->min;
1683 data->max = policy->max;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301685 dprintk("new min and max freqs are %u - %u kHz\n",
1686 data->min, data->max);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
1688 if (cpufreq_driver->setpolicy) {
1689 data->policy = policy->policy;
1690 dprintk("setting range\n");
1691 ret = cpufreq_driver->setpolicy(policy);
1692 } else {
1693 if (policy->governor != data->governor) {
1694 /* save old, working values */
1695 struct cpufreq_governor *old_gov = data->governor;
1696
1697 dprintk("governor switch\n");
1698
1699 /* end old governor */
1700 if (data->governor)
1701 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1702
1703 /* start new governor */
1704 data->governor = policy->governor;
1705 if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1706 /* new governor failed, so re-start old one */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301707 dprintk("starting governor %s failed\n",
1708 data->governor->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 if (old_gov) {
1710 data->governor = old_gov;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301711 __cpufreq_governor(data,
1712 CPUFREQ_GOV_START);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 }
1714 ret = -EINVAL;
1715 goto error_out;
1716 }
1717 /* might be a policy change, too, so fall through */
1718 }
1719 dprintk("governor: change or update limits\n");
1720 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1721 }
1722
Dave Jones7d5e3502006-02-02 17:03:42 -05001723error_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 cpufreq_debug_enable_ratelimit();
1725 return ret;
1726}
1727
1728/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1730 * @cpu: CPU which shall be re-evaluated
1731 *
1732 * Usefull for policy notifiers which have different necessities
1733 * at different times.
1734 */
1735int cpufreq_update_policy(unsigned int cpu)
1736{
1737 struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1738 struct cpufreq_policy policy;
Julia Lawallf1829e42008-07-25 22:44:53 +02001739 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740
Julia Lawallf1829e42008-07-25 22:44:53 +02001741 if (!data) {
1742 ret = -ENODEV;
1743 goto no_policy;
1744 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745
Julia Lawallf1829e42008-07-25 22:44:53 +02001746 if (unlikely(lock_policy_rwsem_write(cpu))) {
1747 ret = -EINVAL;
1748 goto fail;
1749 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750
1751 dprintk("updating policy for CPU %u\n", cpu);
Dave Jones7d5e3502006-02-02 17:03:42 -05001752 memcpy(&policy, data, sizeof(struct cpufreq_policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 policy.min = data->user_policy.min;
1754 policy.max = data->user_policy.max;
1755 policy.policy = data->user_policy.policy;
1756 policy.governor = data->user_policy.governor;
1757
Thomas Renninger0961dd02006-01-26 18:46:33 +01001758 /* BIOS might change freq behind our back
1759 -> ask driver for current freq and notify governors about a change */
1760 if (cpufreq_driver->get) {
1761 policy.cur = cpufreq_driver->get(cpu);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001762 if (!data->cur) {
1763 dprintk("Driver did not initialize current freq");
1764 data->cur = policy.cur;
1765 } else {
1766 if (data->cur != policy.cur)
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301767 cpufreq_out_of_sync(cpu, data->cur,
1768 policy.cur);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001769 }
Thomas Renninger0961dd02006-01-26 18:46:33 +01001770 }
1771
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 ret = __cpufreq_set_policy(data, &policy);
1773
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001774 unlock_policy_rwsem_write(cpu);
1775
Julia Lawallf1829e42008-07-25 22:44:53 +02001776fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 cpufreq_cpu_put(data);
Julia Lawallf1829e42008-07-25 22:44:53 +02001778no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 return ret;
1780}
1781EXPORT_SYMBOL(cpufreq_update_policy);
1782
Satyam Sharmadd184a02007-10-02 13:28:14 -07001783static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
Ashok Rajc32b6b82005-10-30 14:59:54 -08001784 unsigned long action, void *hcpu)
1785{
1786 unsigned int cpu = (unsigned long)hcpu;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001787 struct sys_device *sys_dev;
1788
1789 sys_dev = get_cpu_sysdev(cpu);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001790 if (sys_dev) {
1791 switch (action) {
1792 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001793 case CPU_ONLINE_FROZEN:
Ashok Rajc32b6b82005-10-30 14:59:54 -08001794 cpufreq_add_dev(sys_dev);
1795 break;
1796 case CPU_DOWN_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001797 case CPU_DOWN_PREPARE_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001798 if (unlikely(lock_policy_rwsem_write(cpu)))
1799 BUG();
1800
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001801 __cpufreq_remove_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001802 break;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001803 case CPU_DOWN_FAILED:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001804 case CPU_DOWN_FAILED_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001805 cpufreq_add_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001806 break;
1807 }
1808 }
1809 return NOTIFY_OK;
1810}
1811
Sam Ravnborgf6ebef32008-02-17 13:22:52 +01001812static struct notifier_block __refdata cpufreq_cpu_notifier =
Ashok Rajc32b6b82005-10-30 14:59:54 -08001813{
1814 .notifier_call = cpufreq_cpu_callback,
1815};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816
1817/*********************************************************************
1818 * REGISTER / UNREGISTER CPUFREQ DRIVER *
1819 *********************************************************************/
1820
1821/**
1822 * cpufreq_register_driver - register a CPU Frequency driver
1823 * @driver_data: A struct cpufreq_driver containing the values#
1824 * submitted by the CPU Frequency driver.
1825 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001826 * Registers a CPU Frequency driver to this core code. This code
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 * returns zero on success, -EBUSY when another driver got here first
Dave Jones32ee8c32006-02-28 00:43:23 -05001828 * (and isn't unregistered in the meantime).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 *
1830 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001831int cpufreq_register_driver(struct cpufreq_driver *driver_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832{
1833 unsigned long flags;
1834 int ret;
1835
1836 if (!driver_data || !driver_data->verify || !driver_data->init ||
1837 ((!driver_data->setpolicy) && (!driver_data->target)))
1838 return -EINVAL;
1839
1840 dprintk("trying to register driver %s\n", driver_data->name);
1841
1842 if (driver_data->setpolicy)
1843 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1844
1845 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1846 if (cpufreq_driver) {
1847 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1848 return -EBUSY;
1849 }
1850 cpufreq_driver = driver_data;
1851 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1852
Mike Travis7a6aedf2008-03-25 15:06:53 -07001853 ret = sysdev_driver_register(&cpu_sysdev_class,
1854 &cpufreq_sysdev_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855
1856 if ((!ret) && !(cpufreq_driver->flags & CPUFREQ_STICKY)) {
1857 int i;
1858 ret = -ENODEV;
1859
1860 /* check for at least one working CPU */
Mike Travis7a6aedf2008-03-25 15:06:53 -07001861 for (i = 0; i < nr_cpu_ids; i++)
1862 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 ret = 0;
Mike Travis7a6aedf2008-03-25 15:06:53 -07001864 break;
1865 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
1867 /* if all ->init() calls failed, unregister */
1868 if (ret) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301869 dprintk("no CPU initialized for driver %s\n",
1870 driver_data->name);
1871 sysdev_driver_unregister(&cpu_sysdev_class,
1872 &cpufreq_sysdev_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
1874 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1875 cpufreq_driver = NULL;
1876 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1877 }
1878 }
1879
1880 if (!ret) {
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001881 register_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 dprintk("driver %s up and running\n", driver_data->name);
1883 cpufreq_debug_enable_ratelimit();
1884 }
1885
Dave Jones4d34a672008-02-07 16:33:49 -05001886 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887}
1888EXPORT_SYMBOL_GPL(cpufreq_register_driver);
1889
1890
1891/**
1892 * cpufreq_unregister_driver - unregister the current CPUFreq driver
1893 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001894 * Unregister the current CPUFreq driver. Only call this if you have
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 * the right to do so, i.e. if you have succeeded in initialising before!
1896 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1897 * currently not initialised.
1898 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001899int cpufreq_unregister_driver(struct cpufreq_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900{
1901 unsigned long flags;
1902
1903 cpufreq_debug_disable_ratelimit();
1904
1905 if (!cpufreq_driver || (driver != cpufreq_driver)) {
1906 cpufreq_debug_enable_ratelimit();
1907 return -EINVAL;
1908 }
1909
1910 dprintk("unregistering driver %s\n", driver->name);
1911
1912 sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001913 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914
1915 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1916 cpufreq_driver = NULL;
1917 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1918
1919 return 0;
1920}
1921EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001922
1923static int __init cpufreq_core_init(void)
1924{
1925 int cpu;
1926
1927 for_each_possible_cpu(cpu) {
1928 per_cpu(policy_cpu, cpu) = -1;
1929 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
1930 }
1931 return 0;
1932}
1933
1934core_initcall(cpufreq_core_init);