blob: bbd5c2164ab6cf8d52bb2abbe3d81412c8daada0 [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
Thomas Renninger4bfa0422009-07-24 15:25:03 +0200759/*
760 * Returns:
761 * Negative: Failure
762 * 0: Success
763 * Positive: When we have a managed CPU and the sysfs got symlinked
764 */
Dave Jonesecf7e462009-07-08 18:48:47 -0400765int cpufreq_add_dev_policy(unsigned int cpu, struct cpufreq_policy *policy,
766 struct sys_device *sys_dev)
767{
768 int ret = 0;
769#ifdef CONFIG_SMP
770 unsigned long flags;
771 unsigned int j;
772
773#ifdef CONFIG_HOTPLUG_CPU
774 if (per_cpu(cpufreq_cpu_governor, cpu)) {
775 policy->governor = per_cpu(cpufreq_cpu_governor, cpu);
776 dprintk("Restoring governor %s for cpu %d\n",
777 policy->governor->name, cpu);
778 }
779#endif
780
781 for_each_cpu(j, policy->cpus) {
782 struct cpufreq_policy *managed_policy;
783
784 if (cpu == j)
785 continue;
786
787 /* Check for existing affected CPUs.
788 * They may not be aware of it due to CPU Hotplug.
789 * cpufreq_cpu_put is called when the device is removed
790 * in __cpufreq_remove_dev()
791 */
792 managed_policy = cpufreq_cpu_get(j);
793 if (unlikely(managed_policy)) {
794
795 /* Set proper policy_cpu */
796 unlock_policy_rwsem_write(cpu);
797 per_cpu(policy_cpu, cpu) = managed_policy->cpu;
798
799 if (lock_policy_rwsem_write(cpu) < 0) {
800 /* Should not go through policy unlock path */
801 if (cpufreq_driver->exit)
802 cpufreq_driver->exit(policy);
803 cpufreq_cpu_put(managed_policy);
804 return -EBUSY;
805 }
806
807 spin_lock_irqsave(&cpufreq_driver_lock, flags);
808 cpumask_copy(managed_policy->cpus, policy->cpus);
809 per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
810 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
811
812 dprintk("CPU already managed, adding link\n");
813 ret = sysfs_create_link(&sys_dev->kobj,
814 &managed_policy->kobj,
815 "cpufreq");
816 if (ret)
817 cpufreq_cpu_put(managed_policy);
818 /*
819 * Success. We only needed to be added to the mask.
820 * Call driver->exit() because only the cpu parent of
821 * the kobj needed to call init().
822 */
823 if (cpufreq_driver->exit)
824 cpufreq_driver->exit(policy);
Thomas Renninger4bfa0422009-07-24 15:25:03 +0200825
826 if (!ret)
827 return 1;
828 else
829 return ret;
Dave Jonesecf7e462009-07-08 18:48:47 -0400830 }
831 }
832#endif
833 return ret;
834}
835
836
Dave Jones19d6f7e2009-07-08 17:35:39 -0400837/* symlink affected CPUs */
838int cpufreq_add_dev_symlink(unsigned int cpu, struct cpufreq_policy *policy)
839{
840 unsigned int j;
841 int ret = 0;
842
843 for_each_cpu(j, policy->cpus) {
844 struct cpufreq_policy *managed_policy;
845 struct sys_device *cpu_sys_dev;
846
847 if (j == cpu)
848 continue;
849 if (!cpu_online(j))
850 continue;
851
852 dprintk("CPU %u already managed, adding link\n", j);
853 managed_policy = cpufreq_cpu_get(cpu);
854 cpu_sys_dev = get_cpu_sysdev(j);
855 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
856 "cpufreq");
857 if (ret) {
858 cpufreq_cpu_put(managed_policy);
859 return ret;
860 }
861 }
862 return ret;
863}
864
Dave Jones909a6942009-07-08 18:05:42 -0400865int cpufreq_add_dev_interface(unsigned int cpu, struct cpufreq_policy *policy,
866 struct sys_device *sys_dev)
867{
Dave Jonesecf7e462009-07-08 18:48:47 -0400868 struct cpufreq_policy new_policy;
Dave Jones909a6942009-07-08 18:05:42 -0400869 struct freq_attr **drv_attr;
870 unsigned long flags;
871 int ret = 0;
872 unsigned int j;
873
874 /* prepare interface data */
875 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
876 &sys_dev->kobj, "cpufreq");
877 if (ret)
878 return ret;
879
880 /* set up files for this cpu device */
881 drv_attr = cpufreq_driver->attr;
882 while ((drv_attr) && (*drv_attr)) {
883 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
884 if (ret)
885 goto err_out_kobj_put;
886 drv_attr++;
887 }
888 if (cpufreq_driver->get) {
889 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
890 if (ret)
891 goto err_out_kobj_put;
892 }
893 if (cpufreq_driver->target) {
894 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
895 if (ret)
896 goto err_out_kobj_put;
897 }
898
899 spin_lock_irqsave(&cpufreq_driver_lock, flags);
900 for_each_cpu(j, policy->cpus) {
901 if (!cpu_online(j))
902 continue;
903 per_cpu(cpufreq_cpu_data, j) = policy;
904 per_cpu(policy_cpu, j) = policy->cpu;
905 }
906 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
907
908 ret = cpufreq_add_dev_symlink(cpu, policy);
Dave Jonesecf7e462009-07-08 18:48:47 -0400909 if (ret)
910 goto err_out_kobj_put;
911
912 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
913 /* assure that the starting sequence is run in __cpufreq_set_policy */
914 policy->governor = NULL;
915
916 /* set default policy */
917 ret = __cpufreq_set_policy(policy, &new_policy);
918 policy->user_policy.policy = policy->policy;
919 policy->user_policy.governor = policy->governor;
920
921 if (ret) {
922 dprintk("setting policy failed\n");
923 if (cpufreq_driver->exit)
924 cpufreq_driver->exit(policy);
925 }
Dave Jones909a6942009-07-08 18:05:42 -0400926 return ret;
927
928err_out_kobj_put:
929 kobject_put(&policy->kobj);
930 wait_for_completion(&policy->kobj_unregister);
931 return ret;
932}
933
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
935/**
936 * cpufreq_add_dev - add a CPU device
937 *
Dave Jones32ee8c32006-02-28 00:43:23 -0500938 * Adds the cpufreq interface for a CPU device.
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400939 *
940 * The Oracle says: try running cpufreq registration/unregistration concurrently
941 * with with cpu hotplugging and all hell will break loose. Tried to clean this
942 * mess up, but more thorough testing is needed. - Mathieu
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 */
Dave Jones905d77c2008-03-05 14:28:32 -0500944static int cpufreq_add_dev(struct sys_device *sys_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945{
946 unsigned int cpu = sys_dev->id;
947 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 struct cpufreq_policy *policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 unsigned long flags;
950 unsigned int j;
951
Ashok Rajc32b6b82005-10-30 14:59:54 -0800952 if (cpu_is_offline(cpu))
953 return 0;
954
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 cpufreq_debug_disable_ratelimit();
956 dprintk("adding CPU %u\n", cpu);
957
958#ifdef CONFIG_SMP
959 /* check whether a different CPU already registered this
960 * CPU because it is in the same boat. */
961 policy = cpufreq_cpu_get(cpu);
962 if (unlikely(policy)) {
Dave Jones8ff69732006-03-05 03:37:23 -0500963 cpufreq_cpu_put(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 cpufreq_debug_enable_ratelimit();
965 return 0;
966 }
967#endif
968
969 if (!try_module_get(cpufreq_driver->owner)) {
970 ret = -EINVAL;
971 goto module_out;
972 }
973
Dave Jones059019a2009-07-08 16:30:03 -0400974 ret = -ENOMEM;
Dave Jonese98df502005-10-20 15:17:43 -0700975 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
Dave Jones059019a2009-07-08 16:30:03 -0400976 if (!policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 goto nomem_out;
Dave Jones059019a2009-07-08 16:30:03 -0400978
979 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400980 goto err_free_policy;
Dave Jones059019a2009-07-08 16:30:03 -0400981
982 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400983 goto err_free_cpumask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
985 policy->cpu = cpu;
Rusty Russell835481d2009-01-04 05:18:06 -0800986 cpumask_copy(policy->cpus, cpumask_of(cpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800988 /* Initially set CPU itself as the policy_cpu */
989 per_cpu(policy_cpu, cpu) = cpu;
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400990 ret = (lock_policy_rwsem_write(cpu) < 0);
991 WARN_ON(ret);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 init_completion(&policy->kobj_unregister);
David Howells65f27f32006-11-22 14:55:48 +0000994 INIT_WORK(&policy->update, handle_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995
Thomas Renninger8122c6c2007-10-02 13:28:09 -0700996 /* Set governor before ->init, so that driver could check it */
997 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 /* call driver. From then on the cpufreq must be able
999 * to accept all calls to ->verify and ->setpolicy for this CPU
1000 */
1001 ret = cpufreq_driver->init(policy);
1002 if (ret) {
1003 dprintk("initialization failed\n");
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -04001004 goto err_unlock_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 }
Mike Chan187d9f42008-12-04 12:19:17 -08001006 policy->user_policy.min = policy->min;
1007 policy->user_policy.max = policy->max;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
Thomas Renningera1531ac2008-07-29 22:32:58 -07001009 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1010 CPUFREQ_START, policy);
1011
Dave Jonesecf7e462009-07-08 18:48:47 -04001012 ret = cpufreq_add_dev_policy(cpu, policy, sys_dev);
Thomas Renninger4bfa0422009-07-24 15:25:03 +02001013 if (ret) {
1014 if (ret > 0)
1015 /* This is a managed cpu, symlink created,
1016 exit with 0 */
1017 ret = 0;
Dave Jonesecf7e462009-07-08 18:48:47 -04001018 goto err_unlock_policy;
Thomas Renninger4bfa0422009-07-24 15:25:03 +02001019 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020
Dave Jones909a6942009-07-08 18:05:42 -04001021 ret = cpufreq_add_dev_interface(cpu, policy, sys_dev);
Dave Jones19d6f7e2009-07-08 17:35:39 -04001022 if (ret)
1023 goto err_out_unregister;
Dave Jones8ff69732006-03-05 03:37:23 -05001024
Lothar Waßmanndca02612008-05-29 17:54:52 +02001025 unlock_policy_rwsem_write(cpu);
1026
Greg Kroah-Hartman038c5b32007-12-17 15:54:39 -04001027 kobject_uevent(&policy->kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 module_put(cpufreq_driver->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 dprintk("initialization complete\n");
1030 cpufreq_debug_enable_ratelimit();
Dave Jones87c32272006-03-29 01:48:37 -05001031
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 return 0;
1033
1034
1035err_out_unregister:
1036 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Rusty Russell835481d2009-01-04 05:18:06 -08001037 for_each_cpu(j, policy->cpus)
Mike Travis7a6aedf2008-03-25 15:06:53 -07001038 per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1040
Greg Kroah-Hartmanc10997f2007-12-20 08:13:05 -08001041 kobject_put(&policy->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 wait_for_completion(&policy->kobj_unregister);
1043
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -04001044err_unlock_policy:
Dave Jones45709112008-03-05 14:07:34 -05001045 unlock_policy_rwsem_write(cpu);
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -04001046err_free_cpumask:
1047 free_cpumask_var(policy->cpus);
1048err_free_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 kfree(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050nomem_out:
1051 module_put(cpufreq_driver->owner);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001052module_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 cpufreq_debug_enable_ratelimit();
1054 return ret;
1055}
1056
1057
1058/**
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001059 * __cpufreq_remove_dev - remove a CPU device
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 *
1061 * Removes the cpufreq interface for a CPU device.
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001062 * Caller should already have policy_rwsem in write mode for this CPU.
1063 * This routine frees the rwsem before returning.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 */
Dave Jones905d77c2008-03-05 14:28:32 -05001065static int __cpufreq_remove_dev(struct sys_device *sys_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066{
1067 unsigned int cpu = sys_dev->id;
1068 unsigned long flags;
1069 struct cpufreq_policy *data;
1070#ifdef CONFIG_SMP
Grant Coadye738cf62005-11-21 21:32:28 -08001071 struct sys_device *cpu_sys_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 unsigned int j;
1073#endif
1074
1075 cpufreq_debug_disable_ratelimit();
1076 dprintk("unregistering CPU %u\n", cpu);
1077
1078 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Mike Travis7a6aedf2008-03-25 15:06:53 -07001079 data = per_cpu(cpufreq_cpu_data, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
1081 if (!data) {
1082 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 cpufreq_debug_enable_ratelimit();
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001084 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 return -EINVAL;
1086 }
Mike Travis7a6aedf2008-03-25 15:06:53 -07001087 per_cpu(cpufreq_cpu_data, cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
1089
1090#ifdef CONFIG_SMP
1091 /* if this isn't the CPU which is the parent of the kobj, we
Dave Jones32ee8c32006-02-28 00:43:23 -05001092 * only need to unlink, put and exit
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 */
1094 if (unlikely(cpu != data->cpu)) {
1095 dprintk("removing link\n");
Rusty Russell835481d2009-01-04 05:18:06 -08001096 cpumask_clear_cpu(cpu, data->cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1098 sysfs_remove_link(&sys_dev->kobj, "cpufreq");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 cpufreq_cpu_put(data);
1100 cpufreq_debug_enable_ratelimit();
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001101 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 return 0;
1103 }
1104#endif
1105
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106#ifdef CONFIG_SMP
Thomas Renninger084f3492007-07-09 11:35:28 -07001107
1108#ifdef CONFIG_HOTPLUG_CPU
Mike Travis7a6aedf2008-03-25 15:06:53 -07001109 per_cpu(cpufreq_cpu_governor, cpu) = data->governor;
Thomas Renninger084f3492007-07-09 11:35:28 -07001110#endif
1111
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 /* if we have other CPUs still registered, we need to unlink them,
1113 * or else wait_for_completion below will lock up. Clean the
Mike Travis7a6aedf2008-03-25 15:06:53 -07001114 * per_cpu(cpufreq_cpu_data) while holding the lock, and remove
1115 * the sysfs links afterwards.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 */
Rusty Russell835481d2009-01-04 05:18:06 -08001117 if (unlikely(cpumask_weight(data->cpus) > 1)) {
1118 for_each_cpu(j, data->cpus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 if (j == cpu)
1120 continue;
Mike Travis7a6aedf2008-03-25 15:06:53 -07001121 per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 }
1123 }
1124
1125 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1126
Rusty Russell835481d2009-01-04 05:18:06 -08001127 if (unlikely(cpumask_weight(data->cpus) > 1)) {
1128 for_each_cpu(j, data->cpus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 if (j == cpu)
1130 continue;
1131 dprintk("removing link for cpu %u\n", j);
Thomas Renninger084f3492007-07-09 11:35:28 -07001132#ifdef CONFIG_HOTPLUG_CPU
Mike Travis7a6aedf2008-03-25 15:06:53 -07001133 per_cpu(cpufreq_cpu_governor, j) = data->governor;
Thomas Renninger084f3492007-07-09 11:35:28 -07001134#endif
Ashok Rajd434fca2005-10-30 14:59:52 -08001135 cpu_sys_dev = get_cpu_sysdev(j);
1136 sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 cpufreq_cpu_put(data);
1138 }
1139 }
1140#else
1141 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1142#endif
1143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 if (cpufreq_driver->target)
1145 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001146
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 kobject_put(&data->kobj);
1148
1149 /* we need to make sure that the underlying kobj is actually
Dave Jones32ee8c32006-02-28 00:43:23 -05001150 * not referenced anymore by anybody before we proceed with
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 * unloading.
1152 */
1153 dprintk("waiting for dropping of refcount\n");
1154 wait_for_completion(&data->kobj_unregister);
1155 dprintk("wait complete\n");
1156
1157 if (cpufreq_driver->exit)
1158 cpufreq_driver->exit(data);
1159
venkatesh.pallipadi@intel.com7d26e2d2009-07-02 17:08:30 -07001160 unlock_policy_rwsem_write(cpu);
1161
Rusty Russell835481d2009-01-04 05:18:06 -08001162 free_cpumask_var(data->related_cpus);
1163 free_cpumask_var(data->cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 kfree(data);
Rusty Russell835481d2009-01-04 05:18:06 -08001165 per_cpu(cpufreq_cpu_data, cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
1167 cpufreq_debug_enable_ratelimit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 return 0;
1169}
1170
1171
Dave Jones905d77c2008-03-05 14:28:32 -05001172static int cpufreq_remove_dev(struct sys_device *sys_dev)
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001173{
1174 unsigned int cpu = sys_dev->id;
1175 int retval;
Venki Pallipadiec282972007-03-26 12:03:19 -07001176
1177 if (cpu_is_offline(cpu))
1178 return 0;
1179
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001180 if (unlikely(lock_policy_rwsem_write(cpu)))
1181 BUG();
1182
1183 retval = __cpufreq_remove_dev(sys_dev);
1184 return retval;
1185}
1186
1187
David Howells65f27f32006-11-22 14:55:48 +00001188static void handle_update(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189{
David Howells65f27f32006-11-22 14:55:48 +00001190 struct cpufreq_policy *policy =
1191 container_of(work, struct cpufreq_policy, update);
1192 unsigned int cpu = policy->cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 dprintk("handle_update for cpu %u called\n", cpu);
1194 cpufreq_update_policy(cpu);
1195}
1196
1197/**
1198 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
1199 * @cpu: cpu number
1200 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1201 * @new_freq: CPU frequency the CPU actually runs at
1202 *
Dave Jones29464f22009-01-18 01:37:11 -05001203 * We adjust to current frequency first, and need to clean up later.
1204 * So either call to cpufreq_update_policy() or schedule handle_update()).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301206static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1207 unsigned int new_freq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208{
1209 struct cpufreq_freqs freqs;
1210
Jan Beulichb10eec22006-04-28 13:47:13 +02001211 dprintk("Warning: CPU frequency out of sync: cpufreq and timing "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1213
1214 freqs.cpu = cpu;
1215 freqs.old = old_freq;
1216 freqs.new = new_freq;
1217 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
1218 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
1219}
1220
1221
Dave Jones32ee8c32006-02-28 00:43:23 -05001222/**
Dhaval Giani4ab70df2006-12-13 14:49:15 +05301223 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001224 * @cpu: CPU number
1225 *
1226 * This is the last known freq, without actually getting it from the driver.
1227 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1228 */
1229unsigned int cpufreq_quick_get(unsigned int cpu)
1230{
1231 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301232 unsigned int ret_freq = 0;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001233
1234 if (policy) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301235 ret_freq = policy->cur;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001236 cpufreq_cpu_put(policy);
1237 }
1238
Dave Jones4d34a672008-02-07 16:33:49 -05001239 return ret_freq;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001240}
1241EXPORT_SYMBOL(cpufreq_quick_get);
1242
1243
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001244static unsigned int __cpufreq_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245{
Mike Travis7a6aedf2008-03-25 15:06:53 -07001246 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301247 unsigned int ret_freq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 if (!cpufreq_driver->get)
Dave Jones4d34a672008-02-07 16:33:49 -05001250 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301252 ret_freq = cpufreq_driver->get(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301254 if (ret_freq && policy->cur &&
1255 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1256 /* verify no discrepancy between actual and
1257 saved value exists */
1258 if (unlikely(ret_freq != policy->cur)) {
1259 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 schedule_work(&policy->update);
1261 }
1262 }
1263
Dave Jones4d34a672008-02-07 16:33:49 -05001264 return ret_freq;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001265}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001267/**
1268 * cpufreq_get - get the current CPU frequency (in kHz)
1269 * @cpu: CPU number
1270 *
1271 * Get the CPU current (static) CPU frequency
1272 */
1273unsigned int cpufreq_get(unsigned int cpu)
1274{
1275 unsigned int ret_freq = 0;
1276 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1277
1278 if (!policy)
1279 goto out;
1280
1281 if (unlikely(lock_policy_rwsem_read(cpu)))
1282 goto out_policy;
1283
1284 ret_freq = __cpufreq_get(cpu);
1285
1286 unlock_policy_rwsem_read(cpu);
1287
1288out_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 cpufreq_cpu_put(policy);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001290out:
Dave Jones4d34a672008-02-07 16:33:49 -05001291 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292}
1293EXPORT_SYMBOL(cpufreq_get);
1294
1295
1296/**
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001297 * cpufreq_suspend - let the low level driver prepare for suspend
1298 */
1299
Dave Jones905d77c2008-03-05 14:28:32 -05001300static int cpufreq_suspend(struct sys_device *sysdev, pm_message_t pmsg)
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001301{
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301302 int ret = 0;
Dave Jones4bc5d342009-08-04 14:03:25 -04001303
Dave Jones4bc5d342009-08-04 14:03:25 -04001304 int cpu = sysdev->id;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001305 struct cpufreq_policy *cpu_policy;
1306
Dave Jones0e37b152006-09-26 23:02:34 -04001307 dprintk("suspending cpu %u\n", cpu);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001308
1309 if (!cpu_online(cpu))
1310 return 0;
1311
1312 /* we may be lax here as interrupts are off. Nonetheless
1313 * we need to grab the correct cpu policy, as to check
1314 * whether we really run on this CPU.
1315 */
1316
1317 cpu_policy = cpufreq_cpu_get(cpu);
1318 if (!cpu_policy)
1319 return -EINVAL;
1320
1321 /* only handle each CPU group once */
Dave Jonesc9060492008-02-07 16:32:18 -05001322 if (unlikely(cpu_policy->cpu != cpu))
1323 goto out;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001324
1325 if (cpufreq_driver->suspend) {
Bernard Blackhame00d9962005-07-07 17:56:42 -07001326 ret = cpufreq_driver->suspend(cpu_policy, pmsg);
Dominik Brodowskice6c3992009-08-07 22:58:51 +02001327 if (ret)
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001328 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1329 "step on CPU %u\n", cpu_policy->cpu);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001330 }
1331
Dave Jones7d5e3502006-02-02 17:03:42 -05001332out:
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001333 cpufreq_cpu_put(cpu_policy);
Dave Jonesc9060492008-02-07 16:32:18 -05001334 return ret;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001335}
1336
1337/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 * cpufreq_resume - restore proper CPU frequency handling after resume
1339 *
1340 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
Dominik Brodowskice6c3992009-08-07 22:58:51 +02001341 * 2.) schedule call cpufreq_update_policy() ASAP as interrupts are
1342 * restored. It will verify that the current freq is in sync with
1343 * what we believe it to be. This is a bit later than when it
1344 * should be, but nonethteless it's better than calling
1345 * cpufreq_driver->get() here which might re-enable interrupts...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 */
Dave Jones905d77c2008-03-05 14:28:32 -05001347static int cpufreq_resume(struct sys_device *sysdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348{
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301349 int ret = 0;
Dave Jones4bc5d342009-08-04 14:03:25 -04001350
Dave Jones4bc5d342009-08-04 14:03:25 -04001351 int cpu = sysdev->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 struct cpufreq_policy *cpu_policy;
1353
1354 dprintk("resuming cpu %u\n", cpu);
1355
1356 if (!cpu_online(cpu))
1357 return 0;
1358
1359 /* we may be lax here as interrupts are off. Nonetheless
1360 * we need to grab the correct cpu policy, as to check
1361 * whether we really run on this CPU.
1362 */
1363
1364 cpu_policy = cpufreq_cpu_get(cpu);
1365 if (!cpu_policy)
1366 return -EINVAL;
1367
1368 /* only handle each CPU group once */
Dave Jonesc9060492008-02-07 16:32:18 -05001369 if (unlikely(cpu_policy->cpu != cpu))
1370 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371
1372 if (cpufreq_driver->resume) {
1373 ret = cpufreq_driver->resume(cpu_policy);
1374 if (ret) {
1375 printk(KERN_ERR "cpufreq: resume failed in ->resume "
1376 "step on CPU %u\n", cpu_policy->cpu);
Dave Jonesc9060492008-02-07 16:32:18 -05001377 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 }
1379 }
1380
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 schedule_work(&cpu_policy->update);
Dominik Brodowskice6c3992009-08-07 22:58:51 +02001382
Dave Jonesc9060492008-02-07 16:32:18 -05001383fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 cpufreq_cpu_put(cpu_policy);
1385 return ret;
1386}
1387
1388static struct sysdev_driver cpufreq_sysdev_driver = {
1389 .add = cpufreq_add_dev,
1390 .remove = cpufreq_remove_dev,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001391 .suspend = cpufreq_suspend,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 .resume = cpufreq_resume,
1393};
1394
1395
1396/*********************************************************************
1397 * NOTIFIER LISTS INTERFACE *
1398 *********************************************************************/
1399
1400/**
1401 * cpufreq_register_notifier - register a driver with cpufreq
1402 * @nb: notifier function to register
1403 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1404 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001405 * Add a driver to one of two lists: either a list of drivers that
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 * are notified about clock rate changes (once before and once after
1407 * the transition), or a list of drivers that are notified about
1408 * changes in cpufreq policy.
1409 *
1410 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001411 * blocking_notifier_chain_register.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 */
1413int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1414{
1415 int ret;
1416
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -02001417 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1418
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 switch (list) {
1420 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001421 ret = srcu_notifier_chain_register(
Alan Sterne041c682006-03-27 01:16:30 -08001422 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 break;
1424 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001425 ret = blocking_notifier_chain_register(
1426 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 break;
1428 default:
1429 ret = -EINVAL;
1430 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
1432 return ret;
1433}
1434EXPORT_SYMBOL(cpufreq_register_notifier);
1435
1436
1437/**
1438 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1439 * @nb: notifier block to be unregistered
1440 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1441 *
1442 * Remove a driver from the CPU frequency notifier list.
1443 *
1444 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001445 * blocking_notifier_chain_unregister.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 */
1447int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1448{
1449 int ret;
1450
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 switch (list) {
1452 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001453 ret = srcu_notifier_chain_unregister(
Alan Sterne041c682006-03-27 01:16:30 -08001454 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 break;
1456 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001457 ret = blocking_notifier_chain_unregister(
1458 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 break;
1460 default:
1461 ret = -EINVAL;
1462 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463
1464 return ret;
1465}
1466EXPORT_SYMBOL(cpufreq_unregister_notifier);
1467
1468
1469/*********************************************************************
1470 * GOVERNORS *
1471 *********************************************************************/
1472
1473
1474int __cpufreq_driver_target(struct cpufreq_policy *policy,
1475 unsigned int target_freq,
1476 unsigned int relation)
1477{
1478 int retval = -EINVAL;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001479
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
1481 target_freq, relation);
1482 if (cpu_online(policy->cpu) && cpufreq_driver->target)
1483 retval = cpufreq_driver->target(policy, target_freq, relation);
Ashok Raj90d45d12005-11-08 21:34:24 -08001484
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 return retval;
1486}
1487EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1488
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489int cpufreq_driver_target(struct cpufreq_policy *policy,
1490 unsigned int target_freq,
1491 unsigned int relation)
1492{
Julia Lawallf1829e42008-07-25 22:44:53 +02001493 int ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
1495 policy = cpufreq_cpu_get(policy->cpu);
1496 if (!policy)
Julia Lawallf1829e42008-07-25 22:44:53 +02001497 goto no_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001499 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
Julia Lawallf1829e42008-07-25 22:44:53 +02001500 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501
1502 ret = __cpufreq_driver_target(policy, target_freq, relation);
1503
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001504 unlock_policy_rwsem_write(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505
Julia Lawallf1829e42008-07-25 22:44:53 +02001506fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 cpufreq_cpu_put(policy);
Julia Lawallf1829e42008-07-25 22:44:53 +02001508no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 return ret;
1510}
1511EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1512
venkatesh.pallipadi@intel.combf0b90e2008-08-04 11:59:07 -07001513int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001514{
1515 int ret = 0;
1516
1517 policy = cpufreq_cpu_get(policy->cpu);
1518 if (!policy)
1519 return -EINVAL;
1520
venkatesh.pallipadi@intel.combf0b90e2008-08-04 11:59:07 -07001521 if (cpu_online(cpu) && cpufreq_driver->getavg)
1522 ret = cpufreq_driver->getavg(policy, cpu);
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001523
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001524 cpufreq_cpu_put(policy);
1525 return ret;
1526}
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001527EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001528
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001529/*
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001530 * when "event" is CPUFREQ_GOV_LIMITS
1531 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301533static int __cpufreq_governor(struct cpufreq_policy *policy,
1534 unsigned int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535{
Dave Jonescc993ca2005-07-28 09:43:56 -07001536 int ret;
Thomas Renninger6afde102007-10-02 13:28:13 -07001537
1538 /* Only must be defined when default governor is known to have latency
1539 restrictions, like e.g. conservative or ondemand.
1540 That this is the case is already ensured in Kconfig
1541 */
1542#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1543 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1544#else
1545 struct cpufreq_governor *gov = NULL;
1546#endif
Thomas Renninger1c256242007-10-02 13:28:12 -07001547
1548 if (policy->governor->max_transition_latency &&
1549 policy->cpuinfo.transition_latency >
1550 policy->governor->max_transition_latency) {
Thomas Renninger6afde102007-10-02 13:28:13 -07001551 if (!gov)
1552 return -EINVAL;
1553 else {
1554 printk(KERN_WARNING "%s governor failed, too long"
1555 " transition latency of HW, fallback"
1556 " to %s governor\n",
1557 policy->governor->name,
1558 gov->name);
1559 policy->governor = gov;
1560 }
Thomas Renninger1c256242007-10-02 13:28:12 -07001561 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562
1563 if (!try_module_get(policy->governor->owner))
1564 return -EINVAL;
1565
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301566 dprintk("__cpufreq_governor for CPU %u, event %u\n",
1567 policy->cpu, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 ret = policy->governor->governor(policy, event);
1569
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301570 /* we keep one module reference alive for
1571 each CPU governed by this CPU */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 if ((event != CPUFREQ_GOV_START) || ret)
1573 module_put(policy->governor->owner);
1574 if ((event == CPUFREQ_GOV_STOP) && !ret)
1575 module_put(policy->governor->owner);
1576
1577 return ret;
1578}
1579
1580
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581int cpufreq_register_governor(struct cpufreq_governor *governor)
1582{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001583 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584
1585 if (!governor)
1586 return -EINVAL;
1587
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001588 mutex_lock(&cpufreq_governor_mutex);
Dave Jones32ee8c32006-02-28 00:43:23 -05001589
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001590 err = -EBUSY;
1591 if (__find_governor(governor->name) == NULL) {
1592 err = 0;
1593 list_add(&governor->governor_list, &cpufreq_governor_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
Dave Jones32ee8c32006-02-28 00:43:23 -05001596 mutex_unlock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001597 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598}
1599EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1600
1601
1602void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1603{
1604 if (!governor)
1605 return;
1606
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001607 mutex_lock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 list_del(&governor->governor_list);
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001609 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 return;
1611}
1612EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1613
1614
1615
1616/*********************************************************************
1617 * POLICY INTERFACE *
1618 *********************************************************************/
1619
1620/**
1621 * cpufreq_get_policy - get the current cpufreq_policy
Dave Jones29464f22009-01-18 01:37:11 -05001622 * @policy: struct cpufreq_policy into which the current cpufreq_policy
1623 * is written
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 *
1625 * Reads the current cpufreq policy.
1626 */
1627int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1628{
1629 struct cpufreq_policy *cpu_policy;
1630 if (!policy)
1631 return -EINVAL;
1632
1633 cpu_policy = cpufreq_cpu_get(cpu);
1634 if (!cpu_policy)
1635 return -EINVAL;
1636
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
1639 cpufreq_cpu_put(cpu_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 return 0;
1641}
1642EXPORT_SYMBOL(cpufreq_get_policy);
1643
1644
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001645/*
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301646 * data : current policy.
1647 * policy : policy to be set.
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001648 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301649static int __cpufreq_set_policy(struct cpufreq_policy *data,
1650 struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651{
1652 int ret = 0;
1653
1654 cpufreq_debug_disable_ratelimit();
1655 dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1656 policy->min, policy->max);
1657
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301658 memcpy(&policy->cpuinfo, &data->cpuinfo,
1659 sizeof(struct cpufreq_cpuinfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Yi Yang53391fa2008-01-30 13:33:34 +01001661 if (policy->min > data->max || policy->max < data->min) {
Mattia Dongili9c9a43e2006-07-05 23:12:20 +02001662 ret = -EINVAL;
1663 goto error_out;
1664 }
1665
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 /* verify the cpu speed can be set within this limit */
1667 ret = cpufreq_driver->verify(policy);
1668 if (ret)
1669 goto error_out;
1670
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 /* adjust if necessary - all reasons */
Alan Sterne041c682006-03-27 01:16:30 -08001672 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1673 CPUFREQ_ADJUST, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674
1675 /* adjust if necessary - hardware incompatibility*/
Alan Sterne041c682006-03-27 01:16:30 -08001676 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1677 CPUFREQ_INCOMPATIBLE, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678
1679 /* verify the cpu speed can be set within this limit,
1680 which might be different to the first one */
1681 ret = cpufreq_driver->verify(policy);
Alan Sterne041c682006-03-27 01:16:30 -08001682 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 goto error_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684
1685 /* notification of the new policy */
Alan Sterne041c682006-03-27 01:16:30 -08001686 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1687 CPUFREQ_NOTIFY, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
Dave Jones7d5e3502006-02-02 17:03:42 -05001689 data->min = policy->min;
1690 data->max = policy->max;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301692 dprintk("new min and max freqs are %u - %u kHz\n",
1693 data->min, data->max);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694
1695 if (cpufreq_driver->setpolicy) {
1696 data->policy = policy->policy;
1697 dprintk("setting range\n");
1698 ret = cpufreq_driver->setpolicy(policy);
1699 } else {
1700 if (policy->governor != data->governor) {
1701 /* save old, working values */
1702 struct cpufreq_governor *old_gov = data->governor;
1703
1704 dprintk("governor switch\n");
1705
1706 /* end old governor */
1707 if (data->governor)
1708 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1709
1710 /* start new governor */
1711 data->governor = policy->governor;
1712 if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1713 /* new governor failed, so re-start old one */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301714 dprintk("starting governor %s failed\n",
1715 data->governor->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 if (old_gov) {
1717 data->governor = old_gov;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301718 __cpufreq_governor(data,
1719 CPUFREQ_GOV_START);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 }
1721 ret = -EINVAL;
1722 goto error_out;
1723 }
1724 /* might be a policy change, too, so fall through */
1725 }
1726 dprintk("governor: change or update limits\n");
1727 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1728 }
1729
Dave Jones7d5e3502006-02-02 17:03:42 -05001730error_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 cpufreq_debug_enable_ratelimit();
1732 return ret;
1733}
1734
1735/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1737 * @cpu: CPU which shall be re-evaluated
1738 *
1739 * Usefull for policy notifiers which have different necessities
1740 * at different times.
1741 */
1742int cpufreq_update_policy(unsigned int cpu)
1743{
1744 struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1745 struct cpufreq_policy policy;
Julia Lawallf1829e42008-07-25 22:44:53 +02001746 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
Julia Lawallf1829e42008-07-25 22:44:53 +02001748 if (!data) {
1749 ret = -ENODEV;
1750 goto no_policy;
1751 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752
Julia Lawallf1829e42008-07-25 22:44:53 +02001753 if (unlikely(lock_policy_rwsem_write(cpu))) {
1754 ret = -EINVAL;
1755 goto fail;
1756 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757
1758 dprintk("updating policy for CPU %u\n", cpu);
Dave Jones7d5e3502006-02-02 17:03:42 -05001759 memcpy(&policy, data, sizeof(struct cpufreq_policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 policy.min = data->user_policy.min;
1761 policy.max = data->user_policy.max;
1762 policy.policy = data->user_policy.policy;
1763 policy.governor = data->user_policy.governor;
1764
Thomas Renninger0961dd02006-01-26 18:46:33 +01001765 /* BIOS might change freq behind our back
1766 -> ask driver for current freq and notify governors about a change */
1767 if (cpufreq_driver->get) {
1768 policy.cur = cpufreq_driver->get(cpu);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001769 if (!data->cur) {
1770 dprintk("Driver did not initialize current freq");
1771 data->cur = policy.cur;
1772 } else {
1773 if (data->cur != policy.cur)
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301774 cpufreq_out_of_sync(cpu, data->cur,
1775 policy.cur);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001776 }
Thomas Renninger0961dd02006-01-26 18:46:33 +01001777 }
1778
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 ret = __cpufreq_set_policy(data, &policy);
1780
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001781 unlock_policy_rwsem_write(cpu);
1782
Julia Lawallf1829e42008-07-25 22:44:53 +02001783fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 cpufreq_cpu_put(data);
Julia Lawallf1829e42008-07-25 22:44:53 +02001785no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 return ret;
1787}
1788EXPORT_SYMBOL(cpufreq_update_policy);
1789
Satyam Sharmadd184a02007-10-02 13:28:14 -07001790static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
Ashok Rajc32b6b82005-10-30 14:59:54 -08001791 unsigned long action, void *hcpu)
1792{
1793 unsigned int cpu = (unsigned long)hcpu;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001794 struct sys_device *sys_dev;
1795
1796 sys_dev = get_cpu_sysdev(cpu);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001797 if (sys_dev) {
1798 switch (action) {
1799 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001800 case CPU_ONLINE_FROZEN:
Ashok Rajc32b6b82005-10-30 14:59:54 -08001801 cpufreq_add_dev(sys_dev);
1802 break;
1803 case CPU_DOWN_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001804 case CPU_DOWN_PREPARE_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001805 if (unlikely(lock_policy_rwsem_write(cpu)))
1806 BUG();
1807
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001808 __cpufreq_remove_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001809 break;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001810 case CPU_DOWN_FAILED:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001811 case CPU_DOWN_FAILED_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001812 cpufreq_add_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001813 break;
1814 }
1815 }
1816 return NOTIFY_OK;
1817}
1818
Sam Ravnborgf6ebef32008-02-17 13:22:52 +01001819static struct notifier_block __refdata cpufreq_cpu_notifier =
Ashok Rajc32b6b82005-10-30 14:59:54 -08001820{
1821 .notifier_call = cpufreq_cpu_callback,
1822};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
1824/*********************************************************************
1825 * REGISTER / UNREGISTER CPUFREQ DRIVER *
1826 *********************************************************************/
1827
1828/**
1829 * cpufreq_register_driver - register a CPU Frequency driver
1830 * @driver_data: A struct cpufreq_driver containing the values#
1831 * submitted by the CPU Frequency driver.
1832 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001833 * Registers a CPU Frequency driver to this core code. This code
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 * returns zero on success, -EBUSY when another driver got here first
Dave Jones32ee8c32006-02-28 00:43:23 -05001835 * (and isn't unregistered in the meantime).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 *
1837 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001838int cpufreq_register_driver(struct cpufreq_driver *driver_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839{
1840 unsigned long flags;
1841 int ret;
1842
1843 if (!driver_data || !driver_data->verify || !driver_data->init ||
1844 ((!driver_data->setpolicy) && (!driver_data->target)))
1845 return -EINVAL;
1846
1847 dprintk("trying to register driver %s\n", driver_data->name);
1848
1849 if (driver_data->setpolicy)
1850 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1851
1852 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1853 if (cpufreq_driver) {
1854 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1855 return -EBUSY;
1856 }
1857 cpufreq_driver = driver_data;
1858 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1859
Mike Travis7a6aedf2008-03-25 15:06:53 -07001860 ret = sysdev_driver_register(&cpu_sysdev_class,
1861 &cpufreq_sysdev_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862
1863 if ((!ret) && !(cpufreq_driver->flags & CPUFREQ_STICKY)) {
1864 int i;
1865 ret = -ENODEV;
1866
1867 /* check for at least one working CPU */
Mike Travis7a6aedf2008-03-25 15:06:53 -07001868 for (i = 0; i < nr_cpu_ids; i++)
1869 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 ret = 0;
Mike Travis7a6aedf2008-03-25 15:06:53 -07001871 break;
1872 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
1874 /* if all ->init() calls failed, unregister */
1875 if (ret) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301876 dprintk("no CPU initialized for driver %s\n",
1877 driver_data->name);
1878 sysdev_driver_unregister(&cpu_sysdev_class,
1879 &cpufreq_sysdev_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880
1881 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1882 cpufreq_driver = NULL;
1883 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1884 }
1885 }
1886
1887 if (!ret) {
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001888 register_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 dprintk("driver %s up and running\n", driver_data->name);
1890 cpufreq_debug_enable_ratelimit();
1891 }
1892
Dave Jones4d34a672008-02-07 16:33:49 -05001893 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894}
1895EXPORT_SYMBOL_GPL(cpufreq_register_driver);
1896
1897
1898/**
1899 * cpufreq_unregister_driver - unregister the current CPUFreq driver
1900 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001901 * Unregister the current CPUFreq driver. Only call this if you have
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 * the right to do so, i.e. if you have succeeded in initialising before!
1903 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1904 * currently not initialised.
1905 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001906int cpufreq_unregister_driver(struct cpufreq_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907{
1908 unsigned long flags;
1909
1910 cpufreq_debug_disable_ratelimit();
1911
1912 if (!cpufreq_driver || (driver != cpufreq_driver)) {
1913 cpufreq_debug_enable_ratelimit();
1914 return -EINVAL;
1915 }
1916
1917 dprintk("unregistering driver %s\n", driver->name);
1918
1919 sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001920 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921
1922 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1923 cpufreq_driver = NULL;
1924 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1925
1926 return 0;
1927}
1928EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001929
1930static int __init cpufreq_core_init(void)
1931{
1932 int cpu;
1933
1934 for_each_possible_cpu(cpu) {
1935 per_cpu(policy_cpu, cpu) = -1;
1936 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
1937 }
1938 return 0;
1939}
1940
1941core_initcall(cpufreq_core_init);