blob: 31d6f535a79de51d322d8d76af3eccfd2bf11140 [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 */
107static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800108static unsigned int __cpufreq_get(unsigned int cpu);
David Howells65f27f32006-11-22 14:55:48 +0000109static void handle_update(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111/**
Dave Jones32ee8c32006-02-28 00:43:23 -0500112 * Two notifier lists: the "policy" list is involved in the
113 * validation process for a new CPU frequency policy; the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 * "transition" list for kernel code that needs to handle
115 * changes to devices when the CPU clock speed changes.
116 * The mutex locks both lists.
117 */
Alan Sterne041c682006-03-27 01:16:30 -0800118static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700119static struct srcu_notifier_head cpufreq_transition_notifier_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -0200121static bool init_cpufreq_transition_notifier_list_called;
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700122static int __init init_cpufreq_transition_notifier_list(void)
123{
124 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -0200125 init_cpufreq_transition_notifier_list_called = true;
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700126 return 0;
127}
Linus Torvaldsb3438f82006-11-20 11:47:18 -0800128pure_initcall(init_cpufreq_transition_notifier_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
130static LIST_HEAD(cpufreq_governor_list);
Dave Jones7d5e3502006-02-02 17:03:42 -0500131static DEFINE_MUTEX (cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Dave Jones7d5e3502006-02-02 17:03:42 -0500133struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134{
135 struct cpufreq_policy *data;
136 unsigned long flags;
137
Mike Travis7a6aedf2008-03-25 15:06:53 -0700138 if (cpu >= nr_cpu_ids)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 goto err_out;
140
141 /* get the cpufreq driver */
142 spin_lock_irqsave(&cpufreq_driver_lock, flags);
143
144 if (!cpufreq_driver)
145 goto err_out_unlock;
146
147 if (!try_module_get(cpufreq_driver->owner))
148 goto err_out_unlock;
149
150
151 /* get the CPU */
Mike Travis7a6aedf2008-03-25 15:06:53 -0700152 data = per_cpu(cpufreq_cpu_data, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 if (!data)
155 goto err_out_put_module;
156
157 if (!kobject_get(&data->kobj))
158 goto err_out_put_module;
159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 return data;
162
Dave Jones7d5e3502006-02-02 17:03:42 -0500163err_out_put_module:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 module_put(cpufreq_driver->owner);
Dave Jones7d5e3502006-02-02 17:03:42 -0500165err_out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Dave Jones7d5e3502006-02-02 17:03:42 -0500167err_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 return NULL;
169}
170EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
171
Dave Jones7d5e3502006-02-02 17:03:42 -0500172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173void cpufreq_cpu_put(struct cpufreq_policy *data)
174{
175 kobject_put(&data->kobj);
176 module_put(cpufreq_driver->owner);
177}
178EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
179
180
181/*********************************************************************
182 * UNIFIED DEBUG HELPERS *
183 *********************************************************************/
184#ifdef CONFIG_CPU_FREQ_DEBUG
185
186/* what part(s) of the CPUfreq subsystem are debugged? */
187static unsigned int debug;
188
189/* is the debug output ratelimit'ed using printk_ratelimit? User can
190 * set or modify this value.
191 */
192static unsigned int debug_ratelimit = 1;
193
194/* is the printk_ratelimit'ing enabled? It's enabled after a successful
195 * loading of a cpufreq driver, temporarily disabled when a new policy
196 * is set, and disabled upon cpufreq driver removal
197 */
198static unsigned int disable_ratelimit = 1;
199static DEFINE_SPINLOCK(disable_ratelimit_lock);
200
Arjan van de Ven858119e2006-01-14 13:20:43 -0800201static void cpufreq_debug_enable_ratelimit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202{
203 unsigned long flags;
204
205 spin_lock_irqsave(&disable_ratelimit_lock, flags);
206 if (disable_ratelimit)
207 disable_ratelimit--;
208 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
209}
210
Arjan van de Ven858119e2006-01-14 13:20:43 -0800211static void cpufreq_debug_disable_ratelimit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
213 unsigned long flags;
214
215 spin_lock_irqsave(&disable_ratelimit_lock, flags);
216 disable_ratelimit++;
217 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
218}
219
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530220void cpufreq_debug_printk(unsigned int type, const char *prefix,
Dave Jones905d77c2008-03-05 14:28:32 -0500221 const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222{
223 char s[256];
224 va_list args;
225 unsigned int len;
226 unsigned long flags;
Dave Jones32ee8c32006-02-28 00:43:23 -0500227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 WARN_ON(!prefix);
229 if (type & debug) {
230 spin_lock_irqsave(&disable_ratelimit_lock, flags);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530231 if (!disable_ratelimit && debug_ratelimit
232 && !printk_ratelimit()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
234 return;
235 }
236 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
237
238 len = snprintf(s, 256, KERN_DEBUG "%s: ", prefix);
239
240 va_start(args, fmt);
241 len += vsnprintf(&s[len], (256 - len), fmt, args);
242 va_end(args);
243
244 printk(s);
245
246 WARN_ON(len < 5);
247 }
248}
249EXPORT_SYMBOL(cpufreq_debug_printk);
250
251
252module_param(debug, uint, 0644);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530253MODULE_PARM_DESC(debug, "CPUfreq debugging: add 1 to debug core,"
254 " 2 to debug drivers, and 4 to debug governors.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256module_param(debug_ratelimit, uint, 0644);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530257MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging:"
258 " set to 0 to disable ratelimiting.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260#else /* !CONFIG_CPU_FREQ_DEBUG */
261
262static inline void cpufreq_debug_enable_ratelimit(void) { return; }
263static inline void cpufreq_debug_disable_ratelimit(void) { return; }
264
265#endif /* CONFIG_CPU_FREQ_DEBUG */
266
267
268/*********************************************************************
269 * EXTERNALLY AFFECTING FREQUENCY CHANGES *
270 *********************************************************************/
271
272/**
273 * adjust_jiffies - adjust the system "loops_per_jiffy"
274 *
275 * This function alters the system "loops_per_jiffy" for the clock
276 * speed change. Note that loops_per_jiffy cannot be updated on SMP
Dave Jones32ee8c32006-02-28 00:43:23 -0500277 * systems as each CPU might be scaled differently. So, use the arch
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 * per-CPU loops_per_jiffy value wherever possible.
279 */
280#ifndef CONFIG_SMP
281static unsigned long l_p_j_ref;
282static unsigned int l_p_j_ref_freq;
283
Arjan van de Ven858119e2006-01-14 13:20:43 -0800284static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285{
286 if (ci->flags & CPUFREQ_CONST_LOOPS)
287 return;
288
289 if (!l_p_j_ref_freq) {
290 l_p_j_ref = loops_per_jiffy;
291 l_p_j_ref_freq = ci->old;
Joe Perchesa4a9df52007-11-19 17:48:06 -0800292 dprintk("saving %lu as reference value for loops_per_jiffy; "
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530293 "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 }
295 if ((val == CPUFREQ_PRECHANGE && ci->old < ci->new) ||
296 (val == CPUFREQ_POSTCHANGE && ci->old > ci->new) ||
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -0700297 (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530298 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
299 ci->new);
Joe Perchesa4a9df52007-11-19 17:48:06 -0800300 dprintk("scaling loops_per_jiffy to %lu "
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530301 "for frequency %u kHz\n", loops_per_jiffy, ci->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 }
303}
304#else
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530305static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
306{
307 return;
308}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309#endif
310
311
312/**
Dave Jonese4472cb2006-01-31 15:53:55 -0800313 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
314 * on frequency transition.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 *
Dave Jonese4472cb2006-01-31 15:53:55 -0800316 * This function calls the transition notifiers and the "adjust_jiffies"
317 * function. It is called twice on all CPU frequency changes that have
Dave Jones32ee8c32006-02-28 00:43:23 -0500318 * external effects.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 */
320void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
321{
Dave Jonese4472cb2006-01-31 15:53:55 -0800322 struct cpufreq_policy *policy;
323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 BUG_ON(irqs_disabled());
325
326 freqs->flags = cpufreq_driver->flags;
Dave Jonese4472cb2006-01-31 15:53:55 -0800327 dprintk("notification %u of frequency transition to %u kHz\n",
328 state, freqs->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Mike Travis7a6aedf2008-03-25 15:06:53 -0700330 policy = per_cpu(cpufreq_cpu_data, freqs->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 switch (state) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 case CPUFREQ_PRECHANGE:
Dave Jones32ee8c32006-02-28 00:43:23 -0500334 /* detect if the driver reported a value as "old frequency"
Dave Jonese4472cb2006-01-31 15:53:55 -0800335 * which is not equal to what the cpufreq core thinks is
336 * "old frequency".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 */
338 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800339 if ((policy) && (policy->cpu == freqs->cpu) &&
340 (policy->cur) && (policy->cur != freqs->old)) {
Jan Beulichb10eec22006-04-28 13:47:13 +0200341 dprintk("Warning: CPU frequency is"
Dave Jonese4472cb2006-01-31 15:53:55 -0800342 " %u, cpufreq assumed %u kHz.\n",
343 freqs->old, policy->cur);
344 freqs->old = policy->cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 }
346 }
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700347 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800348 CPUFREQ_PRECHANGE, freqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
350 break;
Dave Jonese4472cb2006-01-31 15:53:55 -0800351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 case CPUFREQ_POSTCHANGE:
353 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700354 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800355 CPUFREQ_POSTCHANGE, freqs);
Dave Jonese4472cb2006-01-31 15:53:55 -0800356 if (likely(policy) && likely(policy->cpu == freqs->cpu))
357 policy->cur = freqs->new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 break;
359 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360}
361EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
362
363
364
365/*********************************************************************
366 * SYSFS INTERFACE *
367 *********************************************************************/
368
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700369static struct cpufreq_governor *__find_governor(const char *str_governor)
370{
371 struct cpufreq_governor *t;
372
373 list_for_each_entry(t, &cpufreq_governor_list, governor_list)
374 if (!strnicmp(str_governor,t->name,CPUFREQ_NAME_LEN))
375 return t;
376
377 return NULL;
378}
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380/**
381 * cpufreq_parse_governor - parse a governor string
382 */
Dave Jones905d77c2008-03-05 14:28:32 -0500383static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 struct cpufreq_governor **governor)
385{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700386 int err = -EINVAL;
387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 if (!cpufreq_driver)
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700389 goto out;
390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 if (cpufreq_driver->setpolicy) {
392 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
393 *policy = CPUFREQ_POLICY_PERFORMANCE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700394 err = 0;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530395 } else if (!strnicmp(str_governor, "powersave",
396 CPUFREQ_NAME_LEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 *policy = CPUFREQ_POLICY_POWERSAVE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700398 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700400 } else if (cpufreq_driver->target) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 struct cpufreq_governor *t;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700402
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800403 mutex_lock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700404
405 t = __find_governor(str_governor);
406
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700407 if (t == NULL) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530408 char *name = kasprintf(GFP_KERNEL, "cpufreq_%s",
409 str_governor);
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700410
411 if (name) {
412 int ret;
413
414 mutex_unlock(&cpufreq_governor_mutex);
Chris Wright326f6a52008-06-06 21:26:02 -0700415 ret = request_module("%s", name);
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700416 mutex_lock(&cpufreq_governor_mutex);
417
418 if (ret == 0)
419 t = __find_governor(str_governor);
420 }
421
422 kfree(name);
423 }
424
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700425 if (t != NULL) {
426 *governor = t;
427 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700429
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800430 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700432 out:
433 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436
437/* drivers/base/cpu.c */
438extern struct sysdev_class cpu_sysdev_class;
439
440
441/**
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530442 * cpufreq_per_cpu_attr_read() / show_##file_name() -
443 * print out cpufreq information
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 *
445 * Write out information from cpufreq_driver->policy[cpu]; object must be
446 * "unsigned int".
447 */
448
Dave Jones32ee8c32006-02-28 00:43:23 -0500449#define show_one(file_name, object) \
450static ssize_t show_##file_name \
Dave Jones905d77c2008-03-05 14:28:32 -0500451(struct cpufreq_policy *policy, char *buf) \
Dave Jones32ee8c32006-02-28 00:43:23 -0500452{ \
453 return sprintf (buf, "%u\n", policy->object); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454}
455
456show_one(cpuinfo_min_freq, cpuinfo.min_freq);
457show_one(cpuinfo_max_freq, cpuinfo.max_freq);
458show_one(scaling_min_freq, min);
459show_one(scaling_max_freq, max);
460show_one(scaling_cur_freq, cur);
461
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530462static int __cpufreq_set_policy(struct cpufreq_policy *data,
463 struct cpufreq_policy *policy);
Thomas Renninger7970e082006-04-13 15:14:04 +0200464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465/**
466 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
467 */
468#define store_one(file_name, object) \
469static ssize_t store_##file_name \
Dave Jones905d77c2008-03-05 14:28:32 -0500470(struct cpufreq_policy *policy, const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471{ \
472 unsigned int ret = -EINVAL; \
473 struct cpufreq_policy new_policy; \
474 \
475 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
476 if (ret) \
477 return -EINVAL; \
478 \
479 ret = sscanf (buf, "%u", &new_policy.object); \
480 if (ret != 1) \
481 return -EINVAL; \
482 \
Thomas Renninger7970e082006-04-13 15:14:04 +0200483 ret = __cpufreq_set_policy(policy, &new_policy); \
484 policy->user_policy.object = policy->object; \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 \
486 return ret ? ret : count; \
487}
488
489store_one(scaling_min_freq,min);
490store_one(scaling_max_freq,max);
491
492/**
493 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
494 */
Dave Jones905d77c2008-03-05 14:28:32 -0500495static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
496 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497{
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800498 unsigned int cur_freq = __cpufreq_get(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 if (!cur_freq)
500 return sprintf(buf, "<unknown>");
501 return sprintf(buf, "%u\n", cur_freq);
502}
503
504
505/**
506 * show_scaling_governor - show the current policy for the specified CPU
507 */
Dave Jones905d77c2008-03-05 14:28:32 -0500508static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509{
510 if(policy->policy == CPUFREQ_POLICY_POWERSAVE)
511 return sprintf(buf, "powersave\n");
512 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
513 return sprintf(buf, "performance\n");
514 else if (policy->governor)
515 return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", policy->governor->name);
516 return -EINVAL;
517}
518
519
520/**
521 * store_scaling_governor - store policy for the specified CPU
522 */
Dave Jones905d77c2008-03-05 14:28:32 -0500523static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
524 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525{
526 unsigned int ret = -EINVAL;
527 char str_governor[16];
528 struct cpufreq_policy new_policy;
529
530 ret = cpufreq_get_policy(&new_policy, policy->cpu);
531 if (ret)
532 return ret;
533
534 ret = sscanf (buf, "%15s", str_governor);
535 if (ret != 1)
536 return -EINVAL;
537
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530538 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
539 &new_policy.governor))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 return -EINVAL;
541
Thomas Renninger7970e082006-04-13 15:14:04 +0200542 /* Do not use cpufreq_set_policy here or the user_policy.max
543 will be wrongly overridden */
Thomas Renninger7970e082006-04-13 15:14:04 +0200544 ret = __cpufreq_set_policy(policy, &new_policy);
545
546 policy->user_policy.policy = policy->policy;
547 policy->user_policy.governor = policy->governor;
Thomas Renninger7970e082006-04-13 15:14:04 +0200548
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530549 if (ret)
550 return ret;
551 else
552 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553}
554
555/**
556 * show_scaling_driver - show the cpufreq driver currently loaded
557 */
Dave Jones905d77c2008-03-05 14:28:32 -0500558static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
560 return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", cpufreq_driver->name);
561}
562
563/**
564 * show_scaling_available_governors - show the available CPUfreq governors
565 */
Dave Jones905d77c2008-03-05 14:28:32 -0500566static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
567 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
569 ssize_t i = 0;
570 struct cpufreq_governor *t;
571
572 if (!cpufreq_driver->target) {
573 i += sprintf(buf, "performance powersave");
574 goto out;
575 }
576
577 list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
578 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char)) - (CPUFREQ_NAME_LEN + 2)))
579 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
587static ssize_t show_cpus(cpumask_t mask, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588{
589 ssize_t i = 0;
590 unsigned int cpu;
591
Mike Travis068b1272008-05-12 21:21:13 +0200592 for_each_cpu_mask_nr(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))
597 break;
598 }
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{
609 if (cpus_empty(policy->related_cpus))
610 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);
663define_one_ro(scaling_available_governors);
664define_one_ro(scaling_driver);
665define_one_ro(scaling_cur_freq);
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700666define_one_ro(related_cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667define_one_ro(affected_cpus);
668define_one_rw(scaling_min_freq);
669define_one_rw(scaling_max_freq);
670define_one_rw(scaling_governor);
Venki Pallipadi9e769882007-10-26 10:18:21 -0700671define_one_rw(scaling_setspeed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
Dave Jones905d77c2008-03-05 14:28:32 -0500673static struct attribute *default_attrs[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 &cpuinfo_min_freq.attr,
675 &cpuinfo_max_freq.attr,
676 &scaling_min_freq.attr,
677 &scaling_max_freq.attr,
678 &affected_cpus.attr,
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700679 &related_cpus.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 &scaling_governor.attr,
681 &scaling_driver.attr,
682 &scaling_available_governors.attr,
Venki Pallipadi9e769882007-10-26 10:18:21 -0700683 &scaling_setspeed.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 NULL
685};
686
687#define to_policy(k) container_of(k,struct cpufreq_policy,kobj)
688#define to_attr(a) container_of(a,struct freq_attr,attr)
689
Dave Jones905d77c2008-03-05 14:28:32 -0500690static ssize_t show(struct kobject *kobj, struct attribute *attr ,char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691{
Dave Jones905d77c2008-03-05 14:28:32 -0500692 struct cpufreq_policy *policy = to_policy(kobj);
693 struct freq_attr *fattr = to_attr(attr);
Dave Jones0db4a8a2008-03-05 14:20:57 -0500694 ssize_t ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 policy = cpufreq_cpu_get(policy->cpu);
696 if (!policy)
Dave Jones0db4a8a2008-03-05 14:20:57 -0500697 goto no_policy;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800698
699 if (lock_policy_rwsem_read(policy->cpu) < 0)
Dave Jones0db4a8a2008-03-05 14:20:57 -0500700 goto fail;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800701
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530702 if (fattr->show)
703 ret = fattr->show(policy, buf);
704 else
705 ret = -EIO;
706
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800707 unlock_policy_rwsem_read(policy->cpu);
Dave Jones0db4a8a2008-03-05 14:20:57 -0500708fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 cpufreq_cpu_put(policy);
Dave Jones0db4a8a2008-03-05 14:20:57 -0500710no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 return ret;
712}
713
Dave Jones905d77c2008-03-05 14:28:32 -0500714static ssize_t store(struct kobject *kobj, struct attribute *attr,
715 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716{
Dave Jones905d77c2008-03-05 14:28:32 -0500717 struct cpufreq_policy *policy = to_policy(kobj);
718 struct freq_attr *fattr = to_attr(attr);
Dave Jonesa07530b2008-03-05 14:22:25 -0500719 ssize_t ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 policy = cpufreq_cpu_get(policy->cpu);
721 if (!policy)
Dave Jonesa07530b2008-03-05 14:22:25 -0500722 goto no_policy;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800723
724 if (lock_policy_rwsem_write(policy->cpu) < 0)
Dave Jonesa07530b2008-03-05 14:22:25 -0500725 goto fail;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800726
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530727 if (fattr->store)
728 ret = fattr->store(policy, buf, count);
729 else
730 ret = -EIO;
731
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800732 unlock_policy_rwsem_write(policy->cpu);
Dave Jonesa07530b2008-03-05 14:22:25 -0500733fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 cpufreq_cpu_put(policy);
Dave Jonesa07530b2008-03-05 14:22:25 -0500735no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 return ret;
737}
738
Dave Jones905d77c2008-03-05 14:28:32 -0500739static void cpufreq_sysfs_release(struct kobject *kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740{
Dave Jones905d77c2008-03-05 14:28:32 -0500741 struct cpufreq_policy *policy = to_policy(kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 dprintk("last reference is dropped\n");
743 complete(&policy->kobj_unregister);
744}
745
746static struct sysfs_ops sysfs_ops = {
747 .show = show,
748 .store = store,
749};
750
751static struct kobj_type ktype_cpufreq = {
752 .sysfs_ops = &sysfs_ops,
753 .default_attrs = default_attrs,
754 .release = cpufreq_sysfs_release,
755};
756
757
758/**
759 * cpufreq_add_dev - add a CPU device
760 *
Dave Jones32ee8c32006-02-28 00:43:23 -0500761 * Adds the cpufreq interface for a CPU device.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 */
Dave Jones905d77c2008-03-05 14:28:32 -0500763static int cpufreq_add_dev(struct sys_device *sys_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764{
765 unsigned int cpu = sys_dev->id;
766 int ret = 0;
767 struct cpufreq_policy new_policy;
768 struct cpufreq_policy *policy;
769 struct freq_attr **drv_attr;
Dave Jones8ff69732006-03-05 03:37:23 -0500770 struct sys_device *cpu_sys_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 unsigned long flags;
772 unsigned int j;
Dave Jones8ff69732006-03-05 03:37:23 -0500773#ifdef CONFIG_SMP
774 struct cpufreq_policy *managed_policy;
775#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Ashok Rajc32b6b82005-10-30 14:59:54 -0800777 if (cpu_is_offline(cpu))
778 return 0;
779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 cpufreq_debug_disable_ratelimit();
781 dprintk("adding CPU %u\n", cpu);
782
783#ifdef CONFIG_SMP
784 /* check whether a different CPU already registered this
785 * CPU because it is in the same boat. */
786 policy = cpufreq_cpu_get(cpu);
787 if (unlikely(policy)) {
Dave Jones8ff69732006-03-05 03:37:23 -0500788 cpufreq_cpu_put(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 cpufreq_debug_enable_ratelimit();
790 return 0;
791 }
792#endif
793
794 if (!try_module_get(cpufreq_driver->owner)) {
795 ret = -EINVAL;
796 goto module_out;
797 }
798
Dave Jonese98df502005-10-20 15:17:43 -0700799 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 if (!policy) {
801 ret = -ENOMEM;
802 goto nomem_out;
803 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
805 policy->cpu = cpu;
806 policy->cpus = cpumask_of_cpu(cpu);
807
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800808 /* Initially set CPU itself as the policy_cpu */
809 per_cpu(policy_cpu, cpu) = cpu;
810 lock_policy_rwsem_write(cpu);
811
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 init_completion(&policy->kobj_unregister);
David Howells65f27f32006-11-22 14:55:48 +0000813 INIT_WORK(&policy->update, handle_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Thomas Renninger8122c6c2007-10-02 13:28:09 -0700815 /* Set governor before ->init, so that driver could check it */
816 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 /* call driver. From then on the cpufreq must be able
818 * to accept all calls to ->verify and ->setpolicy for this CPU
819 */
820 ret = cpufreq_driver->init(policy);
821 if (ret) {
822 dprintk("initialization failed\n");
823 goto err_out;
824 }
Thomas Renninger22c970f2007-04-19 15:48:34 +0200825 policy->user_policy.min = policy->cpuinfo.min_freq;
826 policy->user_policy.max = policy->cpuinfo.max_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Thomas Renningera1531ac2008-07-29 22:32:58 -0700828 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
829 CPUFREQ_START, policy);
830
Dave Jones8ff69732006-03-05 03:37:23 -0500831#ifdef CONFIG_SMP
Thomas Renninger084f3492007-07-09 11:35:28 -0700832
833#ifdef CONFIG_HOTPLUG_CPU
Mike Travis7a6aedf2008-03-25 15:06:53 -0700834 if (per_cpu(cpufreq_cpu_governor, cpu)) {
835 policy->governor = per_cpu(cpufreq_cpu_governor, cpu);
Thomas Renninger084f3492007-07-09 11:35:28 -0700836 dprintk("Restoring governor %s for cpu %d\n",
837 policy->governor->name, cpu);
838 }
839#endif
840
Mike Travis068b1272008-05-12 21:21:13 +0200841 for_each_cpu_mask_nr(j, policy->cpus) {
Dave Jones8ff69732006-03-05 03:37:23 -0500842 if (cpu == j)
843 continue;
844
845 /* check for existing affected CPUs. They may not be aware
846 * of it due to CPU Hotplug.
847 */
Dave Jones45709112008-03-05 14:07:34 -0500848 managed_policy = cpufreq_cpu_get(j); // FIXME: Where is this released? What about error paths?
Dave Jones8ff69732006-03-05 03:37:23 -0500849 if (unlikely(managed_policy)) {
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800850
851 /* Set proper policy_cpu */
852 unlock_policy_rwsem_write(cpu);
853 per_cpu(policy_cpu, cpu) = managed_policy->cpu;
854
855 if (lock_policy_rwsem_write(cpu) < 0)
856 goto err_out_driver_exit;
857
Dave Jones8ff69732006-03-05 03:37:23 -0500858 spin_lock_irqsave(&cpufreq_driver_lock, flags);
859 managed_policy->cpus = policy->cpus;
Mike Travis7a6aedf2008-03-25 15:06:53 -0700860 per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
Dave Jones8ff69732006-03-05 03:37:23 -0500861 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
862
863 dprintk("CPU already managed, adding link\n");
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200864 ret = sysfs_create_link(&sys_dev->kobj,
865 &managed_policy->kobj,
866 "cpufreq");
Dave Jones45709112008-03-05 14:07:34 -0500867 if (ret)
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200868 goto err_out_driver_exit;
Dave Jones8ff69732006-03-05 03:37:23 -0500869
870 cpufreq_debug_enable_ratelimit();
Dave Jones8ff69732006-03-05 03:37:23 -0500871 ret = 0;
872 goto err_out_driver_exit; /* call driver->exit() */
873 }
874 }
875#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
877
878 /* prepare interface data */
Greg Kroah-Hartman038c5b32007-12-17 15:54:39 -0400879 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq, &sys_dev->kobj,
880 "cpufreq");
Dave Jones45709112008-03-05 14:07:34 -0500881 if (ret)
Venkatesh Pallipadi8085e1f2005-08-25 13:14:06 -0700882 goto err_out_driver_exit;
Dave Jones45709112008-03-05 14:07:34 -0500883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 /* set up files for this cpu device */
885 drv_attr = cpufreq_driver->attr;
886 while ((drv_attr) && (*drv_attr)) {
Tobias Klauser58a72952007-06-14 00:28:15 +0200887 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
Dave Jones45709112008-03-05 14:07:34 -0500888 if (ret)
Thomas Renninger0a4b2cc2007-05-21 07:20:04 -0500889 goto err_out_driver_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 drv_attr++;
891 }
Dave Jones45709112008-03-05 14:07:34 -0500892 if (cpufreq_driver->get) {
Tobias Klauser58a72952007-06-14 00:28:15 +0200893 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
Dave Jones45709112008-03-05 14:07:34 -0500894 if (ret)
Thomas Renninger0a4b2cc2007-05-21 07:20:04 -0500895 goto err_out_driver_exit;
896 }
Dave Jones45709112008-03-05 14:07:34 -0500897 if (cpufreq_driver->target) {
Tobias Klauser58a72952007-06-14 00:28:15 +0200898 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
Dave Jones45709112008-03-05 14:07:34 -0500899 if (ret)
Thomas Renninger0a4b2cc2007-05-21 07:20:04 -0500900 goto err_out_driver_exit;
901 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
903 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Mike Travis068b1272008-05-12 21:21:13 +0200904 for_each_cpu_mask_nr(j, policy->cpus) {
Mike Travis7a6aedf2008-03-25 15:06:53 -0700905 per_cpu(cpufreq_cpu_data, j) = policy;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800906 per_cpu(policy_cpu, j) = policy->cpu;
907 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Dave Jones8ff69732006-03-05 03:37:23 -0500909
910 /* symlink affected CPUs */
Mike Travis068b1272008-05-12 21:21:13 +0200911 for_each_cpu_mask_nr(j, policy->cpus) {
Dave Jones8ff69732006-03-05 03:37:23 -0500912 if (j == cpu)
913 continue;
914 if (!cpu_online(j))
915 continue;
916
Dave Jones1f8b2c92006-03-29 01:40:04 -0500917 dprintk("CPU %u already managed, adding link\n", j);
Dave Jones8ff69732006-03-05 03:37:23 -0500918 cpufreq_cpu_get(cpu);
919 cpu_sys_dev = get_cpu_sysdev(j);
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200920 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
921 "cpufreq");
Dave Jones45709112008-03-05 14:07:34 -0500922 if (ret)
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200923 goto err_out_unregister;
Dave Jones8ff69732006-03-05 03:37:23 -0500924 }
925
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 policy->governor = NULL; /* to assure that the starting sequence is
927 * run in cpufreq_set_policy */
Dave Jones87c32272006-03-29 01:48:37 -0500928
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 /* set default policy */
Thomas Renninger22c970f2007-04-19 15:48:34 +0200930 ret = __cpufreq_set_policy(policy, &new_policy);
931 policy->user_policy.policy = policy->policy;
Thomas Renninger084f3492007-07-09 11:35:28 -0700932 policy->user_policy.governor = policy->governor;
Thomas Renninger22c970f2007-04-19 15:48:34 +0200933
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 if (ret) {
935 dprintk("setting policy failed\n");
936 goto err_out_unregister;
937 }
938
Lothar Waßmanndca02612008-05-29 17:54:52 +0200939 unlock_policy_rwsem_write(cpu);
940
Greg Kroah-Hartman038c5b32007-12-17 15:54:39 -0400941 kobject_uevent(&policy->kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 module_put(cpufreq_driver->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 dprintk("initialization complete\n");
944 cpufreq_debug_enable_ratelimit();
Dave Jones87c32272006-03-29 01:48:37 -0500945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 return 0;
947
948
949err_out_unregister:
950 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Mike Travis068b1272008-05-12 21:21:13 +0200951 for_each_cpu_mask_nr(j, policy->cpus)
Mike Travis7a6aedf2008-03-25 15:06:53 -0700952 per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
954
Greg Kroah-Hartmanc10997f2007-12-20 08:13:05 -0800955 kobject_put(&policy->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 wait_for_completion(&policy->kobj_unregister);
957
Venkatesh Pallipadi8085e1f2005-08-25 13:14:06 -0700958err_out_driver_exit:
959 if (cpufreq_driver->exit)
960 cpufreq_driver->exit(policy);
961
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962err_out:
Dave Jones45709112008-03-05 14:07:34 -0500963 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 kfree(policy);
965
966nomem_out:
967 module_put(cpufreq_driver->owner);
Ashok Rajc32b6b82005-10-30 14:59:54 -0800968module_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 cpufreq_debug_enable_ratelimit();
970 return ret;
971}
972
973
974/**
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800975 * __cpufreq_remove_dev - remove a CPU device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 *
977 * Removes the cpufreq interface for a CPU device.
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800978 * Caller should already have policy_rwsem in write mode for this CPU.
979 * This routine frees the rwsem before returning.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 */
Dave Jones905d77c2008-03-05 14:28:32 -0500981static int __cpufreq_remove_dev(struct sys_device *sys_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982{
983 unsigned int cpu = sys_dev->id;
984 unsigned long flags;
985 struct cpufreq_policy *data;
986#ifdef CONFIG_SMP
Grant Coadye738cf62005-11-21 21:32:28 -0800987 struct sys_device *cpu_sys_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 unsigned int j;
989#endif
990
991 cpufreq_debug_disable_ratelimit();
992 dprintk("unregistering CPU %u\n", cpu);
993
994 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Mike Travis7a6aedf2008-03-25 15:06:53 -0700995 data = per_cpu(cpufreq_cpu_data, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996
997 if (!data) {
998 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 cpufreq_debug_enable_ratelimit();
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001000 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 return -EINVAL;
1002 }
Mike Travis7a6aedf2008-03-25 15:06:53 -07001003 per_cpu(cpufreq_cpu_data, cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
1005
1006#ifdef CONFIG_SMP
1007 /* if this isn't the CPU which is the parent of the kobj, we
Dave Jones32ee8c32006-02-28 00:43:23 -05001008 * only need to unlink, put and exit
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 */
1010 if (unlikely(cpu != data->cpu)) {
1011 dprintk("removing link\n");
Dave Jones8ff69732006-03-05 03:37:23 -05001012 cpu_clear(cpu, data->cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1014 sysfs_remove_link(&sys_dev->kobj, "cpufreq");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 cpufreq_cpu_put(data);
1016 cpufreq_debug_enable_ratelimit();
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001017 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 return 0;
1019 }
1020#endif
1021
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022#ifdef CONFIG_SMP
Thomas Renninger084f3492007-07-09 11:35:28 -07001023
1024#ifdef CONFIG_HOTPLUG_CPU
Mike Travis7a6aedf2008-03-25 15:06:53 -07001025 per_cpu(cpufreq_cpu_governor, cpu) = data->governor;
Thomas Renninger084f3492007-07-09 11:35:28 -07001026#endif
1027
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 /* if we have other CPUs still registered, we need to unlink them,
1029 * or else wait_for_completion below will lock up. Clean the
Mike Travis7a6aedf2008-03-25 15:06:53 -07001030 * per_cpu(cpufreq_cpu_data) while holding the lock, and remove
1031 * the sysfs links afterwards.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 */
1033 if (unlikely(cpus_weight(data->cpus) > 1)) {
Mike Travis068b1272008-05-12 21:21:13 +02001034 for_each_cpu_mask_nr(j, data->cpus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 if (j == cpu)
1036 continue;
Mike Travis7a6aedf2008-03-25 15:06:53 -07001037 per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 }
1039 }
1040
1041 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1042
1043 if (unlikely(cpus_weight(data->cpus) > 1)) {
Mike Travis068b1272008-05-12 21:21:13 +02001044 for_each_cpu_mask_nr(j, data->cpus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 if (j == cpu)
1046 continue;
1047 dprintk("removing link for cpu %u\n", j);
Thomas Renninger084f3492007-07-09 11:35:28 -07001048#ifdef CONFIG_HOTPLUG_CPU
Mike Travis7a6aedf2008-03-25 15:06:53 -07001049 per_cpu(cpufreq_cpu_governor, j) = data->governor;
Thomas Renninger084f3492007-07-09 11:35:28 -07001050#endif
Ashok Rajd434fca2005-10-30 14:59:52 -08001051 cpu_sys_dev = get_cpu_sysdev(j);
1052 sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 cpufreq_cpu_put(data);
1054 }
1055 }
1056#else
1057 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1058#endif
1059
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 if (cpufreq_driver->target)
1061 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001062
1063 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 kobject_put(&data->kobj);
1066
1067 /* we need to make sure that the underlying kobj is actually
Dave Jones32ee8c32006-02-28 00:43:23 -05001068 * not referenced anymore by anybody before we proceed with
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 * unloading.
1070 */
1071 dprintk("waiting for dropping of refcount\n");
1072 wait_for_completion(&data->kobj_unregister);
1073 dprintk("wait complete\n");
1074
1075 if (cpufreq_driver->exit)
1076 cpufreq_driver->exit(data);
1077
1078 kfree(data);
1079
1080 cpufreq_debug_enable_ratelimit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 return 0;
1082}
1083
1084
Dave Jones905d77c2008-03-05 14:28:32 -05001085static int cpufreq_remove_dev(struct sys_device *sys_dev)
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001086{
1087 unsigned int cpu = sys_dev->id;
1088 int retval;
Venki Pallipadiec282972007-03-26 12:03:19 -07001089
1090 if (cpu_is_offline(cpu))
1091 return 0;
1092
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001093 if (unlikely(lock_policy_rwsem_write(cpu)))
1094 BUG();
1095
1096 retval = __cpufreq_remove_dev(sys_dev);
1097 return retval;
1098}
1099
1100
David Howells65f27f32006-11-22 14:55:48 +00001101static void handle_update(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102{
David Howells65f27f32006-11-22 14:55:48 +00001103 struct cpufreq_policy *policy =
1104 container_of(work, struct cpufreq_policy, update);
1105 unsigned int cpu = policy->cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 dprintk("handle_update for cpu %u called\n", cpu);
1107 cpufreq_update_policy(cpu);
1108}
1109
1110/**
1111 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
1112 * @cpu: cpu number
1113 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1114 * @new_freq: CPU frequency the CPU actually runs at
1115 *
1116 * We adjust to current frequency first, and need to clean up later. So either call
1117 * to cpufreq_update_policy() or schedule handle_update()).
1118 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301119static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1120 unsigned int new_freq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121{
1122 struct cpufreq_freqs freqs;
1123
Jan Beulichb10eec22006-04-28 13:47:13 +02001124 dprintk("Warning: CPU frequency out of sync: cpufreq and timing "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1126
1127 freqs.cpu = cpu;
1128 freqs.old = old_freq;
1129 freqs.new = new_freq;
1130 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
1131 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
1132}
1133
1134
Dave Jones32ee8c32006-02-28 00:43:23 -05001135/**
Dhaval Giani4ab70df2006-12-13 14:49:15 +05301136 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001137 * @cpu: CPU number
1138 *
1139 * This is the last known freq, without actually getting it from the driver.
1140 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1141 */
1142unsigned int cpufreq_quick_get(unsigned int cpu)
1143{
1144 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301145 unsigned int ret_freq = 0;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001146
1147 if (policy) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301148 ret_freq = policy->cur;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001149 cpufreq_cpu_put(policy);
1150 }
1151
Dave Jones4d34a672008-02-07 16:33:49 -05001152 return ret_freq;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001153}
1154EXPORT_SYMBOL(cpufreq_quick_get);
1155
1156
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001157static unsigned int __cpufreq_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158{
Mike Travis7a6aedf2008-03-25 15:06:53 -07001159 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301160 unsigned int ret_freq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 if (!cpufreq_driver->get)
Dave Jones4d34a672008-02-07 16:33:49 -05001163 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301165 ret_freq = cpufreq_driver->get(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301167 if (ret_freq && policy->cur &&
1168 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1169 /* verify no discrepancy between actual and
1170 saved value exists */
1171 if (unlikely(ret_freq != policy->cur)) {
1172 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 schedule_work(&policy->update);
1174 }
1175 }
1176
Dave Jones4d34a672008-02-07 16:33:49 -05001177 return ret_freq;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001178}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001180/**
1181 * cpufreq_get - get the current CPU frequency (in kHz)
1182 * @cpu: CPU number
1183 *
1184 * Get the CPU current (static) CPU frequency
1185 */
1186unsigned int cpufreq_get(unsigned int cpu)
1187{
1188 unsigned int ret_freq = 0;
1189 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1190
1191 if (!policy)
1192 goto out;
1193
1194 if (unlikely(lock_policy_rwsem_read(cpu)))
1195 goto out_policy;
1196
1197 ret_freq = __cpufreq_get(cpu);
1198
1199 unlock_policy_rwsem_read(cpu);
1200
1201out_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 cpufreq_cpu_put(policy);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001203out:
Dave Jones4d34a672008-02-07 16:33:49 -05001204 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205}
1206EXPORT_SYMBOL(cpufreq_get);
1207
1208
1209/**
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001210 * cpufreq_suspend - let the low level driver prepare for suspend
1211 */
1212
Dave Jones905d77c2008-03-05 14:28:32 -05001213static int cpufreq_suspend(struct sys_device *sysdev, pm_message_t pmsg)
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001214{
1215 int cpu = sysdev->id;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301216 int ret = 0;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001217 unsigned int cur_freq = 0;
1218 struct cpufreq_policy *cpu_policy;
1219
Dave Jones0e37b152006-09-26 23:02:34 -04001220 dprintk("suspending cpu %u\n", cpu);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001221
1222 if (!cpu_online(cpu))
1223 return 0;
1224
1225 /* we may be lax here as interrupts are off. Nonetheless
1226 * we need to grab the correct cpu policy, as to check
1227 * whether we really run on this CPU.
1228 */
1229
1230 cpu_policy = cpufreq_cpu_get(cpu);
1231 if (!cpu_policy)
1232 return -EINVAL;
1233
1234 /* only handle each CPU group once */
Dave Jonesc9060492008-02-07 16:32:18 -05001235 if (unlikely(cpu_policy->cpu != cpu))
1236 goto out;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001237
1238 if (cpufreq_driver->suspend) {
Bernard Blackhame00d9962005-07-07 17:56:42 -07001239 ret = cpufreq_driver->suspend(cpu_policy, pmsg);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001240 if (ret) {
1241 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1242 "step on CPU %u\n", cpu_policy->cpu);
Dave Jonesc9060492008-02-07 16:32:18 -05001243 goto out;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001244 }
1245 }
1246
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001247 if (cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)
1248 goto out;
1249
1250 if (cpufreq_driver->get)
1251 cur_freq = cpufreq_driver->get(cpu_policy->cpu);
1252
1253 if (!cur_freq || !cpu_policy->cur) {
1254 printk(KERN_ERR "cpufreq: suspend failed to assert current "
1255 "frequency is what timing core thinks it is.\n");
1256 goto out;
1257 }
1258
1259 if (unlikely(cur_freq != cpu_policy->cur)) {
1260 struct cpufreq_freqs freqs;
1261
1262 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
Jan Beulichb10eec22006-04-28 13:47:13 +02001263 dprintk("Warning: CPU frequency is %u, "
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001264 "cpufreq assumed %u kHz.\n",
1265 cur_freq, cpu_policy->cur);
1266
1267 freqs.cpu = cpu;
1268 freqs.old = cpu_policy->cur;
1269 freqs.new = cur_freq;
1270
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001271 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001272 CPUFREQ_SUSPENDCHANGE, &freqs);
1273 adjust_jiffies(CPUFREQ_SUSPENDCHANGE, &freqs);
1274
1275 cpu_policy->cur = cur_freq;
1276 }
1277
Dave Jones7d5e3502006-02-02 17:03:42 -05001278out:
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001279 cpufreq_cpu_put(cpu_policy);
Dave Jonesc9060492008-02-07 16:32:18 -05001280 return ret;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001281}
1282
1283/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 * cpufreq_resume - restore proper CPU frequency handling after resume
1285 *
1286 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1287 * 2.) if ->target and !CPUFREQ_CONST_LOOPS: verify we're in sync
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001288 * 3.) schedule call cpufreq_update_policy() ASAP as interrupts are
1289 * restored.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 */
Dave Jones905d77c2008-03-05 14:28:32 -05001291static int cpufreq_resume(struct sys_device *sysdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292{
1293 int cpu = sysdev->id;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301294 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 struct cpufreq_policy *cpu_policy;
1296
1297 dprintk("resuming cpu %u\n", cpu);
1298
1299 if (!cpu_online(cpu))
1300 return 0;
1301
1302 /* we may be lax here as interrupts are off. Nonetheless
1303 * we need to grab the correct cpu policy, as to check
1304 * whether we really run on this CPU.
1305 */
1306
1307 cpu_policy = cpufreq_cpu_get(cpu);
1308 if (!cpu_policy)
1309 return -EINVAL;
1310
1311 /* only handle each CPU group once */
Dave Jonesc9060492008-02-07 16:32:18 -05001312 if (unlikely(cpu_policy->cpu != cpu))
1313 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314
1315 if (cpufreq_driver->resume) {
1316 ret = cpufreq_driver->resume(cpu_policy);
1317 if (ret) {
1318 printk(KERN_ERR "cpufreq: resume failed in ->resume "
1319 "step on CPU %u\n", cpu_policy->cpu);
Dave Jonesc9060492008-02-07 16:32:18 -05001320 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 }
1322 }
1323
1324 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1325 unsigned int cur_freq = 0;
1326
1327 if (cpufreq_driver->get)
1328 cur_freq = cpufreq_driver->get(cpu_policy->cpu);
1329
1330 if (!cur_freq || !cpu_policy->cur) {
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001331 printk(KERN_ERR "cpufreq: resume failed to assert "
1332 "current frequency is what timing core "
1333 "thinks it is.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 goto out;
1335 }
1336
1337 if (unlikely(cur_freq != cpu_policy->cur)) {
1338 struct cpufreq_freqs freqs;
1339
Benjamin Herrenschmidtac09f692005-05-02 16:25:10 +10001340 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
Joe Perchesa4a9df52007-11-19 17:48:06 -08001341 dprintk("Warning: CPU frequency "
Benjamin Herrenschmidtac09f692005-05-02 16:25:10 +10001342 "is %u, cpufreq assumed %u kHz.\n",
1343 cur_freq, cpu_policy->cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
1345 freqs.cpu = cpu;
1346 freqs.old = cpu_policy->cur;
1347 freqs.new = cur_freq;
1348
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001349 srcu_notifier_call_chain(
Alan Sterne041c682006-03-27 01:16:30 -08001350 &cpufreq_transition_notifier_list,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001351 CPUFREQ_RESUMECHANGE, &freqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 adjust_jiffies(CPUFREQ_RESUMECHANGE, &freqs);
1353
1354 cpu_policy->cur = cur_freq;
1355 }
1356 }
1357
1358out:
1359 schedule_work(&cpu_policy->update);
Dave Jonesc9060492008-02-07 16:32:18 -05001360fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 cpufreq_cpu_put(cpu_policy);
1362 return ret;
1363}
1364
1365static struct sysdev_driver cpufreq_sysdev_driver = {
1366 .add = cpufreq_add_dev,
1367 .remove = cpufreq_remove_dev,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001368 .suspend = cpufreq_suspend,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 .resume = cpufreq_resume,
1370};
1371
1372
1373/*********************************************************************
1374 * NOTIFIER LISTS INTERFACE *
1375 *********************************************************************/
1376
1377/**
1378 * cpufreq_register_notifier - register a driver with cpufreq
1379 * @nb: notifier function to register
1380 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1381 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001382 * Add a driver to one of two lists: either a list of drivers that
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 * are notified about clock rate changes (once before and once after
1384 * the transition), or a list of drivers that are notified about
1385 * changes in cpufreq policy.
1386 *
1387 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001388 * blocking_notifier_chain_register.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 */
1390int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1391{
1392 int ret;
1393
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -02001394 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1395
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 switch (list) {
1397 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001398 ret = srcu_notifier_chain_register(
Alan Sterne041c682006-03-27 01:16:30 -08001399 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 break;
1401 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001402 ret = blocking_notifier_chain_register(
1403 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 break;
1405 default:
1406 ret = -EINVAL;
1407 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
1409 return ret;
1410}
1411EXPORT_SYMBOL(cpufreq_register_notifier);
1412
1413
1414/**
1415 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1416 * @nb: notifier block to be unregistered
1417 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1418 *
1419 * Remove a driver from the CPU frequency notifier list.
1420 *
1421 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001422 * blocking_notifier_chain_unregister.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 */
1424int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1425{
1426 int ret;
1427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 switch (list) {
1429 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001430 ret = srcu_notifier_chain_unregister(
Alan Sterne041c682006-03-27 01:16:30 -08001431 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 break;
1433 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001434 ret = blocking_notifier_chain_unregister(
1435 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 break;
1437 default:
1438 ret = -EINVAL;
1439 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
1441 return ret;
1442}
1443EXPORT_SYMBOL(cpufreq_unregister_notifier);
1444
1445
1446/*********************************************************************
1447 * GOVERNORS *
1448 *********************************************************************/
1449
1450
1451int __cpufreq_driver_target(struct cpufreq_policy *policy,
1452 unsigned int target_freq,
1453 unsigned int relation)
1454{
1455 int retval = -EINVAL;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001456
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
1458 target_freq, relation);
1459 if (cpu_online(policy->cpu) && cpufreq_driver->target)
1460 retval = cpufreq_driver->target(policy, target_freq, relation);
Ashok Raj90d45d12005-11-08 21:34:24 -08001461
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 return retval;
1463}
1464EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1465
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466int cpufreq_driver_target(struct cpufreq_policy *policy,
1467 unsigned int target_freq,
1468 unsigned int relation)
1469{
Julia Lawallf1829e42008-07-25 22:44:53 +02001470 int ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
1472 policy = cpufreq_cpu_get(policy->cpu);
1473 if (!policy)
Julia Lawallf1829e42008-07-25 22:44:53 +02001474 goto no_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001476 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
Julia Lawallf1829e42008-07-25 22:44:53 +02001477 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478
1479 ret = __cpufreq_driver_target(policy, target_freq, relation);
1480
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001481 unlock_policy_rwsem_write(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
Julia Lawallf1829e42008-07-25 22:44:53 +02001483fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 cpufreq_cpu_put(policy);
Julia Lawallf1829e42008-07-25 22:44:53 +02001485no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 return ret;
1487}
1488EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1489
venkatesh.pallipadi@intel.combf0b90e2008-08-04 11:59:07 -07001490int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001491{
1492 int ret = 0;
1493
1494 policy = cpufreq_cpu_get(policy->cpu);
1495 if (!policy)
1496 return -EINVAL;
1497
venkatesh.pallipadi@intel.combf0b90e2008-08-04 11:59:07 -07001498 if (cpu_online(cpu) && cpufreq_driver->getavg)
1499 ret = cpufreq_driver->getavg(policy, cpu);
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001500
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001501 cpufreq_cpu_put(policy);
1502 return ret;
1503}
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001504EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001505
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001506/*
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001507 * when "event" is CPUFREQ_GOV_LIMITS
1508 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301510static int __cpufreq_governor(struct cpufreq_policy *policy,
1511 unsigned int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512{
Dave Jonescc993ca2005-07-28 09:43:56 -07001513 int ret;
Thomas Renninger6afde102007-10-02 13:28:13 -07001514
1515 /* Only must be defined when default governor is known to have latency
1516 restrictions, like e.g. conservative or ondemand.
1517 That this is the case is already ensured in Kconfig
1518 */
1519#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1520 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1521#else
1522 struct cpufreq_governor *gov = NULL;
1523#endif
Thomas Renninger1c256242007-10-02 13:28:12 -07001524
1525 if (policy->governor->max_transition_latency &&
1526 policy->cpuinfo.transition_latency >
1527 policy->governor->max_transition_latency) {
Thomas Renninger6afde102007-10-02 13:28:13 -07001528 if (!gov)
1529 return -EINVAL;
1530 else {
1531 printk(KERN_WARNING "%s governor failed, too long"
1532 " transition latency of HW, fallback"
1533 " to %s governor\n",
1534 policy->governor->name,
1535 gov->name);
1536 policy->governor = gov;
1537 }
Thomas Renninger1c256242007-10-02 13:28:12 -07001538 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539
1540 if (!try_module_get(policy->governor->owner))
1541 return -EINVAL;
1542
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301543 dprintk("__cpufreq_governor for CPU %u, event %u\n",
1544 policy->cpu, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 ret = policy->governor->governor(policy, event);
1546
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301547 /* we keep one module reference alive for
1548 each CPU governed by this CPU */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 if ((event != CPUFREQ_GOV_START) || ret)
1550 module_put(policy->governor->owner);
1551 if ((event == CPUFREQ_GOV_STOP) && !ret)
1552 module_put(policy->governor->owner);
1553
1554 return ret;
1555}
1556
1557
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558int cpufreq_register_governor(struct cpufreq_governor *governor)
1559{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001560 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
1562 if (!governor)
1563 return -EINVAL;
1564
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001565 mutex_lock(&cpufreq_governor_mutex);
Dave Jones32ee8c32006-02-28 00:43:23 -05001566
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001567 err = -EBUSY;
1568 if (__find_governor(governor->name) == NULL) {
1569 err = 0;
1570 list_add(&governor->governor_list, &cpufreq_governor_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572
Dave Jones32ee8c32006-02-28 00:43:23 -05001573 mutex_unlock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001574 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575}
1576EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1577
1578
1579void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1580{
1581 if (!governor)
1582 return;
1583
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001584 mutex_lock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 list_del(&governor->governor_list);
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001586 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 return;
1588}
1589EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1590
1591
1592
1593/*********************************************************************
1594 * POLICY INTERFACE *
1595 *********************************************************************/
1596
1597/**
1598 * cpufreq_get_policy - get the current cpufreq_policy
1599 * @policy: struct cpufreq_policy into which the current cpufreq_policy is written
1600 *
1601 * Reads the current cpufreq policy.
1602 */
1603int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1604{
1605 struct cpufreq_policy *cpu_policy;
1606 if (!policy)
1607 return -EINVAL;
1608
1609 cpu_policy = cpufreq_cpu_get(cpu);
1610 if (!cpu_policy)
1611 return -EINVAL;
1612
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614
1615 cpufreq_cpu_put(cpu_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 return 0;
1617}
1618EXPORT_SYMBOL(cpufreq_get_policy);
1619
1620
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001621/*
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301622 * data : current policy.
1623 * policy : policy to be set.
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001624 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301625static int __cpufreq_set_policy(struct cpufreq_policy *data,
1626 struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627{
1628 int ret = 0;
1629
1630 cpufreq_debug_disable_ratelimit();
1631 dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1632 policy->min, policy->max);
1633
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301634 memcpy(&policy->cpuinfo, &data->cpuinfo,
1635 sizeof(struct cpufreq_cpuinfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
Yi Yang53391fa2008-01-30 13:33:34 +01001637 if (policy->min > data->max || policy->max < data->min) {
Mattia Dongili9c9a43e2006-07-05 23:12:20 +02001638 ret = -EINVAL;
1639 goto error_out;
1640 }
1641
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 /* verify the cpu speed can be set within this limit */
1643 ret = cpufreq_driver->verify(policy);
1644 if (ret)
1645 goto error_out;
1646
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 /* adjust if necessary - all reasons */
Alan Sterne041c682006-03-27 01:16:30 -08001648 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1649 CPUFREQ_ADJUST, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650
1651 /* adjust if necessary - hardware incompatibility*/
Alan Sterne041c682006-03-27 01:16:30 -08001652 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1653 CPUFREQ_INCOMPATIBLE, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
1655 /* verify the cpu speed can be set within this limit,
1656 which might be different to the first one */
1657 ret = cpufreq_driver->verify(policy);
Alan Sterne041c682006-03-27 01:16:30 -08001658 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 goto error_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661 /* notification of the new policy */
Alan Sterne041c682006-03-27 01:16:30 -08001662 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1663 CPUFREQ_NOTIFY, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664
Dave Jones7d5e3502006-02-02 17:03:42 -05001665 data->min = policy->min;
1666 data->max = policy->max;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301668 dprintk("new min and max freqs are %u - %u kHz\n",
1669 data->min, data->max);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670
1671 if (cpufreq_driver->setpolicy) {
1672 data->policy = policy->policy;
1673 dprintk("setting range\n");
1674 ret = cpufreq_driver->setpolicy(policy);
1675 } else {
1676 if (policy->governor != data->governor) {
1677 /* save old, working values */
1678 struct cpufreq_governor *old_gov = data->governor;
1679
1680 dprintk("governor switch\n");
1681
1682 /* end old governor */
1683 if (data->governor)
1684 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1685
1686 /* start new governor */
1687 data->governor = policy->governor;
1688 if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1689 /* new governor failed, so re-start old one */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301690 dprintk("starting governor %s failed\n",
1691 data->governor->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 if (old_gov) {
1693 data->governor = old_gov;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301694 __cpufreq_governor(data,
1695 CPUFREQ_GOV_START);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 }
1697 ret = -EINVAL;
1698 goto error_out;
1699 }
1700 /* might be a policy change, too, so fall through */
1701 }
1702 dprintk("governor: change or update limits\n");
1703 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1704 }
1705
Dave Jones7d5e3502006-02-02 17:03:42 -05001706error_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 cpufreq_debug_enable_ratelimit();
1708 return ret;
1709}
1710
1711/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1713 * @cpu: CPU which shall be re-evaluated
1714 *
1715 * Usefull for policy notifiers which have different necessities
1716 * at different times.
1717 */
1718int cpufreq_update_policy(unsigned int cpu)
1719{
1720 struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1721 struct cpufreq_policy policy;
Julia Lawallf1829e42008-07-25 22:44:53 +02001722 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723
Julia Lawallf1829e42008-07-25 22:44:53 +02001724 if (!data) {
1725 ret = -ENODEV;
1726 goto no_policy;
1727 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
Julia Lawallf1829e42008-07-25 22:44:53 +02001729 if (unlikely(lock_policy_rwsem_write(cpu))) {
1730 ret = -EINVAL;
1731 goto fail;
1732 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733
1734 dprintk("updating policy for CPU %u\n", cpu);
Dave Jones7d5e3502006-02-02 17:03:42 -05001735 memcpy(&policy, data, sizeof(struct cpufreq_policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 policy.min = data->user_policy.min;
1737 policy.max = data->user_policy.max;
1738 policy.policy = data->user_policy.policy;
1739 policy.governor = data->user_policy.governor;
1740
Thomas Renninger0961dd02006-01-26 18:46:33 +01001741 /* BIOS might change freq behind our back
1742 -> ask driver for current freq and notify governors about a change */
1743 if (cpufreq_driver->get) {
1744 policy.cur = cpufreq_driver->get(cpu);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001745 if (!data->cur) {
1746 dprintk("Driver did not initialize current freq");
1747 data->cur = policy.cur;
1748 } else {
1749 if (data->cur != policy.cur)
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301750 cpufreq_out_of_sync(cpu, data->cur,
1751 policy.cur);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001752 }
Thomas Renninger0961dd02006-01-26 18:46:33 +01001753 }
1754
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 ret = __cpufreq_set_policy(data, &policy);
1756
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001757 unlock_policy_rwsem_write(cpu);
1758
Julia Lawallf1829e42008-07-25 22:44:53 +02001759fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 cpufreq_cpu_put(data);
Julia Lawallf1829e42008-07-25 22:44:53 +02001761no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 return ret;
1763}
1764EXPORT_SYMBOL(cpufreq_update_policy);
1765
Satyam Sharmadd184a02007-10-02 13:28:14 -07001766static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
Ashok Rajc32b6b82005-10-30 14:59:54 -08001767 unsigned long action, void *hcpu)
1768{
1769 unsigned int cpu = (unsigned long)hcpu;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001770 struct sys_device *sys_dev;
1771
1772 sys_dev = get_cpu_sysdev(cpu);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001773 if (sys_dev) {
1774 switch (action) {
1775 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001776 case CPU_ONLINE_FROZEN:
Ashok Rajc32b6b82005-10-30 14:59:54 -08001777 cpufreq_add_dev(sys_dev);
1778 break;
1779 case CPU_DOWN_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001780 case CPU_DOWN_PREPARE_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001781 if (unlikely(lock_policy_rwsem_write(cpu)))
1782 BUG();
1783
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001784 __cpufreq_remove_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001785 break;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001786 case CPU_DOWN_FAILED:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001787 case CPU_DOWN_FAILED_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001788 cpufreq_add_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001789 break;
1790 }
1791 }
1792 return NOTIFY_OK;
1793}
1794
Sam Ravnborgf6ebef32008-02-17 13:22:52 +01001795static struct notifier_block __refdata cpufreq_cpu_notifier =
Ashok Rajc32b6b82005-10-30 14:59:54 -08001796{
1797 .notifier_call = cpufreq_cpu_callback,
1798};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799
1800/*********************************************************************
1801 * REGISTER / UNREGISTER CPUFREQ DRIVER *
1802 *********************************************************************/
1803
1804/**
1805 * cpufreq_register_driver - register a CPU Frequency driver
1806 * @driver_data: A struct cpufreq_driver containing the values#
1807 * submitted by the CPU Frequency driver.
1808 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001809 * Registers a CPU Frequency driver to this core code. This code
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 * returns zero on success, -EBUSY when another driver got here first
Dave Jones32ee8c32006-02-28 00:43:23 -05001811 * (and isn't unregistered in the meantime).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 *
1813 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001814int cpufreq_register_driver(struct cpufreq_driver *driver_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815{
1816 unsigned long flags;
1817 int ret;
1818
1819 if (!driver_data || !driver_data->verify || !driver_data->init ||
1820 ((!driver_data->setpolicy) && (!driver_data->target)))
1821 return -EINVAL;
1822
1823 dprintk("trying to register driver %s\n", driver_data->name);
1824
1825 if (driver_data->setpolicy)
1826 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1827
1828 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1829 if (cpufreq_driver) {
1830 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1831 return -EBUSY;
1832 }
1833 cpufreq_driver = driver_data;
1834 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1835
Mike Travis7a6aedf2008-03-25 15:06:53 -07001836 ret = sysdev_driver_register(&cpu_sysdev_class,
1837 &cpufreq_sysdev_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838
1839 if ((!ret) && !(cpufreq_driver->flags & CPUFREQ_STICKY)) {
1840 int i;
1841 ret = -ENODEV;
1842
1843 /* check for at least one working CPU */
Mike Travis7a6aedf2008-03-25 15:06:53 -07001844 for (i = 0; i < nr_cpu_ids; i++)
1845 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 ret = 0;
Mike Travis7a6aedf2008-03-25 15:06:53 -07001847 break;
1848 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849
1850 /* if all ->init() calls failed, unregister */
1851 if (ret) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301852 dprintk("no CPU initialized for driver %s\n",
1853 driver_data->name);
1854 sysdev_driver_unregister(&cpu_sysdev_class,
1855 &cpufreq_sysdev_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
1857 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1858 cpufreq_driver = NULL;
1859 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1860 }
1861 }
1862
1863 if (!ret) {
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001864 register_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 dprintk("driver %s up and running\n", driver_data->name);
1866 cpufreq_debug_enable_ratelimit();
1867 }
1868
Dave Jones4d34a672008-02-07 16:33:49 -05001869 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870}
1871EXPORT_SYMBOL_GPL(cpufreq_register_driver);
1872
1873
1874/**
1875 * cpufreq_unregister_driver - unregister the current CPUFreq driver
1876 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001877 * Unregister the current CPUFreq driver. Only call this if you have
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 * the right to do so, i.e. if you have succeeded in initialising before!
1879 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1880 * currently not initialised.
1881 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001882int cpufreq_unregister_driver(struct cpufreq_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883{
1884 unsigned long flags;
1885
1886 cpufreq_debug_disable_ratelimit();
1887
1888 if (!cpufreq_driver || (driver != cpufreq_driver)) {
1889 cpufreq_debug_enable_ratelimit();
1890 return -EINVAL;
1891 }
1892
1893 dprintk("unregistering driver %s\n", driver->name);
1894
1895 sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001896 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897
1898 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1899 cpufreq_driver = NULL;
1900 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1901
1902 return 0;
1903}
1904EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001905
1906static int __init cpufreq_core_init(void)
1907{
1908 int cpu;
1909
1910 for_each_possible_cpu(cpu) {
1911 per_cpu(policy_cpu, cpu) = -1;
1912 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
1913 }
1914 return 0;
1915}
1916
1917core_initcall(cpufreq_core_init);